openwork-server 0.18.57 → 0.18.58

package/dist/opencode-plugins/openwork-extensions-preview-steering.js

@@ -47,7 +47,7 @@ const connectCatalogResponseSchema = z.object({
     instruction: z.string(),
 }).passthrough();
 export const OPENWORK_GOOGLE_CONNECTION_INSTRUCTION = `Google Workspace uses OpenWork Cloud Connect only, with the member's Google connection managed by the Cloud backend. Do not set up local Google OAuth, request Google tokens, or offer a legacy Google extension or another provider stack. OpenWork Cloud readiness alone does not establish Google connection readiness. When the user requests Google setup or the requested operation is blocked by its connection, follow the exact live Cloud connection status action returned for that connection under the openwork-cloud server instructions. Never invent a connection status, connection id, or setup action; if no live status action is available, report that limitation.
-For Google Drive uploads and Gmail attachments, Cloud search results alone do not establish that upload is unavailable. Discover the native Gmail draft schema before declaring attachments unsupported: OpenWork fulfills its attachment paths through host file transport, preserving the selected connection. Draft creation does not send email; sending is a separate, permissioned operation that requires the user's authorization. For Google Drive uploads, when OpenWork host tools are exposed, first query extension.actions with extensionId openwork-cloud-uploads. Only if drive_upload_file is returned and the user authorizes the upload, execute that exact action through openwork_execute id extension.call with extensionId openwork-cloud-uploads and args containing path and optional folderId. This host action supports files up to 4 MiB under authorized roots and preserves bytes outside model context. Drive uses the member's default Google connection and cannot select another named connection; do not substitute it for a requested account unless it is confirmed to be the default. If using the Gmail host action directly, only if gmail_create_draft_with_attachments is returned and the user authorizes draft creation, execute it with authorized paths and draft fields from its returned input schema, including the selected connectionId. It creates a reviewable draft, does not send email, and supports up to 10 files totaling 4 MiB. The bridge uses the Cloud backend member connection, not local Google credentials. Never load file bytes into model context or tool arguments, extract tokens, or use shell uploads as a fallback. If host tools or the action are absent, including in external MCP-only clients, report that limitation rather than claiming this host upload route is available. Do not retry or switch routes after an uncertain result; verify whether the draft was created first.`;
+For Google Drive uploads and Gmail attachments, Cloud search results alone do not establish that upload is unavailable. Discover the native Gmail draft schema before declaring attachments unsupported: OpenWork fulfills its attachment paths through host file transport, preserving the selected connection. Draft creation does not send email; sending is a separate, permissioned operation that requires the user's authorization. For Google Drive uploads, when OpenWork host tools are exposed, first query extension.actions with extensionId openwork-cloud-uploads. Only if drive_upload_file is returned and the user authorizes the upload, execute that exact action through openwork_execute id extension.call with extensionId openwork-cloud-uploads and args containing path and optional folderId. This host action preserves bytes outside model context under authorized roots. Pass connectionId to preserve a requested Google Workspace account; omission uses the default. Files above 4 MiB use resumable transport when enabled for the organization; the host keeps the session URL out of model context. External clients with file transport may discover createGoogleDriveUploadSession and upload only the authorized file to its returned Google session URL without OAuth headers. That returned URL is a secret bearer credential (valid for up to a week): never print, share, log or persist it, and query the same session after an uncertain PUT instead of creating another session. If using the Gmail host action directly, only if gmail_create_draft_with_attachments is returned and the user authorizes draft creation, execute it with authorized paths and draft fields from its returned input schema, including the selected connectionId. It creates a reviewable draft, does not send email, and supports up to 10 files totaling 4 MiB. The bridge uses the Cloud backend member connection, not local Google credentials. Never load file bytes into model context or tool arguments, extract OAuth tokens, or improvise shell uploads as a fallback. A discovered createGoogleDriveUploadSession capability explicitly authorizes direct file transport to its returned session URL only after the user requests the upload. If host tools or the action are absent, including in external MCP-only clients, report that limitation rather than claiming this host upload route is available. Do not retry or switch routes after an uncertain result; verify whether the draft was created first.`;
 export const OPENWORK_EXTENSION_DISCOVERY_INSTRUCTION = `If the user asks for something you cannot do with obvious built-in tools, check OpenWork extensions before saying the capability is unavailable. Use openwork_query with id extension.actions to inspect available extension actions, then openwork_execute with id extension.call for the matching action. Do not use another route to bypass a failed connection; follow its connection guidance. ${OPENWORK_GOOGLE_CONNECTION_INSTRUCTION}`;
 export const OPENWORK_CLOUD_SKILL_AUTHORING_INSTRUCTION = "Skill creation: Cloud. When the user asks to create a skill, retrieve and follow the listed create-skill remote skill by calling openwork-cloud_get_skill with { name: \"create-skill\" }, or openwork-cloud_execute_capability with its exact <capability> when get_skill is not exposed. Create the skill in OpenWork Cloud as a private plugin, not in the workspace. For later steps, use share-plugin when the user wants a specific person or team to use a skill, and use add-to-marketplace or add-user-to-marketplace only when the user asks. Use a workspace-local skill only when the user explicitly requests one. Do not create both copies.";
 export const OPENWORK_LOCAL_SKILL_AUTHORING_INSTRUCTION = "Skill creation: Local. Create or update a workspace-local skill only when the user requests one. Keep one skill in .opencode/skills/<skill-name>/SKILL.md, validate it, and re-read it after writing. Do not create a Cloud copy.";

