conductor-remote 1.116.0 → 1.118.0

package/dist-node/src/{run-activity.js → dev-server/run-activity.js}

@@ -20,7 +20,7 @@
  * must be `run-run:<n>.sh` specifically, so the setup wrapper (`run-setup:<n>.sh`) that
  * runs beside it is not read as an active Run.
  *
- * Like src/background-tasks.ts, only `ps` **args** are read, never the environment. The
+ * Like src/reads/background-tasks.ts, only `ps` **args** are read, never the environment. The
  * args snapshot can itself hold sensitive command-line data, so it is never logged.
  */
 import { execFile } from 'node:child_process';
@@ -70,7 +70,7 @@ let refreshing = null;
 /**
  * The project keys with a live Run wrapper, stale-while-revalidate.
  *
- * Synchronous on purpose, exactly like src/background-tasks.ts ▸ `agentProcessStarts`:
+ * Synchronous on purpose, exactly like src/reads/background-tasks.ts ▸ `agentProcessStarts`:
  * `/api/state` is assembled from plain reads and must not fork a `ps` on every 2.5s
  * poll. The first call after start answers empty — no badge for one poll — and every
  * call after that answers from the last listing while a fresh one lands.

package/dist-node/src/dev-server/types.js

@@ -0,0 +1 @@
+export {};

package/dist-node/src/{file-preview.js → files/file-preview.js}

@@ -1,6 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
-import { isPreviewableImage, isPreviewableSource } from "./shared.js";
+import { isPreviewableImage, isPreviewableSource } from "../shared.js";
 /** True only for a descendant. A prefix test would let `/workspaces-old` escape `/workspaces`. */
 function insideDirectory(filePath, root) {
     const relative = path.relative(root, filePath);

package/dist-node/src/{change-stats.js → git/change-stats.js}

@@ -1,4 +1,4 @@
-import { workspaceDiffStats } from "./git.js";
+import { workspaceDiffStats } from "./diff.js";
 /**
  * Git stats are local and cheap, but not cheap enough to run synchronously for every
  * workspace on the 2.5s state poll. Keep the last answer on the wire while a bounded

package/dist-node/src/{git.js → git/diff.js}

@@ -1,7 +1,7 @@
 import { execFile } from 'node:child_process';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { isPreviewableSource } from "./shared.js";
+import { isPreviewableSource } from "../shared.js";
 const exec = promisify(execFile);
 const MAX_PATCH_BYTES = 400_000;
 const MAX_LISTED_FILES = 20_000;

package/dist-node/src/{autoupdate.js → host/autoupdate.js}

@@ -30,7 +30,7 @@ import { execFile } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { packageRoot } from "./pkg-root.js";
+import { packageRoot } from "../pkg-root.js";
 const execFileP = promisify(execFile);
 const NAME = 'conductor-remote';
 const projectDir = packageRoot(import.meta.dirname);

package/dist-node/src/{funnel-watchdog.js → host/funnel-watchdog.js}

@@ -28,10 +28,10 @@ import { Resolver } from 'node:dns/promises';
 import https from 'node:https';
 import net from 'node:net';
 import { promisify } from 'node:util';
-import { readSettings } from "./settings.js";
+import { readSettings } from "../settings.js";
+import { joinInstantHotspot } from "../writes/system.js";
 import { magicDnsName, parseServeStatus, readExposeMode, relayPort, relayServeState, tailscaleBin } from "./tailscale.js";
 import { hasDefaultRoute, joinNetwork, preferredNetworks } from "./wifi.js";
-import { joinInstantHotspot } from "./writes.js";
 const execFileP = promisify(execFile);
 const PROBE_PATH = '/health'; // unauthenticated 200 on the relay — no token needed to prove reachability
 const PROBE_TIMEOUT_MS = 8000;
@@ -205,7 +205,7 @@ async function routeAppeared(waitMs) {
  *
  * The guards matter more than the action. Switching Wi-Fi networks can take a working
  * Mac off a working network, so this borrows the shape of `serverWindowCount()`'s veto in
- * writes.ts: **a probe that can't answer must prevent the action, never cause it.**
+ * src/writes/applescript/window.applescript: **a probe that can't answer must prevent the action, never cause it.**
  *  - Opt-in only (`autoRejoin`), and only with somewhere to go.
  *  - Only when `hasDefaultRoute()` is definitively false. That probe needs no permission
  *    grant, unlike reading the SSID, which macOS refuses without Location Services and
@@ -216,7 +216,7 @@ async function routeAppeared(waitMs) {
  *
  * Two ways in, tried in order. `networksetup` first — cheap, no UI — and when it answers
  * "Could not find network" (a hotspot doesn't broadcast until asked), the Accessibility
- * press on the Wi-Fi menu's own row (`joinInstantHotspot` in writes.ts), which wakes the
+ * press on the Wi-Fi menu's own row (`joinInstantHotspot` in src/writes/system.ts), which wakes the
  * phone's hotspot over Continuity exactly like clicking it. The press needs an unlocked
  * screen — the lock hides the session from Accessibility, and the failure names that —
  * so a lid-closed Mac still wants macOS's own Auto-Join Hotspot set to Automatic as the

package/dist-node/src/{logbuf.js → host/logbuf.js}

@@ -21,7 +21,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import util from 'node:util';
-import { scrubWorkflowSecrets } from "./shared.js";
+import { scrubWorkflowSecrets } from "../shared.js";
 /** Kept small enough that a phone on a slow link can pull the whole thing; ~a day of a quiet relay. */
 const CAPACITY = 600;
 /** One AppleScript failure can carry a long stack; keep a single entry from crowding out the rest. */

package/dist-node/src/{nosleep-helper.js → host/nosleep-helper.js}

@@ -30,7 +30,7 @@ export const HELPER_PATH = '/usr/local/libexec/conductor-remote-nosleep';
  * with SIGKILL leaves this file behind, macOS recycles pids freely, and the helper runs
  * as root — so `kill -0` succeeds against whatever inherited the number, and `--stop`
  * would then SIGTERM an unrelated root process. Readers that only want the pid and the
- * expiry (`src/nosleep.ts` ▸ readPidfile) can ignore it; a two-field file from an older
+ * expiry (`src/host/nosleep.ts` ▸ readPidfile) can ignore it; a two-field file from an older
  * version still parses, and skips the check. The fourth field records whether this
  * window also holds the display assertion that blocks the automatic screen lock.
  */

package/dist-node/src/{tailscale.js → host/tailscale.js}

@@ -1,6 +1,6 @@
 /**
  * Shared Tailscale helpers used by BOTH the deploy script (scripts/service.ts) and the runtime funnel
- * watchdog (src/funnel-watchdog.ts). They must agree: the watchdog re-establishes Funnel with the same
+ * watchdog (src/host/funnel-watchdog.ts). They must agree: the watchdog re-establishes Funnel with the same
  * port and posture the deploy configured, so "how do we find tailscale / this node's public name / the
  * expose mode" lives here once rather than drifting between deploy-time and runtime copies.
  *

package/dist-node/src/http/router-types.js

@@ -0,0 +1,2 @@
+/** Distinguishes an unmatched route from a handled streaming or empty response. */
+export const NOT_HANDLED = Symbol('route not handled');

package/dist-node/src/http/router.js

@@ -0,0 +1,78 @@
+import http from 'node:http';
+import { UiBusyError, uiQueueDepth, withUiPriority } from "../writes/ui-lock.js";
+import { NOT_HANDLED } from "./router-types.js";
+import { createCreateWorkspaceRoutes } from "./routes/create-workspace.js";
+import { createFilesRoutes } from "./routes/files.js";
+import { createPromptsRoutes } from "./routes/prompts.js";
+import { createSessionsRoutes } from "./routes/sessions.js";
+import { createStateRoutes } from "./routes/state.js";
+import { createSystemRoutes } from "./routes/system.js";
+import { createVoiceRoutes } from "./routes/voice.js";
+import { createWorkflowsRoutes } from "./routes/workflows.js";
+import { createWorkspacesRoutes } from "./routes/workspaces.js";
+export function createRelayServer(services) {
+    const { handleMcpHttp, serveStatic, authed, json, PayloadTooLargeError, workflowHttpError } = services;
+    const handlers = [
+        createStateRoutes(services),
+        createWorkflowsRoutes(services),
+        createVoiceRoutes(services),
+        createSystemRoutes(services),
+        createCreateWorkspaceRoutes(services),
+        createFilesRoutes(services),
+        createWorkspacesRoutes(services),
+        createSessionsRoutes(services),
+        createPromptsRoutes(services)
+    ];
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? '/', 'http://x');
+        const { pathname } = url;
+        // POST /mcp — the MCP Streamable HTTP transport, for a client that can only reach a
+        // URL (an agent on another machine, or a hosted one). Same tools as
+        // `conductor-remote mcp`'s stdio, same token gate as /api/*, and — because this runs
+        // *inside* the relay — the same UI lock, with no second process to sit outside it.
+        //
+        // Deliberately minimal: this server never initiates a message, so there is no SSE
+        // stream to open and GET is answered 405, which the spec allows. It keeps no session
+        // either, so no `Mcp-Session-Id` is issued and every request stands alone.
+        if (pathname === '/mcp')
+            return handleMcpHttp(req, res);
+        if (!pathname.startsWith('/api/'))
+            return serveStatic(req, res, pathname);
+        // Everything under /api requires the shared secret.
+        if (!authed(req))
+            return json(req, res, 401, { error: 'unauthorized' });
+        // Who is asking decides who waits for Conductor's window. An agent (src/mcp.ts sets
+        // this header) yields the UI lock to the person holding the phone — see src/writes/ui-lock.ts ▸
+        // uiTurn. Anything unlabelled is treated as the person, because the phone is the
+        // only caller that predates the header and mislabelling it would be the bad way round.
+        const priority = req.headers['x-relay-client'] === 'mcp' ? 'background' : 'interactive';
+        return withUiPriority(priority, async () => {
+            try {
+                for (const handler of handlers) {
+                    if ((await handler(req, res, url)) !== NOT_HANDLED)
+                        return;
+                }
+                return json(req, res, 404, { error: 'no route', pathname });
+            }
+            catch (err) {
+                if (err instanceof PayloadTooLargeError)
+                    return json(req, res, 413, { error: err.message });
+                const workflowError = workflowHttpError(err);
+                if (workflowError) {
+                    console.warn(`[workflow] ${req.method} ${pathname}: ${workflowError.error.code}: ${workflowError.error.message}`);
+                    return json(req, res, workflowError.status, { ok: false, error: workflowError.error });
+                }
+                // A refused UI turn is not a server fault and a retry is the right move, so it gets
+                // 503 + Retry-After rather than a 500 that reads as "the relay is broken".
+                if (err instanceof UiBusyError) {
+                    res.setHeader('retry-after', '15');
+                    return json(req, res, 503, { error: err.message, busy: true, queue: uiQueueDepth() });
+                }
+                // Log the detail locally; don't reflect internals (paths, stack strings) back over the wire.
+                console.error(`[relay] ${req.method} ${pathname} failed:`, err);
+                return json(req, res, 500, { error: 'internal error' });
+            }
+        });
+    });
+    return server;
+}

