@robinpath/slack - npm Package Compare versions

Comparing version

0.1.0

0.1.1

+38

-7

package.json

		{
		"name": "@robinpath/slack",
		"version": "0.1.0",
		"publishConfig": { "access": "public" },
		"version": "0.1.1",
		"publishConfig": {
		"access": "public"
		},
		"type": "module",
		"main": "dist/index.js",
		"types": "dist/index.d.ts",
		"exports": { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } },
		"files": ["dist"],
		"scripts": { "build": "tsc" },
		"peerDependencies": { "@wiredwp/robinpath": ">=0.20.0" },
		"devDependencies": { "@wiredwp/robinpath": "^0.30.1", "typescript": "^5.6.0" }
		"exports": {
		".": {
		"import": "./dist/index.js",
		"types": "./dist/index.d.ts"
		}
		},
		"files": [
		"dist"
		],
		"scripts": {
		"build": "tsc"
		},
		"peerDependencies": {
		"@robinpath/core": ">=0.20.0"
		},
		"devDependencies": {
		"@robinpath/core": "^0.30.1",
		"typescript": "^5.6.0"
		},
		"description": "Slack Web API and Incoming Webhooks client for messaging, channels, reactions, file uploads, and user management",
		"keywords": [
		"slack",
		"messaging",
		"api",
		"webhook"
		],
		"license": "MIT",
		"robinpath": {
		"category": "messaging",
		"type": "integration",
		"auth": "bearer-token",
		"functionCount": 12,
		"baseUrl": "https://slack.com"
		}
		}

-6

dist/index.d.ts

		import type { ModuleAdapter } from "@wiredwp/robinpath";
		declare const SlackModule: ModuleAdapter;
		export default SlackModule;
		export { SlackModule };
		export { SlackFunctions, SlackFunctionMetadata, SlackModuleMetadata } from "./slack.js";
		//# sourceMappingURL=index.d.ts.map

-1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,QAAA,MAAM,WAAW,EAAE,aAMlB,CAAC;AAEF,eAAe,WAAW,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

-12

dist/index.js

		import { SlackFunctions, SlackFunctionMetadata, SlackModuleMetadata } from "./slack.js";
		const SlackModule = {
		name: "slack",
		functions: SlackFunctions,
		functionMetadata: SlackFunctionMetadata,
		moduleMetadata: SlackModuleMetadata,
		global: false,
		}; // as ModuleAdapter
		export default SlackModule;
		export { SlackModule };
		export { SlackFunctions, SlackFunctionMetadata, SlackModuleMetadata } from "./slack.js";
		//# sourceMappingURL=index.js.map

-1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAExF,MAAM,WAAW,GAAkB;IACjC,IAAI,EAAE,OAAO;IACb,SAAS,EAAE,cAAc;IACzB,gBAAgB,EAAE,qBAA4B;IAC9C,cAAc,EAAE,mBAA0B;IAC1C,MAAM,EAAE,KAAK;CACd,CAAC,CAAC,mBAAmB;AAEtB,eAAe,WAAW,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

-165

dist/slack.d.ts

		import type { BuiltinHandler } from "@wiredwp/robinpath";
		export declare const SlackFunctions: Record<string, BuiltinHandler>;
		export declare const SlackFunctionMetadata: {
		setToken: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		send: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		sendWebhook: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		reply: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		react: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		upload: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		listChannels: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		getHistory: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		setStatus: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		userInfo: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		createChannel: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		updateMessage: {
		description: string;
		parameters: {
		name: string;
		dataType: string;
		description: string;
		formInputType: string;
		required: boolean;
		}[];
		returnType: string;
		returnDescription: string;
		example: string;
		};
		};
		export declare const SlackModuleMetadata: {
		description: string;
		methods: string[];
		};
		//# sourceMappingURL=slack.d.ts.map

-1

dist/slack.d.ts.map

