conductor-remote 1.79.0 → 1.81.0

package/dist-node/src/preview-urls.js

@@ -0,0 +1,283 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const MAX_PREVIEWS = 10;
+function validPort(value) {
+    return Number.isInteger(value) && value > 0 && value <= 65535;
+}
+/** Remove a TOML comment without treating a `#` inside a quoted string as one. */
+function withoutComment(line) {
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '#')
+            return line.slice(0, i);
+    }
+    return line;
+}
+function tomlString(raw) {
+    const value = withoutComment(raw).trim();
+    if (value.startsWith("'") && value.endsWith("'"))
+        return value.slice(1, -1);
+    if (!(value.startsWith('"') && value.endsWith('"')))
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function fields(text) {
+    const found = {};
+    for (const line of text.split('\n')) {
+        const match = withoutComment(line).match(/^\s*(name|url)\s*=\s*(.+?)\s*$/);
+        if (!match)
+            continue;
+        const value = tomlString(match[2]);
+        if (value !== null)
+            found[match[1]] = value;
+    }
+    return found;
+}
+/**
+ * Split an inline TOML table on top-level commas. Preview URL fields are strings,
+ * so this deliberately implements only the small grammar the Conductor schema
+ * permits instead of pulling a TOML runtime into the dependency-free relay.
+ */
+function inlineFields(text) {
+    const parts = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === ',') {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return fields(parts.join('\n'));
+}
+/** Extract a balanced TOML array, ignoring brackets inside strings and comments. */
+function arrayAt(text, start) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    let comment = false;
+    for (let i = start; i < text.length; i++) {
+        const char = text[i];
+        if (comment) {
+            if (char === '\n')
+                comment = false;
+            continue;
+        }
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '#')
+            comment = true;
+        else if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '[')
+            depth++;
+        else if (char === ']' && --depth === 0)
+            return { body: text.slice(start + 1, i), end: i + 1 };
+    }
+    return null;
+}
+function inlineTables(body) {
+    const tables = [];
+    let quote = null;
+    let escaped = false;
+    let comment = false;
+    let start = -1;
+    for (let i = 0; i < body.length; i++) {
+        const char = body[i];
+        if (comment) {
+            if (char === '\n')
+                comment = false;
+            continue;
+        }
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '#')
+            comment = true;
+        else if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '{')
+            start = i + 1;
+        else if (char === '}' && start >= 0) {
+            tables.push(inlineFields(body.slice(start, i)));
+            start = -1;
+        }
+    }
+    return tables;
+}
+/**
+ * Read just Conductor's `preview_urls` setting from TOML. Conductor serializes
+ * these as `[[preview_urls]]`; the inline-array form is accepted as well because
+ * it is equally valid against the public schema. `null` means the layer did not
+ * set the key, while `[]` is an explicit override.
+ */
+export function parsePreviewUrlsToml(text) {
+    const tables = [];
+    let seen = false;
+    const headers = [...text.matchAll(/^\s*\[\[\s*preview_urls\s*\]\]\s*(?:#.*)?$/gm)];
+    for (const [index, header] of headers.entries()) {
+        seen = true;
+        const start = (header.index ?? 0) + header[0].length;
+        const nextHeader = text.slice(start).search(/^\s*\[{1,2}[^\n]+\]{1,2}\s*(?:#.*)?$/m);
+        const end = nextHeader < 0 ? text.length : start + nextHeader;
+        tables.push(fields(text.slice(start, end)));
+        if (index >= MAX_PREVIEWS - 1)
+            break;
+    }
+    // A root inline array has to appear before the first TOML table; after a table
+    // header, an unqualified key belongs to that table rather than to the root.
+    const firstTable = text.search(/^\s*\[/m);
+    const root = firstTable < 0 ? text : text.slice(0, firstTable);
+    const inline = root.match(/^\s*preview_urls\s*=\s*\[/m);
+    if (inline?.index !== undefined) {
+        seen = true;
+        const open = inline.index + inline[0].lastIndexOf('[');
+        const array = arrayAt(root, open);
+        if (array)
+            tables.unshift(...inlineTables(array.body));
+    }
+    if (!seen)
+        return null;
+    return tables
+        .flatMap(entry => (typeof entry.url === 'string' ? [{ name: entry.name, url: entry.url }] : []))
+        .slice(0, MAX_PREVIEWS);
+}
+const fileCache = new Map();
+function readLayer(file) {
+    try {
+        const stat = fs.statSync(file);
+        const cached = fileCache.get(file);
+        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+            return cached.value;
+        const value = parsePreviewUrlsToml(fs.readFileSync(file, 'utf8'));
+        fileCache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, value });
+        return value;
+    }
+    catch {
+        fileCache.delete(file);
+        return null;
+    }
+}
+/** Resolve Conductor's user → repository → repository-local → managed precedence. */
+export function previewUrlSettings(workspace) {
+    let resolved = readLayer(path.join(os.homedir(), '.conductor', 'settings.toml')) ?? [];
+    const shared = workspace.worktree
+        ? path.join(workspace.worktree, '.conductor', 'settings.toml')
+        : workspace.repo_root
+            ? path.join(workspace.repo_root, '.conductor', 'settings.toml')
+            : null;
+    if (shared)
+        resolved = readLayer(shared) ?? resolved;
+    // Machine-local repository settings live in the main checkout and outrank the
+    // shared file. A copied worktree-local file wins when one intentionally exists.
+    for (const file of [
+        workspace.repo_root ? path.join(workspace.repo_root, '.conductor', 'settings.local.toml') : null,
+        workspace.worktree ? path.join(workspace.worktree, '.conductor', 'settings.local.toml') : null
+    ]) {
+        if (!file)
+            continue;
+        resolved = readLayer(file) ?? resolved;
+    }
+    resolved = readLayer(path.join(os.homedir(), '.conductor', 'settings.managed.toml')) ?? resolved;
+    return resolved;
+}
+/** Expand the supported Conductor template and retain only loopback HTTP servers. */
+export function resolvePreviewTargets(settings, conductorPort) {
+    const targets = [];
+    const seen = new Set();
+    for (const setting of settings) {
+        let value = setting.url;
+        if (/\$(?:CONDUCTOR_PORT\b|\{CONDUCTOR_PORT\})/.test(value)) {
+            if (!conductorPort)
+                continue;
+            value = value.replace(/\$(?:CONDUCTOR_PORT\b|\{CONDUCTOR_PORT\})/g, String(conductorPort));
+        }
+        // Other Conductor variables can describe paths, but forwarding an unresolved
+        // template would point at a URL different from the one Conductor opens.
+        if (/\$\{?[A-Za-z_][A-Za-z0-9_]*\}?/.test(value))
+            continue;
+        try {
+            const url = new URL(value);
+            if (url.protocol !== 'http:' || !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
+                continue;
+            const port = Number(url.port || 80);
+            if (!validPort(port))
+                continue;
+            const previewPath = `${url.pathname || '/'}${url.search}${url.hash}`;
+            const key = `${port}\0${previewPath}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            targets.push({ name: setting.name?.trim() || `Port ${port}`, port, path: previewPath });
+            if (targets.length >= MAX_PREVIEWS)
+                break;
+        }
+        catch {
+            // Invalid settings are already surfaced by Conductor's schema UI. They are
+            // not a reason for the relay to guess at a different host or port.
+        }
+    }
+    return targets;
+}

package/dist-node/src/reads.js

@@ -193,31 +193,35 @@ export class Reads {
         return out;
     }
     /**
-     * Every chat in the named repos, archived workspaces included — the repo filter
-     * as the search index needs it, since its chunks carry a chat id and nothing else.
-     * Names, not ids, because names are what the phone's picker and `list_repos` hold.
+     * Every chat in the requested search scope. The index only carries chat ids, so
+     * repo and archive filters have to be resolved here before ranking. Names, not repo
+     * ids, because names are what the phone's picker and `list_repos` hold.
      */
-    sessionIdsInRepos(names) {
-        if (!names.length)
+    searchSessionIds(repos, includeArchived) {
+        if (repos && !repos.length)
             return [];
-        const holes = names.map(() => '?').join(',');
+        const scope = [
+            ...(repos ? [`r.name IN (${repos.map(() => '?').join(',')})`] : []),
+            ...(!includeArchived ? ["w.state IS NOT 'archived'"] : [])
+        ];
         return this.db
             .query(`SELECT s.id FROM sessions s
 				 JOIN workspaces w ON w.id = s.workspace_id
-				 JOIN repos r ON r.id = w.repository_id
-				 WHERE r.name IN (${holes})`, names)
+				 LEFT JOIN repos r ON r.id = w.repository_id
+				${scope.length ? ` WHERE ${scope.join(' AND ')}` : ''}`, repos ?? [])
             .map(r => r.id);
     }
     /**
      * Workspaces whose own identity matches every token — name, PR title, branch,
-     * worktree codename or repo. Archived included, same reason as `searchTargets`.
-     * `repos` narrows to those repos by name; an empty list matches nothing.
+     * worktree codename or repo. Archived are included by default, for the same reason
+     * as `searchTargets`; `includeArchived` lets the phone narrow the search to current
+     * work. `repos` narrows to those repos by name; an empty list matches nothing.
      *
      * This is the half of search the transcript index cannot do. A workspace named for
      * the thing you are looking for may never have said those words in its chat, and
      * one whose chat is empty has no chunks at all.
      */
-    findWorkspacesByName(tokens, limit = 20, repos) {
+    findWorkspacesByName(tokens, limit = 20, repos, includeArchived = true) {
         if (!tokens.length)
             return [];
         if (repos && !repos.length)
@@ -226,7 +230,10 @@ export class Reads {
         // AND across tokens, OR across fields: "auk lamp" should find the lamp workspace in
         // the auk repo, where no single column holds both words.
         const byToken = tokens.map(() => `(${fields.map(f => `${f} LIKE ? ESCAPE '\\'`).join(' OR ')})`);
-        const scope = repos ? [`r.name IN (${repos.map(() => '?').join(',')})`] : [];
+        const scope = [
+            ...(repos ? [`r.name IN (${repos.map(() => '?').join(',')})`] : []),
+            ...(!includeArchived ? ["w.state IS NOT 'archived'"] : [])
+        ];
         const where = [...byToken, ...scope].join(' AND ');
         const params = [...tokens.flatMap(t => fields.map(() => `%${escapeLike(t)}%`)), ...(repos ?? [])];
         const rows = this.db.query(`SELECT w.id, w.workspace_name, w.pr_title, w.branch, w.directory_name, w.state, w.updated_at,

package/dist-node/src/routes.js

@@ -62,6 +62,12 @@ export const routes = {
     /** Drop a staged file the user removed before creating its workspace. */
     discardStagedAttachment: param('DELETE', '/api/attachments/:attachmentId'),
     logs: flat('GET', '/api/logs'),
+    /**
+     * Quit Conductor and start it again. Not a workspace route: it is about the app,
+     * and its whole reason to exist is a Conductor that looks healthy from every other
+     * route while nothing behind it runs (src/writes.ts ▸ restartConductorApp).
+     */
+    restartConductor: flat('POST', '/api/conductor/restart'),
     settings: flat('GET', '/api/settings'),
     updateSettings: flat('PATCH', '/api/settings'),
     /** Durable, device-independent PWA state. localStorage remains its offline-first mirror. */

package/dist-node/src/server.js

@@ -32,7 +32,7 @@ import { discardStagedAttachment, materializeStagedAttachments, stageAttachment,
 import { driftWarningLines, readExposeMode, tailscaleBin } from "./tailscale.js";
 import { renderTranscript, transcriptThrough } from "./transcript.js";
 import { autoJoinHotspotMode, currentSsid, looksLikeHotspot, preferredNetworks } from "./wifi.js";
-import { archiveWorkspace, createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setDefaultModel, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiQueueDepth, WORKSPACE_STATUS_LABELS, withUiPriority } from "./writes.js";
+import { archiveWorkspace, createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, restartConductorApp, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setDefaultModel, 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();
@@ -824,12 +824,14 @@ const server = http.createServer(async (req, res) => {
             // Both reach archived workspaces. That is the point: 1,846 of the 1,886 here are
             // archived, so a search limited to the live sidebar would miss almost everything.
             //
-            // `repo=` (repeatable) scopes both halves to those repos. It is resolved to chat
-            // ids and pushed *into* the FTS query rather than applied to its top 300 chunks,
-            // or a common word would fill every slot from the busiest repo (search.ts ▸ search).
+            // `repo=` (repeatable) and `archived=0` scope both halves. They are resolved to
+            // chat ids and pushed *into* the FTS query rather than applied to its top 300
+            // chunks, or excluded work would fill every slot (search.ts ▸ search).
             if (isRoute(routes.search, req.method, pathname)) {
                 const q = url.searchParams.get('q') ?? '';
                 const repos = [...new Set(url.searchParams.getAll('repo').filter(Boolean))];
+                // Archived search predates the toggle and stays the default for cached PWAs and MCP.
+                const includeArchived = url.searchParams.get('archived') !== '0';
                 // 12, not 50: an OR query over common words ("add", "remove") has a long weak tail,
                 // and past the first screenful nobody scrolls — they retype instead.
                 const limit = Math.min(50, Math.max(1, Number(url.searchParams.get('limit') ?? 12) || 12));
@@ -837,13 +839,19 @@ const server = http.createServer(async (req, res) => {
                 const tokens = queryTokens(q);
                 if (!tokens.length)
                     return json(req, res, 200, { query: q, repos, results: [], index });
-                const scope = repos.length ? { sessionIds: reads.sessionIdsInRepos(repos) } : {};
+                const scoped = repos.length > 0 || !includeArchived;
+                const scope = scoped
+                    ? { sessionIds: reads.searchSessionIds(repos.length ? repos : undefined, includeArchived) }
+                    : {};
                 const hits = search.search(q, scope);
                 const targets = reads.searchTargets([...new Set(hits.map(h => h.sessionId))]);
-                const fromChats = foldHits(hits, sid => targets.get(sid)?.workspace ?? null);
+                const fromChats = foldHits(hits, sid => {
+                    const workspace = targets.get(sid)?.workspace ?? null;
+                    return !includeArchived && workspace?.archived ? null : workspace;
+                });
                 const remaining = new Map(fromChats.map(r => [r.workspace.id, r]));
                 const merged = [];
-                for (const workspace of reads.findWorkspacesByName(tokens, limit, repos.length ? repos : undefined)) {
+                for (const workspace of reads.findWorkspacesByName(tokens, limit, repos.length ? repos : undefined, includeArchived)) {
                     const evidence = remaining.get(workspace.id);
                     remaining.delete(workspace.id);
                     // Keep the chat evidence when there is any: the snippet is what tells you this
@@ -957,6 +965,36 @@ const server = http.createServer(async (req, res) => {
                 const result = await disarmNoSleep();
                 return json(req, res, result.ok ? 200 : result.state.available ? 502 : 409, result);
             }
+            // POST /api/conductor/restart { stopAgents? } — quit Conductor and start it again.
+            //
+            // The lever exists in the actuator already, but only as activateConductor's last
+            // resort, which fires exclusively for a *windowless* Conductor. This is for the
+            // other shape: window up, prompts landing as rows, and no agent output behind any
+            // of it (measured 2026-09-02 — 2h35m of user rows after the last agent frame).
+            // The running agents are counted from the DB before the UI is touched and refused
+            // unless the caller meant it, the same way archiving is: quitting ends every turn
+            // in flight. The lock screen is the actuator's own gate, since only it can ask.
+            if (isRoute(routes.restartConductor, req.method, pathname)) {
+                const body = JSON.parse((await readBody(req)) || '{}');
+                const working = reads.listSessionStates().filter(state => state.status === 'working').length;
+                if (working > 0 && body.stopAgents !== true) {
+                    return json(req, res, 409, {
+                        ok: false,
+                        agentsRunning: true,
+                        working,
+                        error: `${working} chat${working === 1 ? ' is' : 's are'} mid-turn. Restarting Conductor ends ${working === 1 ? 'it' : 'them'}.`
+                    });
+                }
+                const startedAt = Date.now();
+                const result = await restartConductorApp();
+                const ms = Date.now() - startedAt;
+                if (!result.ok) {
+                    console.warn(`[restart] Conductor restart failed after ${(ms / 1000).toFixed(1)}s: ${result.error}`);
+                    return json(req, res, 502, { ok: false, ms, error: result.error });
+                }
+                console.log(`[restart] quit Conductor and relaunched it in ${(ms / 1000).toFixed(1)}s`);
+                return json(req, res, 200, { ok: true, ms });
+            }
             // GET /api/logs?file=&limit= — the relay's own log, so a phone can diagnose a failed send
             // without reaching the Mac. Default is this process's captured console (ordered, timestamped);
             // `file` tails the daemon's stdout/stderr on disk, which is the only place the *previous*

package/dist-node/src/writes.js

@@ -103,6 +103,13 @@ export function uiTurn(op) {
  * a doomed one waits it out, and the caller's own deadline is what bounds that.
  */
 export const SEND_ATTEMPT_MS = 28_000;
+/**
+ * A restart's own ceiling. It is longer than a send's because it is mostly *waiting*:
+ * up to 4s for the quit to be honoured, then a cold launch, then `waitForWindow(60)`'s
+ * 15s for the first window — none of which can be hurried, and all of which the caller
+ * would rather wait through than be told "try again" about.
+ */
+export const RESTART_ATTEMPT_MS = 45_000;
 /**
  * A run's own ceiling, taken off the caller's deadline at the moment it actually
  * starts.
@@ -649,6 +656,42 @@ return "ok"`.trim();
         return { ok: false, strategy: 'applescript', error: osaError(err) };
     }
 }
+/**
+ * Quit Conductor and start it again because the phone asked — the one write here
+ * whose subject is the app rather than anything inside it.
+ *
+ * The lever already existed and was unreachable. `activateConductor` restarts as its
+ * last resort, but only after a *running* Conductor has drawn no window through
+ * `reopen` and a Dock click, so it answers exactly one failure: a windowless app. The
+ * failure this is for looks healthy from every probe on that ladder — window up,
+ * sidebar drawing, composer taking prompts — while the agent runtime behind it has
+ * stopped producing anything. Measured on this Mac (2026-09-02): the last agent frame
+ * in `session_messages` was 20:47:44 and prompts kept landing as user rows for the
+ * next two and a half hours, each turn flipping `working → idle` having written
+ * nothing. Nothing on the read side can fix that, and "quit it on your Mac" is not
+ * advice a phone can act on.
+ *
+ * Two gates, and neither lives here. The **working chats** are counted from the DB by
+ * server.ts, which refuses without `stopAgents` — quitting takes every agent mid-turn
+ * down with it, so that has to be said out loud, exactly as it is for archiving. The
+ * **lock screen** is asked by `restartApp` itself, because a relaunch fired behind it
+ * comes up windowless (and once, wedged). What is left for this function is the UI
+ * lock: a restart is not a read, and letting one land while a send is mid-flight would
+ * quit the app between the composer write and the Enter.
+ */
+export async function restartConductorApp() {
+    const script = `
+${CONDUCTOR_HANDLERS}
+
+return my restartApp()`.trim();
+    try {
+        await uiTurn(() => exec('osascript', ['-e', script], { env: { ...process.env }, timeout: RESTART_ATTEMPT_MS }));
+        return { ok: true, strategy: 'applescript' };
+    }
+    catch (err) {
+        return { ok: false, strategy: 'applescript', error: osaError(err, 'Conductor didn’t come back in time') };
+    }
+}
 /**
  * The workspace statuses Conductor's sidebar groups by, mapped from the value it
  * stores in `workspaces.manual_status` to the label on its own menu. `canceled`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.79.0",
+	"version": "1.81.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.",