@joe-broadhead/opencode-plaud 0.0.0 → 0.0.1

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.1] - 2026-11-03
+
+### Added
+
+- The tools RPC, `plaud.recordings.tools`: a script can call Plaud's five read tools with no model, through `opencode api`, as a session and its agent, and with an optional `account` for another account. 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. Every signed link is withheld, as for the model. `describe` lists the methods with each tool's live input schema. `plaud_export` and any other Plaud tool are never methods. `docs/scripting.md` explains it.
+
 ## [0.0.0] - 2026-11-01
 
 ### Added

package/README.md

@@ -74,6 +74,17 @@ The skills are `opencode-plaud` (the tools and Plaud's data model), `opencode-pl
 
 See [SECURITY.md](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/SECURITY.md) for saved approvals and other risks.
 
+### Scripts
+
+A script or a cron job can call Plaud's five 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. Add `"account": "<alias>"` to read another account. Exports and every other Plaud tool are never available to scripts, and a script never gets a signed link:
+
+```sh
+opencode api post /api/rpc/plaud.recordings.tools/list_files \
+  -d '{"input":{"sessionID":"ses_…","input":{"page_size":10}}}'
+```
+
+See [Scripting](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/scripting.md).
+
 ## Permissions
 
 The plugin adds default rules to each agent: Plaud's read tools run without a prompt, and `plaud_export` and any other Plaud tool ask first. "Always allow" on an export remembers only that account and kind, such as `default:transcript`. Your own `permissions` rules win over the defaults.
@@ -134,7 +145,7 @@ Members then only sign in, once per account: run `/connect` and choose **Plaud**
 | `/plaud-status` and the palette command are missing | The plugin did not start. Open `/plugins` to see the error. |
 | `Permission plaud_export needs approval` | The run cannot ask. Add an `allow` rule for that export. |
 
-Errors from the plugin read `CODE: what happened. Next step: What to do.` Every code is listed in [Errors](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/configuration.md#errors).
+Errors from the plugin read `CODE: what happened. Next step: What to do.` Every code is listed in [Errors](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/configuration.md#errors). A script that uses the tools RPC has its own codes, listed in [Scripting](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/scripting.md#errors).
 
 ## Uninstall
 
@@ -151,6 +162,7 @@ Run `opencode mcp logout plaud-<alias>` for each extra account too, before you r
 
 - [Configuration](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/configuration.md)
 - [Architecture](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/architecture.md)
+- [Scripting](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/docs/scripting.md)
 - [Contributing](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/CONTRIBUTING.md)
 - [Security](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/SECURITY.md)
 - [Changelog](https://github.com/joe-broadhead/opencode-plaud/blob/HEAD/CHANGELOG.md)

package/dist/index.js

@@ -154,9 +154,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key, getter) {
+function defineLazy(object3, key, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key, {
+  Object.defineProperty(object3, key, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -168,7 +168,7 @@ function defineLazy(object2, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object2, key, {
+      Object.defineProperty(object3, key, {
         value: v
         // configurable: true,
       });
@@ -4256,8 +4256,8 @@ function foldObjects(members2) {
   }
   const properties = {};
   const required2 = /* @__PURE__ */ new Set();
-  for (const object2 of objects) {
-    for (const key in object2.properties) {
+  for (const object3 of objects) {
+    for (const key in object3.properties) {
       if (Object.prototype.hasOwnProperty.call(properties, key))
         continue;
       const parts = [];
@@ -4271,18 +4271,18 @@ function foldObjects(members2) {
       const merged = parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts };
       assignProp(properties, key, merged);
     }
-    for (const key of object2.required ?? [])
+    for (const key of object3.required ?? [])
       required2.add(key);
   }
   const folded = { type: "object", properties };
   if (required2.size)
     folded.required = [...required2];
-  if (objects.every((object2) => object2.additionalProperties === false)) {
+  if (objects.every((object3) => object3.additionalProperties === false)) {
     folded.additionalProperties = false;
   } else {
     const constraints = [];
-    for (const object2 of objects) {
-      const constraint = undeclaredConstraint(object2);
+    for (const object3 of objects) {
+      const constraint = undeclaredConstraint(object3);
       if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
         constraints.push(constraint);
     }
@@ -6082,6 +6082,9 @@ function withholdSignedLinks(value) {
   });
   return changed ? Object.fromEntries(entries) : value;
 }
+function withholdSignedLinksInOutput(output) {
+  return typeof output === "string" ? withholdSignedLinksInText(output) : withholdSignedLinks(output);
+}
 function withholdSignedLinksInText(text2) {
   if (!FIELDS.some((field) => text2.includes(field))) return text2;
   const inner = unwrap(text2);
@@ -6102,6 +6105,9 @@ var KNOWN_READS = ["list_files", "get_file", "get_note", "get_transcript", "get_
 function serverName(account2) {
   return account2 === DEFAULT_ACCOUNT ? SERVER : `${SERVER}-${account2}`;
 }
+function accountServer(aliases) {
+  return (account2) => account2 === void 0 || account2 === DEFAULT_ACCOUNT || aliases.includes(account2) ? serverName(account2 ?? DEFAULT_ACCOUNT) : void 0;
+}
 function mcpServers(accounts) {
   return [DEFAULT_ACCOUNT, ...accounts].map((account2) => ({ account: account2, name: serverName(account2) }));
 }
@@ -6218,11 +6224,11 @@ function overallState(status) {
 var READY_STEP = "Nothing to do.";
 function statusLines(status) {
   const several = status.accounts.length > 1;
-  const connection = status.accounts.map(
+  const connection2 = status.accounts.map(
     (account2) => [`${several ? `${account2.account}: ` : ""}${STATE_TEXT[account2.state]}`, ...account2.reason === void 0 ? [] : [` (${account2.reason})`]].join("")
   );
   const lines = [
-    { label: "Connection", value: connection.join("; "), tone: STATE_TONE[overallState(status)] },
+    { label: "Connection", value: connection2.join("; "), tone: STATE_TONE[overallState(status)] },
     {
       label: "Account",
       value: status.accounts.map((account2) => `${account2.account} (server ${account2.server}${account2.userServer ? ", from your OpenCode config" : ""})`).join(", "),
@@ -6430,13 +6436,13 @@ function nameIntegrations(ctx, servers) {
     }
     for (const [id, state] of states) {
       if (stopped.signal.aborted) return;
-      const connection = await ctx.integration.connection.active(id);
-      if (connection?.type !== "credential") continue;
-      const reported = connection.status?.message === SIGN_IN_AGAIN;
-      if (state === "needs_auth" && !connection.status) {
-        await ctx.integration.connection.status({ integrationID: id, connection, status: { status: "needs_auth", message: SIGN_IN_AGAIN } });
+      const connection2 = await ctx.integration.connection.active(id);
+      if (connection2?.type !== "credential") continue;
+      const reported = connection2.status?.message === SIGN_IN_AGAIN;
+      if (state === "needs_auth" && !connection2.status) {
+        await ctx.integration.connection.status({ integrationID: id, connection: connection2, status: { status: "needs_auth", message: SIGN_IN_AGAIN } });
       } else if (state === "connected" && reported) {
-        await ctx.integration.connection.status({ integrationID: id, connection, status: void 0 });
+        await ctx.integration.connection.status({ integrationID: id, connection: connection2, status: void 0 });
       }
     }
   };
@@ -6949,7 +6955,7 @@ async function registerTools(ctx, options) {
       const { output, content } = event.result;
       event.result = {
         ...event.result,
-        ...output === void 0 ? {} : { output: typeof output === "string" ? withholdSignedLinksInText(output) : withholdSignedLinks(output) },
+        ...output === void 0 ? {} : { output: withholdSignedLinksInOutput(output) },
         ...content === void 0 ? {} : {
           content: typeof content === "string" ? withholdSignedLinksInText(content) : content.map((part) => part.type === "text" ? { ...part, text: withholdSignedLinksInText(part.text) } : part)
         }
@@ -6963,6 +6969,10 @@ async function registerTools(ctx, options) {
   };
 }
 
+// src/host/tools-rpc.ts
+import { randomUUID } from "node:crypto";
+import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
+
 // src/version.ts
 var PLUGIN_ID = "plaud.recordings";
 var TESTED_HOST = ">=2.2.3 <2.3.0";
@@ -6992,6 +7002,327 @@ function checkHost(version2, allowUntestedHost) {
   return { version: version2, tested: false, warning: `${untested} It was loaded because "allowUntestedHost" is set.` };
 }
 
+// src/host/tools-rpc.ts
+var PLUGIN_ID2 = PLUGIN_ID;
+var KNOWN_READS2 = KNOWN_READS;
+function shapeResult(_method, result) {
+  const text2 = withholdSignedLinksInText(result.text);
+  return result.output === void 0 ? { text: text2 } : { output: withholdSignedLinksInOutput(result.output), text: text2 };
+}
+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 of that name from mcp.servers in opencode.json so that the plugin manages it, then restart OpenCode.",
+  AUTH_REQUIRED: "Run /connect and choose Plaud, or Plaud (<alias>) for another account, then press o or Enter to open the sign-in page.",
+  CONNECTING: "Wait a few seconds while OpenCode connects to the account's server, then call the method again.",
+  CONNECTION_FAILED: "Run /plaud-status and follow its next step.",
+  DISABLED: "Enable the account's server, plaud or plaud-<alias>, in /mcps.",
+  NOT_REGISTERED: "Run /plaud-status and follow its next step.",
+  TOOL_UNAVAILABLE: "Call describe to see which methods OpenCode lists now, and run /plaud-status.",
+  UPSTREAM_ERROR: "Check the input against the method's schema from describe, and run /plaud-status if it keeps failing.",
+  CANCELLED: "Call the method again if you still need the result.",
+  ACCOUNT_UNKNOWN: `Leave "account" out for the default account, or pass "default" or an alias from the plugin's accounts option, as /plaud-status lists them.`
+};
+function pluginError(_error) {
+  return void 0;
+}
+var TOOLS_RPC_ID = `${PLUGIN_ID2}.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 object2 = (properties, required2) => ({
+  type: "object",
+  properties,
+  required: required2,
+  additionalProperties: false
+});
+var STRING = { type: "string" };
+var ANY_OBJECT = { type: "object" };
+var NO_INPUT = object2({}, []);
+var FAILED = object2({ code: STRING, next: STRING }, ["code", "next"]);
+var mcpOutput = (output = {}) => object2({ output, text: STRING }, ["text"]);
+var DESCRIBED = object2(
+  {
+    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 = object2({ 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 validate2 = (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: validate2 }, enumerable: false });
+}
+var ScriptError = class extends Error {
+  failure;
+  constructor(failure2) {
+    super(`${failure2.code}: ${failure2.what.replace(/[.\s]+$/, "")}. Next step: ${failure2.next}`);
+    this.failure = failure2;
+  }
+};
+var fail2 = (code, what) => new ScriptError({ code, what, next: NEXT_STEPS[code] });
+var record = (value) => typeof value === "object" && value !== null;
+function notFound(error2, tags) {
+  if (!record(error2)) return false;
+  const tag = error2["_tag"] ?? error2["name"];
+  return typeof tag === "string" && tags.includes(tag) || error2["status"] === 404 || error2["statusCode"] === 404;
+}
+var toolError = (error2) => record(error2) && error2["_tag"] === "Tool.Error";
+var wildcard = (pattern, value) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`).test(value);
+var hidden = (rules, action) => rules.findLast((rule2) => wildcard(rule2.action, action) && wildcard(rule2.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, (url2) => {
+  const cut = url2.search(/[?#]/);
+  return cut === -1 ? url2 : `${url2.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(status) {
+  switch (status) {
+    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_READS2.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_READS2, ...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 = (account2) => {
+    const server = typeof mcp.server === "function" ? mcp.server(account2) : mcp.server;
+    if (server !== void 0) return server;
+    throw new ScriptError({ code: "ACCOUNT_UNKNOWN", what: `there is no account '${account2}'`, next: NEXT_STEPS.ACCOUNT_UNKNOWN });
+  };
+  const session = async (sessionID) => {
+    let info;
+    try {
+      info = await ctx.session.get({ sessionID });
+    } catch (error2) {
+      if (notFound(error2, ["Session.NotFoundError", "SessionNotFoundError"])) throw fail2("SESSION_UNKNOWN", `there is no session '${sessionID}'`);
+      throw error2;
+    }
+    if (!info.agent) throw fail2("SESSION_AGENT_REQUIRED", `session '${sessionID}' names no agent`);
+    let agent;
+    try {
+      agent = await ctx.agent.get({ agentID: info.agent, location: info.location });
+    } catch (error2) {
+      if (notFound(error2, ["Agent.NotFoundError", "AgentNotFoundError"])) throw fail2("SESSION_AGENT_REQUIRED", `session '${sessionID}' names the agent '${info.agent}', which does not exist`);
+      throw error2;
+    }
+    const rules = [...agent.data.permissions, ...info.permissions ?? []];
+    return { agent: info.agent, rules };
+  };
+  const unavailable = async (server, tool, connected) => {
+    const status = (await ctx.mcp.list()).data.find((entry2) => entry2.name === server)?.status.status;
+    const code = connection(status) ?? connected;
+    if (code === "TOOL_UNAVAILABLE") return fail2(code, `OpenCode does not list ${tool} on the connected "${server}" server`);
+    return fail2(code, `the "${server}" server ${STATUS_TEXT[code] ?? "is unavailable"}`);
+  };
+  const denied = (action, error2) => {
+    const reason2 = record(error2) && typeof error2["message"] === "string" ? error2["message"] : String(error2);
+    return fail2("PERMISSION_DENIED", `${action} was refused for this session's agent: ${upstreamText(reason2)}`);
+  };
+  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 fail2("SERVER_CONFLICT", `the "${server}" server in your config is not the one this plugin manages`);
+        const tool = (await ctx.tool.list()).find((entry2) => entry2.id === action);
+        if (!tool) throw await unavailable(server, action, "TOOL_UNAVAILABLE");
+        let result;
+        try {
+          result = await tool.execute(envelope2.input, call);
+        } catch (error2) {
+          if (error2 instanceof Error && error2.message.startsWith(`MCP server "${server}" `)) throw await unavailable(server, action, "CONNECTION_FAILED");
+          throw error2;
+        }
+        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 fail2("CANCELLED", "the call was cancelled");
+      method = target(envelope2);
+      const { agent, rules } = await session(envelope2.sessionID);
+      if (hidden(rules, method.action)) throw fail2("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 (error2) {
+      const failure2 = refusal(error2, method, context.signal);
+      if (!failure2) throw error2;
+      return context.error("failed", new ScriptError(failure2).message, { code: failure2.code, next: failure2.next });
+    }
+  };
+  const refusal = (error2, method, signal) => {
+    if (signal.aborted) return fail2("CANCELLED", "the call was cancelled").failure;
+    if (error2 instanceof ScriptError) return error2.failure;
+    const own2 = pluginError(error2);
+    if (own2 || !method || !toolError(error2)) return own2;
+    if (error2.error !== void 0) return denied(method.action, error2).failure;
+    if (method.mcp) return fail2("UPSTREAM_ERROR", `${method.action} failed: ${upstreamText(error2.message)}`).failure;
+    return void 0;
+  };
+  const describe3 = async () => {
+    const tools = mcp ? await ctx.tool.list() : [];
+    const methods = [];
+    if (mcp) {
+      const server = serverOf(void 0);
+      const managed = mcp.managed(server);
+      const status = managed ? (await ctx.mcp.list()).data.find((entry2) => entry2.name === server)?.status.status : void 0;
+      for (const name of KNOWN_READS2) {
+        const id = `${server}_${name}`;
+        const tool = managed ? tools.find((entry2) => entry2.id === id) : void 0;
+        const reason2 = !managed ? "SERVER_CONFLICT" : tool ? void 0 : connection(status) ?? "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: reason2 === void 0,
+          ...reason2 ? { reason: reason2 } : {},
+          input,
+          output: mcpOutput(output)
+        });
+      }
+    }
+    for (const spec of owned) {
+      const reason2 = await spec.available?.();
+      methods.push({
+        name: spec.name,
+        tool: spec.name,
+        kind: "plugin",
+        action: spec.action,
+        description: spec.description,
+        available: reason2 === void 0,
+        ...reason2 === void 0 ? {} : { reason: reason2 },
+        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(
+    object2({ 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 = Rpc2.define({
+    id: TOOLS_RPC_ID,
+    methods: {
+      describe: { input: NO_INPUT, output: DESCRIPTION },
+      ...Object.fromEntries(KNOWN_READS2.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: () => describe3(),
+    ...Object.fromEntries(KNOWN_READS2.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/index.ts
 var src_default = Plugin.define({
   id: PLUGIN_ID,
@@ -7013,6 +7344,7 @@ var src_default = Plugin.define({
       registrations.push(await registerCommands(ctx, status));
       registrations.push(await registerSkills(ctx, new URL("../skills/", import.meta.url)));
       registrations.push(await registerRpc(ctx, status));
+      registrations.push({ dispose: await registerToolsRpc(ctx, { mcp: { server: accountServer(options.accounts), managed: () => true } }) });
     } catch (error2) {
       await cleanup();
       throw error2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joe-broadhead/opencode-plaud",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Unofficial OpenCode plugin for Plaud recordings",
   "type": "module",
   "license": "MIT",

package/skills/opencode-plaud/SKILL.md

@@ -29,6 +29,23 @@ upload, share or send a recording.
 - Load `opencode-plaud-export` before an export, and `opencode-plaud-digest`
   for a summary across several recordings or a follow-up draft.
 
+## Scripts
+
+When the user wants a job that runs without you, such as a cron job or a
+shell script, it can call Plaud's five read tools through the OpenCode server,
+with no model. The RPC `plaud.recordings.tools` has one method per read, such
+as `list_files`, `get_note` and `get_transcript`, with the tools' own input,
+and `describe`, which lists them with their input schemas. Each call is
+`opencode api post /api/rpc/plaud.recordings.tools/<method>` with the body
+`{"input":{"sessionID":"<session>","input":<the tool's input>}}`; add
+`"account":"work"` to read the `work` account. 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":"weekly recordings","agent":"build"}`. An ask is refused, so the
+agent needs the reads allowed; the default rules allow them. Scripts cannot
+export files, use any other Plaud tool, or get a signed link. The details are
+in the plugin's `docs/scripting.md`.
+
 ## Data model
 
 - **Durations and offsets are milliseconds**, not seconds: `5400000` is