{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../src/slack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAoC,MAAM,oBAAoB,CAAC;AAyW3F,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAazD,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2IjC,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;CAgB/B,CAAC"}

-455

dist/slack.js

		import { readFileSync, statSync } from "node:fs";
		import { basename } from "node:path";
		const workspaces = new Map();
		// ── Helper ──────────────────────────────────────────────────────────
		async function callSlackApi(workspaceId, method, body) {
		const config = workspaces.get(workspaceId);
		if (!config) {
		throw new Error(`Workspace "${workspaceId}" not configured. Call slack.setToken first.`);
		}
		const response = await fetch(`https://slack.com/api/${method}`, {
		method: "POST",
		headers: {
		Authorization: `Bearer ${config.token}`,
		"Content-Type": "application/json",
		},
		body: JSON.stringify(body),
		});
		const result = (await response.json());
		if (!result.ok) {
		throw new Error(`Slack API ${method} failed: ${String(result.error ?? "unknown_error")}`);
		}
		return result;
		}
		// ── Function Handlers ───────────────────────────────────────────────
		const setToken = (args) => {
		const workspaceId = String(args[0] ?? "default");
		const token = String(args[1] ?? "");
		const opts = (typeof args[2] === "object" && args[2] !== null ? args[2] : {});
		if (!token)
		throw new Error("Token is required");
		workspaces.set(workspaceId, {
		token,
		defaultChannel: String(opts.defaultChannel ?? "general"),
		});
		return { workspaceId, defaultChannel: opts.defaultChannel ?? "general" };
		};
		const send = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const text = String(args[2] ?? "");
		const opts = (typeof args[3] === "object" && args[3] !== null ? args[3] : {});
		if (!channel) {
		const config = workspaces.get(workspaceId);
		if (!config)
		throw new Error("Channel is required");
		}
		const body = {
		channel: channel \|\| workspaces.get(workspaceId)?.defaultChannel \|\| "general",
		text,
		};
		if (opts.blocks)
		body.blocks = opts.blocks;
		if (opts.unfurlLinks !== undefined)
		body.unfurl_links = Boolean(opts.unfurlLinks);
		if (opts.threadTs)
		body.thread_ts = String(opts.threadTs);
		const result = (await callSlackApi(workspaceId, "chat.postMessage", body));
		return { ts: result.ts, channel: result.channel };
		};
		const sendWebhook = async (args) => {
		const webhookUrl = String(args[0] ?? "");
		const text = String(args[1] ?? "");
		const opts = (typeof args[2] === "object" && args[2] !== null ? args[2] : {});
		if (!webhookUrl)
		throw new Error("Webhook URL is required");
		const body = { text };
		if (opts.username)
		body.username = String(opts.username);
		if (opts.iconEmoji)
		body.icon_emoji = String(opts.iconEmoji);
		if (opts.blocks)
		body.blocks = opts.blocks;
		if (opts.attachments)
		body.attachments = opts.attachments;
		const response = await fetch(webhookUrl, {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify(body),
		});
		if (!response.ok) {
		const errText = await response.text();
		throw new Error(`Webhook request failed (${response.status}): ${errText}`);
		}
		return { ok: true, status: response.status };
		};
		const reply = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const threadTs = String(args[2] ?? "");
		const text = String(args[3] ?? "");
		const opts = (typeof args[4] === "object" && args[4] !== null ? args[4] : {});
		if (!channel)
		throw new Error("Channel is required");
		if (!threadTs)
		throw new Error("Thread timestamp (threadTs) is required");
		const body = {
		channel,
		text,
		thread_ts: threadTs,
		};
		if (opts.blocks)
		body.blocks = opts.blocks;
		if (opts.unfurlLinks !== undefined)
		body.unfurl_links = Boolean(opts.unfurlLinks);
		const result = (await callSlackApi(workspaceId, "chat.postMessage", body));
		return { ts: result.ts, channel: result.channel };
		};
		const react = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const timestamp = String(args[2] ?? "");
		const emoji = String(args[3] ?? "");
		if (!channel)
		throw new Error("Channel is required");
		if (!timestamp)
		throw new Error("Message timestamp is required");
		if (!emoji)
		throw new Error("Emoji name is required");
		// Strip colons if provided (e.g. ":thumbsup:" -> "thumbsup")
		const emojiName = emoji.replace(/^:\|:$/g, "");
		await callSlackApi(workspaceId, "reactions.add", {
		channel,
		timestamp,
		name: emojiName,
		});
		return { ok: true, channel, timestamp, emoji: emojiName };
		};
		const upload = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const filePath = String(args[2] ?? "");
		const opts = (typeof args[3] === "object" && args[3] !== null ? args[3] : {});
		if (!channel)
		throw new Error("Channel is required");
		if (!filePath)
		throw new Error("File path is required");
		const config = workspaces.get(workspaceId);
		if (!config) {
		throw new Error(`Workspace "${workspaceId}" not configured. Call slack.setToken first.`);
		}
		// Read file
		const fileData = readFileSync(filePath);
		const fileName = opts.title ? String(opts.title) : basename(filePath);
		const fileSize = statSync(filePath).size;
		// Step 1: Get upload URL
		const uploadUrlResult = (await callSlackApi(workspaceId, "files.getUploadURLExternal", {
		filename: fileName,
		length: fileSize,
		}));
		const uploadUrl = String(uploadUrlResult.upload_url);
		const fileId = String(uploadUrlResult.file_id);
		// Step 2: PUT file data to the upload URL
		const putResponse = await fetch(uploadUrl, {
		method: "PUT",
		headers: { "Content-Type": "application/octet-stream" },
		body: fileData,
		});
		if (!putResponse.ok) {
		throw new Error(`File upload PUT failed (${putResponse.status}): ${await putResponse.text()}`);
		}
		// Step 3: Complete the upload
		const completeBody = {
		files: [{ id: fileId, title: fileName }],
		channel_id: channel,
		};
		if (opts.initialComment) {
		completeBody.initial_comment = String(opts.initialComment);
		}
		const completeResult = (await callSlackApi(workspaceId, "files.completeUploadExternal", completeBody));
		return {
		ok: true,
		fileId,
		files: completeResult.files,
		};
		};
		const listChannels = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const opts = (typeof args[1] === "object" && args[1] !== null ? args[1] : {});
		const body = {
		limit: Number(opts.limit ?? 200),
		};
		if (opts.types)
		body.types = String(opts.types); // e.g. "public_channel,private_channel"
		const result = (await callSlackApi(workspaceId, "conversations.list", body));
		const channels = result.channels ?? [];
		return channels.map((ch) => ({
		id: ch.id,
		name: ch.name,
		topic: ch.topic?.value ?? "",
		}));
		};
		const getHistory = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const opts = (typeof args[2] === "object" && args[2] !== null ? args[2] : {});
		if (!channel)
		throw new Error("Channel is required");
		const body = {
		channel,
		limit: Number(opts.limit ?? 20),
		};
		if (opts.oldest)
		body.oldest = String(opts.oldest);
		if (opts.latest)
		body.latest = String(opts.latest);
		const result = (await callSlackApi(workspaceId, "conversations.history", body));
		return result.messages ?? [];
		};
		const setStatus = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const text = String(args[1] ?? "");
		const emoji = String(args[2] ?? "");
		const opts = (typeof args[3] === "object" && args[3] !== null ? args[3] : {});
		const profile = {
		status_text: text,
		status_emoji: emoji,
		};
		if (opts.expiration) {
		profile.status_expiration = Number(opts.expiration);
		}
		const result = (await callSlackApi(workspaceId, "users.profile.set", {
		profile,
		}));
		return { ok: true, profile: result.profile };
		};
		const userInfo = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const userId = String(args[1] ?? "");
		if (!userId)
		throw new Error("User ID is required");
		const result = (await callSlackApi(workspaceId, "users.info", {
		user: userId,
		}));
		const user = result.user;
		const profile = (user.profile ?? {});
		return {
		id: user.id,
		name: user.name,
		real_name: user.real_name,
		email: profile.email ?? null,
		is_admin: user.is_admin ?? false,
		};
		};
		const createChannel = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const name = String(args[1] ?? "");
		const opts = (typeof args[2] === "object" && args[2] !== null ? args[2] : {});
		if (!name)
		throw new Error("Channel name is required");
		const body = {
		name,
		};
		if (opts.isPrivate)
		body.is_private = true;
		const result = (await callSlackApi(workspaceId, "conversations.create", body));
		const channel = result.channel;
		return {
		id: channel.id,
		name: channel.name,
		is_private: channel.is_private ?? false,
		};
		};
		const updateMessage = async (args) => {
		const workspaceId = String(args[0] ?? "default");
		const channel = String(args[1] ?? "");
		const ts = String(args[2] ?? "");
		const text = String(args[3] ?? "");
		const opts = (typeof args[4] === "object" && args[4] !== null ? args[4] : {});
		if (!channel)
		throw new Error("Channel is required");
		if (!ts)
		throw new Error("Message timestamp (ts) is required");
		const body = {
		channel,
		ts,
		text,
		};
		if (opts.blocks)
		body.blocks = opts.blocks;
		const result = (await callSlackApi(workspaceId, "chat.update", body));
		return { ts: result.ts, channel: result.channel, text: result.text };
		};
		// ── Exports ─────────────────────────────────────────────────────────
		export const SlackFunctions = {
		setToken,
		send,
		sendWebhook,
		reply,
		react,
		upload,
		listChannels,
		getHistory,
		setStatus,
		userInfo,
		createChannel,
		updateMessage,
		};
		export const SlackFunctionMetadata = {
		setToken: {
		description: "Store a Slack Bot User OAuth Token for a workspace",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier (e.g. 'default')", formInputType: "text", required: true },
		{ name: "token", dataType: "string", description: "Bot User OAuth Token (xoxb-...)", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{defaultChannel?: string}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{workspaceId, defaultChannel}",
		example: 'slack.setToken "default" "xoxb-your-token" {"defaultChannel": "general"}',
		},
		send: {
		description: "Send a message to a Slack channel via chat.postMessage",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID or name", formInputType: "text", required: true },
		{ name: "text", dataType: "string", description: "Message text", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{blocks?, unfurlLinks?, threadTs?}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ts, channel}",
		example: 'slack.send "default" "#general" "Hello from RobinPath!"',
		},
		sendWebhook: {
		description: "Send a message via a Slack Incoming Webhook URL (no token needed)",
		parameters: [
		{ name: "webhookUrl", dataType: "string", description: "Incoming Webhook URL", formInputType: "text", required: true },
		{ name: "text", dataType: "string", description: "Message text", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{username?, iconEmoji?, blocks?}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ok, status}",
		example: 'slack.sendWebhook "https://hooks.slack.com/services/T.../B.../xxx" "Deploy complete!"',
		},
		reply: {
		description: "Reply to a message thread via chat.postMessage with thread_ts",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID", formInputType: "text", required: true },
		{ name: "threadTs", dataType: "string", description: "Parent message timestamp", formInputType: "text", required: true },
		{ name: "text", dataType: "string", description: "Reply text", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{blocks?, unfurlLinks?}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ts, channel}",
		example: 'slack.reply "default" "C01234" "1234567890.123456" "Got it, thanks!"',
		},
		react: {
		description: "Add an emoji reaction to a message via reactions.add",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID", formInputType: "text", required: true },
		{ name: "timestamp", dataType: "string", description: "Message timestamp", formInputType: "text", required: true },
		{ name: "emoji", dataType: "string", description: "Emoji name (e.g. 'thumbsup' or ':thumbsup:')", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "{ok, channel, timestamp, emoji}",
		example: 'slack.react "default" "C01234" "1234567890.123456" "thumbsup"',
		},
		upload: {
		description: "Upload a file to a Slack channel using the new file upload API",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID to share the file in", formInputType: "text", required: true },
		{ name: "filePath", dataType: "string", description: "Local path to the file", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{title?, initialComment?}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ok, fileId, files}",
		example: 'slack.upload "default" "C01234" "./report.pdf" {"title": "Report", "initialComment": "Here is the report"}',
		},
		listChannels: {
		description: "List Slack channels via conversations.list",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{types?, limit?}. types: 'public_channel,private_channel'", formInputType: "text", required: false },
		],
		returnType: "array",
		returnDescription: "Array of {id, name, topic}",
		example: 'slack.listChannels "default" {"limit": 50}',
		},
		getHistory: {
		description: "Get message history for a channel via conversations.history",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{limit?, oldest?, latest?}", formInputType: "text", required: false },
		],
		returnType: "array",
		returnDescription: "Array of message objects",
		example: 'slack.getHistory "default" "C01234" {"limit": 10}',
		},
		setStatus: {
		description: "Set the authenticated user's status via users.profile.set",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "text", dataType: "string", description: "Status text", formInputType: "text", required: true },
		{ name: "emoji", dataType: "string", description: "Status emoji (e.g. ':house_with_garden:')", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{expiration?: number} — Unix timestamp when status expires", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ok, profile}",
		example: 'slack.setStatus "default" "Working from home" ":house_with_garden:"',
		},
		userInfo: {
		description: "Get user information via users.info",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "userId", dataType: "string", description: "Slack user ID (e.g. 'U01234')", formInputType: "text", required: true },
		],
		returnType: "object",
		returnDescription: "{id, name, real_name, email, is_admin}",
		example: 'slack.userInfo "default" "U01234ABC"',
		},
		createChannel: {
		description: "Create a new Slack channel via conversations.create",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "name", dataType: "string", description: "Channel name (lowercase, no spaces)", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{isPrivate?: boolean}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{id, name, is_private}",
		example: 'slack.createChannel "default" "project-updates" {"isPrivate": true}',
		},
		updateMessage: {
		description: "Update an existing message via chat.update",
		parameters: [
		{ name: "workspaceId", dataType: "string", description: "Workspace identifier", formInputType: "text", required: true },
		{ name: "channel", dataType: "string", description: "Channel ID", formInputType: "text", required: true },
		{ name: "ts", dataType: "string", description: "Timestamp of the message to update", formInputType: "text", required: true },
		{ name: "text", dataType: "string", description: "New message text", formInputType: "text", required: true },
		{ name: "options", dataType: "object", description: "{blocks?}", formInputType: "text", required: false },
		],
		returnType: "object",
		returnDescription: "{ts, channel, text}",
		example: 'slack.updateMessage "default" "C01234" "1234567890.123456" "Updated message text"',
		},
		};
		export const SlackModuleMetadata = {
		description: "Slack Web API and Incoming Webhooks client for messaging, channels, reactions, file uploads, and user management",
		methods: [
		"setToken",
		"send",
		"sendWebhook",
		"reply",
		"react",
		"upload",
		"listChannels",
		"getHistory",
		"setStatus",
		"userInfo",
		"createChannel",
		"updateMessage",
		],
		};
		//# sourceMappingURL=slack.js.map

-1

dist/slack.js.map

@robinpath/slack - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics