@joe-broadhead/opencode-slack 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.2] - 2026-11-03
+
+### Added
+
+- The tools RPC, `slack.workspace.tools`: a script can call Slack's twelve reads, `slack_search_public_and_private` and `slack_read_file` with no model, through `opencode api`, as a session and its agent. It gets exactly the access that agent's model has: a tool its rules hide is refused, OpenCode checks each call against the agent's and the session's rules, and an ask is refused at once because no one is there to answer it, so the private search and the file read need an allow rule. `describe` lists the methods with each tool's live input schema. Slack's writes and sends, and any tool Slack adds later, are never methods. `docs/scripting.md` explains it.
+
 ## [0.0.1] - 2026-11-03
 
 ### Added

package/README.md

@@ -42,6 +42,17 @@ The Slack tools are Slack's own. With Code Mode, which is on by default, agents
 - `OpenCode`: the version and the tested range;
 - `Next step`: exactly one, or `Nothing to do.`
 
+### Scripts
+
+A script or a cron job can call Slack's fourteen read tools with no model, through `opencode api`. It runs as a session and its agent, under that agent's permission rules and the session's own. The private search and the file read ask by default, so a script needs an allow rule for them. Writes and sends are never available to scripts:
+
+```sh
+opencode api post /api/rpc/slack.workspace.tools/slack_search_public \
+  -d '{"input":{"sessionID":"ses_…","input":{"keywords":["launch"]}}}'
+```
+
+See [Scripting](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/scripting.md).
+
 ## Permissions
 
 **What runs without asking:** the known read tools: `slack_search_public`, `slack_search_channels`, `slack_search_users`, `slack_read_channel`, `slack_read_thread`, `slack_read_user_profile`, `slack_read_canvas`, `slack_list_channel_members`, `slack_get_reactions`, `slack_list_user_channels`, `slack_read_list` and `slack_search_emojis`.
@@ -166,6 +177,8 @@ Run `/slack-status` (or `/slack` in the TUI) first. Its `Connection` row shows a
 
 If status itself cannot be read, `/slack-status` says `STATUS_UNAVAILABLE`; run it again in a moment.
 
+A script's errors from the tools RPC have their own codes, listed in [Scripting](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/scripting.md#errors).
+
 **Slack shows an error during sign-in**
 
 - **`bad_redirect_uri`, or "redirect_uri did not match":** the app does not list the callback URL exactly. Add the `Callback` URL that status shows under **OAuth & Permissions → Redirect URLs**.

package/dist/index.js

@@ -43,14 +43,14 @@ async function resolveClient(integration, options) {
     return { client: { id: options.clientId, ...options.clientSecret === void 0 ? {} : { secret: options.clientSecret }, source: "options" }, invalid: false };
   }
   const integrationID = appIntegrationID(options.server);
