@joe-broadhead/opencode-granola 0.0.0 → 0.0.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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, `granola.meetings.tools`: a script can call Granola's ten read tools 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. `describe` lists the methods with each tool's live input schema. Granola's
+  writes, `sign_out`, `export_markdown` and any tool Granola adds later are never methods. An account read records the
+  workspace for status, and a server that is not connected gets the same codes and next steps as for the model.
+  `docs/scripting.md` explains it.
+
 ## [0.0.0] - 2026-11-01
 
 ### Added

package/README.md

@@ -60,6 +60,19 @@ To see the connection, the workspace, the tools and the next step:
 The workspace name comes from the most recent Granola account read since OpenCode started, and is kept in memory
 only. Until then, status says the workspace is unknown; ask the agent to check your Granola account.
 
+### Scripts
+
+A script or a cron job can call Granola's ten 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. Writes, `sign_out` and `export_markdown` are
+never available to scripts:
+
+```sh
+opencode api post /api/rpc/granola.meetings.tools/list_meetings \
+  -d '{"input":{"sessionID":"ses_…","input":{"limit":10}}}'
+```
+
+See [Scripting](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/docs/scripting.md).
+
 ## Permissions
 
 | Kind | Tools | Default |
@@ -147,6 +160,9 @@ overwrites it. An entry for Granola's official URL is used as it is.
 
 **Status lists Agents without default rules.** See [Permissions](#permissions).
 
+**A script gets an error.** The tools RPC has its own codes, listed in
+[Scripting](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/docs/scripting.md#errors).
+
 Granola uses the workspace that is active in your Granola app; meetings in other workspaces do not appear. The plugin
 supports one Granola account.
 
@@ -163,6 +179,7 @@ Restart OpenCode afterwards. Files you exported stay in your export folder.
 
 - [Configuration](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/docs/configuration.md)
 - [Architecture](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/docs/architecture.md)
+- [Scripting](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/docs/scripting.md)
 - [Contributing](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/CONTRIBUTING.md)
 - [Security](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/SECURITY.md)
 - [Changelog](https://github.com/joe-broadhead/opencode-granola/blob/HEAD/CHANGELOG.md)

package/dist/index.js

@@ -1,8 +1,9 @@
 // src/index.ts
 import { Plugin } from "@opencode/plugin";
 
-// src/meta.ts
-import { readFileSync } from "node:fs";
+// src/host/tools-rpc.ts
+import { randomUUID } from "node:crypto";
+import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
 
 // src/errors.ts
 import { Error as ToolError } from "@opencode/plugin/promise/tool";
@@ -93,17 +94,6 @@ function packageInvalid(problem) {
   return { code: "PACKAGE_INVALID", message: `The Granola plugin's package.json ${problem}.`, next: "Reinstall the plugin." };
 }
 
-// src/meta.ts
-var PLUGIN_ID = "granola.meetings";
-function readPackageInfo(url = new URL("../package.json", import.meta.url)) {
-  const raw = JSON.parse(readFileSync(url, "utf8"));
-  const record3 = (value) => typeof value === "object" && value !== null;
-  if (!record3(raw) || typeof raw.version !== "string" || !record3(raw.opencode) || typeof raw.opencode.host !== "string") {
-    throw new GranolaError(packageInvalid("needs a version and an opencode.host range"));
-  }
-  return { version: raw.version, testedHost: raw.opencode.host };
-}
-
 // src/known-tools.ts
 var SERVER = "granola";
 var READ_TOOLS = [
@@ -143,6 +133,18 @@ function classify(id) {
   return "unknown";
 }
 
+// src/meta.ts
+import { readFileSync } from "node:fs";
+var PLUGIN_ID = "granola.meetings";
+function readPackageInfo(url = new URL("../package.json", import.meta.url)) {
+  const raw = JSON.parse(readFileSync(url, "utf8"));
+  const record4 = (value) => typeof value === "object" && value !== null;
+  if (!record4(raw) || typeof raw.version !== "string" || !record4(raw.opencode) || typeof raw.opencode.host !== "string") {
+    throw new GranolaError(packageInvalid("needs a version and an opencode.host range"));
+  }
+  return { version: raw.version, testedHost: raw.opencode.host };
+}
+
 // src/permissions.ts
 var DEFAULT_RULES = [
   { action: "granola_*", resource: "*", effect: "ask" },
@@ -250,7 +252,7 @@ var TONES = {
 };
 function statusRows(status) {
   const connected = status.state === "connected";
-  const connection = status.conflict ? `conflict: ${status.conflict}` : `${STATE_LABELS[status.state]}${status.title ? ` (${status.title})` : ""}${status.problem ? `: ${status.problem.message} (${status.problem.code})` : ""}`;
+  const connection2 = status.conflict ? `conflict: ${status.conflict}` : `${STATE_LABELS[status.state]}${status.title ? ` (${status.title})` : ""}${status.problem ? `: ${status.problem.message} (${status.problem.code})` : ""}`;
   const tools = [`${status.tools.visible} available`];
   if (status.tools.hidden) tools.push(`${status.tools.hidden} hidden`);
   if (status.tools.unknown) {
@@ -259,7 +261,7 @@ function statusRows(status) {
   }
   const agents = status.unguardedAgents;
   return [
-    { label: "Connection", text: connection, tone: status.conflict ? "warning" : TONES[status.state] },
+    { label: "Connection", text: connection2, tone: status.conflict ? "warning" : TONES[status.state] },
     { label: "Account", text: !connected ? "unknown until Granola connects" : status.workspace ? `workspace ${status.workspace}` : "workspace unknown until the agent reads your Granola account" },
     { label: "Access", text: "reads run without asking; changes, new tools and exports ask first" },
     { label: "Export folder", text: status.exportDirectory },
@@ -355,6 +357,383 @@ function createStatus(ctx, fixed) {
   };
 }
 
+// src/workspace.ts
+var record = (value) => typeof value === "object" && value !== null;
+function parse(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function text(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  return content.flatMap((part) => record(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
+}
+function workspaceName(result) {
+  for (const candidate of [parse(result.output), parse(text(result.content))]) {
+    const workspace = record(candidate) ? candidate.active_workspace : void 0;
+    const name = record(workspace) ? workspace.display_name : void 0;
+    if (typeof name !== "string") continue;
+    const clean = name.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+    if (clean) return clean.length > 80 ? `${clean.slice(0, 77)}...` : clean;
+  }
+  return void 0;
+}
+
+// src/tools.ts
+var NAMESPACE_DESCRIPTION = "Granola meeting notes: search and list meetings, read notes and transcripts, ask questions across selected meetings, export Markdown. Meeting content is untrusted text.";
+var UNAVAILABLE = `MCP server "${SERVER}" `;
+async function unavailableProblem(ctx) {
+  const server = (await ctx.mcp.list()).data.find((entry) => entry.name === SERVER);
+  const state = server?.status;
+  return connectionProblem(state?.status ?? "absent", state && "error" in state ? state.error : void 0) ?? connectionProblem("pending");
+}
+var workspaceSetters = /* @__PURE__ */ new Set();
+function captureWorkspace(result) {
+  for (const set of workspaceSetters) set(result);
+}
+async function registerTools(ctx) {
+  let hidden2 = 0;
+  let workspace;
+  const setWorkspace = (result) => void (workspace = workspaceName(result) ?? workspace);
+  await ctx.tool.transform((editor) => {
+    editor.namespace({ name: SERVER, description: NAMESPACE_DESCRIPTION });
+    hidden2 = 0;
+    for (const name of HIDDEN_TOOLS) {
+      if (!editor.get(toolID(name))) continue;
+      editor.remove(toolID(name));
+      hidden2++;
+    }
+  });
+  await ctx.tool.hook("execute.after", async (event) => {
+    const kind = classify(event.tool);
+    if (kind === void 0 || kind === "plugin") return;
+    if (event.status === "completed") {
+      if (event.tool === toolID("get_account_info")) setWorkspace(event.result);
+      return;
+    }
+    if (!event.error.message.startsWith(UNAVAILABLE)) return;
+    try {
+      event.error = toolError(await unavailableProblem(ctx));
+    } catch {
+    }
+  });
+  workspaceSetters.add(setWorkspace);
+  return { hidden: () => hidden2, workspace: () => workspace, dispose: () => void workspaceSetters.delete(setWorkspace) };
+}
+
+// src/host/tools-rpc.ts
+var PLUGIN_ID2 = PLUGIN_ID;
+var KNOWN_READS = READ_TOOLS;
+function shapeResult(method, result) {
+  if (method === "get_account_info") captureWorkspace({ output: result.output, content: result.text });
+  return result;
+}
+var connectionNext = (state) => connectionProblem(state)?.next ?? "";
+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: CONFLICT_NEXT,
+  AUTH_REQUIRED: connectionNext("needs_auth"),
+  CONNECTING: connectionNext("pending"),
+  CONNECTION_FAILED: connectionNext("failed"),
+  DISABLED: connectionNext("disabled"),
+  NOT_REGISTERED: connectionNext("absent"),
+  TOOL_UNAVAILABLE: toolUnavailable("the tool").next,
+  UPSTREAM_ERROR: "Check the input against the method's schema from describe, and run /granola-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_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 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 = (code2, what) => new ScriptError({ code: code2, what, next: NEXT_STEPS[code2] });
+var record2 = (value) => typeof value === "object" && value !== null;
+function notFound(error, tags) {
+  if (!record2(error)) return false;
+  const tag = error["_tag"] ?? error["name"];
+  return typeof tag === "string" && tags.includes(tag) || error["status"] === 404 || error["statusCode"] === 404;
+}
+var toolError2 = (error) => record2(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 = (text3) => text3.replace(/\bhttps?:\/\/[^\s"'<>()]+/gi, (url) => {
+  const cut = url.search(/[?#]/);
+  return cut === -1 ? url : `${url.slice(0, cut)}?[redacted]`;
+});
+function upstreamText(text3) {
+  const line = text3.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) => record2(schema) && !("ast" in schema) && !("~standard" in schema) ? schema : void 0;
+function normalise(result) {
+  const text3 = typeof result.content === "string" ? result.content : (result.content ?? []).flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+  return result.output === void 0 ? { text: text3 } : { output: result.output, text: text3 };
+}
+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_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 status = (await ctx.mcp.list()).data.find((entry) => entry.name === server)?.status.status;
+    const code2 = connection(status) ?? connected;
+    if (code2 === "TOOL_UNAVAILABLE") return fail(code2, `OpenCode does not list ${tool} on the connected "${server}" server`);
+    return fail(code2, `the "${server}" server ${STATUS_TEXT[code2] ?? "is unavailable"}`);
+  };
+  const denied = (action, error) => {
+    const reason = record2(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 || !toolError2(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 describe2 = 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((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(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: 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 = Rpc2.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: () => describe2(),
+    ...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/commands.ts
 var STATUS_COMMAND = "granola-status";
 async function registerCommands(ctx, status) {
@@ -681,7 +1060,7 @@ function decode(text3) {
 function isMarkup(text3) {
   return new RegExp(`<${NAME}[\\s/>]`).test(text3);
 }
-function parse(text3) {
+function parse2(text3) {
   const root = { name: "", attributes: {}, children: [] };
   const stack = [root];
   const append = (value) => {
@@ -731,7 +1110,7 @@ var HEADINGS = {
   transcript: "Granola meeting transcripts",
   both: "Granola meeting notes and transcripts"
 };
-var UNAVAILABLE = {
+var UNAVAILABLE2 = {
   /** Not one of Granola's reasons: the notes read found no meeting and the transcript read failed. */
   meeting_not_found: "Granola returned no meeting for this ID",
   transcript_pending: "Granola is still processing it; export again in a few minutes",
@@ -809,7 +1188,7 @@ function blocks(parent) {
   return result;
 }
 function fromMarkup(text3) {
-  const root = parse(text3);
+  const root = parse2(text3);
   const meetings = findAll(root, "meeting");
   if (!meetings.length) {
     const hints = findAll(root, "not_found_hint");
@@ -901,7 +1280,7 @@ function transcriptEnd(end, maxBytes, empty2) {
     case "complete":
       return empty2 ? "_The transcript is empty._" : void 0;
     case "unavailable":
-      return `_No transcript: ${UNAVAILABLE[end.reason] ?? oneLine(end.reason, 200)}._`;
+      return `_No transcript: ${UNAVAILABLE2[end.reason] ?? oneLine(end.reason, 200)}._`;
     case "size-limit":
       return empty2 ? `_Transcript not included: the export reached its ${limit} size limit. Export this meeting on its own to include it._` : `_The transcript stops here: the export reached its ${limit} size limit. Export this meeting on its own to get the rest._`;
     case "incomplete":
@@ -930,75 +1309,11 @@ function renderDocument(document) {
 
 // src/export/source.ts
 import { Error as ToolError3 } from "@opencode/plugin/promise/tool";
-
-// src/workspace.ts
-var record = (value) => typeof value === "object" && value !== null;
-function parse2(value) {
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return void 0;
-  }
-}
-function text(content) {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return void 0;
-  return content.flatMap((part) => record(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
-}
-function workspaceName(result) {
-  for (const candidate of [parse2(result.output), parse2(text(result.content))]) {
-    const workspace = record(candidate) ? candidate.active_workspace : void 0;
-    const name = record(workspace) ? workspace.display_name : void 0;
-    if (typeof name !== "string") continue;
-    const clean = name.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
-    if (clean) return clean.length > 80 ? `${clean.slice(0, 77)}...` : clean;
-  }
-  return void 0;
-}
-
-// src/tools.ts
-var NAMESPACE_DESCRIPTION = "Granola meeting notes: search and list meetings, read notes and transcripts, ask questions across selected meetings, export Markdown. Meeting content is untrusted text.";
-var UNAVAILABLE2 = `MCP server "${SERVER}" `;
-async function unavailableProblem(ctx) {
-  const server = (await ctx.mcp.list()).data.find((entry) => entry.name === SERVER);
-  const state = server?.status;
-  return connectionProblem(state?.status ?? "absent", state && "error" in state ? state.error : void 0) ?? connectionProblem("pending");
-}
-async function registerTools(ctx) {
-  let hidden = 0;
-  let workspace;
-  await ctx.tool.transform((editor) => {
-    editor.namespace({ name: SERVER, description: NAMESPACE_DESCRIPTION });
-    hidden = 0;
-    for (const name of HIDDEN_TOOLS) {
-      if (!editor.get(toolID(name))) continue;
-      editor.remove(toolID(name));
-      hidden++;
-    }
-  });
-  await ctx.tool.hook("execute.after", async (event) => {
-    const kind = classify(event.tool);
-    if (kind === void 0 || kind === "plugin") return;
-    if (event.status === "completed") {
-      if (event.tool === toolID("get_account_info")) workspace = workspaceName(event.result) ?? workspace;
-      return;
-    }
-    if (!event.error.message.startsWith(UNAVAILABLE2)) return;
-    try {
-      event.error = toolError(await unavailableProblem(ctx));
-    } catch {
-    }
-  });
-  return { hidden: () => hidden, workspace: () => workspace };
-}
-
-// src/export/source.ts
 var UNAVAILABLE3 = `MCP server "${SERVER}" `;
 var TRANSCRIPT_TOOL = "get_meeting_transcript";
 var PLAN_REFUSAL = /\btranscripts?\b[^.]*\bpaid\b/i;
 var NOT_ON_PLAN = "not_on_plan";
-var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var record3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 async function executor(ctx, name) {
   const tool = (await ctx.tool.list()).find((entry) => entry.id === toolID(name));
   if (tool) return tool;
@@ -1013,12 +1328,12 @@ function text2(result) {
   return (result.content ?? []).flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
 }
 function structured(result) {
-  if (record2(result.output)) return result.output;
+  if (record3(result.output)) return result.output;
   const body = text2(result).trim();
   if (!body.startsWith("{")) return void 0;
   try {
     const value = JSON.parse(body);
-    return record2(value) ? value : void 0;
+    return record3(value) ? value : void 0;
   } catch {
     return void 0;
   }
@@ -1027,7 +1342,7 @@ function readPage(result) {
   const value = structured(result);
   if (!value || !("transcript" in value)) return { text: text2(result), endsMidUtterance: false };
   const transcript = typeof value.transcript === "string" ? value.transcript : null;
-  const unavailable = record2(value.transcript_unavailable) ? value.transcript_unavailable.reason : value.transcript_unavailable;
+  const unavailable = record3(value.transcript_unavailable) ? value.transcript_unavailable.reason : value.transcript_unavailable;
   const next = value.truncated === true && Number.isSafeInteger(value.next_offset) ? value.next_offset : void 0;
   return {
     text: transcript,
@@ -1397,13 +1712,13 @@ async function registerIntegration(ctx, conflict) {
     const id = server?.integrationID;
     if (!server || !id || stopped.signal.aborted) return;
     if (id !== attached || (await ctx.integration.get({ integrationID: id })).data.name !== DISPLAY_NAME) await attach(id);
-    const connection = await ctx.integration.connection.active(id);
-    if (connection?.type !== "credential") return;
+    const connection2 = await ctx.integration.connection.active(id);
+    if (connection2?.type !== "credential") return;
     const state = server.status.status;
-    if (state === "needs_auth" && connection.status?.status !== "needs_auth") {
-      await ctx.integration.connection.status({ integrationID: id, connection, status: { status: "needs_auth", message: SIGN_IN_MESSAGE } });
-    } else if (state === "connected" && connection.status) {
-      await ctx.integration.connection.status({ integrationID: id, connection, status: void 0 });
+    if (state === "needs_auth" && connection2.status?.status !== "needs_auth") {
+      await ctx.integration.connection.status({ integrationID: id, connection: connection2, status: { status: "needs_auth", message: SIGN_IN_MESSAGE } });
+    } else if (state === "connected" && connection2.status) {
+      await ctx.integration.connection.status({ integrationID: id, connection: connection2, status: void 0 });
     }
   };
   let checking;
@@ -1560,7 +1875,7 @@ async function registerSkills(ctx, skills = readSkills()) {
 }
 
 // src/setup.ts
-async function setup(ctx) {
+async function setup(ctx, toolsRpc) {
   const info = readPackageInfo();
   const options = parseOptions(ctx.options);
   const host = checkHost(ctx.app.version, info.testedHost, options.allowUntestedHost);
@@ -1581,11 +1896,16 @@ async function setup(ctx) {
   await registerSkills(ctx);
   await registerExport(ctx, options);
   await registerRpc(ctx, status);
-  return () => integration.dispose();
+  const stopTools = await toolsRpc({ mcp: { server: SERVER, managed: () => server.conflict() === void 0 } });
+  return async () => {
+    tools?.dispose();
+    await stopTools();
+    await integration.dispose();
+  };
 }
 
 // src/index.ts
-var src_default = Plugin.define({ id: PLUGIN_ID, setup });
+var src_default = Plugin.define({ id: PLUGIN_ID, setup: (ctx) => setup(ctx, (options) => registerToolsRpc(ctx, options)) });
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joe-broadhead/opencode-granola",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Unofficial OpenCode plugin for Granola meeting notes, through Granola's official MCP server",
   "keywords": [
     "opencode",

package/skills/granola/SKILL.md

@@ -60,6 +60,10 @@ Reads run without a prompt. OpenCode asks the user before each of these, unless
 
 Make a change only when the user asked for it, and say first what it will do. A folder with workspace visibility shares every note in it with the whole workspace. If the user declines or the permission is denied, do not retry or find another way. In `opencode run` with nobody present to answer, these calls are denied unless the user's OpenCode permissions allow them. If `/granola-status` warns that an agent did not get Granola's permission defaults, pass the warning and its fix to the user.
 
+## Scripts
+
+When the user wants a job that runs without you, such as a cron job or a shell script, it can call Granola's read tools through the OpenCode server, with no model. The RPC `granola.meetings.tools` has one method per read, such as `list_meetings`, `get_meetings` and `get_meeting_transcript`, with the tools' own input, and `describe`, which lists them with their input schemas. Each call is `opencode api post /api/rpc/granola.meetings.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":"weekly meetings","agent":"build"}`. An ask is refused, so the agent needs the reads allowed; the default rules allow them. Scripts cannot make changes, sign out or export files. The details are in the plugin's `docs/scripting.md`.
+
 ## Save meetings as Markdown
 
 `export_markdown` writes the notes, the transcript, or both, for 1 to 20 meetings into one Markdown file in the user's export folder; `/granola-status` shows the folder. The content goes straight to the file without passing through the conversation, so prefer it to reading a long transcript just to save it.