@repogo/plugins 0.1.43 → 0.1.45

package/dist/index.js

@@ -13,11 +13,12 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  z: () => z3,
+  z: () => z4,
   workflow: () => workflow,
   upload: () => upload,
   toCallError: () => toCallError,
   stream: () => stream,
+  remotePlugin: () => remotePlugin,
   method: () => method,
   definePlugin: () => definePlugin,
   cached: () => cached,
@@ -43,20 +44,32 @@ 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,
     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) {
@@ -66,24 +79,19 @@ function cached(input, run, options) {
     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, effect: "read", stream: true, description: options.description };
 }
-// src/uploads.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { z } from "zod";
-var callFiles = new AsyncLocalStorage;
-function upload() {
-  return z.object({ id: z.string(), name: z.string(), type: z.string(), size: z.number(), path: z.string() }).refine((file) => (callFiles.getStore() ?? []).some((held) => held.id === file.id && held.path === file.path), {
-    message: "Not a file uploaded for this call."
-  });
-}
-// src/errors.ts
+// src/remote.ts
 import { z as z2 } from "zod";
 
+// src/errors.ts
+import { z } from "zod";
+
 class MethodError extends Error {
   code;
   fieldErrors;
@@ -97,7 +105,7 @@ function toCallError(error) {
   if (error instanceof MethodError) {
     return { code: error.code, message: error.message, ...error.fieldErrors ? { fieldErrors: error.fieldErrors } : {} };
   }
-  if (error instanceof z2.ZodError) {
+  if (error instanceof z.ZodError) {
     const fieldErrors = {};
     for (const issue of error.issues)
       fieldErrors["/" + issue.path.join("/")] ??= issue.message;
@@ -108,8 +116,43 @@ function toCallError(error) {
   return { code: "INTERNAL", message: error instanceof Error ? error.message : String(error) };
 }
 
-// src/index.ts
+// src/remote.ts
+var codes = { 400: "VALIDATION", 403: "FORBIDDEN", 404: "NOT_FOUND" };
+async function remotePlugin(url, name) {
+  const base = `${url.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(z2.fromJSONSchema(m.input), (input) => call(`${base}/${m.name}`, input), {
+      effect: m.effect,
+      description: m.description ?? undefined,
+      output: m.output ? z2.fromJSONSchema(m.output) : undefined
+    });
+  }
+  return { description: listing.description ?? undefined, methods };
+}
+async function call(url, input) {
+  const response = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(input) });
+  const answer = await response.json().catch(() => null);
+  if (response.ok)
+    return answer;
+  throw new MethodError(codes[response.status] ?? "INTERNAL", answer?.error ?? `${url} answered ${response.status}`, answer?.fields ?? undefined);
+}
+// src/uploads.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { z as z3 } from "zod";
+var callFiles = new AsyncLocalStorage;
+function upload() {
+  return z3.object({ id: z3.string(), name: z3.string(), type: z3.string(), size: z3.number(), path: z3.string() }).refine((file) => (callFiles.getStore() ?? []).some((held) => held.id === file.id && held.path === file.path), {
+    message: "Not a file uploaded for this call."
+  });
+}
+
+// src/index.ts
+import { z as z4 } from "zod";
 
 // src/workflow/scope.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
@@ -138,15 +181,16 @@ class NonRetryable extends Error {
   }
 }
 export {
-  z3 as z,
+  z4 as z,
   workflow,
   upload,
   toCallError,
   stream,
+  remotePlugin,
   method,
   definePlugin,
   cached,
   NonRetryable,
   MethodError
 };
-export { parseDuration, callFiles, MethodError, toCallError, attemptScope, workflowScope, workflowContext, exports_src };
+export { parseDuration, MethodError, toCallError, callFiles, attemptScope, workflowScope, workflowContext, exports_src };

package/dist/remote.d.ts

@@ -0,0 +1,7 @@
+import { type PluginDefinition } from "./define";
+/**
+ * A plugin whose methods run on another host: each method `name` opens to
+ * `device` at `url` (such as http://192.168.64.1:47444), with its schemas, as
+ * a request there. That host keeps the plugin's code, keys and data.
+ */
+export declare function remotePlugin(url: string, name: string): Promise<PluginDefinition>;

package/dist/runtime.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { type Schedule } from "./cron";
 import type { Caller, CronEntry, CronStatus, Manifest, Notice } from "./context";
 export type { Manifest, ManifestCron, ManifestMethod } from "./context";
-import type { Effect, HTTPAccess, PluginDefinition } from "./define";
+import type { Effect, HTTPAddresses, PermissionMode, PluginDefinition } from "./define";
 import { EventBus } from "./events";
 import type { WorkflowBridge } from "./workflow/contracts";
 import { type UploadedFile } from "./uploads";
@@ -12,8 +12,9 @@ export type RegisteredMethod = {
     effect: Effect;
     stream?: true;
     description?: string;
-    confirm?: string;
-    http?: HTTPAccess;
+    approve?: string;
+    approveUpTo?: PermissionMode;
+    http?: HTTPAddresses;
     input: z.ZodType;
     output?: z.ZodType;
     /** `raw` is the input as sent, before defaults filled it in. */
@@ -74,11 +75,11 @@ export declare class Runtime {
     private constructor();
     /** The caller's project while a call runs, for plugins that serve every project. */
     private callRoot;
-    /** A running stream's signal, `ctx.signal` to the code it runs. */
+    /** A running stream's or cancelable call's signal, `ctx.signal` to the code it runs. */
     private callSignal;
     /** Who started the outermost call, `ctx.caller` to the code it runs. */
     private callCaller;
-    /** Whether the user answered a `confirm` for this call or one it runs within, which a destructive MCP tool needs. */
+    /** Whether the user answered an `approve` for this call or one it runs within, which a destructive MCP tool needs. */
     private callConfirmed;
     /** Read through `ctx.plugins()` and written as each cron run starts and ends; this runtime's own, so other Workers aren't stirred. */
     private cronsTag;
@@ -117,6 +118,7 @@ export declare class Runtime {
         caller?: Caller;
         chat?: string;
         files?: UploadedFile[];
+        signal?: AbortSignal;
     }): Promise<CallResult>;
     /**
      * Runs a stream method, passing each item it yields to `onItem` until it

package/dist/testing.d.ts

@@ -41,7 +41,7 @@ export type TestMCP = (call: TestMCPCall) => unknown;
 /** Stands in for the host's methods (`chats.start`, `git.status`, …) behind `ctx.host` and `ctx.agent`; throw a MethodError to refuse. */
 export type TestHost = (method: string, params: unknown) => unknown;
 /**
- * `const app = await testRuntime({ notes })`, then `await app.call("notes.add", { text: "hi" })`.
+ * `const app = await testRuntime({ notes })`, then `await app.call("notes.notes.create", { text: "hi" })`.
  * `ctx.root` is an empty temporary folder unless `root` names a fixture project;
  * `mcp` answers `ctx.mcp`, `host` the other host methods. Console lines still print.
  */

package/dist/testing.js

@@ -979,7 +979,7 @@ function kvMethods(name, kv, schema) {
       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)
     }
   };
@@ -1028,7 +1028,7 @@ function streamMethods(name, stream, schema) {
       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)
     }
   };
@@ -1109,7 +1109,7 @@ function bucketMethods(name, bucket, schema) {
       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)
     }
   };
@@ -1503,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(),
@@ -1526,13 +1526,13 @@ 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, effect, input, description, confirm, output) => ({
+  const spec = (method, effect, input, description, approve, output) => ({
     name: `${plugin}.${name}.${method}`,
     plugin,
     effect,
     input,
     description,
-    confirm,
+    approve,
     output,
     run: async (input2, raw) => {
       if (effect === "read")
@@ -1544,7 +1544,7 @@ function workflowMethods(plugin, namespace, name, definition, ctx, bridge, direc
   return [
     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.confirm, RunSummarySchema),
+    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),
@@ -1738,7 +1738,8 @@ class Runtime {
         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,
@@ -1769,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 ?? {};
@@ -1797,12 +1802,12 @@ class Runtime {
     }
     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.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.effect === "read", (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;
@@ -1911,7 +1916,7 @@ class Runtime {
       throw new Error(`${entry.method} isn't one of ${entry.plugin}'s methods`);
     if (method.stream)
       throw new Error(`${name} is a stream; a cron runs a read or a write`);
-    if (method.confirm)
+    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 {}`);
@@ -2016,7 +2021,8 @@ class Runtime {
         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
@@ -2090,8 +2096,8 @@ 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.confirm) {
-      throw new Error(`${method.name} is destructive, so it needs a confirm question, such as { confirm: "Delete {{id}}?" }`);
+    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);
   }
@@ -2109,12 +2115,12 @@ 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, effect, input, output, description, run, confirm) => this.register({
+    const crud = (method, effect, input, output, description, run, approve) => this.register({
       name: `${prefix}.${method}`,
       plugin,
       effect,
       description,
-      confirm,
+      approve,
       input,
       output,
       run: async (value, raw) => run(value, raw)
@@ -2134,7 +2140,7 @@ class Runtime {
     }, "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;
@@ -2159,7 +2165,7 @@ function mcpFailure(server, tool, error) {
     case "NOT_READ_ONLY":
       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<{