package/dist-node/src/http/routes/create-workspace.js

@@ -0,0 +1,90 @@
+import { stagedAttachments } from "../../files/staged-attachments.js";
+import { isRoute, routes } from "../../routes.js";
+import { EFFORT_LABELS } from "../../writes/agent-options.js";
+import { NOT_HANDLED } from "../router-types.js";
+export function createCreateWorkspaceRoutes(services) {
+    const { readBody, json, STAGED_ATTACHMENTS_DIR, reads, createWorkspaceAndRead, firstPrompts } = services;
+    return async (req, res, url) => {
+        const { pathname } = url;
+        // POST /api/workspaces { repo, prompt, model?/effort?/plan?/fast?, send? }
+        // — create a workspace via Conductor's deep link, then configure its first chat.
+        if (isRoute(routes.createWorkspace, req.method, pathname)) {
+            const body = JSON.parse((await readBody(req)) || '{}');
+            const attachmentIds = body.attachmentIds ?? [];
+            if ('workflow' in body)
+                return json(req, res, 400, { error: 'Workflow starts through POST /api/workflows.' });
+            if (body.model !== undefined && typeof body.model !== 'string')
+                return json(req, res, 400, { error: 'model must be a picker label' });
+            if (body.effort !== undefined && typeof body.effort !== 'string')
+                return json(req, res, 400, { error: 'effort must be a string' });
+            const effort = body.effort?.trim() || undefined;
+            if (effort && !EFFORT_LABELS[effort])
+                return json(req, res, 400, { error: `effort must be one of ${Object.keys(EFFORT_LABELS).join(', ')}` });
+            if (body.plan !== undefined && typeof body.plan !== 'boolean')
+                return json(req, res, 400, { error: 'plan must be a boolean' });
+            if (body.fast !== undefined && typeof body.fast !== 'boolean')
+                return json(req, res, 400, { error: 'fast must be a boolean' });
+            const requestedAgent = {
+                model: body.model?.trim() || undefined,
+                effort,
+                plan: body.plan,
+                fast: body.fast
+            };
+            if (!Array.isArray(attachmentIds) || attachmentIds.some(id => typeof id !== 'string'))
+                return json(req, res, 400, { error: 'attachment ids must be a list of strings' });
+            const attachments = stagedAttachments(STAGED_ATTACHMENTS_DIR, attachmentIds);
+            if (!attachments)
+                return json(req, res, 409, { error: 'an attached file is no longer available; add it again' });
+            // The prompt is optional — a bare `path=` opens an empty workspace, like
+            // Conductor's own New workspace — but *something* has to say where it goes.
+            const objective = [...attachments.map(attachment => attachment.token), (body.prompt ?? '').trim()]
+                .filter(Boolean)
+                .join('\n');
+            if (!objective && !body.repo)
+                return json(req, res, 400, { error: 'need a repo or a prompt' });
+            const prompt = objective;
+            const agent = requestedAgent;
+            const configureAgent = Object.values(agent).some(value => value !== undefined);
+            // Resolve the repo to a real path: an unmatched `path` would silently land
+            // the workspace in whichever repo Conductor happens to list first.
+            const repo = body.repo ? reads.listRepos().find(r => r.name === body.repo) : undefined;
+            if (body.repo && !repo)
+                return json(req, res, 404, { error: `unknown repo ${body.repo}` });
+            if (repo && !repo.root_path)
+                return json(req, res, 409, { error: `${repo.name} has no checkout path` });
+            const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name);
+            if (!result.ok)
+                return json(req, res, 502, result);
+            if (!created) {
+                return json(req, res, 502, {
+                    ok: false,
+                    strategy: result.strategy,
+                    error: 'Conductor didn’t create a workspace — check it’s running and not showing a dialog.'
+                });
+            }
+            // Return as soon as the row exists (~2s) — waiting for delivery would block the
+            // request through Conductor's whole setup, measured at 30s+ on a real repo and
+            // past any budget a phone should hold a request open for. The queue delivers on
+            // its own schedule and the phone watches it in /api/state; `send:true` opts API
+            // callers into waiting.
+            // Whatever happens, the prompt is already pre-filled in Conductor's composer.
+            const settled = prompt || configureAgent
+                ? firstPrompts.enqueue(created.id, prompt, body.sendImmediately !== false, attachmentIds, configureAgent ? agent : undefined)
+                : null;
+            const failed = settled && body.send === true ? await settled : null;
+            settled?.catch(() => undefined); // fire-and-forget: it reports failure, it never rejects
+            return json(req, res, 200, {
+                ok: true,
+                workspaceId: created.id,
+                workspace: reads.getWorkspace(created.id) ?? created,
+                pendingPrompt: prompt || undefined,
+                model: agent.model,
+                sent: body.send === true && !!prompt && !failed,
+                configured: body.send === true && configureAgent && !failed,
+                warning: failed?.error &&
+                    `Workspace created; the initial ${configureAgent ? 'agent settings and prompt' : 'prompt'} didn’t finish (${failed.error}).`
+            });
+        }
+        return NOT_HANDLED;
+    };
+}

