npm - conductor-remote - Versions diffs - 1.58.2 → 1.59.0 - Mend

conductor-remote 1.58.2 → 1.59.0

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 (11) hide show

package/dist/assets/index-XDQOL8Jf.js +44 -0
package/dist/index.html +1 -1
package/dist/sw.js +1 -1
package/dist-node/src/mcp-tools.js +13 -2
package/dist-node/src/reads.js +19 -1
package/dist-node/src/routes.js +6 -0
package/dist-node/src/server.js +18 -0
package/dist-node/src/shared.js +12 -0
package/dist-node/src/transcript.js +144 -12
package/package.json +1 -1
package/dist/assets/index-yoen_tHL.js +0 -44

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-yoen_tHL.js"></script>
+		<script type="module" crossorigin src="/assets/index-XDQOL8Jf.js"></script>
 		<link rel="stylesheet" crossorigin href="/assets/index-DT9enoqA.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 l={};const c=e=>i(e,o),t={module:{uri:o},exports:l,require:c};s[o]=Promise.all(n.map(e=>t[e]\|\|c(e))).then(e=>(r(...e),l))}}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:"e1e682e2e5e88fa03b7808ae9db8e098"},{url:"index.html",revision:"~~bccefb2a435fb6775bac9dc39985ea8d~~"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-~~yoen_tHL~~.js",revision:null},{url:"assets/index-DT9enoqA.css",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{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 l={};const c=e=>i(e,o),t={module:{uri:o},exports:l,require:c};s[o]=Promise.all(n.map(e=>t[e]\|\|c(e))).then(e=>(r(...e),l))}}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:"e1e682e2e5e88fa03b7808ae9db8e098"},{url:"index.html",revision:"0fcfd46a66899dffaf188c7d215cb4f3"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-XDQOL8Jf.js",revision:null},{url:"assets/index-DT9enoqA.css",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{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/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, workspaceTitle } from "./shared.js";
+import { HIT_CLOSE, HIT_OPEN, isToolResult, 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' };
@@ -197,7 +197,18 @@ export function createTools(call) {
                 if (anchor !== null && !data.entries.some(entry => entry.rowid === anchor)) {
                     throw new Error('near cursor is not in that session');
                 }
-                const wanted = data.entries.filter(e => e.role === 'thinking' ? includeThinking : e.role === 'tool' ? includeTools : true);
+                const wanted = data.entries.filter(e => {
+                    if (e.role === 'thinking')
+                        return includeThinking;
+                    // A successful result carries the call's output, which is the churn `include_tools`
+                    // exists to keep out of a context window — the call above it already says what ran.
+                    // A failed one stays: one line, and it is why the turn changed course.
+                    if (isToolResult(e) && !e.error)
+                        return false;
+                    if (e.role === 'tool')
+                        return includeTools;
+                    return true;
+                });
                 if (!wanted.length)
                     return `no messages in session ${sessionId}`;
                 let selected;

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

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { describeRepoIcon, resolveRepoIcon } from "./icons.js";
 import { workspaceTitle } from "./shared.js";
-import { parseMessage } from "./transcript.js";
+import { parseMessage, toolImageAt } from "./transcript.js";
 /** Keep the stable wire field in sync with whichever provider owns the chat. */
 function toSessionRow(row) {
     const { codex_thinking_level, ...session } = row;
@@ -309,6 +309,24 @@ export class Reads {
         }
         return null;
     }
+    /**
+     * One image a tool returned, by the reference its transcript entry carries.
+     *
+     * The bytes sit in `session_messages.content` as base64, so this is the same read-only
+     * handle as everything else — nothing is written and nothing is cached to disk. The
+     * reference names a row and the image's position in it, and `toolImageAt` does the
+     * walk, because the numbering has to be the one `parseMessage` used.
+     */
+    toolImage(reference) {
+        const dot = reference.lastIndexOf('.');
+        const rowid = Number(reference.slice(0, dot));
+        const index = Number(reference.slice(dot + 1));
+        if (dot < 0 || !Number.isInteger(rowid) || !Number.isInteger(index) || index < 0)
+            return null;
+        const rows = this.db.query('SELECT content FROM session_messages WHERE rowid = ? LIMIT 1', [rowid]);
+        const content = rows[0]?.content;
+        return content ? toolImageAt(content, index) : null;
+    }
     /**
      * Which workspace a chat belongs to.
      *

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

@@ -51,6 +51,12 @@ export const routes = {
     localImage: param('GET', '/api/local-images/:path'),
     /** A source-file preview linked from agent Markdown. */
     filePreview: param('GET', '/api/files/:reference'),
+    /**
+     * One image a tool returned, addressed `<message rowid>.<image number in that row>`.
+     * It is a route rather than a field because the bytes are ~100 kB of base64 each and a
+     * transcript's first fetch carries a whole chat: the phone asks only for the ones it opens.
+     */
+    toolImage: param('GET', '/api/tool-images/:reference'),
     /** Temporarily hold a file while the phone creates the workspace it will belong to. */
     stageAttachment: flat('POST', '/api/attachments'),
     /** Drop a staged file the user removed before creating its workspace. */

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

@@ -1053,6 +1053,24 @@ const server = http.createServer(async (req, res) => {
             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);

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

@@ -202,3 +202,15 @@ export function isPreviewableSource(filePath) {
     const dot = name.lastIndexOf('.');
     return dot !== -1 && SOURCE_EXTENSIONS.has(name.slice(dot).toLowerCase());
 }
+/**
+ * A transcript row that carries a tool's *output* rather than the call that produced it.
+ *
+ * The two are separate `session_messages` rows and reach the phone as separate entries
+ * (src/transcript.ts), so three places have to agree on which is which: the phone folds
+ * a result onto its call, a rendered transcript prints the call and leaves the output
+ * behind, and `read_chat` does the same for an agent. Structural, because each of them
+ * holds a slightly different view of the same row.
+ */
+export function isToolResult(e) {
+    return e.role === 'tool' && !e.tool && e.output !== undefined;
+}

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

@@ -8,6 +8,7 @@
  * tool_result blocks, never the user's own words. Real prompts are the
  * plain-text rows. Never render an SDK user frame as a user bubble.
  */
+import { isToolResult } from "./shared.js";
 const clip = (s, n) => (s.length > n ? `${s.slice(0, n)}…` : s);
 const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
 /** Make tool details repo-relative: absolute worktree paths waste the whole line on a phone. */
@@ -35,16 +36,113 @@ function summarizeToolUse(name, input, worktree) {
         return { text };
     return { text, detail: stripWorktree(detail, worktree) };
 }
-function resultText(content) {
-    let s = '';
+/**
+ * How much of a tool's output travels to the phone.
+ *
+ * Output is the largest thing in the history — 799 MB of the 3,106 MB in
+ * `session_messages.content` (see src/search.ts) — and a chat's first transcript fetch
+ * carries the whole backlog at once, so this cap is what keeps opening a chat from
+ * paying for every file the agent ever read. Measured over the two biggest chats on
+ * this Mac: 335 results / 271 kB raw and 664 results / 1,732 kB raw, which this cap
+ * brings down to 193 kB and 569 kB. What is past it is worth reading in Conductor.
+ */
+const MAX_OUTPUT_CHARS = 2000;
+/**
+ * Read a tool result, whatever shape it came in.
+ *
+ * Measured over the 40,000 most recent result blocks on this Mac: 35,709 are a plain
+ * string, 3,120 are Conductor's own edit result (`{status, diffString}`), 753 are text
+ * blocks, 205 are `tool_reference` lists and 80 carry an image. Only the first and third
+ * used to be read, so **3,917 results rendered as nothing at all** — an edit's diff, the
+ * tools a search found, and every screenshot, each of them a step that looked like it
+ * did nothing. An unknown shape falls back to its own JSON rather than to silence, which
+ * is what keeps Conductor drift visible instead of blank.
+ */
+function resultOutput(content, worktree) {
+    const plain = (text, diff = false) => ({
+        text: clip(text.replace(/<\/?tool_use_error>/g, '').trim(), MAX_OUTPUT_CHARS),
+        diff,
+        images: 0
+    });
     if (typeof content === 'string')
-        s = content;
-    else if (Array.isArray(content)) {
-        s = content
-            .map(c => (c && typeof c === 'object' && 'text' in c ? String(c.text) : ''))
-            .join('');
+        return plain(content);
+    if (Array.isArray(content)) {
+        const said = [];
+        const tools = [];
+        let images = 0;
+        for (const raw of content) {
+            if (!raw || typeof raw !== 'object')
+                continue;
+            if (raw.type === 'image')
+                images++;
+            else if (str(raw.tool_name))
+                tools.push(str(raw.tool_name));
+            else if (typeof raw.text === 'string')
+                said.push(raw.text);
+        }
+        // A tool_reference list is the whole answer of a tool search; naming them beats the
+        // count, because which tools came back is the thing worth reading later.
+        if (tools.length)
+            said.push(`${plural(tools.length, 'tool')}: ${tools.join(', ')}`);
+        return { ...plain(said.join('')), images };
+    }
+    if (content && typeof content === 'object') {
+        const o = content;
+        // Conductor's edit result. The status names the file it wrote, so it is worth a line
+        // of its own above the hunks — worktree-relative, like every other path here.
+        const patch = str(o.diffString);
+        if (patch) {
+            const status = str(o.status);
+            const head = status ? `${stripWorktree(status, worktree)}\n` : '';
+            return plain(head + patch, true);
+        }
+        return plain(JSON.stringify(content));
+    }
+    return plain('');
+}
+/**
+ * The images one row's tool results carry, in the order the transcript numbered them.
+ *
+ * The reference on an entry is `<rowid>.<n>`, and `n` counts image blocks across every
+ * `tool_result` in that row — so this walk and the one in `parseMessage` must stay the
+ * same walk, which is why they live in one file.
+ */
+export function toolImageAt(content, index) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    let seen = 0;
+    for (const b of parsed.message?.content ?? []) {
+        if (b.type !== 'tool_result' || !Array.isArray(b.content))
+            continue;
+        for (const raw of b.content) {
+            if (raw?.type !== 'image')
+                continue;
+            if (seen++ !== index)
+                continue;
+            const data = str(raw.source?.data);
+            if (!data)
+                return null;
+            return { mediaType: str(raw.source?.media_type) ?? sniffImageType(data), data };
+        }
     }
-    return clip(s.replace(/<\/?tool_use_error>/g, '').trim(), 400);
+    return null;
+}
+/** Base64 magic bytes, for the image blocks that carry no `media_type`. */
+function sniffImageType(base64) {
+    if (base64.startsWith('iVBOR'))
+        return 'image/png';
+    if (base64.startsWith('/9j/'))
+        return 'image/jpeg';
+    if (base64.startsWith('R0lGOD'))
+        return 'image/gif';
+    if (base64.startsWith('UklGR'))
+        return 'image/webp';
+    return 'application/octet-stream';
 }
 export function parseMessage(row, worktree = null) {
     const queued = row.queue_order !== null && row.sent_at === null;
@@ -86,6 +184,9 @@ export function parseMessage(row, worktree = null) {
     }
     const entries = [];
     const push = (e) => entries.push({ ...base, ...e, id: `${row.id}:${entries.length}` });
+    // Images are numbered per row, because that is all a reference needs to find one again
+    // (`toolImageAt`) and a row may hold several results.
+    let imageIndex = 0;
     let pending = [];
     const flush = () => {
         const text = pending.join('\n').trim();
@@ -107,12 +208,36 @@ export function parseMessage(row, worktree = null) {
         }
         else if (b.type === 'tool_use' && typeof b.name === 'string') {
             flush();
-            push({ role: 'tool', tool: b.name, ...summarizeToolUse(b.name, b.input, worktree) });
+            push({ role: 'tool', tool: b.name, toolUseId: str(b.id), ...summarizeToolUse(b.name, b.input, worktree) });
         }
-        else if (b.type === 'tool_result' && b.is_error) {
-            // Successful results are noise on a phone; surface only failures.
+        else if (b.type === 'tool_result') {
+            // A result is written to a later row than the call it answers — anything slower than
+            // the 1s poll lands a tick or more behind it — so it travels as its own entry naming
+            // that call, and the phone folds the two together (web/src/lib/transcript-merge.ts).
+            // Only a failure repeats the output as `text`, which is what an unpaired one renders
+            // as. Repeating it for a success would send the biggest thing here twice: on the
+            // largest chat on this Mac that second copy was 569 kB of a 2.0 MB transcript.
             flush();
-            push({ role: 'tool', error: true, text: resultText(b.content) || '(tool error)' });
+            const read = resultOutput(b.content, worktree);
+            // Bytes stay behind: a screenshot is ~100 kB of base64 in this row, and the phone
+            // fetches one only when the step it belongs to is opened (routes ▸ toolImage).
+            const images = Array.from({ length: read.images }, () => `${row.rowid}.${imageIndex++}`);
+            const output = read.text || (b.is_error ? '(tool error)' : '');
+            if (!output && !images.length)
+                continue;
+            const result = {
+                role: 'tool',
+                text: b.is_error ? output : '',
+                output,
+                toolUseId: str(b.tool_use_id)
+            };
+            if (read.diff)
+                result.diff = true;
+            if (images.length)
+                result.images = images;
+            if (b.is_error)
+                result.error = true;
+            push(result);
         }
     }
     flush();
@@ -169,6 +294,13 @@ export function renderTranscript(entries, format) {
             out.push(`[${parts.join(', ')} elided]`);
     };
     for (const e of entries) {
+        // A successful result is the output of the call printed just above it, and output is
+        // the biggest half of a chat (src/search.ts) as well as the least re-readable. So a
+        // render carries the call and leaves the file dumps behind — this is not an elision
+        // of a tool *call*, so it is not counted as one. A failure still prints: one line,
+        // and it is often why the answer changed course.
+        if (isToolResult(e) && !e.error)
+            continue;
         if (e.role === 'thinking' && !format.thinking) {
             pending.thinking++;
             elided.thinking++;

package/package.json CHANGED Viewed

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