npm - conductor-remote - Versions diffs - 1.77.0 → 1.78.1 - Mend

conductor-remote 1.77.0 → 1.78.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/assets/index-dOiHAzne.js +47 -0
package/dist/index.html +1 -1
package/dist/sw.js +1 -1
package/dist-node/src/background-tasks.js +139 -0
package/dist-node/src/mcp-tools.js +7 -2
package/dist-node/src/reads.js +26 -4
package/dist-node/src/shared.js +13 -0
package/package.json +1 -1
package/dist/assets/index-BcQPCRZ1.js +0 -47

package/dist/index.html CHANGED Viewed

@@ -13,7 +13,7 @@
 		<title>Conductor Remote</title>
 		<!-- Runs before the module bundle so it can catch a stale shell that fails to boot. -->
 		<script src="/self-heal.js"></script>
-		<script type="module" crossorigin src="/assets/index-BcQPCRZ1.js"></script>
+		<script type="module" crossorigin src="/assets/index-dOiHAzne.js"></script>
 		<link rel="stylesheet" crossorigin href="/assets/index-BoeZwP2N.css">
 	<link rel="manifest" href="/manifest.webmanifest"></head>
 	<body>

package/dist/sw.js CHANGED Viewed

	@@ -1 +1 @@
1	- if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]\|\|new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const o=e\|\|("document"in self?document.currentScript.src:"")\|\|location.href;if(s[o])return;let c={};const l=e=>i(e,o),t={module:{uri:o},exports:c,require:l};s[o]=Promise.all(n.map(e=>t[e]\|\|l(e))).then(e=>(r(...e),c))}}define(["./workbox-9c191d2f"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"e7ef44deca46c0539e6ff7bba5eb815e"},{url:"index.html",revision:"~~eeb94531cac92da286c8eb9bdc16605a~~"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-~~BoeZwP2N~~.~~css~~",revision:null},{url:"assets/index-~~BcQPCRZ1~~.js",revision:null},{url:"apple-touch-icon.png",revision:"1127bb396b4648add53dce3f22c92aee"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a9b0d962686287452216492cd2247499"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});
1	+ if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]\|\|new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const o=e\|\|("document"in self?document.currentScript.src:"")\|\|location.href;if(s[o])return;let c={};const l=e=>i(e,o),t={module:{uri:o},exports:c,require:l};s[o]=Promise.all(n.map(e=>t[e]\|\|l(e))).then(e=>(r(...e),c))}}define(["./workbox-9c191d2f"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"e7ef44deca46c0539e6ff7bba5eb815e"},{url:"index.html",revision:"bc2a0334dcf9d3a15034a75c866b2e57"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-dOiHAzne.js",revision:null},{url:"assets/index-BoeZwP2N.css",revision:null},{url:"apple-touch-icon.png",revision:"1127bb396b4648add53dce3f22c92aee"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a9b0d962686287452216492cd2247499"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});

package/dist-node/src/background-tasks.js ADDED Viewed