package/dist-node/src/http/routes/files.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import { routeParam, routes } from "../../routes.js";
+import { NOT_HANDLED } from "../router-types.js";
+export function createFilesRoutes(services) {
+    const { reads, json, serveLocalImage, serveFilePreview } = services;
+    return async (req, res, url) => {
+        const { pathname } = url;
+        // GET /api/repos/:name/icon — the repo's resolved sidebar icon (see src/files/icons.ts)
+        const repo = routeParam(routes.repoIcon, req.method, pathname);
+        if (repo) {
+            const icon = reads.resolveRepoIcon(repo);
+            if (!icon)
+                return json(req, res, 404, { error: 'no icon' });
+            return void fs.readFile(icon.path, (err, data) => {
+                if (err)
+                    return void json(req, res, 404, { error: 'no icon' });
+                // Cache briefly on the phone; the resolver itself refreshes within ~30s of an icon change.
+                res.writeHead(200, { 'content-type': icon.contentType, 'cache-control': 'public, max-age=300' });
+                res.end(data);
+            });
+        }
+        // GET /api/local-images/:path — local images linked from agent Markdown. The browser fetches this
+        // with its Authorization header and turns the reply into an object URL (web/src/components/transcript/Markdown.tsx), so the secret
+        // stays out of the image URL. `serveLocalImage` limits reads to temp files and permitted workspace paths.
+        const localImage = routeParam(routes.localImage, req.method, pathname);
+        if (localImage)
+            return serveLocalImage(req, res, localImage);
+        // GET /api/tool-images/:reference — a screenshot or other image a tool returned. Held
+        // back from the transcript itself (~100 kB of base64 each) and fetched only for a step
+        // the reader opened, with the phone's auth header, like every other image route here.
+        const toolImageRef = routeParam(routes.toolImage, req.method, pathname);
+        if (toolImageRef) {
+            const image = reads.toolImage(toolImageRef);
+            if (!image)
+                return json(req, res, 404, { error: 'image not found' });
+            const bytes = Buffer.from(image.data, 'base64');
+            // Immutable: a transcript row is written once, so the reference names one picture
+            // forever and re-opening the step costs nothing.
+            res.writeHead(200, {
+                'content-type': image.mediaType,
+                'content-length': String(bytes.length),
+                'cache-control': 'private, max-age=86400, immutable'
+            });
+            return void res.end(bytes);
+        }
+        // GET /api/files/:reference — source linked from an agent reply. The Markdown component
+        // intercepts the browser navigation and fetches this endpoint with its auth header.
+        const fileReference = routeParam(routes.filePreview, req.method, pathname);
+        if (fileReference)
+            return serveFilePreview(req, res, fileReference);
+        return NOT_HANDLED;
+    };
+}