openwork-server 0.18.49 → 0.18.56

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

@@ -0,0 +1,255 @@
+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-title-recovery.ts
+var HEADER = "x-openwork-title-attempt";
+var DEADLINE_MS = 60000;
+var MAX_ERROR_BYTES = 16384;
+var attempts = new Map;
+var installed = false;
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function report(attempt, outcome, status, parameter) {
+  attempt.diagnostic = {
+    ...attempt.diagnostic,
+    outcome,
+    recoveryAttempt: attempt.retried ? 2 : 1,
+    ...status === undefined ? {} : { status },
+    ...parameter === undefined ? {} : { parameter }
+  };
+  attempt.report(attempt.diagnostic);
+}
+function finish(id) {
+  const attempt = attempts.get(id);
+  if (attempt)
+    clearTimeout(attempt.timer);
+  attempts.delete(id);
+}
+async function errorBody(response) {
+  const reader = response.clone().body?.getReader();
+  if (!reader)
+    return null;
+  let size = 0;
+  let text = "";
+  const decoder = new TextDecoder;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      size += chunk.value.byteLength;
+      if (size > MAX_ERROR_BYTES)
+        return null;
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    return JSON.parse(text + decoder.decode());
+  } catch {
+    return null;
+  } finally {
+    reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
+function correction(body, value) {
+  if (!record(value) || !record(value.error))
+    return null;
+  const error = value.error;
+  if (error.code !== "unsupported_value" && error.code !== "unsupported_parameter")
+    return null;
+  const parameter = error.param;
+  if (parameter !== "reasoning.effort" && parameter !== "reasoning_effort" && parameter !== "temperature" && parameter !== "top_p")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (!record(parsed))
+    return null;
+  const target = parameter === "reasoning.effort" ? parsed.reasoning : parsed;
+  const key = parameter === "reasoning.effort" ? "effort" : parameter;
+  if (!record(target) || !Object.hasOwn(target, key))
+    return null;
+  const message = typeof error.message === "string" ? error.message : "";
+  const supported = /Supported values are:\s*([^\n]+)/i.exec(message)?.[1] ?? "";
+  const efforts = new Set([...supported.matchAll(/['"](none|minimal|low|medium|high|xhigh|max)['"]/g)].map((match) => match[1]));
+  const effort = ["low", "minimal", "medium", "high", "xhigh", "max", "none"].find((candidate) => efforts.has(candidate) && candidate !== target[key]);
+  if ((parameter === "reasoning.effort" || parameter === "reasoning_effort") && effort)
+    target[key] = effort;
+  else
+    delete target[key];
+  return { body: JSON.stringify(parsed), parameter };
+}
+function failure(status) {
+  if (status === 401 || status === 403)
+    return "access_rejected";
+  if (status === 404)
+    return "model_or_endpoint_missing";
+  if (status === 429)
+    return "rate_or_quota_limited";
+  if (status === 400 || status === 422)
+    return "request_rejected";
+  return "provider_error";
+}
+function install() {
+  if (installed)
+    return;
+  installed = true;
+  const base = globalThis.fetch;
+  const patched = async (input, init) => {
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    const id = headers.get(HEADER);
+    if (!id)
+      return base(input, init);
+    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 };
+    const attempt = attempts.get(id);
+    if (!attempt)
+      return base(input, options);
+    try {
+      const response = await base(input, options);
+      if (!response.ok) {
+        report(attempt, failure(response.status), response.status);
+        if (!attempt.retried && response.status === 400 && typeof init?.body === "string") {
+          const recovered = correction(init.body, await errorBody(response));
+          if (recovered && attempts.get(id) === attempt && !options.signal.aborted) {
+            attempt.retried = true;
+            report(attempt, "retrying_parameter", response.status, recovered.parameter);
+            response.body?.cancel().catch(() => {
+              return;
+            });
+            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);
+            return retry;
+          }
+        }
+      } else
+        report(attempt, "accepted", response.status);
+      return response;
+    } catch (error) {
+      report(attempt, externalSignal?.aborted ? "cancelled" : deadline.aborted ? "timed_out" : "transport_failed");
+      throw error;
+    }
+  };
+  globalThis.fetch = Object.assign(patched, base);
+}
+var OpenWorkTitleRecovery = async (input) => {
+  install();
+  const owned = new Set;
+  const emit = (diagnostic) => {
+    const level = ["started", "accepted", "accepted_after_recovery", "title_available"].includes(diagnostic.outcome) ? "info" : "warn";
+    input.client.app.log({ body: {
+      service: "openwork.title",
+      level,
+      message: "Automatic title generation",
+      extra: diagnostic
+    } }).catch(() => {
+      return;
+    });
+  };
+  return {
+    "chat.headers": async (request, output) => {
+      if (request.agent !== "title")
+        return;
+      const id = crypto.randomUUID();
+      const diagnostic = {
+        sessionID: request.sessionID,
+        providerID: request.model.providerID,
+        modelID: request.model.id,
+        outcome: "started",
+        recoveryAttempt: 1
+      };
+      if (attempts.size >= 512) {
+        emit({ ...diagnostic, outcome: "tracking_capacity_reached" });
+        return;
+      }
+      const timer = setTimeout(() => {
+        const attempt = attempts.get(id);
+        if (attempt && ["started", "accepted", "accepted_after_recovery"].includes(attempt.diagnostic.outcome)) {
+          report(attempt, "title_unconfirmed");
+        }
+        finish(id);
+        owned.delete(id);
+      }, DEADLINE_MS);
+      timer.unref?.();
+      attempts.set(id, { diagnostic, report: emit, timer, retried: false });
+      owned.add(id);
+      output.headers[HEADER] = id;
+      emit(diagnostic);
+    },
+    event: async ({ event }) => {
+      if (event.type !== "session.updated" || !record(event.properties) || !record(event.properties.info))
+        return;
+      const info = event.properties.info;
+      if (typeof info.title !== "string" || !info.title.trim() || info.title.startsWith("New session - "))
+        return;
+      for (const id of owned) {
+        const attempt = attempts.get(id);
+        if (!attempt || attempt.diagnostic.sessionID !== info.id)
+          continue;
+        report(attempt, "title_available");
+        finish(id);
+        owned.delete(id);
+      }
+    },
+    dispose: async () => {
+      for (const id of owned)
+        finish(id);
+      owned.clear();
+    }
+  };
+};
+export {
+  OpenWorkTitleRecovery
+};

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

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+let cachedBridge = null;
+let cachedBridgeAt = 0;
+let cachedBridgeDiscovery;
+const BRIDGE_CACHE_MS = 2_000;
+const BRIDGE_TIMEOUT_MS = 5_000;
+function userAppDataDir() {
+    if (platform() === "darwin")
+        return join(homedir(), "Library", "Application Support");
+    if (platform() === "win32")
+        return process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+}
+function uiControlDiscoveryPaths() {
+    const explicit = process.env.OPENWORK_UI_CONTROL_DISCOVERY?.trim();
+    if (explicit)
+        return [explicit];
+    return [
+        join(userAppDataDir(), "com.differentai.openwork", "openwork-ui-control.json"),
+        join(userAppDataDir(), "com.differentai.openwork.dev", "openwork-ui-control.json"),
+    ].filter((p) => Boolean(p));
+}
+async function discoverUiBridge() {
+    // A changed discovery override points at a different desktop; never reuse
+    // the bridge cached for the previous one.
+    const discovery = process.env.OPENWORK_UI_CONTROL_DISCOVERY?.trim();
+    if (cachedBridge && cachedBridgeDiscovery === discovery && Date.now() - cachedBridgeAt < BRIDGE_CACHE_MS)
+        return cachedBridge;
+    cachedBridge = null;
+    for (const candidate of uiControlDiscoveryPaths()) {
+        try {
+            const raw = await readFile(candidate, "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.baseUrl === "string" && typeof parsed.token === "string") {
+                const url = new URL(parsed.baseUrl);
+                if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || url.username || url.password)
+                    continue;
+                cachedBridge = { baseUrl: parsed.baseUrl, token: parsed.token };
+                cachedBridgeAt = Date.now();
+                cachedBridgeDiscovery = discovery;
+                return cachedBridge;
+            }
+        }
+        catch {
+            // Try next
+        }
+    }
+    return null;
+}
+export async function uiBridgeRequest(path, 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." };
+    try {
+        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),
+            headers: {
+                Authorization: `Bearer ${bridge.token}`,
+                ...(options.body ? { "Content-Type": "application/json" } : {}),
+            },
+            ...(options.body ? { body: JSON.stringify(options.body) } : {}),
+        });
+        const text = await response.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { ok: false, code: "browser_disconnected", mayHaveChangedState: true, retrySafe: false, error: "The browser returned no readable receipt. Inspect the page before retrying an action." };
+        }
+    }
+    catch {
+        cachedBridge = null;
+        cachedBridgeAt = 0;
+        cachedBridgeDiscovery = undefined;
+        return { ok: false, code: "browser_disconnected", mayHaveChangedState: true, retrySafe: false, error: "The browser connection was interrupted. An action may already have run. Reconnect, list this conversation's tabs and observe before deciding what remains." };
+    }
+}