@@ -0,0 +1,139 @@
+/**
+ * The desktop's "Waiting for task" row, re-derived from the SDK stream.
+ *
+ * A `Bash` call with `run_in_background` (or a background Agent) is a *task*: the SDK
+ * writes `system/task_started {task_id, tool_use_id, description, task_type}`, the tool
+ * result says "Command running in background", the turn ends, and `sessions.status`
+ * goes `idle`. Minutes or hours later the command finishes, the SDK writes
+ * `system/task_notification {task_id, status}` and resumes the agent with a fresh
+ * `init`. So a chat waiting on a task reads as a finished turn everywhere `status` is
+ * read — the phone drew nothing, and the notifier said "done" at the wait.
+ *
+ * The open set is what this file computes: started, not yet notified. What makes it
+ * truthful rather than a list that grows forever is the **process gate**. Conductor
+ * runs one `claude --resume=<session>` child per active chat, and a task belongs to
+ * that process: when it goes, the notification never comes. Measured over 4,930 tasks
+ * on this Mac, 25 were never closed and every one of them sits before a process
+ * restart (a later prompt spawned a new child, or Conductor itself relaunched). An
+ * abort does *not* end one — 6 tasks completed straight through an "aborted by user" —
+ * so the notification and the process's death are the only two things that close a
+ * wait, and nothing else here is allowed to.
+ *
+ * The process list is read from `ps` **args only**. The session id sits in the child's
+ * own arguments, so the environment — which carries Conductor's tokens — is never
+ * requested, never held and never logged (the dev-server snapshot has the opposite
+ * problem and the same rule).
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { timestampMs } from "./shared.js";
+const exec = promisify(execFile);
+const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+/**
+ * Fold a chat's task frames into the tasks still open, in the order they started.
+ *
+ * `processStartedAt` is when the chat's agent process came up (epoch ms). A task
+ * started before it belonged to a process that is gone, and its notification will
+ * never be written — so it is dropped here rather than shown until the heat death of
+ * the relay. Pass 0 to trust every frame (a caller that has no process to check).
+ */
+export function openBackgroundTasks(rows, processStartedAt) {
+    const open = new Map();
+    for (const row of rows) {
+        let frame;
+        try {
+            frame = JSON.parse(row.content);
+        }
+        catch {
+            continue;
+        }
+        if (frame.type !== 'system')
+            continue;
+        const taskId = str(frame.task_id);
+        if (!taskId)
+            continue;
+        if (frame.subtype === 'task_notification') {
+            open.delete(taskId);
+        }
+        else if (frame.subtype === 'task_started') {
+            if (timestampMs(row.created_at) < processStartedAt)
+                continue;
+            const taskType = str(frame.task_type) ?? 'task';
+            open.set(taskId, {
+                taskId,
+                toolUseId: str(frame.tool_use_id) ?? null,
+                description: str(frame.description) ?? taskType,
+                taskType,
+                since: row.created_at
+            });
+        }
+    }
+    return [...open.values()];
+}
+/** The SQL prefix filter that selects exactly the frames `openBackgroundTasks` reads. */
+export const TASK_FRAME_FILTER = `(content LIKE '{"type":"system","subtype":"task_started"%'
+   OR content LIKE '{"type":"system","subtype":"task_notification"%')`;
+/**
+ * Which chats have a live agent process, and since when — from one
+ * `ps -axo pid=,lstart=,args=` listing.
+ *
+ * Conductor's child is `…/claude --output-format stream-json … --resume=<session id>`,
+ * and the id in that argument is `sessions.id` (a Conductor chat *is* a Claude Code
+ * session). A brand-new chat may be started with `--session-id` instead, so both are
+ * read. Anything else that happens to run a `claude` binary — the Chrome native host,
+ * a terminal — carries neither and is skipped.
+ *
+ * `lstart` is second-resolution local time in `ps`'s own format ("Wed Sep  2 12:05:23
+ * 2026"), which `Date.parse` reads; a line it cannot parse is kept with a start of 0,
+ * because a process that is there and undatable is still a process that is there.
+ */
+export function parseAgentProcesses(ps) {
+    const starts = new Map();
+    for (const line of ps.split('\n')) {
+        // The executable runs up to the first flag: its path holds a space ("Application Support").
+        const m = /^\s*\d+\s+(\w{3}\s+\w{3}\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.*?)(?:\s+(--.*))?$/.exec(line);
+        if (!m || !/(^|\/)claude$/.test(m[2]))
+            continue;
+        const args = m[3] ?? '';
+        const session = /--(?:resume|session-id)(?:=|\s+)([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b/i.exec(args);
+        if (!session)
+            continue;
+        const started = Date.parse(m[1]);
+        const at = Number.isNaN(started) ? 0 : started;
+        const known = starts.get(session[1]);
+        starts.set(session[1], known === undefined ? at : Math.max(known, at));
+    }
+    return starts;
+}
+/**
+ * How long one `ps` listing is trusted. The sessions poll asks every 2s, the listing
+ * costs tens of milliseconds, and a process that exits is noticed within this window —
+ * one poll late, against a wait that is measured in minutes.
+ */
+const PS_FRESH_MS = 5000;
+let snapshot = { at: 0, sessions: new Map() };
+let refreshing = null;
+/**
+ * The live agent processes, stale-while-revalidate.
+ *
+ * Synchronous on purpose: `Reads.listSessions` is a plain DB read with six callers
+ * that do not await, and a `ps` shell-out is not worth making all of them async. The
+ * first call after start answers with an empty map — no wait shown for one poll —
+ * and every call after that answers from the last listing while a fresh one lands.
+ */
+export function agentProcessStarts() {
+    if (Date.now() - snapshot.at > PS_FRESH_MS && !refreshing) {
+        refreshing = exec('ps', ['-axo', 'pid=,lstart=,args='], { maxBuffer: 16 * 1024 * 1024 })
+            .then(({ stdout }) => {
+            snapshot = { at: Date.now(), sessions: parseAgentProcesses(stdout) };
+        })
+            .catch(() => {
+            // `ps` failing is not a fact about any chat: keep what we had and try again next window.
+            snapshot = { ...snapshot, at: Date.now() };
+        })
+            .finally(() => {
+            refreshing = null;
+        });
+    }
+    return snapshot.sessions;
+}

package/dist-node/src/mcp-tools.js CHANGED Viewed

@@ -27,7 +27,7 @@
  */
 import { chatCursor, parseChatCursor } from "./chat-cursor.js";
 import { routes } from "./routes.js";
-import { HIT_CLOSE, HIT_OPEN, isToolResult, workspaceTitle } from "./shared.js";
+import { HIT_CLOSE, HIT_OPEN, isToolResult, timestampMs, workspaceTitle } from "./shared.js";
 /** Versions we know how to speak. The client's choice wins when we know it. */
 export const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
 export const SERVER_INFO = { name: 'conductor-remote', version: '1' };
@@ -322,7 +322,12 @@ export function createTools(call) {
                     const ctx = typeof s.context_used_percent === 'number' && s.context_used_percent > 0
                         ? ` · ${Math.round(s.context_used_percent)}% context`
                         : '';
-                    return `${s.status === 'working' ? '▶' : '·'} ${s.title ?? '(untitled)'} — ${s.status ?? '?'} · ${s.model ?? '?'}${ctx}\n    session_id: ${s.id}`;
+                    // A chat waiting on a background task reads `idle` in `status` and will resume
+                    // itself; an agent that reads only the status would call it done and send a
+                    // second prompt into the wait.
+                    const waiting = (s.background_tasks ?? []).map(t => `\n    waiting for task: ${t.description} (${Math.max(0, Math.round((Date.now() - timestampMs(t.since)) / 60_000))}m so far)`);
+                    const glyph = s.status === 'working' ? '▶' : waiting.length ? '⧗' : '·';
+                    return `${glyph} ${s.title ?? '(untitled)'} — ${s.status ?? '?'} · ${s.model ?? '?'}${ctx}\n    session_id: ${s.id}${waiting.join('')}`;
                 })
                     .join('\n');
             }

