conductor-remote 1.65.1 → 1.67.0

package/dist-node/src/prefs.js

@@ -0,0 +1,171 @@
+/**
+ * Device-independent PWA state, durable on the host Mac.
+ *
+ * localStorage remains the live, offline-first copy. This store is the sync peer that
+ * survives a PWA origin change and lets another phone or browser pick up where the first
+ * stopped. It deliberately does not contain the access token, pending HTTP requests, or
+ * other device-scoped state.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { stateDir } from "./config.js";
+const MAX_KEYS = 50_000;
+const MAX_KEY_LENGTH = 256;
+const MAX_MARK_LENGTH = 128;
+const MAX_DRAFT_LENGTH = 1_000_000;
+const MAX_AGENT_LABEL_LENGTH = 256;
+function object(raw) {
+    return raw !== null && typeof raw === 'object' && !Array.isArray(raw) ? raw : null;
+}
+function validKey(key) {
+    return key.length > 0 && key.length <= MAX_KEY_LENGTH;
+}
+function sanitizeAgent(raw) {
+    const value = object(raw);
+    if (!value)
+        return {};
+    const agent = {};
+    if (typeof value.model === 'string' && value.model.length <= MAX_AGENT_LABEL_LENGTH)
+        agent.model = value.model;
+    if (typeof value.effort === 'string' && value.effort.length <= MAX_AGENT_LABEL_LENGTH)
+        agent.effort = value.effort;
+    if (typeof value.plan === 'boolean')
+        agent.plan = value.plan;
+    if (typeof value.fast === 'boolean')
+        agent.fast = value.fast;
+    return agent;
+}
+function sanitizeReadMarks(raw) {
+    const value = object(raw);
+    if (!value)
+        return {};
+    const entries = Object.entries(value)
+        .filter((entry) => {
+        const [key, mark] = entry;
+        return validKey(key) && typeof mark === 'string' && mark.length > 0 && mark.length <= MAX_MARK_LENGTH;
+    })
+        .sort((a, b) => b[1].localeCompare(a[1]))
+        .slice(0, MAX_KEYS);
+    return Object.fromEntries(entries);
+}
+function sanitizeDraft(raw) {
+    const value = object(raw);
+    if (!value)
+        return null;
+    const updatedAt = Number(value.updatedAt);
+    if (!Number.isSafeInteger(updatedAt) || updatedAt < 0)
+        return null;
+    const deleted = value.deleted === true;
+    if (deleted)
+        return { text: '', agent: {}, updatedAt, deleted: true };
+    if (typeof value.text !== 'string' || value.text.length > MAX_DRAFT_LENGTH)
+        return null;
+    return { text: value.text, agent: sanitizeAgent(value.agent), updatedAt, deleted: false };
+}
+function sanitizeDrafts(raw) {
+    const value = object(raw);
+    if (!value)
+        return {};
+    const entries = [];
+    for (const [key, candidate] of Object.entries(value)) {
+        if (!validKey(key))
+            continue;
+        const draft = sanitizeDraft(candidate);
+        if (draft)
+            entries.push([key, draft]);
+    }
+    entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt);
+    return Object.fromEntries(entries.slice(0, MAX_KEYS));
+}
+function sanitize(raw) {
+    const value = object(raw);
+    return {
+        readMarks: sanitizeReadMarks(value?.readMarks),
+        drafts: sanitizeDrafts(value?.drafts)
+    };
+}
+function sameDraft(a, b) {
+    return (a.text === b.text &&
+        a.updatedAt === b.updatedAt &&
+        a.deleted === b.deleted &&
+        a.agent.model === b.agent.model &&
+        a.agent.effort === b.agent.effort &&
+        a.agent.plan === b.agent.plan &&
+        a.agent.fast === b.agent.fast);
+}
+/** Cached, single-process JSON store. A custom file keeps its merge rules easy to test. */
+export class PrefsStore {
+    file;
+    cache = null;
+    constructor(file = path.join(stateDir(), 'prefs.json')) {
+        this.file = file;
+    }
+    read() {
+        if (this.cache)
+            return this.cache;
+        try {
+            this.cache = sanitize(JSON.parse(fs.readFileSync(this.file, 'utf8')));
+        }
+        catch {
+            this.cache = { readMarks: {}, drafts: {} };
+        }
+        return this.cache;
+    }
+    /** Merge a client snapshot. Marks take max; draft revisions use LWW with deletion winning a tie. */
+    patch(raw) {
+        const input = object(raw);
+        if (!input)
+            return this.read();
+        const current = this.read();
+        const next = { readMarks: { ...current.readMarks }, drafts: { ...current.drafts } };
+        let changed = false;
+        if (Object.hasOwn(input, 'readMarks')) {
+            for (const [key, mark] of Object.entries(sanitizeReadMarks(input.readMarks))) {
+                if ((next.readMarks[key] ?? '') >= mark)
+                    continue;
+                next.readMarks[key] = mark;
+                changed = true;
+            }
+        }
+        if (Object.hasOwn(input, 'drafts')) {
+            for (const [key, draft] of Object.entries(sanitizeDrafts(input.drafts))) {
+                const previous = next.drafts[key];
+                const wins = !previous ||
+                    draft.updatedAt > previous.updatedAt ||
+                    (draft.updatedAt === previous.updatedAt && draft.deleted && !previous.deleted);
+                if (!wins || (previous && sameDraft(previous, draft)))
+                    continue;
+                next.drafts[key] = draft;
+                changed = true;
+            }
+        }
+        if (!changed)
+            return current;
+        this.persist(next);
+        this.cache = next;
+        return next;
+    }
+    persist(prefs) {
+        const dir = path.dirname(this.file);
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(temporary, `${JSON.stringify(prefs, null, '\t')}\n`, { mode: 0o600 });
+            fs.renameSync(temporary, this.file);
+        }
+        catch (err) {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { }
+            console.warn(`⚠ could not persist synced preferences (${err instanceof Error ? err.message : err})`);
+        }
+    }
+}
+const store = new PrefsStore();
+export function readPrefs() {
+    return store.read();
+}
+export function writePrefs(patch) {
+    return store.patch(patch);
+}