package/dist/opencode-plugins/session-activity.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+const engineSessionStatusesSchema = z.record(z.string(), z.object({ type: z.string() }).passthrough());
+const enginePendingRequestsSchema = z.array(z.object({ sessionID: z.string() }).passthrough());
+export function sessionActivityFrom(statuses, permissions, questions, sessionId, descendantIds = [], unknownDescendants = 0) {
+    const parsedStatuses = engineSessionStatusesSchema.safeParse(statuses);
+    const parsedPermissions = enginePendingRequestsSchema.safeParse(permissions);
+    const parsedQuestions = enginePendingRequestsSchema.safeParse(questions);
+    const probesComplete = parsedStatuses.success && parsedPermissions.success && parsedQuestions.success;
+    const waiting = new Set([
+        ...parsedPermissions.success ? parsedPermissions.data.map((request) => request.sessionID) : [],
+        ...parsedQuestions.success ? parsedQuestions.data.map((request) => request.sessionID) : [],
+    ]);
+    const statusFor = (id) => {
+        const type = parsedStatuses.success ? parsedStatuses.data[id]?.type : undefined;
+        if (type === "error")
+            return "error";
+        if (waiting.has(id) || type === "waiting")
+            return "waiting";
+        if (type === "busy" || type === "running")
+            return "busy";
+        if (type === "retry" || type === "compacting" || type === "thinking" || type === "responding")
+            return type;
+        return probesComplete && (type === undefined || type === "idle") ? "idle" : "unknown";
+    };
+    const descendantActivity = { busy: 0, waiting: 0, unknown: unknownDescendants };
+    for (const id of new Set(descendantIds)) {
+        if (id === sessionId)
+            continue;
+        const status = statusFor(id);
+        if (status === "unknown")
+            descendantActivity.unknown += 1;
+        else if (status === "waiting")
+            descendantActivity.waiting += 1;
+        else if (status !== "idle" && status !== "error")
+            descendantActivity.busy += 1;
+    }
+    const own = statusFor(sessionId);
+    return {
+        status: own !== "error" && descendantActivity.waiting > 0 ? "waiting" : own,
+        working: own !== "idle" && own !== "error" && own !== "unknown"
+            || descendantActivity.busy > 0 || descendantActivity.waiting > 0,
+        descendantActivity,
+        inventoryComplete: probesComplete && own !== "unknown" && descendantActivity.unknown === 0,
+    };
+}

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

