conductor-remote 1.116.0 → 1.118.0

package/dist-node/src/reads/workspaces.js

@@ -0,0 +1,230 @@
+import { describeRepoIcon, resolveRepoIcon } from "../files/icons.js";
+import { resolveWorktree } from "./worktrees.js";
+/**
+ * Neutralize LIKE's own wildcards in a user's search word. `queryTokens` already
+ * strips everything but letters, digits and `_` — and `_` is LIKE's single-character
+ * wildcard, so "add_set" would quietly also match "addaset" without this.
+ */
+function escapeLike(s) {
+    return s.replace(/[\\%_]/g, m => `\\${m}`);
+}
+/** Shared row → `SearchWorkspace` shape for the two search reads below. */
+function toSearchWorkspace(r) {
+    return {
+        id: r.id,
+        workspace_name: r.workspace_name,
+        pr_title: r.pr_title,
+        branch: r.branch,
+        directory_name: r.directory_name,
+        state: r.state,
+        updated_at: r.updated_at,
+        repo_name: r.repo_name,
+        icon: describeRepoIcon({ icon: r.repo_icon, repoRoot: r.repo_root, remoteUrl: r.remote_url }),
+        archived: r.state === 'archived'
+    };
+}
+export class WorkspacesReads {
+    db;
+    workspacesRoot;
+    constructor(db, workspacesRoot) {
+        this.db = db;
+        this.workspacesRoot = workspacesRoot;
+    }
+    /**
+     * Unread chats, grouped by workspace. `workspaces.unread` is a **dead column** —
+     * Conductor still declares it (and its migration still says "when 1, the workspace
+     * should be marked visually as unread") but writes 0 on every row: 0 of 1691 are
+     * non-zero on this Mac, which is why the sidebar's bold/badge never once fired.
+     * The live flag is per session, and it *is* a flag — `unread_count` is only ever
+     * 0 or 1 — so what's worth counting is how many chats have news, not the column.
+     */
+    unreadSessions() {
+        const rows = this.db.query(`SELECT workspace_id, id, updated_at
+			 FROM sessions
+			 WHERE COALESCE(unread_count, 0) > 0 AND COALESCE(is_hidden, 0) = 0`);
+        const byWorkspace = new Map();
+        for (const r of rows) {
+            if (!r.workspace_id)
+                continue;
+            const list = byWorkspace.get(r.workspace_id);
+            if (list)
+                list.push({ id: r.id, at: r.updated_at });
+            else
+                byWorkspace.set(r.workspace_id, [{ id: r.id, at: r.updated_at }]);
+        }
+        return byWorkspace;
+    }
+    listWorkspaces() {
+        const rows = this.db.query(`SELECT w.id, w.directory_name, w.workspace_name, w.branch, w.pr_title, w.derived_status, w.manual_status,
+			        w.state, w.created_at, w.updated_at, w.pinned_at, w.active_session_id, w.intended_target_branch,
+			        r.name AS repo_name, r.root_path AS repo_root, r.icon AS repo_icon,
+			        r.remote_url AS remote_url, r.default_branch AS default_branch,
+			        s.status AS session_status, s.title AS session_title, s.model AS model,
+			        s.agent_type AS agent_type
+			 FROM workspaces w
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 LEFT JOIN sessions s ON s.id = w.active_session_id
+			 WHERE w.state IN ('ready', 'setting_up')
+			 ORDER BY (w.pinned_at IS NULL), w.updated_at DESC`);
+        const unread = this.unreadSessions();
+        return rows.map(r => ({
+            ...r,
+            unread_sessions: unread.get(r.id) ?? [],
+            worktree: resolveWorktree(this.workspacesRoot, r.repo_name, r.directory_name, r.branch, r.repo_root),
+            baseBranch: r.intended_target_branch || r.default_branch || 'main',
+            icon: describeRepoIcon({ icon: r.repo_icon, repoRoot: r.repo_root, remoteUrl: r.remote_url })
+        }));
+    }
+    getWorkspace(id) {
+        return this.listWorkspaces().find(w => w.id === id) ?? null;
+    }
+    /**
+     * The repos Conductor knows about, most recently used first. `root_path` is
+     * what a `conductor://…&path=` deep link needs to pick the target repo — with
+     * no path Conductor silently falls back to the *first* repo.
+     *
+     * "Used" is the newest workspace in the repo, never `repos.updated_at`: that
+     * column moves when the repo's *settings* change, so the repo worked in every
+     * day here reads as last touched six weeks ago. Repos with no workspace at all
+     * keep Conductor's own sidebar order, behind every repo that has one.
+     *
+     * The `replace()`s are load-bearing: `created_at` is always `YYYY-MM-DD HH:MM:SS`
+     * while `updated_at` is written both that way (306 rows) and as ISO with a `Z`
+     * (1,819), and 'T' sorts after ' ', so an untouched string compare can rank an
+     * earlier ISO row above a later plain one on the same day.
+     */
+    listRepos() {
+        const rows = this.db.query(`SELECT r.name, r.root_path, r.default_branch, r.icon, r.remote_url
+			 FROM repos r
+			 LEFT JOIN workspaces w ON w.repository_id = r.id
+			 WHERE COALESCE(r.hidden, 0) = 0
+			 GROUP BY r.id
+			 ORDER BY (MAX(MAX(REPLACE(REPLACE(w.updated_at, 'T', ' '), 'Z', ''), w.created_at)) IS NULL),
+			          MAX(MAX(REPLACE(REPLACE(w.updated_at, 'T', ' '), 'Z', ''), w.created_at)) DESC,
+			          (r.display_order IS NULL), r.display_order, r.name`);
+        return rows.map(r => ({
+            name: r.name,
+            root_path: r.root_path,
+            default_branch: r.default_branch,
+            icon: describeRepoIcon({ icon: r.icon, repoRoot: r.root_path, remoteUrl: r.remote_url })
+        }));
+    }
+    /**
+     * Map chat ids to the workspace that owns them, archived included.
+     *
+     * `listWorkspaces` filters to `state IN ('ready','setting_up')`, which is right for
+     * the sidebar and wrong for search: the whole point of searching the transcript is
+     * to reach work you finished and put away. One query for the whole hit set, because
+     * a search fans out over up to 300 chunks and a per-chat lookup would be 300 of them.
+     */
+    searchTargets(sessionIds) {
+        const out = new Map();
+        if (!sessionIds.length)
+            return out;
+        const holes = sessionIds.map(() => '?').join(',');
+        const rows = this.db.query(`SELECT s.id AS session_id, s.title AS session_title,
+			        w.id, w.workspace_name, w.pr_title, w.branch, w.directory_name, w.state, w.updated_at,
+			        r.name AS repo_name, r.icon AS repo_icon, r.root_path AS repo_root, r.remote_url AS remote_url
+			 FROM sessions s
+			 JOIN workspaces w ON w.id = s.workspace_id
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 WHERE s.id IN (${holes})`, sessionIds);
+        for (const r of rows)
+            out.set(r.session_id, { sessionTitle: r.session_title, workspace: toSearchWorkspace(r) });
+        return out;
+    }
+    /**
+     * 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.
+     */
+    searchSessionIds(repos, includeArchived) {
+        if (repos && !repos.length)
+            return [];
+        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
+				 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 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, includeArchived = true) {
+        if (!tokens.length)
+            return [];
+        if (repos && !repos.length)
+            return [];
+        const fields = ['w.workspace_name', 'w.pr_title', 'w.branch', 'w.directory_name', 'r.name'];
+        // 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(',')})`] : []),
+            ...(!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,
+			        r.name AS repo_name, r.icon AS repo_icon, r.root_path AS repo_root, r.remote_url AS remote_url
+			 FROM workspaces w
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 WHERE ${where}
+			 ORDER BY (w.state = 'archived'), w.updated_at DESC
+			 LIMIT ?`, [...params, limit]);
+        return rows.map(toSearchWorkspace);
+    }
+    /**
+     * One workspace by id, whatever state it is in — the read behind opening an archived
+     * chat (`GET /api/workspaces/:id`).
+     *
+     * `getWorkspace` above is the *live* one: it resolves a worktree and a base branch,
+     * and returns null for the 1,846 archived workspaces here, which is right for every
+     * write (there is nothing to focus and nothing to diff) and wrong for reading. The
+     * transcript survives archiving — Conductor deletes the worktree, not the chat — so
+     * this returns the same `SearchWorkspace` a search result carries, with no worktree
+     * and no git, and `listSessions`/`getMessages` do the rest by id.
+     */
+    getAnyWorkspace(id) {
+        const rows = this.db.query(`SELECT w.id, w.workspace_name, w.pr_title, w.branch, w.directory_name, w.state, w.updated_at,
+			        r.name AS repo_name, r.icon AS repo_icon, r.root_path AS repo_root, r.remote_url AS remote_url
+			 FROM workspaces w
+			 LEFT JOIN repos r ON r.id = w.repository_id
+			 WHERE w.id = ?
+			 LIMIT 1`, [id]);
+        return rows[0] ? toSearchWorkspace(rows[0]) : null;
+    }
+    /** Resolve a repo's icon by its name (the sidebar avatar) — null if the repo or icon is unknown. */
+    resolveRepoIcon(repoName) {
+        const rows = this.db.query('SELECT root_path FROM repos WHERE name = ? LIMIT 1', [
+            repoName
+        ]);
+        const root = rows[0]?.root_path;
+        return root ? resolveRepoIcon(root) : null;
+    }
+    /**
+     * Which workspace a chat belongs to.
+     *
+     * Every other route resolves this by matching `active_session_id`, which only ever
+     * finds the tab that is currently on screen. That is fine for a phone, where the
+     * chat you are looking at is the chat you are sending to. It is wrong for anything
+     * addressing a chat by id — a background tab has a workspace too, and `sessions`
+     * has carried `workspace_id` all along.
+     */
+    sessionWorkspaceId(sessionId) {
+        const rows = this.db.query(`SELECT workspace_id FROM sessions WHERE id = ? LIMIT 1`, [sessionId]);
+        return rows[0]?.workspace_id ?? null;
+    }
+}

package/dist-node/src/reads/worktrees.js

@@ -0,0 +1,45 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+const worktreeCache = new Map();
+/**
+ * Resolve a workspace's worktree path. Conductor lays worktrees out as
+ * `<workspacesRoot>/<repoName>/<directoryName>`, but we verify against
+ * `git worktree list` (matched by branch) so a layout change can't silently
+ * point us at the wrong tree.
+ */
+export function resolveWorktree(workspacesRoot, repoName, directoryName, branch, repoRoot) {
+    if (repoName && directoryName) {
+        const guess = path.join(workspacesRoot, repoName, directoryName);
+        if (fs.existsSync(path.join(guess, '.git')))
+            return guess;
+    }
+    if (!(repoRoot && branch))
+        return null;
+    const cacheKey = repoRoot;
+    let listing = worktreeCache.get(cacheKey);
+    if (listing === undefined) {
+        try {
+            listing = execFileSync('git', ['-C', repoRoot, 'worktree', 'list', '--porcelain'], {
+                encoding: 'utf8',
+                timeout: 5000
+            });
+        }
+        catch {
+            listing = null;
+        }
+        worktreeCache.set(cacheKey, listing);
+    }
+    if (!listing)
+        return null;
+    // Porcelain: blocks of "worktree <path>" / "branch refs/heads/<name>"
+    const blocks = listing.split('\n\n');
+    for (const block of blocks) {
+        if (block.includes(`refs/heads/${branch}`)) {
+            const m = block.match(/^worktree (.+)$/m);
+            if (m)
+                return m[1];
+        }
+    }
+    return null;
+}

package/dist-node/src/routes.js

@@ -2,7 +2,7 @@
  * Every `/api` path, declared once, for the three callers that must agree on it.
  *
  * The relay matches these, the phone builds them (`web/src/lib/api.ts`) and the MCP
- * tools build them too (`src/mcp-tools.ts`). Before this each path was spelled three
+ * tools build them too (`src/mcp/tools/`). Before this each path was spelled three
  * times: a regex here, a template literal there, another template literal in the third
  * place. `src/wire.ts` had already made the *shapes* impossible to disagree about, and
  * this is the other half — a renamed path used to typecheck cleanly in all three files
@@ -85,7 +85,7 @@ export const routes = {
     /**
      * 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).
+     * route while nothing behind it runs (src/writes/system.ts ▸ restartConductorApp).
      */
     restartConductor: flat('POST', '/api/conductor/restart'),
     settings: flat('GET', '/api/settings'),
@@ -142,7 +142,7 @@ export const routes = {
     devServer: param('GET', '/api/workspaces/:workspaceId/dev-server'),
     startDevServer: param('POST', '/api/workspaces/:workspaceId/dev-server'),
     stopDevServer: param('DELETE', '/api/workspaces/:workspaceId/dev-server'),
-    /** Dismiss a first prompt the relay never managed to deliver (src/firstprompt.ts). */
+    /** Dismiss a first prompt the relay never managed to deliver (src/delivery/firstprompt.ts). */
     dismissFirstPrompt: param('DELETE', '/api/workspaces/:workspaceId/prompt'),
     // ── chats ──
     messages: param('GET', '/api/sessions/:sessionId/messages'),
@@ -160,11 +160,11 @@ export const routes = {
     sendPrompt: param('POST', '/api/sessions/:sessionId/prompt'),
     /** Write a phone-selected file into Conductor's attachment layout for this chat's workspace. */
     uploadAttachment: param('POST', '/api/sessions/:sessionId/attachments'),
-    /** Copy a chat into a fresh tab beside it, as a Conductor attachment (src/attachments.ts). */
+    /** Copy a chat into a fresh tab beside it, as a Conductor attachment (src/files/attachments.ts). */
     splitChat: param('POST', '/api/sessions/:sessionId/split'),
     /** Lightweight tracked delegation from a chat outside an active Workflow. */
     delegateTask: param('POST', '/api/sessions/:sessionId/delegate'),
-    /** Dismiss a prompt parked behind the lock screen (src/parked.ts). */
+    /** Dismiss a prompt parked behind the lock screen (src/delivery/parked.ts). */
     dismissParkedPrompt: param('DELETE', '/api/sessions/:sessionId/prompt')
 };
 // ── matching, for the relay ─────────────────────────────────────────────────────

package/dist-node/src/{search.js → search/coordinator.js}

@@ -1,5 +1,5 @@
 import { Worker } from 'node:worker_threads';
-import { chatCursor } from "./chat-cursor.js";
+import { chatCursor } from "../transcript/cursor.js";
 /**
  * Full-text search over the chat history, in a sidecar DB the relay owns.
  *
@@ -48,7 +48,7 @@ const CHUNK_LIMIT = 300;
  * phone, and no transcript contains them, so the client needs no parser. The client
  * must not render them literally.
  */
-export { HIT_CLOSE, HIT_OPEN } from "./shared.js";
+export { HIT_CLOSE, HIT_OPEN } from "../shared.js";
 /**
  * Turn a phone query into an FTS5 MATCH expression.
  *
@@ -114,7 +114,7 @@ export function matchQuery(raw) {
     return required.length ? `${required.join(' AND ')} AND ${looseExpr}` : looseExpr;
 }
 /** The tokens `matchQuery` will search for — what a caller matches names against. */
-export { queryTokens } from "./shared.js";
+export { queryTokens } from "../shared.js";
 /**
  * Main-thread facade for the disposable full-text index.
  *
@@ -142,7 +142,7 @@ export class SearchIndex {
             return;
         this.stopping = false;
         this.indexStatus = { chunks: 0, ready: false, progress: 0 };
-        const module = import.meta.url.endsWith('.ts') ? './search-worker.ts' : './search-worker.js';
+        const module = import.meta.url.endsWith('.ts') ? './worker.ts' : './worker.js';
         try {
             const worker = new Worker(new URL(module, import.meta.url), {
                 workerData: { sourceDbPath: this.sourceDbPath, file: this.file },

package/dist-node/src/{search-worker.js → search/worker.js}

@@ -2,9 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { parentPort, workerData } from 'node:worker_threads';
-import { ConductorDb } from "./db.js";
-import { HIT_CLOSE, HIT_OPEN, matchQuery } from "./search.js";
-import { parseMessage } from "./transcript.js";
+import { ConductorDb } from "../db.js";
+import { parseMessage } from "../transcript/parser.js";
+import { HIT_CLOSE, HIT_OPEN, matchQuery } from "./coordinator.js";
 /** Bump when extraction or an invariant such as one-chunk-per-source changes stored rows. */
 // v3 rebuilds every chunk through WorkflowSecretScrubber so a capability indexed by
 // an older relay cannot survive after the private-envelope boundary is introduced.