@repogo/plugins 0.1.42 → 0.1.44

package/dist/workflow-executor.js

@@ -18,6 +18,7 @@ __export(exports_src, {
   upload: () => upload,
   toCallError: () => toCallError,
   stream: () => stream,
+  remotePlugin: () => remotePlugin,
   method: () => method,
   definePlugin: () => definePlugin,
   cached: () => cached,
@@ -43,36 +44,48 @@ function parseDuration(duration) {
 }
 
 // src/define.ts
+var permissionModes = ["approval-required", "auto-accept-edits", "full-access"];
+function httpAddresses(option) {
+  return option === true ? { public: "key" } : option;
+}
 function definePlugin(plugin) {
   return plugin;
 }
 function method(input, run, options = {}) {
+  if ("kind" in options)
+    throw new Error('method: kind is now effect: "read", "write" or "destructive"');
+  if ("confirm" in options)
+    throw new Error('method: confirm is now approve: "Delete {{id}}?"');
+  if (options.approveUpTo !== undefined && !permissionModes.includes(options.approveUpTo)) {
+    throw new Error(`method: approveUpTo is one of ${permissionModes.join(", ")}`);
+  }
+  if (options.approveUpTo !== undefined && !options.approve)
+    throw new Error("method: approveUpTo needs an approve question to ask");
   return {
     input,
     run,
-    kind: options.kind ?? "mutation",
+    effect: options.effect ?? "write",
     output: options.output,
     description: options.description,
-    confirm: options.confirm,
-    http: options.http === true ? "key" : options.http?.auth
+    approve: options.approve,
+    approveUpTo: options.approveUpTo,
+    http: httpAddresses(options.http)
   };
 }
 function cached(input, run, options) {
   return {
     input,
     run,
-    kind: "query",
+    effect: "read",
     output: options.output,
     description: options.description,
+    http: httpAddresses(options.http),
     cache: { fresh: parseDuration(options.fresh), shared: options.shared ?? false, timeout: parseDuration(options.timeout ?? "1m") }
   };
 }
 function stream(input, run, options = {}) {
-  return { input, run, kind: "stream", description: options.description };
+  return { input, run, effect: "read", stream: true, description: options.description };
 }
-// src/uploads.ts
-import { AsyncLocalStorage } from "async_hooks";
-
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -19492,13 +19505,6 @@ function bigint3(params) {
 function date4(params) {
   return _coercedDate(ZodDate, params);
 }
-// src/uploads.ts
-var callFiles = new AsyncLocalStorage;
-function upload() {
-  return exports_external.object({ id: exports_external.string(), name: exports_external.string(), type: exports_external.string(), size: exports_external.number(), path: exports_external.string() }).refine((file2) => (callFiles.getStore() ?? []).some((held) => held.id === file2.id && held.path === file2.path), {
-    message: "Not a file uploaded for this call."
-  });
-}
 // src/errors.ts
 class MethodError extends Error {
   code;
@@ -19523,6 +19529,40 @@ function toCallError(error62) {
   }
   return { code: "INTERNAL", message: error62 instanceof Error ? error62.message : String(error62) };
 }
+
+// src/remote.ts
+var codes = { 400: "VALIDATION", 403: "FORBIDDEN", 404: "NOT_FOUND" };
+async function remotePlugin(url2, name) {
+  const base = `${url2.replace(/\/$/, "")}/${name}`;
+  const response = await fetch(base);
+  if (!response.ok)
+    throw new Error(`remotePlugin: ${base} answered ${response.status}`);
+  const listing = await response.json();
+  const methods = {};
+  for (const m of listing.methods) {
+    methods[m.name] = method(exports_external.fromJSONSchema(m.input), (input2) => call(`${base}/${m.name}`, input2), {
+      effect: m.effect,
+      description: m.description ?? undefined,
+      output: m.output ? exports_external.fromJSONSchema(m.output) : undefined
+    });
+  }
+  return { description: listing.description ?? undefined, methods };
+}
+async function call(url2, input2) {
+  const response = await fetch(url2, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(input2) });
+  const answer = await response.json().catch(() => null);
+  if (response.ok)
+    return answer;
+  throw new MethodError(codes[response.status] ?? "INTERNAL", answer?.error ?? `${url2} answered ${response.status}`, answer?.fields ?? undefined);
+}
+// src/uploads.ts
+import { AsyncLocalStorage } from "async_hooks";
+var callFiles = new AsyncLocalStorage;
+function upload() {
+  return exports_external.object({ id: exports_external.string(), name: exports_external.string(), type: exports_external.string(), size: exports_external.number(), path: exports_external.string() }).refine((file2) => (callFiles.getStore() ?? []).some((held) => held.id === file2.id && held.path === file2.path), {
+    message: "Not a file uploaded for this call."
+  });
+}
 // src/workflow/scope.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var attemptScope = new AsyncLocalStorage2;
@@ -19669,6 +19709,7 @@ function carryable(value) {
 
 // src/runtime.ts
 import { AsyncLocalStorage as AsyncLocalStorage5 } from "async_hooks";
+import { existsSync } from "fs";
 import { mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
 import { join as join3 } from "path";
 
@@ -19732,7 +19773,7 @@ function recordRead(tag) {
 }
 function assertWritable(tag) {
   if (current.getStore()?.readOnly) {
-    throw new MethodError("FORBIDDEN", `A query can't change data (it tried to write ${tag}).`);
+    throw new MethodError("FORBIDDEN", `A read can't change data (it tried to write ${tag}).`);
   }
 }
 function recordWrite(tag) {
@@ -20108,14 +20149,14 @@ class AnswerCache {
         checked_at integer not null
       )`);
   }
-  async read(key, options, fetch) {
+  async read(key, options, fetch2) {
     const tag = `${this.namespace}.cached.${Bun.hash(key).toString(36)}`;
     recordRead(tag);
     const [row] = await this.database.sql.unsafe(`select value, checked_at from cached_answers where key = $1`, [key]);
     if (!row)
-      return this.refresh(key, tag, options, fetch);
+      return this.refresh(key, tag, options, fetch2);
     if (Date.now() - row.checked_at >= options.fresh) {
-      this.refresh(key, tag, options, fetch).catch((error62) => record2("error", [error62]));
+      this.refresh(key, tag, options, fetch2).catch((error62) => record2("error", [error62]));
     }
     return JSON.parse(row.value);
   }
@@ -20123,12 +20164,12 @@ class AnswerCache {
     while (this.inflight.size)
       await Promise.allSettled([...this.inflight.values()]);
   }
-  refresh(key, tag, options, fetch) {
+  refresh(key, tag, options, fetch2) {
     const running = this.inflight.get(key);
     if (running)
       return running;
     const started = Date.now();
-    const work = isolated(async () => withTimeout(Promise.resolve(fetch()), options.timeout)).then(async (value) => {
+    const work = isolated(async () => withTimeout(Promise.resolve(fetch2()), options.timeout)).then(async (value) => {
       await this.save(key, tag, value ?? null, started);
       return value ?? null;
     }, async (error62) => {
@@ -20529,32 +20570,32 @@ function kvMethods(name, kv, schema) {
   const entry = exports_external.object({ key: exports_external.string(), value: schema, expiresAt: exports_external.string().nullable(), createdAt: exports_external.string(), updatedAt: exports_external.string() });
   return {
     get: {
-      kind: "query",
+      effect: "read",
       description: `Get one ${name} entry by key, or null`,
       input: exports_external.object({ key }),
       output: entry.nullable(),
       run: ({ key: key2 }) => kv.entry(key2)
     },
     list: {
-      kind: "query",
+      effect: "read",
       description: `List ${name} entries in key order, optionally by prefix`,
       input: exports_external.object({ prefix: exports_external.string().optional(), limit }),
       output: exports_external.array(entry),
       run: (input2) => kv.list(input2)
     },
     set: {
-      kind: "mutation",
+      effect: "write",
       description: `Set a ${name} key; ttl ("5m", "1h", "7d" or ms) makes it expire`,
       input: exports_external.object({ key, value: schema, ttl }),
       output: entry,
       run: ({ key: key2, value, ttl: ttl2 }) => kv.set(key2, value, { ttl: ttl2 })
     },
     delete: {
-      kind: "mutation",
+      effect: "destructive",
       description: `Delete a ${name} key`,
       input: exports_external.object({ key }),
       output: exports_external.null(),
-      confirm: "Delete this key?",
+      approve: "Delete this key?",
       run: async ({ key: key2 }) => (await kv.delete(key2), null)
     }
   };
@@ -20564,45 +20605,46 @@ function streamMethods(name, stream2, schema) {
   const line = exports_external.object({ id: exports_external.string(), key: exports_external.string(), offset: exports_external.number(), at: exports_external.string(), data: schema });
   return {
     tail: {
-      kind: "stream",
+      effect: "read",
+      stream: true,
       description: `Follow a ${name} key live: its last lines (100 unless last says), then each new one, until it ends`,
       input: exports_external.object({ key, from: exports_external.number().int().min(0).optional(), last: exports_external.number().int().positive().max(500).optional() }),
       run: ({ key: key2, from, last }, signal) => stream2.follow(key2, { from, last, signal })
     },
     read: {
-      kind: "query",
+      effect: "read",
       description: `Read a ${name} key's lines from an offset`,
       input: exports_external.object({ key, from: exports_external.number().int().min(0).optional(), limit }),
       output: exports_external.array(line),
       run: ({ key: key2, ...options }) => stream2.read(key2, options)
     },
     keys: {
-      kind: "query",
+      effect: "read",
       description: `List ${name} keys, most recently written first`,
       input: exports_external.object({ limit }),
       output: exports_external.array(exports_external.object({ key: exports_external.string(), lines: exports_external.number(), bytes: exports_external.number(), endedAt: exports_external.string().nullable(), updatedAt: exports_external.string() })),
       run: (input2) => stream2.keys(input2)
     },
     append: {
-      kind: "mutation",
+      effect: "write",
       description: `Append a line to a ${name} key`,
       input: exports_external.object({ key, data: schema }),
       output: line,
       run: ({ key: key2, data }) => stream2.append(key2, data)
     },
     end: {
-      kind: "mutation",
+      effect: "write",
       description: `End a ${name} key: followers stop and appends fail`,
       input: exports_external.object({ key }),
       output: exports_external.null(),
       run: async ({ key: key2 }) => (await stream2.end(key2), null)
     },
     delete: {
-      kind: "mutation",
+      effect: "destructive",
       description: `Delete a ${name} key and its lines`,
       input: exports_external.object({ key }),
       output: exports_external.null(),
-      confirm: "Delete this stream and its lines?",
+      approve: "Delete this stream and its lines?",
       run: async ({ key: key2 }) => (await stream2.delete(key2), null)
     }
   };
@@ -20627,28 +20669,28 @@ function bucketMethods(name, bucket, schema) {
   const revision = exports_external.number().int().optional();
   return {
     list: {
-      kind: "query",
+      effect: "read",
       description: `List ${name} files, newest first, optionally in one folder or with one status`,
       input: exports_external.object({ folder: exports_external.string().optional(), status: status.optional(), limit }),
       output: exports_external.array(file2),
       run: (input2) => bucket.list(input2)
     },
     search: {
-      kind: "query",
+      effect: "read",
       description: `Search ${name} files by name, folder and meta`,
       input: exports_external.object({ query: exports_external.string(), limit }),
       output: exports_external.array(file2),
       run: ({ query, limit: limit2 }) => bucket.search(query, { limit: limit2 })
     },
     get: {
-      kind: "query",
+      effect: "read",
       description: `Get one ${name} file by id, or null`,
       input: exports_external.object({ id }),
       output: file2.nullable(),
       run: ({ id: id2 }) => bucket.get(id2)
     },
     put: {
-      kind: "mutation",
+      effect: "write",
       description: `Add a file to ${name}: its name, and text or an absolute path to copy`,
       input: exports_external.object({
         name: exports_external.string(),
@@ -20665,25 +20707,25 @@ function bucketMethods(name, bucket, schema) {
       }
     },
     update: {
-      kind: "mutation",
+      effect: "write",
       description: `Change fields of a ${name} file's meta; null removes one`,
       input: exports_external.object({ id, meta: exports_external.record(exports_external.string(), exports_external.unknown()), revision }),
       output: file2,
       run: ({ id: id2, meta: meta3, revision: revision2 }) => bucket.update(id2, meta3, { revision: revision2 })
     },
     move: {
-      kind: "mutation",
+      effect: "write",
       description: `Rename a ${name} file or move it to another folder`,
       input: exports_external.object({ id, name: exports_external.string().optional(), folder: exports_external.string().optional(), revision }),
       output: file2,
       run: ({ id: id2, name: name2, folder, revision: revision2 }) => bucket.move(id2, { name: name2, folder }, { revision: revision2 })
     },
     delete: {
-      kind: "mutation",
+      effect: "destructive",
       description: `Delete a ${name} file and its meta`,
       input: exports_external.object({ id }),
       output: exports_external.null(),
-      confirm: "Delete this file?",
+      approve: "Delete this file?",
       run: async ({ id: id2 }) => (await bucket.delete(id2), null)
     }
   };
@@ -21092,7 +21134,7 @@ var RunMetadataSchema = exports_external.object({
   root: exports_external.string().refine(isAbsolute2),
   namespace: exports_external.string().regex(/^[a-z0-9][a-z0-9.-]*$/),
   plugin: exports_external.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  caller: exports_external.enum(["card", "agent", "cron", "code", "http"]),
+  caller: exports_external.enum(["card", "agent", "cron", "code", "http", "device"]),
   workflow: exports_external.string().regex(/^[a-z][a-zA-Z0-9_-]*$/),
   input: exports_external.json(),
   key: exports_external.string().nullable(),
@@ -21115,29 +21157,29 @@ function workflowMethods(plugin, namespace, name, definition, ctx, bridge, direc
     return bridge({ operation, dir, plugin, namespace, workflow: name, root: ctx.root, caller: ctx.caller, input: input2, settings: workflowSettings(definition) });
   };
   const id = exports_external.object({ id: exports_external.string().uuid() }).strict();
-  const spec = (method2, kind, input2, description, confirm, output2) => ({
+  const spec = (method2, effect, input2, description, approve, output2) => ({
     name: `${plugin}.${name}.${method2}`,
     plugin,
-    kind,
+    effect,
     input: input2,
     description,
-    confirm,
+    approve,
     output: output2,
     run: async (input3, raw) => {
-      if (kind === "query")
+      if (effect === "read")
         recordRead(workflowTag(namespace));
       const request = method2 === "start" ? { ...input3, input: raw.input } : input3;
       return invoke(method2, request);
     }
   });
   return [
-    spec("list", "query", exports_external.object({ limit: exports_external.number().int().min(1).max(100).default(20), status: exports_external.string().optional(), cursor: exports_external.string().optional() }).strict(), "List workflow runs", undefined, exports_external.object({ items: exports_external.array(RunSummarySchema), cursor: exports_external.string().nullable() })),
-    spec("get", "query", id, "Get one workflow run"),
-    spec("start", "mutation", exports_external.object({ input: definition.input, key: exports_external.string().min(1).max(200).optional() }).strict(), definition.description ?? "Start a durable workflow", definition.confirm, RunSummarySchema),
-    spec("retry", "mutation", id, "Retry a safely failed query step", undefined, RunSummarySchema),
-    spec("restart", "mutation", id, "Start a run that needs attention over from the beginning, on the current code", undefined, RunSummarySchema),
-    spec("cancel", "mutation", id, "Request cancellation of a workflow", undefined, RunSummarySchema),
-    spec("cancelAll", "mutation", exports_external.object({ status: exports_external.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, exports_external.object({ cancelled: exports_external.number().int() }))
+    spec("list", "read", exports_external.object({ limit: exports_external.number().int().min(1).max(100).default(20), status: exports_external.string().optional(), cursor: exports_external.string().optional() }).strict(), "List workflow runs", undefined, exports_external.object({ items: exports_external.array(RunSummarySchema), cursor: exports_external.string().nullable() })),
+    spec("get", "read", id, "Get one workflow run"),
+    spec("start", "write", exports_external.object({ input: definition.input, key: exports_external.string().min(1).max(200).optional() }).strict(), definition.description ?? "Start a durable workflow", definition.approve, RunSummarySchema),
+    spec("retry", "write", id, "Retry a safely failed query step", undefined, RunSummarySchema),
+    spec("restart", "write", id, "Start a run that needs attention over from the beginning, on the current code", undefined, RunSummarySchema),
+    spec("cancel", "write", id, "Request cancellation of a workflow", undefined, RunSummarySchema),
+    spec("cancelAll", "write", exports_external.object({ status: exports_external.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, exports_external.object({ cancelled: exports_external.number().int() }))
   ];
 }
 function workflowSettings(definition) {
@@ -21197,6 +21239,8 @@ class Runtime {
         continue;
       if (only && !only.includes(entry.name))
         continue;
+      if (!existsSync(join3(pluginsDir, entry.name, "app.ts")))
+        continue;
       const module = await logContext.run({ plugin: entry.name }, () => import(join3(pluginsDir, entry.name, "app.ts")));
       await this.add(entry.name, module.default);
     }
@@ -21322,9 +21366,11 @@ class Runtime {
       this.register({
         name: fullName,
         plugin: name,
-        kind: method2.kind,
+        effect: method2.effect,
+        stream: method2.stream,
         description: method2.description,
-        confirm: method2.confirm,
+        approve: method2.approve,
+        approveUpTo: method2.approveUpTo,
         http: method2.http,
         input: method2.input,
         output: method2.output,
@@ -21355,6 +21401,10 @@ class Runtime {
     })))));
   }
   async call(name, input2 = {}, options = {}) {
+    if (options.signal) {
+      const { signal, ...rest } = options;
+      return this.callSignal.run(signal, () => this.call(name, input2, rest));
+    }
     if (options.files) {
       const { files, ...rest } = options;
       const fields = input2 ?? {};
@@ -21378,17 +21428,17 @@ class Runtime {
       return runWith(where, () => this.call(name, input2, options));
     if (where !== logContext.getStore())
       return logContext.run(where, () => this.call(name, input2, options));
-    if ((options.expect === "query" || currentAccess()?.readOnly) && method2.kind === "mutation") {
+    if ((options.expect === "read" || currentAccess()?.readOnly) && method2.effect !== "read") {
       throw new MethodError("FORBIDDEN", `${name} changes data, so it only runs when the user acts.`);
     }
     const raw = input2 ?? {};
     const parsed = method2.input.parse(raw);
-    if (method2.confirm && (options.confirmed === false || workflowScope.getStore()))
-      throw new MethodError("CONFIRM", fillConfirm(method2.confirm, parsed));
-    if (method2.kind === "stream")
+    if (method2.approve && (options.confirmed === false || workflowScope.getStore()))
+      throw new MethodError("CONFIRM", fillQuestion(method2.approve, parsed));
+    if (method2.stream)
       return { result: await this.sample(name, input2), reads: [], invalidates: [] };
     const confirmed = this.callConfirmed.getStore() ?? false;
-    const run = await tracked(method2.kind === "query", (tags) => this.notifyInvalidated(tags), () => this.callConfirmed.run(confirmed || method2.confirm !== undefined, async () => {
+    const run = await tracked(method2.effect === "read", (tags) => this.notifyInvalidated(tags), () => this.callConfirmed.run(confirmed || method2.approve !== undefined, async () => {
       const result = await method2.run(parsed, raw);
       await this.events.emit(name, { input: parsed, result });
       return result;
@@ -21407,8 +21457,8 @@ class Runtime {
     const method2 = this.methods.get(name);
     if (!method2)
       throw new MethodError("NOT_FOUND", `There is no method ${name}.`);
-    if (method2.kind !== "stream")
-      throw new MethodError("VALIDATION", `${name} is a ${method2.kind}, not a stream.`);
+    if (!method2.stream)
+      throw new MethodError("VALIDATION", `${name} is not a stream.`);
     const raw = input2 ?? {};
     const parsed = method2.input.parse(raw);
     const root = options.root ?? this.callRoot.getStore() ?? this.root;
@@ -21463,7 +21513,7 @@ class Runtime {
     const statuses = [];
     for (const entry of entries) {
       const timezone = entry.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
-      const signature = `${entry.plugin}.${entry.method} ${entry.schedule} ${timezone}`;
+      const signature = `${entry.plugin}.${entry.method} ${entry.schedule} ${timezone} ${entry.root ?? ""}`;
       try {
         const job = kept.get(signature) ?? this.cronJob(entry, timezone, signature);
         jobs.push(job);
@@ -21495,9 +21545,9 @@ class Runtime {
     const method2 = this.methods.get(name);
     if (!method2 || method2.plugin !== entry.plugin)
       throw new Error(`${entry.method} isn't one of ${entry.plugin}'s methods`);
-    if (method2.kind === "stream")
-      throw new Error(`${name} is a stream; a cron runs a query or a mutation`);
-    if (method2.confirm)
+    if (method2.stream)
+      throw new Error(`${name} is a stream; a cron runs a read or a write`);
+    if (method2.approve)
       throw new Error(`${name} asks before it runs, so nothing may run it on a schedule`);
     if (!method2.input.safeParse({}).success)
       throw new Error(`${name} needs input; a cron calls it with {}`);
@@ -21513,6 +21563,7 @@ class Runtime {
     return {
       signature,
       plugin: entry.plugin,
+      root: entry.root,
       method: name,
       schedule: entry.schedule,
       timezone,
@@ -21537,7 +21588,7 @@ class Runtime {
       job.running = true;
       job.lastRunAt = now;
       const startedAt = Date.now();
-      started.push(this.call(job.method, {}, { caller: "cron" }).then(() => {
+      started.push(this.call(job.method, {}, { caller: "cron", root: job.root }).then(() => {
         job.lastError = null;
       }, (error62) => {
         job.lastError = toCallError(error62).message;
@@ -21598,9 +21649,11 @@ class Runtime {
       description: plugin.description ?? null,
       methods: [...this.methods.values()].filter((method2) => method2.plugin === name).map((method2) => ({
         name: method2.name,
-        kind: method2.kind,
+        effect: method2.effect,
+        stream: method2.stream ?? false,
         description: method2.description ?? null,
-        confirm: method2.confirm ?? null,
+        approve: method2.approve ?? null,
+        approveUpTo: method2.approve ? method2.approveUpTo ?? "full-access" : null,
         http: method2.http ?? null,
         input: exports_external.toJSONSchema(method2.input, { io: "input", unrepresentable: "any" }),
         output: method2.output ? exports_external.toJSONSchema(method2.output, { io: "output", unrepresentable: "any" }) : null
@@ -21674,6 +21727,9 @@ class Runtime {
   register(method2) {
     if (this.methods.has(method2.name))
       throw new Error(`${method2.name} is defined twice; rename the method or the data`);
+    if (method2.effect === "destructive" && !method2.approve) {
+      throw new Error(`${method2.name} is destructive, so it needs an approve question, such as { approve: "Delete {{id}}?" }`);
+    }
     this.methods.set(method2.name, method2);
   }
   registerGenerated(plugin, name, methods) {
@@ -21690,32 +21746,32 @@ class Runtime {
     const prefix = `${plugin}.${name}`;
     const id = exports_external.object({ id: exports_external.string() });
     const record3 = schema.extend({ id: exports_external.string(), createdAt: exports_external.string(), updatedAt: exports_external.string() });
-    const crud = (method2, kind, input2, output2, description, run, confirm) => this.register({
+    const crud = (method2, effect, input2, output2, description, run, approve) => this.register({
       name: `${prefix}.${method2}`,
       plugin,
-      kind,
+      effect,
       description,
-      confirm,
+      approve,
       input: input2,
       output: output2,
       run: async (value, raw) => run(value, raw)
     });
-    crud("list", "query", exports_external.object({
+    crud("list", "read", exports_external.object({
       limit: exports_external.number().int().positive().max(500).optional(),
       offset: exports_external.number().int().min(0).optional(),
       orderBy: exports_external.string().optional(),
       order: exports_external.enum(["asc", "desc"]).optional()
     }), exports_external.array(record3), `List ${name} records, newest first unless orderBy says`, (input2) => collection.list(input2));
-    crud("get", "query", id, record3.nullable(), `Get one ${name} record by id, or null`, (input2) => collection.get(input2.id));
-    crud("create", "mutation", schema, record3, `Create a ${name} record`, (input2) => collection.create(input2));
-    crud("update", "mutation", id.extend(schema.partial().shape), record3, `Update fields on a ${name} record`, ({ id: id2, ...fields }, raw) => collection.update(id2, Object.fromEntries(Object.entries(fields).filter(([key]) => Object.hasOwn(raw ?? {}, key)))));
-    crud("delete", "mutation", id, exports_external.null(), `Delete a ${name} record by id`, async (input2) => {
+    crud("get", "read", id, record3.nullable(), `Get one ${name} record by id, or null`, (input2) => collection.get(input2.id));
+    crud("create", "write", schema, record3, `Create a ${name} record`, (input2) => collection.create(input2));
+    crud("update", "write", id.extend(schema.partial().shape), record3, `Update fields on a ${name} record`, ({ id: id2, ...fields }, raw) => collection.update(id2, Object.fromEntries(Object.entries(fields).filter(([key]) => Object.hasOwn(raw ?? {}, key)))));
+    crud("delete", "destructive", id, exports_external.null(), `Delete a ${name} record by id`, async (input2) => {
       await collection.delete(input2.id);
       return null;
     }, "Delete this record?");
   }
 }
-function fillConfirm(question, input2) {
+function fillQuestion(question, input2) {
   const fields = input2 ?? {};
   return question.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_, field2) => {
     const value = Object.hasOwn(fields, field2) ? fields[field2] : undefined;
@@ -21738,9 +21794,9 @@ function cronState(job) {
 function mcpFailure(server, tool, error62) {
   switch (error62.code) {
     case "NOT_READ_ONLY":
-      return new MethodError("FORBIDDEN", `${server}.${tool} changes data, so it runs from a mutation, not a query.`);
+      return new MethodError("FORBIDDEN", `${server}.${tool} changes data, so it runs from a write, not a read.`);
     case "CONFIRM":
-      return new MethodError("FORBIDDEN", `${server}.${tool} may destroy data, so it runs only from a method with a confirm.`);
+      return new MethodError("FORBIDDEN", `${server}.${tool} may destroy data, so it runs only from a method with an approve.`);
   }
   return new MethodError("INTERNAL", error62.message);
 }
@@ -22848,12 +22904,12 @@ function runExecutor() {
       return;
     }
     if (message.type === "hosted") {
-      const call = waiting.get(message.id);
+      const call2 = waiting.get(message.id);
       waiting.delete(message.id);
       if (message.error)
-        call?.reject(new MethodError(message.error.code, message.error.message));
+        call2?.reject(new MethodError(message.error.code, message.error.message));
       else
-        call?.resolve(message.result);
+        call2?.resolve(message.result);
       return;
     }
     if (launched)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repogo/plugins",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Write RepoGo plugins: collections and methods over SQLite that agents and cards call",
   "type": "module",
   "exports": {
@@ -27,7 +27,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "zod": "^4.1.0"
+    "zod": "^4.6.0"
   },
   "devDependencies": {
     "@types/bun": "latest",