@@ -0,0 +1,162 @@
+import { constants } from "node:fs";
+import { lstat, open, realpath, rm } from "node:fs/promises";
+import { dirname, isAbsolute, relative } from "node:path";
+/**
+ * Open-then-verify access to files under the workspace, shared by the plugins
+ * that read attachments or read and write workbooks.
+ *
+ * Node exposes neither openat nor O_RESOLVE_BENEATH, so any pathname is
+ * resolved again by every syscall and a directory under the workspace could
+ * be swapped for a link between two of them. These helpers therefore never
+ * decide anything from a pathname check that precedes a syscall. They obtain
+ * the file handle FIRST, then prove — from the handle's own inode — that it
+ * is the regular file sitting at exactly the requested path inside the real
+ * workspace root, with no symbolic link in any component and a real directory
+ * as its parent. Only a handle that passes is ever read from or written to.
+ *
+ * The one pathname-dependent effect that can survive a concurrent swap is the
+ * exclusive creation of an EMPTY file: O_EXCL can never replace an existing
+ * file, no content is written before the proof passes, callers restrict the
+ * name to an inert extension, and a misplaced empty inode is removed by
+ * identity. Overwrites open without O_CREAT and without O_TRUNC, so nothing
+ * changes until the handle is proven to be the very inode the caller decided
+ * to overwrite.
+ */
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+export class WorkspaceFileError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export function sameFile(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function isWithin(root, candidate) {
+    const rel = relative(root, candidate);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+/**
+ * Prove that an already-open handle refers to the regular file at exactly
+ * `path`: the directory entry at `path` is the handle's inode, `path` resolves
+ * to itself (no link in any component), its parent is a real directory that
+ * also resolves to itself, and everything sits under `realRoot`. Evaluated
+ * after the open, so a swap before the open fails the proof and a swap after
+ * it cannot redirect the handle.
+ */
+export async function proveHandleInPlace(actual, path, realRoot) {
+    if (!actual.isFile() || !isWithin(realRoot, path))
+        return false;
+    const folder = dirname(path);
+    const [placed, placedReal, folderNow, folderReal] = await Promise.all([
+        lstat(path).catch(() => null),
+        realpath(path).catch(() => null),
+        lstat(folder).catch(() => null),
+        realpath(folder).catch(() => null),
+    ]);
+    return placed !== null && sameFile(placed, actual) && placedReal === path
+        && folderNow !== null && folderNow.isDirectory() && folderReal === folder;
+}
+function errorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "";
+}
+/**
+ * Fast path before the open: refuse a folder that is missing or that already
+ * resolves through a link. This is not the safety boundary (a swap after it
+ * is caught by the post-open proof); it keeps the ordinary case from creating
+ * even a transient empty inode through a link.
+ */
+async function refuseLinkedFolder(path, label, missingCode) {
+    const folder = dirname(path);
+    const folderReal = await realpath(folder).catch(() => null);
+    if (folderReal === null) {
+        throw new WorkspaceFileError(missingCode, missingCode === "missing" ? `${label} was not found in the workspace.` : `${label}: its folder does not exist.`);
+    }
+    if (folderReal !== folder)
+        throw new WorkspaceFileError("link", `${label} passes through a symbolic link, which is not allowed.`);
+}
+/**
+ * Open a regular file for reading without following a link at any level and
+ * prove it is in place before returning the handle. The caller must close it.
+ */
+export async function openWorkspaceFileForReading(realRoot, path, label) {
+    await refuseLinkedFolder(path, label, "missing");
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | NO_FOLLOW);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "ENOENT" || code === "ENOTDIR")
+            throw new WorkspaceFileError("missing", `${label} was not found in the workspace.`);
+        if (code === "ELOOP" || code === "EMLINK")
+            throw new WorkspaceFileError("link", `${label} passes through a symbolic link, which is not allowed.`);
+        throw error;
+    }
+    try {
+        const info = await handle.stat();
+        if (!info.isFile())
+            throw new WorkspaceFileError("not-file", `${label} is not a regular file.`);
+        if (!(await proveHandleInPlace(info, path, realRoot))) {
+            const real = await realpath(path).catch(() => null);
+            if (real !== null && real !== path)
+                throw new WorkspaceFileError("link", `${label} passes through a symbolic link, which is not allowed.`);
+            throw new WorkspaceFileError("changed", `${label} changed on disk while it was being opened; nothing was read. Try again.`);
+        }
+        return { handle, info, created: false };
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+/**
+ * Open a regular file for writing and prove it is in place before returning
+ * the handle. An existing file is opened without O_CREAT and without O_TRUNC
+ * and must be the inode the caller observed (`expected`); a new file is
+ * created with O_EXCL, which can never replace anything, and is removed by
+ * identity if it proves to have landed anywhere but at `path`. The caller
+ * truncates and writes through the returned handle, then closes it.
+ */
+export async function openWorkspaceFileForWriting(realRoot, path, expected, label) {
+    await refuseLinkedFolder(path, label, "folder-missing");
+    let handle;
+    try {
+        handle = expected
+            ? await open(path, constants.O_WRONLY | NO_FOLLOW)
+            : await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NO_FOLLOW, 0o644);
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "ENOENT" || code === "ENOTDIR")
+            throw new WorkspaceFileError("folder-missing", `${label}: its folder does not exist.`);
+        if (code === "EEXIST")
+            throw new WorkspaceFileError("exists", `${label} appeared on disk while it was being created; nothing was written. Try again.`);
+        if (code === "ELOOP" || code === "EMLINK")
+            throw new WorkspaceFileError("link", `${label} passes through a symbolic link, which is not allowed.`);
+        throw error;
+    }
+    try {
+        const info = await handle.stat();
+        const inPlace = await proveHandleInPlace(info, path, realRoot) && (expected === null || sameFile(info, expected));
+        if (!inPlace) {
+            const real = await realpath(path).catch(() => null);
+            if (expected === null) {
+                // Our own empty inode may have been created through a swapped folder:
+                // remove it wherever the path currently leads, but only if it is ours.
+                const placed = await lstat(path).catch(() => null);
+                if (placed && sameFile(placed, info))
+                    await rm(path, { force: true }).catch(() => undefined);
+            }
+            if (real !== null && real !== path)
+                throw new WorkspaceFileError("link", `${label} passes through a symbolic link, which is not allowed.`);
+            throw new WorkspaceFileError("changed", `${label} changed on disk while it was being opened; nothing was written. Try again.`);
+        }
+        return { handle, info, created: expected === null };
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}