package/dist-node/src/routes.js

@@ -64,6 +64,9 @@ export const routes = {
     logs: flat('GET', '/api/logs'),
     settings: flat('GET', '/api/settings'),
     updateSettings: flat('PATCH', '/api/settings'),
+    /** Durable, device-independent PWA state. localStorage remains its offline-first mirror. */
+    prefs: flat('GET', '/api/prefs'),
+    updatePrefs: flat('PATCH', '/api/prefs'),
     nosleep: flat('GET', '/api/nosleep'),
     armNoSleep: flat('POST', '/api/nosleep'),
     disarmNoSleep: flat('DELETE', '/api/nosleep'),
@@ -78,6 +81,8 @@ export const routes = {
     sessions: param('GET', '/api/workspaces/:workspaceId/sessions'),
     newChat: param('POST', '/api/workspaces/:workspaceId/sessions'),
     diff: param('GET', '/api/workspaces/:workspaceId/diff'),
+    /** The worktree's own file list, which is what makes a chat's `src/foo.ts` a link. */
+    workspaceFiles: param('GET', '/api/workspaces/:workspaceId/files'),
     merge: param('POST', '/api/workspaces/:workspaceId/merge'),
     workspaceStatus: param('POST', '/api/workspaces/:workspaceId/status'),
     /** Read, start/forward, or stop a local workspace's selected Conductor Run task. */

package/dist-node/src/server.js

@@ -12,7 +12,7 @@ import { DevServerController } from "./dev-server.js";
 import { isAllowedPreviewPath, parseFileReference } from "./file-preview.js";
 import { FirstPromptQueue } from "./firstprompt.js";
 import { startFunnelWatchdog } from "./funnel-watchdog.js";
-import { workspaceDiff } from "./git.js";
+import { listSourceFiles, workspaceDiff } from "./git.js";
 import { installLogCapture, isManaged, LOG_FILE_NAMES, logFiles, processStartedAt, recentLogs, redactSecrets, tailLogFile } from "./logbuf.js";
 import { createTools, handleRpc, READ_TIMEOUT_MS } from "./mcp-tools.js";
 import { mergePr } from "./merge.js";
@@ -21,6 +21,7 @@ import { armNoSleep, disarmNoSleep, MAX_SECONDS as NOSLEEP_MAX_SECONDS, nosleepS
 import { chatRoute, notifyAll, notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
 import { ParkedPromptQueue } from "./parked.js";
 import { attachPrStatus } from "./pr.js";
+import { readPrefs, writePrefs } from "./prefs.js";
 import { Reads } from "./reads.js";
 import { isRoute, routeParam, routes } from "./routes.js";
 import { foldHits, queryTokens, SearchIndex } from "./search.js";
@@ -30,7 +31,7 @@ import { discardStagedAttachment, materializeStagedAttachments, stageAttachment,
 import { driftWarningLines, readExposeMode, tailscaleBin } from "./tailscale.js";
 import { renderTranscript } from "./transcript.js";
 import { autoJoinHotspotMode, currentSsid, looksLikeHotspot, preferredNetworks } from "./wifi.js";
-import { createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, retryWontHelp, screenLocked, setAgentOptions, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiQueueDepth, WORKSPACE_STATUS_LABELS, withUiPriority } from "./writes.js";
+import { createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiQueueDepth, WORKSPACE_STATUS_LABELS, withUiPriority } from "./writes.js";
 // Before anything that logs: from here on every console line is also kept in memory for
 // `GET /api/logs`, so the phone can read why a send failed without ssh-ing into the Mac.
 installLogCapture();
@@ -258,7 +259,14 @@ async function deliverPrompt(ws, sessionId, text, budgetMs = SEND_BUDGET_MS, que
             deadline: deadline - MIN_CONFIRM_MS,
             queue
         });
-        if (await confirmDelivery(sessionId, text, beforeRowid, deadline)) {
+        // A run that left the prompt in the composer proved it wrote no row, so the
+        // window would be six seconds of watching for nothing. One check still happens:
+        // an *earlier* attempt's row can be arriving, and typing again over that is the
+        // duplicate this whole path exists to avoid.
+        const landed = sendNeverStarted(last.error)
+            ? deliveredSince(sessionId, text, beforeRowid)
+            : await confirmDelivery(sessionId, text, beforeRowid, deadline);
+        if (landed) {
             if (attempts > 1)
                 console.info(`[relay] send to ${label} landed on attempt ${attempts}`);
             return { ok: true, strategy: last.strategy, attempts };
@@ -481,6 +489,10 @@ async function serveFilePreview(req, res, reference) {
     const target = parseFileReference(reference);
     if (!target)
         return json(req, res, 404, { error: 'source file not found' });
+    const refused = (filePath) => {
+        const answer = previewRefusal(filePath);
+        return json(req, res, answer.status, { error: answer.error });
+    };
     let filePath;
     let workspaceRoot;
     let homeRoot;
@@ -495,7 +507,7 @@ async function serveFilePreview(req, res, reference) {
             fs.promises.realpath(BUNDLED_SKILLS_ROOT).catch(() => null)
         ]);
         if (!isAllowedPreviewPath(filePath, workspaceRoot, homeRoot, readExposeMode(), bundledSkillsRoot)) {
-            return json(req, res, 404, { error: 'source file not found' });
+            return refused(filePath);
         }
         const info = await fs.promises.stat(filePath);
         if (!info.isFile())
@@ -503,7 +515,9 @@ async function serveFilePreview(req, res, reference) {
         size = info.size;
     }
     catch {
-        return json(req, res, 404, { error: 'source file not found' });
+        // A path this relay would refuse must answer the same whether or not it is there, or
+        // a public client learns which home files exist by watching 404 turn into 403.
+        return refused(target.path);
     }
     if (size > FILE_PREVIEW_MAX_BYTES)
         return json(req, res, 413, { error: 'source file is too large to preview' });
@@ -533,6 +547,28 @@ async function serveFilePreview(req, res, reference) {
         truncated: start > 0 || end < lines.length
     });
 }
+/**
+ * How to answer for a file the preview will not serve, from the path alone.
+ *
+ * Chat mentions made the home-directory case ordinary — agents write "plan written to
+ * `~/.gstack/plan.md`" constantly — and on a public funnel every one of those is refused
+ * by policy. Answering "source file not found" then sends someone hunting for a file that
+ * is sitting right there, so a refusal says it is a refusal. It discloses nothing: the
+ * verdict comes from the path and the funnel's posture, never from the disk, and it is
+ * the answer for an out-of-bounds path whether or not that path exists.
+ */
+function previewRefusal(filePath) {
+    const mode = readExposeMode();
+    if (isAllowedPreviewPath(path.resolve(filePath), cfg.workspacesRoot, os.homedir(), mode, BUNDLED_SKILLS_ROOT)) {
+        return { status: 404, error: 'source file not found' };
+    }
+    return {
+        status: 403,
+        error: mode === 'public'
+            ? 'this relay is reachable from the internet, so it previews files inside Conductor workspaces only'
+            : 'outside the files this relay may read'
+    };
+}
 /** Per-file ceiling for a relay exposed through Tailscale Funnel. Large media belongs in a link. */
 const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 class PayloadTooLargeError extends Error {
@@ -842,6 +878,22 @@ const server = http.createServer(async (req, res) => {
                     return json(req, res, 400, { error: 'nothing to change' });
                 return json(req, res, 200, { settings: writeSettings(patch) });
             }
+            // PWA state remains local-first; this host copy survives origin changes and
+            // reconciles phones. PATCH accepts a full client snapshot and merges per key.
+            if (isRoute(routes.prefs, req.method, pathname)) {
+                return json(req, res, 200, { prefs: readPrefs() });
+            }
+            if (isRoute(routes.updatePrefs, req.method, pathname)) {
+                const raw = JSON.parse((await readBody(req)) || '{}');
+                if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+                    return json(req, res, 400, { error: 'preferences must be an object' });
+                }
+                const body = raw;
+                if (!Object.hasOwn(body, 'readMarks') && !Object.hasOwn(body, 'drafts')) {
+                    return json(req, res, 400, { error: 'nothing to sync' });
+                }
+                return json(req, res, 200, { prefs: writePrefs(body) });
+            }
             // GET /api/nosleep — is the Mac being held awake, and can this relay do it at all
             if (isRoute(routes.nosleep, req.method, pathname)) {
                 return json(req, res, 200, { ...(await nosleepState()), maxSeconds: NOSLEEP_MAX_SECONDS });
@@ -1116,6 +1168,18 @@ const server = http.createServer(async (req, res) => {
                 const diff = await workspaceDiff(ws.worktree, ws.baseBranch);
                 return json(req, res, 200, diff);
             }
+            // GET /api/workspaces/:id/files — the worktree's own file list, which is what lets the
+            // phone link `tests/foo.ts` in a message: a mention becomes a link only when it names
+            // a file that is really there. A workspace with no worktree simply links nothing.
+            const filesOf = routeParam(routes.workspaceFiles, req.method, pathname);
+            if (filesOf) {
+                const ws = reads.getWorkspace(filesOf);
+                if (!ws)
+                    return json(req, res, 404, { error: 'workspace not found' });
+                if (!ws.worktree)
+                    return json(req, res, 200, { files: [], truncated: false });
+                return json(req, res, 200, await listSourceFiles(ws.worktree));
+            }
             // POST /api/workspaces/:id/merge — merge the workspace's open PR (mirrors Conductor's merge button)
             const mergeOf = routeParam(routes.merge, req.method, pathname);
             if (mergeOf) {

package/dist-node/src/writes.js

@@ -150,6 +150,20 @@ export function retryWontHelp(error) {
 export function lockBlocked(error) {
     return (error ?? '').includes('The Mac is locked');
 }
+/**
+ * A run that ended with the prompt still sitting in Conductor's composer
+ * (`submitComposer`). The draft was never consumed, so this run wrote no row and
+ * the caller's confirm window has nothing to wait for — six seconds spent watching
+ * for something the run already proved didn't happen. Only the *waiting* is
+ * skipped: an earlier attempt's row can still be arriving, so the caller checks
+ * once before typing again.
+ *
+ * Matched on the phrase the send script writes itself, like `lockBlocked` above,
+ * so macOS wording can't drift under it.
+ */
+export function sendNeverStarted(error) {
+    return (error ?? '').includes('still sitting in its composer');
+}
 /**
  * Node's own read of the lock screen — the same CGSessionCopyCurrentDictionary
  * probe `screenLocked()` in conductor.applescript makes, minus the AppleScript

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.65.1",
+	"version": "1.67.0",
 	"type": "module",
 	"packageManager": "yarn@4.15.0",
 	"description": "Phone control panel for local Conductor agents. Reads ride SQLite + git; prompts ride Conductor's own dispatch path.",