openwork-server 0.18.57 → 0.18.59

package/dist/opencode-plugins/openwork-spreadsheets.js

@@ -13621,7 +13621,7 @@ function appendAgentInstructions(system, ...groups) {
 ${body}` : body;
 }
 
-// src/opencode-plugins/workspace-file-identity.ts
+// src/workspace-file-identity.ts
 import { constants } from "node:fs";
 import { lstat, open, realpath, rm } from "node:fs/promises";
 import { dirname, isAbsolute, relative } from "node:path";

package/dist/opencode-plugins/openwork-title-recovery.js

@@ -87,7 +87,12 @@ async function errorBody(response) {
         return null;
       text += decoder.decode(chunk.value, { stream: true });
     }
-    return JSON.parse(text + decoder.decode());
+    text += decoder.decode();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
   } catch {
     return null;
   } finally {
@@ -127,7 +132,11 @@ function correction(body, value) {
     delete target[key];
   return { body: JSON.stringify(parsed), parameter };
 }
-function failure(status) {
+function failure(status, value) {
+  const messages = typeof value === "string" ? [value] : record(value) ? [value.message, value.__type] : [];
+  if (status === 403 && messages.some((part) => typeof part === "string" && /SignatureDoesNotMatch|signature we calculated does not match/i.test(part))) {
+    return "signature_rejected";
+  }
   if (status === 401 || status === 403)
     return "access_rejected";
   if (status === 404)
@@ -148,7 +157,8 @@ function install() {
     const id = headers.get(HEADER);
     if (!id)
       return base(input, init);
-    headers.delete(HEADER);
+    if (!/^AWS4-HMAC-SHA256\s/i.test(headers.get("authorization") ?? ""))
+      headers.delete(HEADER);
     const externalSignal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
     const deadline = AbortSignal.timeout(DEADLINE_MS);
     const options = { ...init, headers, signal: externalSignal ? AbortSignal.any([externalSignal, deadline]) : deadline };
@@ -158,9 +168,10 @@ function install() {
     try {
       const response = await base(input, options);
       if (!response.ok) {
-        report(attempt, failure(response.status), response.status);
+        const value = response.status === 400 || response.status === 403 ? await errorBody(response) : null;
+        report(attempt, failure(response.status, value), response.status);
         if (!attempt.retried && response.status === 400 && typeof init?.body === "string") {
-          const recovered = correction(init.body, await errorBody(response));
+          const recovered = correction(init.body, value);
           if (recovered && attempts.get(id) === attempt && !options.signal.aborted) {
             attempt.retried = true;
             report(attempt, "retrying_parameter", response.status, recovered.parameter);
@@ -170,7 +181,8 @@ function install() {
             const retryHeaders = new Headers(headers);
             retryHeaders.delete("content-length");
             const retry = await base(input, { ...options, headers: retryHeaders, body: recovered.body });
-            report(attempt, retry.ok ? "accepted_after_recovery" : failure(retry.status), retry.status);
+            const retryError = retry.status === 403 ? await errorBody(retry) : null;
+            report(attempt, retry.ok ? "accepted_after_recovery" : failure(retry.status, retryError), retry.status);
             return retry;
           }
         }

package/dist/opencode-plugins/openwork-ui-bridge.js

@@ -49,7 +49,9 @@ async function discoverUiBridge() {
     }
     return null;
 }
-export async function uiBridgeRequest(path, options = {}) {
+export async function uiBridgeRequest(path, 
+/** `timeoutMs: null` waits until `signal` aborts. */
+options = {}) {
     const bridge = await discoverUiBridge();
     if (!bridge)
         return { ok: false, code: "browser_unavailable", dispatched: false, error: "The built-in browser is unavailable. Open the desktop app on the same machine as this task's server." };
@@ -57,7 +59,8 @@ export async function uiBridgeRequest(path, options = {}) {
         const response = await fetch(`${bridge.baseUrl}${path}`, {
             method: options.method || "GET",
             redirect: "error",
-            signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs ?? BRIDGE_TIMEOUT_MS)]) : AbortSignal.timeout(options.timeoutMs ?? BRIDGE_TIMEOUT_MS),
+            signal: options.timeoutMs === null && options.signal ? options.signal
+                : options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs ?? BRIDGE_TIMEOUT_MS)]) : AbortSignal.timeout(options.timeoutMs ?? BRIDGE_TIMEOUT_MS),
             headers: {
                 Authorization: `Bearer ${bridge.token}`,
                 ...(options.body ? { "Content-Type": "application/json" } : {}),

package/dist/opencode-plugins/workspace-file-destinations.js

@@ -0,0 +1,136 @@
+import { realpath } from "node:fs/promises";
+import { dirname, isAbsolute, relative, win32 } from "node:path";
+import { rulesFromPermissionConfig, winningRule } from "../effective-permissions.js";
+const nativeMutations = new Set(["write", "edit", "apply_patch"]);
+const record = (value) => typeof value === "object" && value !== null;
+function promptWorkspacePath(directory) {
+    return directory.replace(/[\u0000-\u001f\u007f\u2028\u2029<>&]/g, character => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+export function correctWorkspaceRoot(system, directory) {
+    for (let index = 0; index < system.length; index++) {
+        system[index] = system[index].replace(/<env>[\s\S]*?<\/env>/g, block => block.includes("Is directory a git repo: no")
+            ? block.replace(/(^[ \t]*Workspace root folder: )\/(\r?$)/m, (_match, prefix, suffix) => `${prefix}${promptWorkspacePath(directory)}${suffix}`)
+            : block);
+    }
+}
+export function workspaceFileGuidance(directory) {
+    return `The opened workspace directory is ${JSON.stringify(promptWorkspacePath(directory))}. For files requested in this workspace, prefer plain relative names such as report.html; native file tools save them inside this directory. Do not invent /workspace or a drive-root location. On Windows, drive-less rooted file paths such as /report.html or \\report.html are interpreted relative to this workspace, with the actual destination reported. Explicit full drive paths and UNC paths retain external-folder permissions. Do not bypass a denied path using another tool.`;
+}
+/** Only drive-less rooted syntax changes. Fully qualified and shell-drive forms keep native semantics. */
+export function workspaceRootedPath(input, directory) {
+    if (!/^[\\/]/.test(input))
+        return undefined;
+    if (/^[\\/]{2}[^\\/]+[\\/][^\\/]+/.test(input) || /^[\\/]{2}[?.][\\/]/.test(input))
+        return undefined;
+    if (/^\/(?:(?:mnt|cygdrive)\/[a-z](?:\/|$)|[a-z]:(?:[\\/]|$)|[a-z](?:\/|$))/i.test(input))
+        return undefined;
+    if (!win32.isAbsolute(directory) || !/^(?:[a-z]:[\\/]|[\\/]{2})/i.test(directory))
+        throw new Error("The opened workspace must have a fully qualified Windows path.");
+    const target = win32.resolve(directory, input.replace(/^[\\/]+/, ""));
+    const child = win32.relative(directory, target);
+    if (child === ".." || child.startsWith("..\\") || win32.isAbsolute(child))
+        throw new Error(`Workspace-rooted path ${JSON.stringify(input)} escapes ${JSON.stringify(directory)}. Use a filename inside the workspace, or an explicit authorized full path.`);
+    return target;
+}
+export async function assertWorkspaceDestination(directory, target) {
+    let ancestor = target;
+    let actual;
+    while (true) {
+        try {
+            actual = await realpath(ancestor);
+            break;
+        }
+        catch (error) {
+            if (!record(error) || error.code !== "ENOENT" || dirname(ancestor) === ancestor)
+                throw error;
+            ancestor = dirname(ancestor);
+        }
+    }
+    const child = relative(await realpath(directory), actual);
+    if (child === ".." || child.startsWith(".." + (process.platform === "win32" ? "\\" : "/")) || isAbsolute(child))
+        throw new Error(`The workspace destination ${JSON.stringify(target)} follows a link outside ${JSON.stringify(directory)}. No file was changed.`);
+}
+export async function planWorkspacePaths(tool, args, directory, options = {}) {
+    if ((options.platform ?? process.platform) !== "win32" || !nativeMutations.has(tool) || !record(args))
+        return undefined;
+    const resolutions = [];
+    const path = async (requested) => {
+        const resolved = workspaceRootedPath(requested, directory);
+        if (!resolved)
+            return requested;
+        // Explicit folder grants continue to use the engine's original destination/permission flow.
+        const original = tool === "apply_patch" ? win32.resolve(directory, requested) : win32.resolve(options.cwd ?? process.cwd(), requested);
+        if (await options.externalAllowed?.(original))
+            return requested;
+        if (!resolutions.some(entry => entry.requested === requested && entry.resolved === resolved))
+            resolutions.push({ requested, resolved });
+        return resolved;
+    };
+    if ((tool === "write" || tool === "edit") && typeof args.filePath === "string") {
+        const value = await path(args.filePath);
+        return resolutions.length ? { field: "filePath", value, resolutions } : undefined;
+    }
+    if (tool !== "apply_patch" || typeof args.patchText !== "string")
+        return undefined;
+    const lines = args.patchText.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+        // Match the pinned v1 parser's source/move headers, not added/context lines.
+        const match = /^(\*\*\* (?:Add File|Update File|Delete File|Move to):[ \t]*)([^\r]*)(\r?)$/.exec(lines[index]);
+        if (match)
+            lines[index] = match[1] + await path(match[2].trim()) + match[3];
+    }
+    return resolutions.length ? { field: "patchText", value: lines.join("\n"), resolutions } : undefined;
+}
+export function workspaceFileHooks(context, options = {}) {
+    const resolvedCalls = new WeakMap();
+    return {
+        "tool.definition": async (input, output) => {
+            if (!context?.directory || !nativeMutations.has(input.toolID))
+                return;
+            output.description += `\n\n${workspaceFileGuidance(context.directory)}`;
+            // Pinned v1 file schemas; runtime validation remains the engine's original schema.
+            const filePath = { type: "string", description: "Path to the file. Prefer a plain workspace-relative name such as report.html; relative paths are saved in the opened workspace. Explicit full external paths retain folder permissions." };
+            if (input.toolID === "write")
+                output.jsonSchema = { type: "object", properties: { content: { type: "string", description: "The content to write" }, filePath }, required: ["content", "filePath"] };
+            if (input.toolID === "edit")
+                output.jsonSchema = { type: "object", properties: { filePath, oldString: { type: "string", description: "The exact text to replace" }, newString: { type: "string", description: "The replacement text" }, replaceAll: { type: "boolean", description: "Replace every matching occurrence" } }, required: ["filePath", "oldString", "newString"] };
+        },
+        "tool.execute.before": async (input, output) => {
+            if ((options.platform ?? process.platform) === "win32" && nativeMutations.has(input.tool) && !context?.directory)
+                throw new Error("No opened workspace directory is available; no file operation was performed.");
+            if (!context?.directory)
+                return;
+            const plan = await planWorkspacePaths(input.tool, output.args, context.directory, {
+                platform: options.platform,
+                cwd: options.cwd,
+                externalAllowed: async (original) => {
+                    if (!context.client)
+                        return false;
+                    const response = await context.client.config.get();
+                    if (!response.data || response.error)
+                        throw new Error("Could not check external-folder grants; no workspace path was changed. Retry the operation.");
+                    const rules = rulesFromPermissionConfig(response.data.permission);
+                    const grant = winningRule(rules, "external_directory", win32.join(win32.dirname(original), "*"));
+                    // A blanket run-mode allow is not an explicit destination choice.
+                    return grant?.permission === "external_directory" && grant.action === "allow" && grant.pattern !== "*";
+                },
+            });
+            if (!plan || !record(output.args))
+                return;
+            for (const entry of plan.resolutions)
+                await (options.validate ?? assertWorkspaceDestination)(context.directory, entry.resolved);
+            output.args[plan.field] = plan.value;
+            resolvedCalls.set(output.args, plan.resolutions);
+        },
+        "tool.execute.after": async (input, output) => {
+            if (!record(input.args))
+                return;
+            const resolutions = resolvedCalls.get(input.args);
+            if (!resolutions)
+                return;
+            resolvedCalls.delete(input.args);
+            output.metadata.openworkWorkspacePaths = resolutions;
+            output.output = resolutions.map(entry => `Workspace destination: ${entry.resolved} (interpreted ${JSON.stringify(entry.requested)} relative to the opened workspace).`).join("\n") + "\n" + output.output;
+        },
+    };
+}