package/dist/opencode-plugins/openwork-extensions-preview.js

@@ -49,6 +49,13 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 import { AsyncLocalStorage } from "node:async_hooks";
 var openworkReadTransport = new AsyncLocalStorage;
 
+// src/opencode-plugins/opencode-stop-fence-client.ts
+async function assertSessionContinuation(post, input) {
+  if (!input.directory)
+    return;
+  await post("/experimental/session-stop-fence/check", input, AbortSignal.timeout(15000));
+}
+
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -13704,7 +13711,7 @@ function createV2ReadAdapter(read) {
       return { all: [...catalog.values()], connected: [...catalog.keys()] };
     }
     if (url2.pathname === "/question")
-      return items(await native("/api/form/request"));
+      return items(await native("/api/form"));
     const target = /^\/session\/([^/]+)(\/message|\/children)?$/.exec(url2.pathname);
     if (!target)
       throw new Error("Unsupported native engine read");
@@ -14356,12 +14363,16 @@ var automationExecutionTargetSchema = exports_external.enum(["desktop", "cloud"]
 var AUTOMATION_MODEL_ATTENTION_CAPABILITY = "model_attention_v1";
 var REMOTE_SESSION_DESKTOP_RUNNER_CAPABILITY = "remote_session_v1";
 var REMOTE_SESSION_CONTROL_RUNNER_CAPABILITY = "remote_session_control_v1";
+var REMOTE_SESSION_ONLY_RUNNER_CAPABILITY = "remote_session_only_v1";
+var REMOTE_SESSION_RECOVERY_RUNNER_CAPABILITY = "remote_session_recovery_v1";
 var automationDesktopRunnerCapabilitySchema = exports_external.enum([
   AUTOMATION_MODEL_ATTENTION_CAPABILITY,
   REMOTE_SESSION_DESKTOP_RUNNER_CAPABILITY,
-  REMOTE_SESSION_CONTROL_RUNNER_CAPABILITY
+  REMOTE_SESSION_CONTROL_RUNNER_CAPABILITY,
+  REMOTE_SESSION_ONLY_RUNNER_CAPABILITY,
+  REMOTE_SESSION_RECOVERY_RUNNER_CAPABILITY
 ]);
-var AUTOMATION_DESKTOP_RUNNER_CAPABILITY_LIMIT = 3;
+var AUTOMATION_DESKTOP_RUNNER_CAPABILITY_LIMIT = 5;
 var automationDesktopRunnerRegistrationSchema = exports_external.object({
   runnerId: idSchema.min(8),
   protocolVersion: exports_external.literal(1),
@@ -14568,6 +14579,7 @@ var remoteSessionTranscriptMessageSchema = exports_external.object({
   error: remoteSessionCommandErrorSchema.nullable()
 });
 var remoteSessionReadResultSchema = exports_external.object({
+  historyScope: exports_external.enum(["full", "context"]).optional(),
   title: exports_external.string().max(240).nullable(),
   status: remoteSessionStatusSchema,
   waitingFor: remoteSessionWaitingForSchema.nullable(),
@@ -14756,6 +14768,20 @@ var automationListSchema = exports_external.object({
   })),
   nextCursor: exports_external.string().nullable()
 }).meta({ ref: "AutomationList" });
+var AUTOMATION_RUN_RANGE_MAX_DAYS = 45;
+var automationRunRangeQuerySchema = exports_external.object({
+  from: exports_external.coerce.number().int().nonnegative().describe("Inclusive lower bound, epoch milliseconds."),
+  to: exports_external.coerce.number().int().positive().describe("Exclusive upper bound, epoch milliseconds."),
+  cursor: exports_external.string().trim().min(1).max(160).optional().describe("nextCursor from the previous page."),
+  limit: exports_external.coerce.number().int().min(1).max(500).optional().describe("Maximum runs to scan for this page (default 200).")
+}).refine((value) => value.to > value.from, { message: "to must be after from", path: ["to"] }).refine((value) => value.to - value.from <= AUTOMATION_RUN_RANGE_MAX_DAYS * 24 * 60 * 60 * 1000, {
+  message: `The range may cover at most ${AUTOMATION_RUN_RANGE_MAX_DAYS} days`,
+  path: ["to"]
+});
+var automationRunRangeSchema = exports_external.object({
+  items: exports_external.array(automationRunSchema),
+  nextCursor: exports_external.string().nullable()
+}).meta({ ref: "AutomationRunRange" });
 var automationDetailSchema = exports_external.object({
   automation: automationSchema,
   revision: automationRevisionSchema,
@@ -14857,7 +14883,7 @@ var connectCatalogResponseSchema = exports_external.object({
   instruction: exports_external.string()
 }).passthrough();
 var OPENWORK_GOOGLE_CONNECTION_INSTRUCTION = `Google Workspace uses OpenWork Cloud Connect only, with the member's Google connection managed by the Cloud backend. Do not set up local Google OAuth, request Google tokens, or offer a legacy Google extension or another provider stack. OpenWork Cloud readiness alone does not establish Google connection readiness. When the user requests Google setup or the requested operation is blocked by its connection, follow the exact live Cloud connection status action returned for that connection under the openwork-cloud server instructions. Never invent a connection status, connection id, or setup action; if no live status action is available, report that limitation.
-For Google Drive uploads and Gmail attachments, Cloud search results alone do not establish that upload is unavailable. Discover the native Gmail draft schema before declaring attachments unsupported: OpenWork fulfills its attachment paths through host file transport, preserving the selected connection. Draft creation does not send email; sending is a separate, permissioned operation that requires the user's authorization. For Google Drive uploads, when OpenWork host tools are exposed, first query extension.actions with extensionId openwork-cloud-uploads. Only if drive_upload_file is returned and the user authorizes the upload, execute that exact action through openwork_execute id extension.call with extensionId openwork-cloud-uploads and args containing path and optional folderId. This host action supports files up to 4 MiB under authorized roots and preserves bytes outside model context. Drive uses the member's default Google connection and cannot select another named connection; do not substitute it for a requested account unless it is confirmed to be the default. If using the Gmail host action directly, only if gmail_create_draft_with_attachments is returned and the user authorizes draft creation, execute it with authorized paths and draft fields from its returned input schema, including the selected connectionId. It creates a reviewable draft, does not send email, and supports up to 10 files totaling 4 MiB. The bridge uses the Cloud backend member connection, not local Google credentials. Never load file bytes into model context or tool arguments, extract tokens, or use shell uploads as a fallback. If host tools or the action are absent, including in external MCP-only clients, report that limitation rather than claiming this host upload route is available. Do not retry or switch routes after an uncertain result; verify whether the draft was created first.`;
+For Google Drive uploads and Gmail attachments, Cloud search results alone do not establish that upload is unavailable. Discover the native Gmail draft schema before declaring attachments unsupported: OpenWork fulfills its attachment paths through host file transport, preserving the selected connection. Draft creation does not send email; sending is a separate, permissioned operation that requires the user's authorization. For Google Drive uploads, when OpenWork host tools are exposed, first query extension.actions with extensionId openwork-cloud-uploads. Only if drive_upload_file is returned and the user authorizes the upload, execute that exact action through openwork_execute id extension.call with extensionId openwork-cloud-uploads and args containing path and optional folderId. This host action preserves bytes outside model context under authorized roots. Pass connectionId to preserve a requested Google Workspace account; omission uses the default. Files above 4 MiB use resumable transport when enabled for the organization; the host keeps the session URL out of model context. External clients with file transport may discover createGoogleDriveUploadSession and upload only the authorized file to its returned Google session URL without OAuth headers. That returned URL is a secret bearer credential (valid for up to a week): never print, share, log or persist it, and query the same session after an uncertain PUT instead of creating another session. If using the Gmail host action directly, only if gmail_create_draft_with_attachments is returned and the user authorizes draft creation, execute it with authorized paths and draft fields from its returned input schema, including the selected connectionId. It creates a reviewable draft, does not send email, and supports up to 10 files totaling 4 MiB. The bridge uses the Cloud backend member connection, not local Google credentials. Never load file bytes into model context or tool arguments, extract OAuth tokens, or improvise shell uploads as a fallback. A discovered createGoogleDriveUploadSession capability explicitly authorizes direct file transport to its returned session URL only after the user requests the upload. If host tools or the action are absent, including in external MCP-only clients, report that limitation rather than claiming this host upload route is available. Do not retry or switch routes after an uncertain result; verify whether the draft was created first.`;
 var OPENWORK_EXTENSION_DISCOVERY_INSTRUCTION = `If the user asks for something you cannot do with obvious built-in tools, check OpenWork extensions before saying the capability is unavailable. Use openwork_query with id extension.actions to inspect available extension actions, then openwork_execute with id extension.call for the matching action. Do not use another route to bypass a failed connection; follow its connection guidance. ${OPENWORK_GOOGLE_CONNECTION_INSTRUCTION}`;
 var OPENWORK_LOCAL_SKILL_AUTHORING_INSTRUCTION = "Skill creation: Local. Create or update a workspace-local skill only when the user requests one. Keep one skill in .opencode/skills/<skill-name>/SKILL.md, validate it, and re-read it after writing. Do not create a Cloud copy.";
 var OPENWORK_ON_DEMAND_DISCOVERY_INSTRUCTION = `For remote skills and plugin instructions, read the exact known remote skill with openwork-cloud_get_skill by its name or capability, or list every available one with openwork-cloud_list_skills; when those tools are not exposed, execute the exact known remote skill capability with openwork-cloud_execute_capability, or discover it with openwork-cloud_search_capabilities, then execute the exact returned name and follow its instructions. Discover Workflows and Automations on demand; read live before reporting their current state. Follow the openwork-cloud server instructions when its tools are exposed. No Cloud readiness probe has been performed for this prompt; do not infer that Cloud is ready, disconnected, or unavailable.
@@ -16370,6 +16396,11 @@ var OpenWorkExtensionsPreview = async (factoryInput, _options, dependencies) =>
     "tool.execute.before": fulfillGmailAttachments.before,
     event: fulfillGmailAttachments.event,
     dispose: fulfillGmailAttachments.dispose,
+    "chat.params": async (input) => {
+      if (!serverUrl2() || !serverToken2())
+        return;
+      await assertSessionContinuation(postJson, { directory: engineMcpStatusDirectory, sessionID: input.sessionID });
+    },
     "chat.headers": async (input, output) => {
       if (input.model.providerID !== "openwork" && input.model.providerID !== "openwork-free")
         return;

package/dist/opencode-plugins/openwork-mcp-readiness-v2.js

@@ -0,0 +1,192 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/opencode-plugins/openwork-mcp-readiness-v2.ts
+import { Context, Effect, Option, Schema, Scope } from "effect";
+
+// src/opencode-v2-mcp-readiness.ts
+var MCP_READINESS_RPC_ID = "openwork.mcp-readiness";
+var mcpNamespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var mcpToolId = (server, name) => `${mcpNamespace(server)}_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+function mcpBindingsReady(current, server, desired, previous) {
+  const published = new Set(current.filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id));
+  const wanted = new Set(desired);
+  return desired.every((id) => published.has(id)) && previous.every((id) => wanted.has(id) || !published.has(id));
+}
+async function waitForMcpBindings(registry, server, desired, previous, signal) {
+  signal.throwIfAborted();
+  const current = await registry.list();
+  signal.throwIfAborted();
+  if (mcpBindingsReady(current, server, desired, previous))
+    return;
+  let closed = false;
+  let queued = false;
+  let registration;
+  let resolve = () => {};
+  let reject = () => {};
+  const ready = new Promise((accept, fail2) => {
+    resolve = accept;
+    reject = fail2;
+  });
+  ready.catch(() => {});
+  const fail = (error) => {
+    if (closed)
+      return;
+    closed = true;
+    reject(error);
+  };
+  const abort = () => fail(signal.reason ?? new Error("MCP readiness canceled"));
+  const observe = () => {
+    if (closed || queued)
+      return;
+    queued = true;
+    queueMicrotask(() => {
+      queued = false;
+      if (closed)
+        return;
+      registry.list().then((current2) => {
+        if (closed || !mcpBindingsReady(current2, server, desired, previous))
+          return;
+        closed = true;
+        resolve();
+      }, fail);
+    });
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    signal.throwIfAborted();
+    registration = await registry.transform(observe);
+    await ready;
+  } finally {
+    closed = true;
+    signal.removeEventListener("abort", abort);
+    await registration?.dispose();
+  }
+}
+
+// src/opencode-plugins/openwork-mcp-readiness-v2.ts
+class NativeMcp extends Context.Service()("@opencode/MCP") {
+}
+
+class NativeMcpTool extends Context.Service()("@opencode/McpTool") {
+}
+var serverSchema = { type: "string", minLength: 1 };
+var toolsSchema = { type: "array", maxItems: 4096, items: { type: "string", minLength: 1 } };
+var definition = {
+  id: MCP_READINESS_RPC_ID,
+  methods: {
+    catalog: {
+      input: { type: "object", properties: { server: serverSchema }, required: ["server"], additionalProperties: false },
+      output: { type: "object", properties: { tools: toolsSchema }, required: ["tools"], additionalProperties: false }
+    },
+    waitForTools: {
+      input: { type: "object", properties: { server: serverSchema }, required: ["server"], additionalProperties: false },
+      output: { type: "object", properties: { ready: { const: true } }, required: ["ready"], additionalProperties: false }
+    }
+  },
+  events: {}
+};
+var serverInput = Schema.Struct({ server: Schema.String });
+var inputServer = (input) => Schema.decodeUnknownSync(serverInput)(input).server;
+var nativeCatalog = Effect.gen(function* () {
+  const context = yield* Effect.context();
+  const mcp = Context.getOption(context, NativeMcp);
+  const source = Context.getOption(context, NativeMcpTool);
+  if (Option.isNone(mcp) || Option.isNone(source))
+    return yield* Effect.die(new Error("Native MCP readiness services are unavailable"));
+  yield* source.value.flush;
+  return mcp.value;
+});
+var waitForNativeMcpBindings = Effect.fn("OpenWorkMcp.waitForBindings")(function* (tool, server, desired, previous) {
+  const scope = yield* Scope.Scope;
+  yield* Effect.tryPromise({
+    try: (signal) => waitForMcpBindings({
+      list: () => Effect.runPromise(tool.list()),
+      transform: async (observe) => {
+        const registration = await Effect.runPromise(tool.transform(observe).pipe(Effect.provideService(Scope.Scope, scope)));
+        return { dispose: () => Effect.runPromise(registration.dispose) };
+      }
+    }, server, desired, previous, signal),
+    catch: (cause) => cause
+  });
+}, Effect.orDie);
+var openwork_mcp_readiness_v2_default = {
+  id: MCP_READINESS_RPC_ID,
+  effect: (ctx) => {
+    const supported = () => {
+      if (ctx.app.version !== "2.0.26")
+        throw new Error("Review the native MCP readiness bridge before changing the engine pin");
+    };
+    return ctx.rpc.register(definition, {
+      catalog: Effect.fn("OpenWorkMcp.catalog")(function* (input) {
+        supported();
+        const server = inputServer(input);
+        const mcp = yield* nativeCatalog;
+        const discovered = (yield* mcp.tools()).filter((tool) => tool.server === server).map((tool) => mcpToolId(server, tool.name));
+        const published = (yield* ctx.tool.list()).filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id);
+        return { tools: [...new Set([...discovered, ...published])].sort() };
+      }),
+      waitForTools: Effect.fn("OpenWorkMcp.waitForTools")(function* (input) {
+        supported();
+        const server = inputServer(input);
+        const mcp = yield* nativeCatalog;
+        yield* ctx.tool.reload();
+        const previous = (yield* ctx.tool.list()).filter((tool) => tool.options?.namespace === mcpNamespace(server)).map((tool) => tool.id);
+        const target = (yield* mcp.servers()).find((item) => item.name === server);
+        if (target && !["connected", "disabled"].includes(target.status.status)) {
+          return yield* Effect.die(new Error(`MCP ${server} is ${target.status.status}, not executable`));
+        }
+        const desired = (yield* mcp.tools()).filter((tool) => tool.server === server).map((tool) => mcpToolId(server, tool.name));
+        yield* waitForNativeMcpBindings(ctx.tool, server, desired, previous).pipe(Effect.scoped);
+        return { ready: true };
+      })
+    }).pipe(Effect.asVoid);
+  }
+};
+export {
+  openwork_mcp_readiness_v2_default as default
+};