-  const connection2 = await integration.connection.active(integrationID);
-  const stored = connection2 === void 0 ? void 0 : await integration.connection.resolve(connection2);
-  if (connection2 !== void 0 && stored?.type === "key") {
+  const connection3 = await integration.connection.active(integrationID);
+  const stored = connection3 === void 0 ? void 0 : await integration.connection.resolve(connection3);
+  if (connection3 !== void 0 && stored?.type === "key") {
     const id = stored.key.trim();
     const valid = NO_SPACES.test(id);
     await integration.connection.status({
       integrationID,
-      connection: connection2,
+      connection: connection3,
       status: valid ? void 0 : { status: "needs_auth", message: "This is not a Slack client ID: it is empty or has spaces." }
     }).catch(() => void 0);
     if (!valid) return { invalid: true };
@@ -96,13 +96,361 @@ function isTestedHost(version) {
   return compare(host, bounds.slice(0, 3)) >= 0 && compare(host, bounds.slice(3)) < 0;
 }
 
+// src/host/tools-rpc.ts
+import { randomUUID } from "node:crypto";
+import { Rpc } from "@opencode/plugin/rpc";
+
+// src/tools.ts
+var KNOWN = {
+  slack_search_public: "read",
+  slack_search_channels: "read",
+  slack_search_users: "read",
+  slack_read_channel: "read",
+  slack_read_thread: "read",
+  slack_read_user_profile: "read",
+  slack_read_canvas: "read",
+  slack_list_channel_members: "read",
+  slack_get_reactions: "read",
+  slack_list_user_channels: "read",
+  slack_read_list: "read",
+  slack_search_emojis: "read",
+  slack_search_public_and_private: "private",
+  slack_read_file: "file",
+  slack_send_message: "write",
+  slack_send_message_draft: "write",
+  slack_schedule_message: "write",
+  slack_create_canvas: "write",
+  slack_update_canvas: "write",
+  slack_add_reaction: "write",
+  slack_get_file_upload_url: "write",
+  slack_complete_file_upload: "write",
+  slack_create_conversation: "write",
+  slack_create_list: "write",
+  slack_update_list: "write",
+  slack_add_list_record: "write",
+  slack_update_list_record: "write"
+};
+var READ_TOOLS = Object.keys(KNOWN).filter((tool) => KNOWN[tool] === "read");
+var SCRIPTABLE_CLASSES = ["read", "private", "file"];
+var SCRIPTABLE_TOOLS = Object.keys(KNOWN).filter((tool) => SCRIPTABLE_CLASSES.includes(KNOWN[tool]));
+function classify(tool) {
+  return Object.hasOwn(KNOWN, tool) ? KNOWN[tool] : "unknown";
+}
+
+// src/host/tools-rpc.ts
+var PLUGIN_ID = "slack.workspace";
+var KNOWN_READS = SCRIPTABLE_TOOLS;
+function shapeResult(_method, result) {
+  return result;
+}
+var NEXT_STEPS = {
+  SESSION_UNKNOWN: `Create a session that names an agent, such as POST /api/session with {"agent":"build"}, and pass its id.`,
+  SESSION_AGENT_REQUIRED: `Create a session that names an agent, such as POST /api/session with {"agent":"build"}, and pass its id.`,
+  PERMISSION_DENIED: "Add an allow rule for the tool to the session's agent or to the session, or use a session whose agent allows it.",
+  SERVER_CONFLICT: `Remove your own server with this plugin's server name from your OpenCode config, or set this plugin's "server" option to another name.`,
+  AUTH_REQUIRED: "Run /slack-status and follow its next step to sign in to Slack.",
+  CONNECTING: "Wait a few seconds, then call the method again.",
+  CONNECTION_FAILED: "Run /slack-status and follow its next step.",
+  DISABLED: "Enable the Slack server in /mcps, then call the method again.",
+  NOT_REGISTERED: "Run /slack-status and follow its next step.",
+  TOOL_UNAVAILABLE: "Call describe to see which methods OpenCode lists now, and run /slack-status.",
+  UPSTREAM_ERROR: "Check the input against the method's schema from describe, and run /slack-status if it keeps failing.",
+  CANCELLED: "Call the method again if you still need the result."
+};
+function pluginError(_error) {
+  return void 0;
+}
+var TOOLS_RPC_ID = `${PLUGIN_ID}.tools`;
+var UNATTENDED = "A script cannot answer an approval prompt; this needs an allow rule for the session's agent.";
+var MESSAGE_ID = "msg_script";
+var UPSTREAM_LIMIT = 300;
+var object = (properties, required) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+});
+var STRING = { type: "string" };
+var ANY_OBJECT = { type: "object" };
+var NO_INPUT = object({}, []);
+var FAILED = object({ code: STRING, next: STRING }, ["code", "next"]);
+var mcpOutput = (output = {}) => object({ output, text: STRING }, ["text"]);
+var DESCRIBED = object(
+  {
+    name: STRING,
+    tool: STRING,
+    kind: { type: "string", enum: ["mcp", "plugin"] },
+    action: STRING,
+    description: STRING,
+    available: { type: "boolean" },
+    reason: STRING,
+    input: ANY_OBJECT,
+    output: ANY_OBJECT
+  },
+  ["name", "tool", "kind", "action", "description", "available", "input", "output"]
+);
+var DESCRIPTION = object({ id: STRING, call: STRING, location: STRING, methods: { type: "array", items: DESCRIBED } }, [
+  "id",
+  "call",
+  "location",
+  "methods"
+]);
+var plainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function strict(schema, issues) {
+  const keys = Object.keys(schema["properties"]);
+  const validate = (value) => {
+    if (!plainObject(value)) return { issues: [{ message: "Expected an object" }] };
+    const found = [...Object.keys(value).filter((key) => !keys.includes(key)).map((key) => `"${key}" is not allowed`), ...issues(value)];
+    return found.length === 0 ? { value } : { issues: found.map((message) => ({ message })) };
+  };
+  return Object.defineProperty({ ...schema }, "~standard", { value: { version: 1, vendor: "tools-rpc", validate }, enumerable: false });
+}
+var ScriptError = class extends Error {
+  failure;
+  constructor(failure) {
+    super(`${failure.code}: ${failure.what.replace(/[.\s]+$/, "")}. Next step: ${failure.next}`);
+    this.failure = failure;
+  }
+};
+var fail = (code, what) => new ScriptError({ code, what, next: NEXT_STEPS[code] });
+var record = (value) => typeof value === "object" && value !== null;
+function notFound(error, tags) {
+  if (!record(error)) return false;
+  const tag = error["_tag"] ?? error["name"];
+  return typeof tag === "string" && tags.includes(tag) || error["status"] === 404 || error["statusCode"] === 404;
+}
+var toolError = (error) => record(error) && error["_tag"] === "Tool.Error";
+var wildcard = (pattern, value) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`).test(value);
+var hidden = (rules, action) => rules.findLast((rule) => wildcard(rule.action, action) && wildcard(rule.resource, "*"))?.effect === "deny";
+var SECRETS = [
+  [/\b(bearer|basic|token)\s+[\w.~+/=-]{8,}/gi, "$1 [redacted]"],
+  [/\b([\w-]*(?:api[_-]?key|access[_-]?key|private[_-]?key|token|secret|password|signature|credential)["']?\s*[:=]\s*)["']?[^\s"'&,;]+["']?/gi, "$1[redacted]"],
+  [/\beyJ[\w-]{4,}\.[\w-]{4,}\.[\w-]{4,}/g, "[redacted]"],
+  [/\b(?:tvly|sk|pk|rk|ghp|gho|ghu|ghs|ghr|github_pat|glpat|xox[abposr]|lin_api|lin_oauth)[-_][\w-]{8,}/gi, "[redacted]"],
+  [/[\w+=-]{40,}/g, "[redacted]"]
+];
+var withoutQuery = (text2) => text2.replace(/\bhttps?:\/\/[^\s"'<>()]+/gi, (url) => {
+  const cut = url.search(/[?#]/);
+  return cut === -1 ? url : `${url.slice(0, cut)}?[redacted]`;
+});
+function upstreamText(text2) {
+  const line = text2.split(/\r?\n/).find((part) => part.trim() !== "")?.trim() ?? "no message";
+  const redacted = SECRETS.reduce((value, [pattern, replacement]) => value.replace(pattern, replacement), withoutQuery(line));
+  return redacted.length <= UPSTREAM_LIMIT ? redacted : `${redacted.slice(0, UPSTREAM_LIMIT - 1)}\u2026`;
+}
+var jsonSchema = (schema) => record(schema) && !("ast" in schema) && !("~standard" in schema) ? schema : void 0;
+function normalise(result) {
+  const text2 = typeof result.content === "string" ? result.content : (result.content ?? []).flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+  return result.output === void 0 ? { text: text2 } : { output: result.output, text: text2 };
+}
+function connection(status2) {
+  switch (status2) {
+    case "connected":
+      return void 0;
+    case "pending":
+      return "CONNECTING";
+    case "needs_auth":
+      return "AUTH_REQUIRED";
+    case "failed":
+      return "CONNECTION_FAILED";
+    case "disabled":
+      return "DISABLED";
+    default:
+      return "NOT_REGISTERED";
+  }
+}
+var STATUS_TEXT = {
+  CONNECTING: "is still connecting",
+  AUTH_REQUIRED: "needs a sign-in",
+  CONNECTION_FAILED: "could not connect",
+  DISABLED: "is disabled",
+  NOT_REGISTERED: "is not registered"
+};
+async function registerToolsRpc(ctx, options) {
+  const { mcp, owned = [] } = options;
+  const accounts = typeof mcp?.server === "function";
+  if (KNOWN_READS.length > 0 && !mcp) throw new Error("registerToolsRpc: KNOWN_READS needs the mcp option");
+  if (accounts && NEXT_STEPS.ACCOUNT_UNKNOWN === void 0) throw new Error("registerToolsRpc: per-account servers need NEXT_STEPS.ACCOUNT_UNKNOWN");
+  const names = [...KNOWN_READS, ...owned.map((method) => method.name)];
+  const duplicate = names.find((name, index) => name === "describe" || names.indexOf(name) !== index);
+  if (duplicate) throw new Error(`registerToolsRpc: the method name "${duplicate}" is taken`);
+  const live = /* @__PURE__ */ new Set();
+  const serverOf = (account) => {
+    const server = typeof mcp.server === "function" ? mcp.server(account) : mcp.server;
+    if (server !== void 0) return server;
+    throw new ScriptError({ code: "ACCOUNT_UNKNOWN", what: `there is no account '${account}'`, next: NEXT_STEPS.ACCOUNT_UNKNOWN });
+  };
+  const session = async (sessionID) => {
+    let info;
+    try {
+      info = await ctx.session.get({ sessionID });
+    } catch (error) {
+      if (notFound(error, ["Session.NotFoundError", "SessionNotFoundError"])) throw fail("SESSION_UNKNOWN", `there is no session '${sessionID}'`);
+      throw error;
+    }
+    if (!info.agent) throw fail("SESSION_AGENT_REQUIRED", `session '${sessionID}' names no agent`);
+    let agent;
+    try {
+      agent = await ctx.agent.get({ agentID: info.agent, location: info.location });
+    } catch (error) {
+      if (notFound(error, ["Agent.NotFoundError", "AgentNotFoundError"])) throw fail("SESSION_AGENT_REQUIRED", `session '${sessionID}' names the agent '${info.agent}', which does not exist`);
+      throw error;
+    }
+    const rules = [...agent.data.permissions, ...info.permissions ?? []];
+    return { agent: info.agent, rules };
+  };
+  const unavailable = async (server, tool, connected) => {
+    const status2 = (await ctx.mcp.list()).data.find((entry) => entry.name === server)?.status.status;
+    const code = connection(status2) ?? connected;
+    if (code === "TOOL_UNAVAILABLE") return fail(code, `OpenCode does not list ${tool} on the connected "${server}" server`);
+    return fail(code, `the "${server}" server ${STATUS_TEXT[code] ?? "is unavailable"}`);
+  };
+  const denied = (action, error) => {
+    const reason = record(error) && typeof error["message"] === "string" ? error["message"] : String(error);
+    return fail("PERMISSION_DENIED", `${action} was refused for this session's agent: ${upstreamText(reason)}`);
+  };
+  const mcpTarget = (name, envelope2) => {
+    const server = serverOf(envelope2.account);
+    const action = `${server}_${name}`;
+    return {
+      action,
+      mcp: true,
+      async run(call) {
+        if (!mcp.managed(server)) throw fail("SERVER_CONFLICT", `the "${server}" server in your config is not the one this plugin manages`);
+        const tool = (await ctx.tool.list()).find((entry) => entry.id === action);
+        if (!tool) throw await unavailable(server, action, "TOOL_UNAVAILABLE");
+        let result;
+        try {
+          result = await tool.execute(envelope2.input, call);
+        } catch (error) {
+          if (error instanceof Error && error.message.startsWith(`MCP server "${server}" `)) throw await unavailable(server, action, "CONNECTION_FAILED");
+          throw error;
+        }
+        return shapeResult(name, normalise(result));
+      }
+    };
+  };
+  const ownedTarget = (spec, envelope2) => ({
+    action: spec.action,
+    mcp: false,
+    run: async (call) => await spec.run(envelope2.input, call) ?? null
+  });
+  const invoke = async (target, raw, context) => {
+    const envelope2 = raw;
+    let method;
+    try {
+      if (context.signal.aborted) throw fail("CANCELLED", "the call was cancelled");
+      method = target(envelope2);
+      const { agent, rules } = await session(envelope2.sessionID);
+      if (hidden(rules, method.action)) throw fail("PERMISSION_DENIED", `${method.action} is hidden from this session's agent by a deny rule`);
+      const call = {
+        sessionID: envelope2.sessionID,
+        agent,
+        messageID: MESSAGE_ID,
+        id: `script:${randomUUID()}`,
+        signal: context.signal,
+        progress: async () => {
+        }
+      };
+      live.add(call.id);
+      try {
+        return JSON.parse(JSON.stringify(await method.run(call)));
+      } finally {
+        live.delete(call.id);
+      }
+    } catch (error) {
+      const failure = refusal(error, method, context.signal);
+      if (!failure) throw error;
+      return context.error("failed", new ScriptError(failure).message, { code: failure.code, next: failure.next });
+    }
+  };
+  const refusal = (error, method, signal) => {
+    if (signal.aborted) return fail("CANCELLED", "the call was cancelled").failure;
+    if (error instanceof ScriptError) return error.failure;
+    const own = pluginError(error);
+    if (own || !method || !toolError(error)) return own;
+    if (error.error !== void 0) return denied(method.action, error).failure;
+    if (method.mcp) return fail("UPSTREAM_ERROR", `${method.action} failed: ${upstreamText(error.message)}`).failure;
+    return void 0;
+  };
+  const describe = async () => {
+    const tools = mcp ? await ctx.tool.list() : [];
+    const methods = [];
+    if (mcp) {
+      const server = serverOf(void 0);
+      const managed = mcp.managed(server);
+      const status2 = managed ? (await ctx.mcp.list()).data.find((entry) => entry.name === server)?.status.status : void 0;
+      for (const name of KNOWN_READS) {
+        const id = `${server}_${name}`;
+        const tool = managed ? tools.find((entry) => entry.id === id) : void 0;
+        const reason = !managed ? "SERVER_CONFLICT" : tool ? void 0 : connection(status2) ?? "TOOL_UNAVAILABLE";
+        const input = jsonSchema(tool?.input) ?? ANY_OBJECT;
+        const output = jsonSchema(tool?.output);
+        methods.push({
+          name,
+          tool: id,
+          kind: "mcp",
+          action: id,
+          description: tool?.description ?? "",
+          available: reason === void 0,
+          ...reason ? { reason } : {},
+          input,
+          output: mcpOutput(output)
+        });
+      }
+    }
+    for (const spec of owned)
+      methods.push({ name: spec.name, tool: spec.name, kind: "plugin", action: spec.action, description: spec.description, available: true, input: spec.input, output: spec.output });
+    return JSON.parse(
+      JSON.stringify({
+        id: TOOLS_RPC_ID,
+        call: `POST /api/rpc/${TOOLS_RPC_ID}/<method> with {"input":{"sessionID":"<session>",${accounts ? `"account":"<account>",` : ""}"input":<the tool's input>}}`,
+        location: ctx.location.directory,
+        methods
+      })
+    );
+  };
+  const envelope = (input, objectInput) => strict(
+    object({ sessionID: { type: "string", minLength: 1 }, ...accounts ? { account: { type: "string", minLength: 1 } } : {}, input }, ["sessionID", "input"]),
+    (value) => [
+      ...typeof value["sessionID"] === "string" && value["sessionID"] !== "" ? [] : [`"sessionID" must be a non-empty string`],
+      ...value["account"] === void 0 || typeof value["account"] === "string" && value["account"] !== "" ? [] : [`"account" must be a non-empty string`],
+      ...!("input" in value) ? [`"input" is missing`] : objectInput && !plainObject(value["input"]) ? [`"input" must be an object`] : []
+    ]
+  );
+  const contract = Rpc.define({
+    id: TOOLS_RPC_ID,
+    methods: {
+      describe: { input: NO_INPUT, output: DESCRIPTION },
+      ...Object.fromEntries(KNOWN_READS.map((name) => [name, { input: envelope(ANY_OBJECT, true), output: mcpOutput(), errors: { failed: FAILED } }])),
+      ...Object.fromEntries(owned.map((spec) => [spec.name, { input: envelope(spec.input, false), output: spec.output, errors: { failed: FAILED } }]))
+    },
+    events: {}
+  });
+  const handlers = {
+    describe: () => describe(),
+    ...Object.fromEntries(KNOWN_READS.map((name) => [name, (raw, context) => invoke((envelope2) => mcpTarget(name, envelope2), raw, context)])),
+    ...Object.fromEntries(owned.map((spec) => [spec.name, (raw, context) => invoke((envelope2) => ownedTarget(spec, envelope2), raw, context)]))
+  };
+  const registration = await ctx.rpc.register(contract, handlers);
+  const hook = await ctx.permission.hook("evaluate", (evaluation) => {
+    if (evaluation.effect !== "ask" || evaluation.source === void 0 || !live.has(evaluation.source.id)) return;
+    evaluation.effect = "deny";
+    evaluation.message = UNATTENDED;
+  });
+  return async () => {
+    await hook.dispose().catch(() => void 0);
+    await registration.dispose().catch(() => void 0);
+  };
+}
+
 // src/options.ts
 var TOP_KEYS = ["oauth", "server", "allowUntestedHost"];
 var OAUTH_KEYS = ["client_id", "redirect_uri", "callback_port", "scopes", "client_secret"];
 var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
 var NO_SPACES2 = /^\S+$/;
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var fail = (field, message, next) => ({ ok: false, error: { code: "OPTIONS_INVALID", field, message, next } });
+var fail2 = (field, message, next) => ({ ok: false, error: { code: "OPTIONS_INVALID", field, message, next } });
 function redirectProblem(value) {
   let url;
   try {
@@ -123,57 +471,57 @@ function redirectProblem(value) {
 var isPort = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 65535;
 function parseOptions(input) {
   const raw = input ?? {};
-  if (!isRecord(raw)) return fail("options", "Plugin options must be an object.", "Set options to an object, or remove them.");
+  if (!isRecord(raw)) return fail2("options", "Plugin options must be an object.", "Set options to an object, or remove them.");
   const unknownKey = Object.keys(raw).find((key) => !TOP_KEYS.includes(key));
   if (unknownKey !== void 0) {
-    return fail(unknownKey, "This option is not supported.", `Remove it. Supported options: ${TOP_KEYS.join(", ")}.`);
+    return fail2(unknownKey, "This option is not supported.", `Remove it. Supported options: ${TOP_KEYS.join(", ")}.`);
   }
   const oauth = raw.oauth ?? {};
-  if (!isRecord(oauth)) return fail("oauth", "Must be an object.", 'Set oauth to an object such as { "client_id": "..." }.');
+  if (!isRecord(oauth)) return fail2("oauth", "Must be an object.", 'Set oauth to an object such as { "client_id": "..." }.');
   const unknownOAuthKey = Object.keys(oauth).find((key) => !OAUTH_KEYS.includes(key));
   if (unknownOAuthKey !== void 0) {
-    return fail(`oauth.${unknownOAuthKey}`, "This option is not supported.", unknownOAuthKey === "redirect_port" ? `Use oauth.redirect_uri instead, for example ${DEFAULT_REDIRECT_URI}.` : `Remove it. Supported oauth options: ${OAUTH_KEYS.join(", ")}.`);
+    return fail2(`oauth.${unknownOAuthKey}`, "This option is not supported.", unknownOAuthKey === "redirect_port" ? `Use oauth.redirect_uri instead, for example ${DEFAULT_REDIRECT_URI}.` : `Remove it. Supported oauth options: ${OAUTH_KEYS.join(", ")}.`);
   }
   const clientId = oauth.client_id;
   if (clientId !== void 0 && (typeof clientId !== "string" || !NO_SPACES2.test(clientId))) {
-    return fail("oauth.client_id", "Must be a non-empty string without spaces.", "Copy the client ID from the Basic Information page of your Slack app.");
+    return fail2("oauth.client_id", "Must be a non-empty string without spaces.", "Copy the client ID from the Basic Information page of your Slack app.");
   }
   const redirectUri = oauth.redirect_uri ?? DEFAULT_REDIRECT_URI;
   const redirectError = typeof redirectUri === "string" ? redirectProblem(redirectUri) : "Must be a string.";
   if (typeof redirectUri !== "string" || redirectError !== void 0) {
-    return fail("oauth.redirect_uri", redirectError ?? "Must be a string.", `Use a URL listed in the app's Redirect URLs, for example ${DEFAULT_REDIRECT_URI} or ${HOSTED_REDIRECT_EXAMPLE}.`);
+    return fail2("oauth.redirect_uri", redirectError ?? "Must be a string.", `Use a URL listed in the app's Redirect URLs, for example ${DEFAULT_REDIRECT_URI} or ${HOSTED_REDIRECT_EXAMPLE}.`);
   }
   const hosted = new URL(redirectUri).protocol === "https:";
   const callbackPort = oauth.callback_port;
   if (callbackPort !== void 0 && !isPort(callbackPort)) {
-    return fail("oauth.callback_port", "Must be a whole number from 1 to 65535.", `Set it to the local port that receives the forwarded callback, for example ${CALLBACK_PORT_EXAMPLE}.`);
+    return fail2("oauth.callback_port", "Must be a whole number from 1 to 65535.", `Set it to the local port that receives the forwarded callback, for example ${CALLBACK_PORT_EXAMPLE}.`);
   }
   if (callbackPort !== void 0 && !hosted) {
-    return fail("oauth.callback_port", "Applies only to an https: oauth.redirect_uri.", "Remove it: with a loopback oauth.redirect_uri, OpenCode listens on that URL's port.");
+    return fail2("oauth.callback_port", "Applies only to an https: oauth.redirect_uri.", "Remove it: with a loopback oauth.redirect_uri, OpenCode listens on that URL's port.");
   }
   if (callbackPort === void 0 && hosted) {
-    return fail("oauth.callback_port", "Must be set with an https: oauth.redirect_uri.", `Set it to the local port your proxy forwards the redirect to, for example ${CALLBACK_PORT_EXAMPLE}.`);
+    return fail2("oauth.callback_port", "Must be set with an https: oauth.redirect_uri.", `Set it to the local port your proxy forwards the redirect to, for example ${CALLBACK_PORT_EXAMPLE}.`);
   }
   const scopes = oauth.scopes ?? DEFAULT_SCOPES;
   const isScope = (scope) => typeof scope === "string" && NO_SPACES2.test(scope);
   if (!Array.isArray(scopes) || scopes.length === 0 || !scopes.every(isScope)) {
-    return fail("oauth.scopes", "Must be a non-empty list of scope names without spaces.", `List Slack user scopes, for example ${JSON.stringify(DEFAULT_SCOPES)}.`);
+    return fail2("oauth.scopes", "Must be a non-empty list of scope names without spaces.", `List Slack user scopes, for example ${JSON.stringify(DEFAULT_SCOPES)}.`);
   }
-  if (new Set(scopes).size !== scopes.length) return fail("oauth.scopes", "Lists a scope more than once.", "Remove the duplicate scope.");
+  if (new Set(scopes).size !== scopes.length) return fail2("oauth.scopes", "Lists a scope more than once.", "Remove the duplicate scope.");
   const clientSecret = oauth.client_secret;
   if (clientSecret !== void 0 && (typeof clientSecret !== "string" || clientSecret === "")) {
-    return fail("oauth.client_secret", "Must be a non-empty string.", "Set it to {env:SLACK_CLIENT_SECRET} and export that variable, or remove it to use PKCE.");
+    return fail2("oauth.client_secret", "Must be a non-empty string.", "Set it to {env:SLACK_CLIENT_SECRET} and export that variable, or remove it to use PKCE.");
   }
   if (clientSecret !== void 0 && clientId === void 0) {
-    return fail("oauth.client_secret", "Needs oauth.client_id.", "Set oauth.client_id to your Slack app's client ID, or remove oauth.client_secret.");
+    return fail2("oauth.client_secret", "Needs oauth.client_id.", "Set oauth.client_id to your Slack app's client ID, or remove oauth.client_secret.");
   }
   const server = raw.server ?? DEFAULT_SERVER;
   if (typeof server !== "string" || !SERVER_NAME.test(server)) {
-    return fail("server", "Must contain only letters, digits, _ and -.", `Use a name such as "${DEFAULT_SERVER}".`);
+    return fail2("server", "Must contain only letters, digits, _ and -.", `Use a name such as "${DEFAULT_SERVER}".`);
   }
   const allowUntestedHost = raw.allowUntestedHost ?? false;
   if (typeof allowUntestedHost !== "boolean") {
-    return fail("allowUntestedHost", "Must be true or false.", "Set it to true only to run on an OpenCode version this plugin is not tested with.");
+    return fail2("allowUntestedHost", "Must be true or false.", "Set it to true only to run on an OpenCode version this plugin is not tested with.");
   }
   return {
     ok: true,
@@ -189,41 +537,6 @@ function parseOptions(input) {
   };
 }
 
-// src/tools.ts
-var KNOWN = {
-  slack_search_public: "read",
-  slack_search_channels: "read",
-  slack_search_users: "read",
-  slack_read_channel: "read",
-  slack_read_thread: "read",
-  slack_read_user_profile: "read",
-  slack_read_canvas: "read",
-  slack_list_channel_members: "read",
-  slack_get_reactions: "read",
-  slack_list_user_channels: "read",
-  slack_read_list: "read",
-  slack_search_emojis: "read",
-  slack_search_public_and_private: "private",
-  slack_read_file: "file",
-  slack_send_message: "write",
-  slack_send_message_draft: "write",
-  slack_schedule_message: "write",
-  slack_create_canvas: "write",
-  slack_update_canvas: "write",
-  slack_add_reaction: "write",
-  slack_get_file_upload_url: "write",
-  slack_complete_file_upload: "write",
-  slack_create_conversation: "write",
-  slack_create_list: "write",
-  slack_update_list: "write",
-  slack_add_list_record: "write",
-  slack_update_list_record: "write"
-};
-var READ_TOOLS = Object.keys(KNOWN).filter((tool) => KNOWN[tool] === "read");
-function classify(tool) {
-  return Object.hasOwn(KNOWN, tool) ? KNOWN[tool] : "unknown";
-}
-
 // src/permissions.ts
 function defaultRules(server) {
   return [
@@ -250,11 +563,11 @@ function insertDefaultRules(editor, server) {
 }
 
 // src/rpc.ts
-import { Rpc } from "@opencode/plugin/rpc";
+import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
 var text = { type: "string" };
 var texts = { type: "array", items: text };
-var object = (properties, required) => ({ type: "object", properties, required, additionalProperties: false });
-var status = object({
+var object2 = (properties, required) => ({ type: "object", properties, required, additionalProperties: false });
+var status = object2({
   state: { enum: ["connected", "not_signed_in", "connecting", "disabled", "failed", "not_registered", "no_client_id", "config_invalid", "host_untested"] },
   code: {
     enum: ["OPTIONS_INVALID", "SERVER_NAME_IN_USE", "HOST_UNTESTED", "CLIENT_ID_MISSING", "CLIENT_ID_INVALID", "AUTH_REQUIRED", "CONNECTION_FAILED", "SERVER_DISABLED"]
@@ -262,13 +575,13 @@ var status = object({
   message: text,
   detail: text,
   next: text,
-  server: object({ name: text, url: text }, ["name", "url"]),
-  client: object({ id: text, mode: { enum: ["public_pkce", "confidential"] }, source: { enum: ["options", "connect"] } }, ["id", "mode", "source"]),
+  server: object2({ name: text, url: text }, ["name", "url"]),
+  client: object2({ id: text, mode: { enum: ["public_pkce", "confidential"] }, source: { enum: ["options", "connect"] } }, ["id", "mode", "source"]),
   callback: text,
   callbackPort: { type: "integer" },
   scopes: texts,
   asksBefore: texts,
-  tools: object({
+  tools: object2({
     read: { type: "integer" },
     private: { type: "integer" },
     file: { type: "integer" },
@@ -276,13 +589,13 @@ var status = object({
     unknown: texts
   }, ["read", "private", "file", "write", "unknown"]),
   unguardedAgents: texts,
-  host: object({ version: text, range: text, tested: { type: "boolean" } }, ["version", "range", "tested"])
+  host: object2({ version: text, range: text, tested: { type: "boolean" } }, ["version", "range", "tested"])
 }, ["state", "message", "next", "server", "asksBefore", "tools", "unguardedAgents", "host"]);
-var SlackRpc = Rpc.define({
+var SlackRpc = Rpc2.define({
   id: "slack.workspace",
   methods: {
     status: {
-      input: object({}, []),
+      input: object2({}, []),
       output: status,
       errors: { unavailable: {} }
     }
@@ -367,7 +680,7 @@ var unknownAction = (server) => `${server}_.`;
 var NOTHING_TO_DO = "Nothing to do.";
 var quote = (rule) => `{ "action": "${rule.action}", "resource": "${rule.resource}", "effect": "${rule.effect}" }`;
 var remedy = (server) => `[${defaultRules(server).map(quote).join(", ")}]`;
-function connection(server, status2, unguarded, toolCount) {
+function connection2(server, status2, unguarded, toolCount) {
   if (status2 === void 0) {
     return { state: "not_registered", message: `The ${server} server is not registered.`, next: "Run opencode reload, then check again." };
   }
@@ -461,7 +774,7 @@ function buildStatus(input) {
     };
   }
   const status2 = input.servers.find((item) => item.name === server)?.status;
-  return { ...base, ...connection(server, status2, unguardedAgents, names.length) };
+  return { ...base, ...connection2(server, status2, unguardedAgents, names.length) };
 }
 function callbackRow(callback, port) {
   const register = "register exactly this URL in the app's Redirect URLs";
@@ -625,6 +938,8 @@ var src_default = Plugin.define({
         }
       }
     });
+    const stopTools = options === void 0 ? async () => {
+    } : await registerToolsRpc(ctx, { mcp: { server: options.server, managed: () => !nameInUse } });
     await ctx.command.transform((editor) => {
       editor.add({
         name: "slack-status",
@@ -638,6 +953,7 @@ var src_default = Plugin.define({
     return async () => {
       stopped.abort();
       await cleanup();
+      await stopTools();
     };
   }
 });

package/dist/tui.js

@@ -86,6 +86,8 @@ var KNOWN = {
   slack_update_list_record: "write"
 };
 var READ_TOOLS = Object.keys(KNOWN).filter((tool) => KNOWN[tool] === "read");
+var SCRIPTABLE_CLASSES = ["read", "private", "file"];
+var SCRIPTABLE_TOOLS = Object.keys(KNOWN).filter((tool) => SCRIPTABLE_CLASSES.includes(KNOWN[tool]));
 
 // src/permissions.ts
 function defaultRules(server) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joe-broadhead/opencode-slack",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Unofficial OpenCode plugin for Slack",
   "keywords": [
     "opencode",

package/skills/slack-search/SKILL.md

@@ -23,6 +23,10 @@ If the Slack tools are not in the listed catalog, find them with `search({ names
 
 The parameters below are the common ones. The schema that Slack serves for each tool is the source of truth; follow it if it differs.
 
+## Scripts
+
+When the user wants a job that runs without you, such as a cron job or a shell script, it can call the read tools through the OpenCode server, with no model. The RPC `slack.workspace.tools` has one method per read tool, named as the tool (for example `slack_search_public` or `slack_read_thread`), with the tool's own input, and `describe`, which lists them with their input schemas. Each call is `opencode api post /api/rpc/slack.workspace.tools/<method>` with the body `{"input":{"sessionID":"<session>","input":<the tool's input>}}`. The script runs as that session's agent, under its permission rules, so have the script create its session once with `opencode api post /api/session` and a body such as `{"title":"release digest","agent":"build"}`. An ask is refused, so `slack_search_public_and_private` and `slack_read_file` need an allow rule in the agent's or the session's `permissions`. Scripts cannot send or change anything in Slack. The details are in the plugin's `docs/scripting.md`.
+
 ## 1. Find
 
 | Need | Tool | Main parameters |