@joe-broadhead/opencode-slack 0.0.0 → 0.0.2

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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
+
+- A `jelly` section in `package.json`: each tool with its permission, its default effect and whether it only reads, the skill ids. Jelly reads it without loading the plugin and applies the declared asks, because its agents have no base allow rule for this plugin's own default rules to follow. `docs/jelly.md` explains it.
+- `title` and `signIns` in the `jelly` section: the name Jelly shows on the plugin's card, and what the plugin signs in to, so that one card can say whether each sign-in is connected and start, renew or end it. `docs/jelly.md` lists them.
+- Hosted callbacks, so sign-in works when OpenCode runs on another machine ([#1](https://github.com/joe-broadhead/opencode-slack/issues/1)): `oauth.redirect_uri` also accepts an `https:` URL with a path and no credentials, query or fragment, together with the new `oauth.callback_port`, the port of OpenCode's local callback listener, which a reverse proxy forwards the address to. The server config then carries `callback_port`, and status shows the port in `callbackPort` and its `Callback` row. `oauth.callback_port` is refused with a loopback redirect, whose own port is the listener's. The docs explain how to add a hosted address to the Slack app's Redirect URLs, and how two sign-ins on one machine avoid colliding on port 8765.
+- `presetBy` on the `jelly.signIns` Slack app step: with `oauth.client_id` set in the plugin options, the step is done, so Jelly asks nobody to paste a client ID.
+
+### Changed
+
+- The `oauth.redirect_uri` errors say which rule an `http:` URL broke, and their next step names both a loopback and a hosted example. The `Callback` status row says to register the URL in the app's Redirect URLs.
+
 ## [0.0.0] - 2026-11-01
 
 ### Added

package/README.md

@@ -21,7 +21,7 @@ opencode plugin add @joe-broadhead/opencode-slack
 
    If your organisation already set the client ID for you (see [Organisation rollout](#organisation-rollout)), there is no **Slack app** entry; go straight to step 2.
 2. **Sign in to Slack.** Run `/connect` and choose **Slack**. In the TUI, press `o` or Enter to open the sign-in page in your browser. In a terminal, `opencode mcp auth slack` opens the browser automatically. `/mcps` → `slack` is an equivalent way in.
-3. Slack shows the workspace, the account and what the app asks for. Approve it. Slack sends the browser back to `http://localhost:8765/callback`, and OpenCode finishes the sign-in.
+3. Slack shows the workspace, the account and what the app asks for. Approve it. Slack sends the browser back to the callback, `http://localhost:8765/callback` unless you set another, and OpenCode finishes the sign-in.
 
 `/slack-status` now shows `connected` and the Slack tools it found. OpenCode stores the credential and refreshes it. To sign out, run `opencode mcp logout slack`.
 
@@ -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`.
@@ -106,7 +117,7 @@ Do not put this block in the top-level `permissions`. OpenCode adds top-level ru
 
 ## Configure
 
-Everything works without options. Options set the client ID for everyone (instead of `/connect`), the callback URL, the scopes, a client secret for apps without PKCE, the server name and the host check. To pass them, use the object form of the `plugins` entry:
+Everything works without options. Options set the client ID for everyone (instead of `/connect`), the callback URL and its local port, the scopes, a client secret for apps without PKCE, the server name and the host check. To pass them, use the object form of the `plugins` entry:
 
 ```jsonc
 {
@@ -116,6 +127,14 @@ Everything works without options. Options set the client ID for everyone (instea
 }
 ```
 
+**OpenCode on another machine.** The default callback, `http://localhost:8765/callback`, works only when the browser runs on OpenCode's machine. Otherwise use a hosted callback: an `https:` address the browser can reach, which a reverse proxy forwards to OpenCode's local listener on `oauth.callback_port`:
+
+```jsonc
+"oauth": { "client_id": "YOUR_SLACK_CLIENT_ID", "redirect_uri": "https://host.example/oauth/return", "callback_port": 8766 }
+```
+
+Add the address to the Slack app's **OAuth & Permissions → Redirect URLs** (or `oauth_config.redirect_urls` in the [manifest](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/slack-app-manifest.json)). Slack matches the host and port exactly. [The callback: loopback or hosted](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/configuration.md#the-callback-loopback-or-hosted) explains the proxy and how two sign-ins on one machine avoid colliding on port 8765.
+
 [docs/configuration.md](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/configuration.md) lists every option, the scopes each tool needs, the permission rules and the status model.
 
 ## Organisation rollout
@@ -158,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**.
@@ -165,6 +186,8 @@ If status itself cannot be read, `/slack-status` says `STATUS_UNAVAILABLE`; run
 - **Slack asks you to request approval:** your workspace requires admin approval for apps or scopes. Ask an admin to approve the app, then sign in again.
 - **Slack refuses the app for MCP:** turn on **Agents → Slack Model Context Protocol (MCP) Server** in the app settings. The app must be internal to your organisation or published in the Slack Marketplace.
 - **The browser cannot open `localhost:8765` after Slack approves:** OpenCode listens for the callback on `127.0.0.1` only. If your browser tries IPv6 for `localhost`, replace `localhost` with `127.0.0.1` in the address bar. To avoid it, register `http://127.0.0.1:8765/callback` in the app and set it as `oauth.redirect_uri`.
+- **The browser cannot open `localhost:8765` because OpenCode runs on another machine:** the browser's `localhost` is not OpenCode's. Use a [hosted callback](https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/configuration.md#the-callback-loopback-or-hosted).
+- **Sign-in fails because the callback port is in use:** another sign-in on this machine is waiting on port 8765. Finish it first, or give this OpenCode its own callback, such as `http://localhost:8767/callback`, registered in the Slack app too.
 
 **A Slack tool fails**
 

package/dist/index.js

@@ -3,6 +3,8 @@ import { Plugin } from "@opencode/plugin";
 
 // src/defaults.ts
 var DEFAULT_REDIRECT_URI = "http://localhost:8765/callback";
+var HOSTED_REDIRECT_EXAMPLE = "https://host.example/oauth/return";
+var CALLBACK_PORT_EXAMPLE = 8766;
 var DEFAULT_SCOPES = ["channels:history", "channels:read", "search:read.public", "users:read"];
 var DEFAULT_SERVER = "slack";
 var APP_MANIFEST_URL = "https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/slack-app-manifest.json";
@@ -41,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 };
@@ -94,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", "scopes", "client_secret"];
+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 {
@@ -108,62 +458,77 @@ function redirectProblem(value) {
   } catch {
     return "Must be a valid URL.";
   }
-  if (url.protocol !== "http:") return "Must use http:.";
-  if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1") return "Must use the host localhost or 127.0.0.1.";
-  if (url.port === "") return "Must include an explicit port.";
+  if (url.protocol !== "http:" && url.protocol !== "https:") return "Must use http: or https:.";
+  if (url.protocol === "http:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+    return "An http: URL must use the host localhost or 127.0.0.1.";
+  }
+  if (url.protocol === "http:" && url.port === "") return "An http: URL must include an explicit port.";
   if (url.username !== "" || url.password !== "") return "Must not include credentials.";
   if (value.includes("?") || value.includes("#")) return "Must not include a query or fragment.";
   if (url.pathname === "/") return "Must include a path, such as /callback.";
   return void 0;
 }
+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 the loopback URL registered in your Slack app, for example ${DEFAULT_REDIRECT_URI}.`);
+    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 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 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 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,
     options: {
       ...clientId === void 0 ? {} : { clientId },
       redirectUri,
+      ...callbackPort === void 0 ? {} : { callbackPort },
       scopes: [...scopes],
       ...clientSecret === void 0 ? {} : { clientSecret },
       server,
@@ -172,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 [
@@ -233,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"]
@@ -245,12 +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" },
@@ -258,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: {} }
     }
@@ -280,6 +611,7 @@ function serverConfig(options, client) {
     oauth: {
       client_id: client.id,
       redirect_uri: options.redirectUri,
+      ...options.callbackPort === void 0 ? {} : { callback_port: options.callbackPort },
       scope: options.scopes.join(" "),
       ...client.secret === void 0 ? {} : { client_secret: client.secret }
     }
@@ -348,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." };
   }
@@ -402,6 +734,7 @@ function buildStatus(input) {
         client: { id: client.id, mode: client.secret === void 0 ? "public_pkce" : "confidential", source: client.source }
       },
       callback: options.redirectUri,
+      ...options.callbackPort === void 0 ? {} : { callbackPort: options.callbackPort },
       scopes: options.scopes
     },
     asksBefore: ASKS_BEFORE,
@@ -441,7 +774,12 @@ 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";
+  if (port === void 0) return `${callback} (${register})`;
+  return `${callback} (${register}, and forward it to http://127.0.0.1:${port}${new URL(callback).pathname}, where OpenCode listens)`;
 }
 var CLIENT_SOURCE = { options: "set in plugin options", connect: "saved in /connect" };
 function stateLabel(status2) {
@@ -477,7 +815,7 @@ function statusRows(status2) {
     const mode = status2.client.mode === "public_pkce" ? "public, PKCE" : "confidential, secret set";
     rows.push({ label: "Client", value: `${status2.client.id} (${mode}; ${CLIENT_SOURCE[status2.client.source]})` });
   }
-  if (status2.callback !== void 0) rows.push({ label: "Callback", value: `${status2.callback} (register exactly this URL in the Slack app)` });
+  if (status2.callback !== void 0) rows.push({ label: "Callback", value: callbackRow(status2.callback, status2.callbackPort) });
   if (status2.scopes !== void 0) rows.push({ label: "Scopes", value: status2.scopes.join(" ") });
   rows.push({
     label: "Tools",
@@ -600,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",
@@ -613,6 +953,7 @@ var src_default = Plugin.define({
     return async () => {
       stopped.abort();
       await cleanup();
+      await stopTools();
     };
   }
 });

package/dist/tui.js

@@ -25,6 +25,7 @@ var status = object({
   server: object({ name: text, url: text }, ["name", "url"]),
   client: object({ 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({
@@ -85,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) {
@@ -97,6 +100,11 @@ function defaultRules(server) {
 // src/status.ts
 var quote = (rule) => `{ "action": "${rule.action}", "resource": "${rule.resource}", "effect": "${rule.effect}" }`;
 var remedy = (server) => `[${defaultRules(server).map(quote).join(", ")}]`;
+function callbackRow(callback, port) {
+  const register = "register exactly this URL in the app's Redirect URLs";
+  if (port === void 0) return `${callback} (${register})`;
+  return `${callback} (${register}, and forward it to http://127.0.0.1:${port}${new URL(callback).pathname}, where OpenCode listens)`;
+}
 var CLIENT_SOURCE = { options: "set in plugin options", connect: "saved in /connect" };
 function stateLabel(status2) {
   switch (status2.state) {
@@ -131,7 +139,7 @@ function statusRows(status2) {
     const mode = status2.client.mode === "public_pkce" ? "public, PKCE" : "confidential, secret set";
     rows.push({ label: "Client", value: `${status2.client.id} (${mode}; ${CLIENT_SOURCE[status2.client.source]})` });
   }
-  if (status2.callback !== void 0) rows.push({ label: "Callback", value: `${status2.callback} (register exactly this URL in the Slack app)` });
+  if (status2.callback !== void 0) rows.push({ label: "Callback", value: callbackRow(status2.callback, status2.callbackPort) });
   if (status2.scopes !== void 0) rows.push({ label: "Scopes", value: status2.scopes.join(" ") });
   rows.push({
     label: "Tools",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joe-broadhead/opencode-slack",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Unofficial OpenCode plugin for Slack",
   "keywords": [
     "opencode",
@@ -55,5 +55,201 @@
     "esbuild": "0.28.2",
     "solid-js": "1.9.17",
     "typescript": "5.9.3"
+  },
+  "jelly": {
+    "title": "Slack",
+    "tools": [
+      {
+        "name": "slack.slack_search_public",
+        "permission": "slack_slack_search_public",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_search_channels",
+        "permission": "slack_slack_search_channels",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_search_users",
+        "permission": "slack_slack_search_users",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_channel",
+        "permission": "slack_slack_read_channel",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_thread",
+        "permission": "slack_slack_read_thread",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_user_profile",
+        "permission": "slack_slack_read_user_profile",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_canvas",
+        "permission": "slack_slack_read_canvas",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_list_channel_members",
+        "permission": "slack_slack_list_channel_members",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_get_reactions",
+        "permission": "slack_slack_get_reactions",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_list_user_channels",
+        "permission": "slack_slack_list_user_channels",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_list",
+        "permission": "slack_slack_read_list",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_search_emojis",
+        "permission": "slack_slack_search_emojis",
+        "effect": "allow",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_search_public_and_private",
+        "permission": "slack_slack_search_public_and_private",
+        "effect": "ask",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_read_file",
+        "permission": "slack_slack_read_file",
+        "effect": "ask",
+        "readOnly": true
+      },
+      {
+        "name": "slack.slack_send_message",
+        "permission": "slack_slack_send_message",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_send_message_draft",
+        "permission": "slack_slack_send_message_draft",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_schedule_message",
+        "permission": "slack_slack_schedule_message",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_create_canvas",
+        "permission": "slack_slack_create_canvas",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_update_canvas",
+        "permission": "slack_slack_update_canvas",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_add_reaction",
+        "permission": "slack_slack_add_reaction",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_get_file_upload_url",
+        "permission": "slack_slack_get_file_upload_url",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_complete_file_upload",
+        "permission": "slack_slack_complete_file_upload",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_create_conversation",
+        "permission": "slack_slack_create_conversation",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_create_list",
+        "permission": "slack_slack_create_list",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_update_list",
+        "permission": "slack_slack_update_list",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_add_list_record",
+        "permission": "slack_slack_add_list_record",
+        "effect": "ask",
+        "readOnly": false
+      },
+      {
+        "name": "slack.slack_update_list_record",
+        "permission": "slack_slack_update_list_record",
+        "effect": "ask",
+        "readOnly": false
+      }
+    ],
+    "skills": [
+      "slack-search"
+    ],
+    "rpc": [],
+    "views": [],
+    "signIns": [
+      {
+        "id": "app",
+        "label": "Slack app",
+        "integration": "slack-app",
+        "presetBy": "oauth.client_id",
+        "help": {
+          "url": "https://github.com/joe-broadhead/opencode-slack/blob/HEAD/docs/slack-app-manifest.json",
+          "label": "Create the Slack app from its manifest, then paste its client ID"
+        }
+      },
+      {
+        "id": "slack",
+        "label": "Slack",
+        "server": "slack",
+        "after": "app"
+      }
+    ],
+    "contributes": {
+      "homeFeeds": [],
+      "homeWidgets": [],
+      "workKinds": [],
+      "settings": []
+    }
   }
 }

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 |