package/dist-node/src/reads.js CHANGED Viewed

@@ -1,15 +1,17 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { agentProcessStarts, openBackgroundTasks, TASK_FRAME_FILTER } from "./background-tasks.js";
 import { describeRepoIcon, resolveRepoIcon } from "./icons.js";
 import { workspaceTitle } from "./shared.js";
 import { parseMessage, toolImageAt } from "./transcript.js";
 /** Keep the stable wire field in sync with whichever provider owns the chat. */
-function toSessionRow(row) {
+function toSessionRow(row, background_tasks) {
     const { codex_thinking_level, ...session } = row;
     return {
         ...session,
-        claude_effort_level: row.agent_type === 'codex' ? codex_thinking_level : row.claude_effort_level
+        claude_effort_level: row.agent_type === 'codex' ? codex_thinking_level : row.claude_effort_level,
+        background_tasks
     };
 }
 const worktreeCache = new Map();
@@ -80,9 +82,12 @@ function resolveWorktree(workspacesRoot, repoName, directoryName, branch, repoRo
 export class Reads {
     db;
     workspacesRoot;
-    constructor(db, workspacesRoot) {
+    /** Chats with a live agent process, and its start — the gate on `background_tasks`. */
+    liveAgents;
+    constructor(db, workspacesRoot, liveAgents = agentProcessStarts) {
         this.db = db;
         this.workspacesRoot = workspacesRoot;
+        this.liveAgents = liveAgents;
     }
     /**
      * Unread chats, grouped by workspace. `workspaces.unread` is a **dead column** —
@@ -285,7 +290,24 @@ export class Reads {
 			 FROM sessions s
 			 WHERE s.workspace_id = ? AND COALESCE(s.is_hidden, 0) = 0
 			 ORDER BY s.created_at ASC`, [workspaceId]);
-        return rows.map(toSessionRow);
+        const live = this.liveAgents();
+        return rows.map(row => {
+            const started = live.get(row.id);
+            return toSessionRow(row, started === undefined ? [] : this.openBackgroundTasks(row.id, started));
+        });
+    }
+    /**
+     * The background tasks a chat is still waiting on (src/background-tasks.ts).
+     *
+     * Only asked for a chat with a live agent process, which bounds the cost twice over:
+     * a handful of chats at a time, and a prefix scan measured at 4–8ms on the largest
+     * chats here (1,000–1,700 rows, 30–58 MB) — under the 2s sessions poll it rides on.
+     */
+    openBackgroundTasks(sessionId, processStartedAt) {
+        const rows = this.db.query(`SELECT created_at, content FROM session_messages
+			 WHERE session_id = ? AND ${TASK_FRAME_FILTER}
+			 ORDER BY rowid ASC`, [sessionId]);
+        return openBackgroundTasks(rows, processStartedAt);
     }
     /**
      * Every live chat's status, across all workspaces — what the notifier watches for

package/dist-node/src/shared.js CHANGED Viewed

@@ -50,6 +50,19 @@ export function workspaceTitle(w) {
 export function queryTokens(raw) {
     return raw.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
 }
+/**
+ * Parse one of Conductor's timestamps as an epoch.
+ *
+ * Its SQLite defaults/triggers use `datetime('now')`, which is UTC but serializes as
+ * `YYYY-MM-DD HH:MM:SS` with no zone. Other writers use ISO strings ending in `Z`.
+ * Browsers interpret the bare SQLite form as local time, making a fresh chat look two
+ * hours old in Oslo during summer. Add the zone only to that exact database shape;
+ * explicitly zoned ISO values and local wall-clock strings keep their native meaning.
+ */
+export function timestampMs(value) {
+    const sqliteUtc = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(value);
+    return Date.parse(sqliteUtc ? `${value.replace(' ', 'T')}Z` : value);
+}
 /**
  * A temporary `NEW` marker in Conductor's picker is a badge, not part of the
  * model name. The relay and phone use this value for the visible label and for

package/package.json CHANGED Viewed

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