@repogo/plugins 0.1.42 → 0.1.44

package/dist/testing.js

@@ -91,6 +91,7 @@ function carryable(value) {
 
 // src/runtime.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+import { existsSync } from "fs";
 import { mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
 import { join as join3 } from "path";
 import { z as z5 } from "zod";
@@ -155,7 +156,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) {
@@ -953,32 +954,32 @@ function kvMethods(name, kv, schema) {
   const entry = z.object({ key: z.string(), value: schema, expiresAt: z.string().nullable(), createdAt: z.string(), updatedAt: z.string() });
   return {
     get: {
-      kind: "query",
+      effect: "read",
       description: `Get one ${name} entry by key, or null`,
       input: z.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: z.object({ prefix: z.string().optional(), limit }),
       output: z.array(entry),
       run: (input) => kv.list(input)
     },
     set: {
-      kind: "mutation",
+      effect: "write",
       description: `Set a ${name} key; ttl ("5m", "1h", "7d" or ms) makes it expire`,
       input: z.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: z.object({ key }),
       output: z.null(),
-      confirm: "Delete this key?",
+      approve: "Delete this key?",
       run: async ({ key: key2 }) => (await kv.delete(key2), null)
     }
   };
@@ -988,45 +989,46 @@ function streamMethods(name, stream, schema) {
   const line = z.object({ id: z.string(), key: z.string(), offset: z.number(), at: z.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: z.object({ key, from: z.number().int().min(0).optional(), last: z.number().int().positive().max(500).optional() }),
       run: ({ key: key2, from, last }, signal) => stream.follow(key2, { from, last, signal })
     },
     read: {
-      kind: "query",
+      effect: "read",
       description: `Read a ${name} key's lines from an offset`,
       input: z.object({ key, from: z.number().int().min(0).optional(), limit }),
       output: z.array(line),
       run: ({ key: key2, ...options }) => stream.read(key2, options)
     },
     keys: {
-      kind: "query",
+      effect: "read",
       description: `List ${name} keys, most recently written first`,
       input: z.object({ limit }),
       output: z.array(z.object({ key: z.string(), lines: z.number(), bytes: z.number(), endedAt: z.string().nullable(), updatedAt: z.string() })),
       run: (input) => stream.keys(input)
     },
     append: {
-      kind: "mutation",
+      effect: "write",
       description: `Append a line to a ${name} key`,
       input: z.object({ key, data: schema }),
       output: line,
       run: ({ key: key2, data }) => stream.append(key2, data)
     },
     end: {
-      kind: "mutation",
+      effect: "write",
       description: `End a ${name} key: followers stop and appends fail`,
       input: z.object({ key }),
       output: z.null(),
       run: async ({ key: key2 }) => (await stream.end(key2), null)
     },
     delete: {
-      kind: "mutation",
+      effect: "destructive",
       description: `Delete a ${name} key and its lines`,
       input: z.object({ key }),
       output: z.null(),
-      confirm: "Delete this stream and its lines?",
+      approve: "Delete this stream and its lines?",
       run: async ({ key: key2 }) => (await stream.delete(key2), null)
     }
   };
@@ -1051,28 +1053,28 @@ function bucketMethods(name, bucket, schema) {
   const revision = z.number().int().optional();
   return {
     list: {
-      kind: "query",
+      effect: "read",
       description: `List ${name} files, newest first, optionally in one folder or with one status`,
       input: z.object({ folder: z.string().optional(), status: status.optional(), limit }),
       output: z.array(file),
       run: (input) => bucket.list(input)
     },
     search: {
-      kind: "query",
+      effect: "read",
       description: `Search ${name} files by name, folder and meta`,
       input: z.object({ query: z.string(), limit }),
       output: z.array(file),
       run: ({ query, limit: limit2 }) => bucket.search(query, { limit: limit2 })
     },
     get: {
-      kind: "query",
+      effect: "read",
       description: `Get one ${name} file by id, or null`,
       input: z.object({ id }),
       output: file.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: z.object({
         name: z.string(),
@@ -1089,25 +1091,25 @@ function bucketMethods(name, bucket, schema) {
       }
     },
     update: {
-      kind: "mutation",
+      effect: "write",
       description: `Change fields of a ${name} file's meta; null removes one`,
       input: z.object({ id, meta: z.record(z.string(), z.unknown()), revision }),
       output: file,
       run: ({ id: id2, meta, revision: revision2 }) => bucket.update(id2, meta, { revision: revision2 })
     },
     move: {
-      kind: "mutation",
+      effect: "write",
       description: `Rename a ${name} file or move it to another folder`,
       input: z.object({ id, name: z.string().optional(), folder: z.string().optional(), revision }),
       output: file,
       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: z.object({ id }),
       output: z.null(),
-      confirm: "Delete this file?",
+      approve: "Delete this file?",
       run: async ({ id: id2 }) => (await bucket.delete(id2), null)
     }
   };
@@ -1501,7 +1503,7 @@ var RunMetadataSchema = z3.object({
   root: z3.string().refine(isAbsolute2),
   namespace: z3.string().regex(/^[a-z0-9][a-z0-9.-]*$/),
   plugin: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  caller: z3.enum(["card", "agent", "cron", "code", "http"]),
+  caller: z3.enum(["card", "agent", "cron", "code", "http", "device"]),
   workflow: z3.string().regex(/^[a-z][a-zA-Z0-9_-]*$/),
   input: z3.json(),
   key: z3.string().nullable(),
@@ -1524,29 +1526,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, settings: workflowSettings(definition) });
   };
   const id = z4.object({ id: z4.string().uuid() }).strict();
-  const spec = (method, kind, input, description, confirm, output) => ({
+  const spec = (method, effect, input, description, approve, output) => ({
     name: `${plugin}.${name}.${method}`,
     plugin,
-    kind,
+    effect,
     input,
     description,
-    confirm,
+    approve,
     output,
     run: async (input2, raw) => {
-      if (kind === "query")
+      if (effect === "read")
         recordRead(workflowTag(namespace));
       const request = method === "start" ? { ...input2, input: raw.input } : input2;
       return invoke(method, request);
     }
   });
   return [
-    spec("list", "query", z4.object({ limit: z4.number().int().min(1).max(100).default(20), status: z4.string().optional(), cursor: z4.string().optional() }).strict(), "List workflow runs", undefined, z4.object({ items: z4.array(RunSummarySchema), cursor: z4.string().nullable() })),
-    spec("get", "query", id, "Get one workflow run"),
-    spec("start", "mutation", z4.object({ input: definition.input, key: z4.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", z4.object({ status: z4.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, z4.object({ cancelled: z4.number().int() }))
+    spec("list", "read", z4.object({ limit: z4.number().int().min(1).max(100).default(20), status: z4.string().optional(), cursor: z4.string().optional() }).strict(), "List workflow runs", undefined, z4.object({ items: z4.array(RunSummarySchema), cursor: z4.string().nullable() })),
+    spec("get", "read", id, "Get one workflow run"),
+    spec("start", "write", z4.object({ input: definition.input, key: z4.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", z4.object({ status: z4.string().optional() }).strict(), "Cancel every unfinished run, or only those in one status", undefined, z4.object({ cancelled: z4.number().int() }))
   ];
 }
 function workflowSettings(definition) {
@@ -1606,6 +1608,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);
     }
@@ -1731,9 +1735,11 @@ class Runtime {
       this.register({
         name: fullName,
         plugin: name,
-        kind: method.kind,
+        effect: method.effect,
+        stream: method.stream,
         description: method.description,
-        confirm: method.confirm,
+        approve: method.approve,
+        approveUpTo: method.approveUpTo,
         http: method.http,
         input: method.input,
         output: method.output,
@@ -1764,6 +1770,10 @@ class Runtime {
     })))));
   }
   async call(name, input = {}, options = {}) {
+    if (options.signal) {
+      const { signal, ...rest } = options;
+      return this.callSignal.run(signal, () => this.call(name, input, rest));
+    }
     if (options.files) {
       const { files, ...rest } = options;
       const fields = input ?? {};
@@ -1787,17 +1797,17 @@ class Runtime {
       return runWith(where, () => this.call(name, input, options));
     if (where !== logContext.getStore())
       return logContext.run(where, () => this.call(name, input, options));
-    if ((options.expect === "query" || currentAccess()?.readOnly) && method.kind === "mutation") {
+    if ((options.expect === "read" || currentAccess()?.readOnly) && method.effect !== "read") {
       throw new MethodError("FORBIDDEN", `${name} changes data, so it only runs when the user acts.`);
     }
     const raw = input ?? {};
     const parsed = method.input.parse(raw);
-    if (method.confirm && (options.confirmed === false || workflowScope.getStore()))
-      throw new MethodError("CONFIRM", fillConfirm(method.confirm, parsed));
-    if (method.kind === "stream")
+    if (method.approve && (options.confirmed === false || workflowScope.getStore()))
+      throw new MethodError("CONFIRM", fillQuestion(method.approve, parsed));
+    if (method.stream)
       return { result: await this.sample(name, input), reads: [], invalidates: [] };
     const confirmed = this.callConfirmed.getStore() ?? false;
-    const run = await tracked(method.kind === "query", (tags) => this.notifyInvalidated(tags), () => this.callConfirmed.run(confirmed || method.confirm !== undefined, async () => {
+    const run = await tracked(method.effect === "read", (tags) => this.notifyInvalidated(tags), () => this.callConfirmed.run(confirmed || method.approve !== undefined, async () => {
       const result = await method.run(parsed, raw);
       await this.events.emit(name, { input: parsed, result });
       return result;
@@ -1816,8 +1826,8 @@ class Runtime {
     const method = this.methods.get(name);
     if (!method)
       throw new MethodError("NOT_FOUND", `There is no method ${name}.`);
-    if (method.kind !== "stream")
-      throw new MethodError("VALIDATION", `${name} is a ${method.kind}, not a stream.`);
+    if (!method.stream)
+      throw new MethodError("VALIDATION", `${name} is not a stream.`);
     const raw = input ?? {};
     const parsed = method.input.parse(raw);
     const root = options.root ?? this.callRoot.getStore() ?? this.root;
@@ -1872,7 +1882,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);
@@ -1904,9 +1914,9 @@ class Runtime {
     const method = this.methods.get(name);
     if (!method || method.plugin !== entry.plugin)
       throw new Error(`${entry.method} isn't one of ${entry.plugin}'s methods`);
-    if (method.kind === "stream")
-      throw new Error(`${name} is a stream; a cron runs a query or a mutation`);
-    if (method.confirm)
+    if (method.stream)
+      throw new Error(`${name} is a stream; a cron runs a read or a write`);
+    if (method.approve)
       throw new Error(`${name} asks before it runs, so nothing may run it on a schedule`);
     if (!method.input.safeParse({}).success)
       throw new Error(`${name} needs input; a cron calls it with {}`);
@@ -1922,6 +1932,7 @@ class Runtime {
     return {
       signature,
       plugin: entry.plugin,
+      root: entry.root,
       method: name,
       schedule: entry.schedule,
       timezone,
@@ -1946,7 +1957,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;
       }, (error) => {
         job.lastError = toCallError(error).message;
@@ -2007,9 +2018,11 @@ class Runtime {
       description: plugin.description ?? null,
       methods: [...this.methods.values()].filter((method) => method.plugin === name).map((method) => ({
         name: method.name,
-        kind: method.kind,
+        effect: method.effect,
+        stream: method.stream ?? false,
         description: method.description ?? null,
-        confirm: method.confirm ?? null,
+        approve: method.approve ?? null,
+        approveUpTo: method.approve ? method.approveUpTo ?? "full-access" : null,
         http: method.http ?? null,
         input: z5.toJSONSchema(method.input, { io: "input", unrepresentable: "any" }),
         output: method.output ? z5.toJSONSchema(method.output, { io: "output", unrepresentable: "any" }) : null
@@ -2083,6 +2096,9 @@ class Runtime {
   register(method) {
     if (this.methods.has(method.name))
       throw new Error(`${method.name} is defined twice; rename the method or the data`);
+    if (method.effect === "destructive" && !method.approve) {
+      throw new Error(`${method.name} is destructive, so it needs an approve question, such as { approve: "Delete {{id}}?" }`);
+    }
     this.methods.set(method.name, method);
   }
   registerGenerated(plugin, name, methods) {
@@ -2099,32 +2115,32 @@ class Runtime {
     const prefix = `${plugin}.${name}`;
     const id = z5.object({ id: z5.string() });
     const record2 = schema.extend({ id: z5.string(), createdAt: z5.string(), updatedAt: z5.string() });
-    const crud = (method, kind, input, output, description, run, confirm) => this.register({
+    const crud = (method, effect, input, output, description, run, approve) => this.register({
       name: `${prefix}.${method}`,
       plugin,
-      kind,
+      effect,
       description,
-      confirm,
+      approve,
       input,
       output,
       run: async (value, raw) => run(value, raw)
     });
-    crud("list", "query", z5.object({
+    crud("list", "read", z5.object({
       limit: z5.number().int().positive().max(500).optional(),
       offset: z5.number().int().min(0).optional(),
       orderBy: z5.string().optional(),
       order: z5.enum(["asc", "desc"]).optional()
     }), z5.array(record2), `List ${name} records, newest first unless orderBy says`, (input) => collection.list(input));
-    crud("get", "query", id, record2.nullable(), `Get one ${name} record by id, or null`, (input) => collection.get(input.id));
-    crud("create", "mutation", schema, record2, `Create a ${name} record`, (input) => collection.create(input));
-    crud("update", "mutation", id.extend(schema.partial().shape), record2, `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, z5.null(), `Delete a ${name} record by id`, async (input) => {
+    crud("get", "read", id, record2.nullable(), `Get one ${name} record by id, or null`, (input) => collection.get(input.id));
+    crud("create", "write", schema, record2, `Create a ${name} record`, (input) => collection.create(input));
+    crud("update", "write", id.extend(schema.partial().shape), record2, `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, z5.null(), `Delete a ${name} record by id`, async (input) => {
       await collection.delete(input.id);
       return null;
     }, "Delete this record?");
   }
 }
-function fillConfirm(question, input) {
+function fillQuestion(question, input) {
   const fields = input ?? {};
   return question.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_, field2) => {
     const value = Object.hasOwn(fields, field2) ? fields[field2] : undefined;
@@ -2147,9 +2163,9 @@ function cronState(job) {
 function mcpFailure(server, tool, error) {
   switch (error.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", error.message);
 }

package/dist/workflow/contracts.d.ts

@@ -35,7 +35,7 @@ export type WorkflowTarget = {
 export type WorkflowRequest = WorkflowTarget & {
     operation: "start" | "list" | "get" | "cancel" | "cancelAll" | "retry" | "restart";
     input: Record<string, unknown>;
-    caller?: "card" | "agent" | "cron" | "code" | "http";
+    caller?: "card" | "agent" | "cron" | "code" | "http" | "device";
     settings?: {
         timeoutMs: number;
         maxOfflineMs: number;
@@ -55,6 +55,7 @@ export declare const RunMetadataSchema: z.ZodObject<{
         cron: "cron";
         code: "code";
         http: "http";
+        device: "device";
     }>;
     workflow: z.ZodString;
     input: z.ZodJSONSchema;
@@ -79,6 +80,7 @@ export declare const RunLocationSchema: z.ZodObject<{
         cron: "cron";
         code: "code";
         http: "http";
+        device: "device";
     }>;
 }, z.core.$strict>;
 export type RunMetadata = z.infer<typeof RunMetadataSchema>;

package/dist/workflow/definition.d.ts

@@ -23,7 +23,7 @@ export declare function workflowContext(base: Context, run: RunContext & {
 export type WorkflowOptions<O extends z.ZodType = z.ZodType> = {
     description?: string;
     output?: O;
-    confirm?: string;
+    approve?: string;
     timeout?: Duration;
     maxOffline?: Duration;
     retention?: Duration;

package/dist/workflow/events.d.ts

@@ -24,6 +24,7 @@ export declare const EventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             cron: "cron";
             code: "code";
             http: "http";
+            device: "device";
         }>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{