conductor-remote 1.9.0 → 1.9.1

package/dist-node/src/sidecar.js

@@ -0,0 +1,186 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Client for Conductor's sidecar IPC — the `conductor-runtime sidecar` process
+ * that owns every live `claude`/`codex` agent. The desktop app drives it over a
+ * unix socket speaking newline-delimited JSON-RPC 2.0; we speak the same
+ * protocol as an additional local client.
+ *
+ * This is by far the most precise write path: prompts are addressed by
+ * `sessionId`, so there is no window focus or AppleScript involved and the app's
+ * UI updates correctly because it's the real dispatch path. It is also the most
+ * update-fragile surface (a private, versioned IPC), which is why it lives
+ * behind the Actuator interface and falls back to AppleScript when the socket
+ * can't be reached (see writes.ts).
+ *
+ * Reverse-engineered from conductor-runtime (Conductor 0.76):
+ *   - socket:      `$TMPDIR/conductor-sidecar-v2-<sidecarPid>.sock`
+ *   - transport:   newline-delimited JSON-RPC 2.0 (`{jsonrpc,id,method,params}`)
+ *   - local auth:  the literal `{ userId: 'local', auth: 'local' }`
+ *   - send prompt: method `query`, params `{ type: 'sendUserMessageRequest', … }`
+ *   - safe read:   method `contextUsage`, params `{ sessionId, …auth }`
+ *
+ * Stale socket files from exited sidecars linger in `$TMPDIR`, so discovery is
+ * connectivity-based: we try candidates newest-first and use the first that
+ * actually accepts a connection.
+ */
+const SOCKET_PREFIX = 'conductor-sidecar-v2-';
+const LOCAL_AUTH = { userId: 'local', auth: 'local' };
+/** Candidate sidecar socket paths in `$TMPDIR`, newest mtime first. */
+function listSidecarSockets() {
+    const dir = os.tmpdir();
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const name of names) {
+        if (!(name.startsWith(SOCKET_PREFIX) && name.endsWith('.sock')))
+            continue;
+        const p = path.join(dir, name);
+        try {
+            const st = fs.statSync(p);
+            if (st.isSocket())
+                found.push({ p, m: st.mtimeMs });
+        }
+        catch {
+            // vanished between readdir and stat — skip
+        }
+    }
+    return found.sort((a, b) => b.m - a.m).map(x => x.p);
+}
+function isConnRefused(err) {
+    const code = err?.code;
+    return code === 'ECONNREFUSED' || code === 'ENOENT';
+}
+/** One JSON-RPC request/response over a fresh connection to a specific socket. */
+function rpcOnSocket(socketPath, method, params, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const sock = net.connect(socketPath);
+        const id = 1;
+        let buf = '';
+        let settled = false;
+        const finish = (err, val) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            sock.destroy();
+            if (err)
+                reject(err);
+            else
+                resolve(val);
+        };
+        const timer = setTimeout(() => finish(new Error(`sidecar RPC "${method}" timed out`)), timeoutMs);
+        sock.on('connect', () => {
+            sock.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+        });
+        sock.on('data', chunk => {
+            buf += chunk.toString('utf8');
+            // The sidecar also pushes unsolicited notifications — ignore anything
+            // that isn't the response to our id.
+            let nl = buf.indexOf('\n');
+            while (nl >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                nl = buf.indexOf('\n');
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.id === id && ('result' in msg || 'error' in msg)) {
+                    if (msg.error)
+                        return finish(new Error(msg.error.message || `sidecar RPC error ${msg.error.code}`));
+                    return finish(null, msg.result);
+                }
+            }
+        });
+        sock.on('error', e => finish(e instanceof Error ? e : new Error(String(e))));
+        sock.on('close', () => finish(new Error('sidecar closed the connection before responding')));
+    });
+}
+/** Try each candidate socket, skipping stale ones (connection refused). */
+async function rpc(method, params, timeoutMs = 8000) {
+    const candidates = listSidecarSockets();
+    if (!candidates.length)
+        throw new Error('no Conductor sidecar socket found — is Conductor running?');
+    let lastErr;
+    for (const socketPath of candidates) {
+        try {
+            return await rpcOnSocket(socketPath, method, params, timeoutMs);
+        }
+        catch (err) {
+            lastErr = err;
+            if (isConnRefused(err))
+                continue; // stale socket file, try the next
+            throw err; // a real RPC/protocol error — surface it, don't mask
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error('sidecar unreachable');
+}
+/** Resolve a connectable sidecar socket, or null. Used to decide write strategy. */
+export function sidecarSocket(timeoutMs = 800) {
+    const candidates = listSidecarSockets();
+    return (async () => {
+        for (const p of candidates) {
+            const ok = await canConnect(p, timeoutMs);
+            if (ok)
+                return p;
+        }
+        return null;
+    })();
+}
+function canConnect(socketPath, timeoutMs) {
+    return new Promise(resolve => {
+        const sock = net.connect(socketPath);
+        let done = false;
+        const finish = (ok) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(t);
+            sock.destroy();
+            resolve(ok);
+        };
+        const t = setTimeout(() => finish(false), timeoutMs);
+        sock.on('connect', () => finish(true));
+        sock.on('error', () => finish(false));
+    });
+}
+/** True when a precise (sidecar) send path is currently reachable. */
+export async function sidecarAvailable() {
+    return (await sidecarSocket()) !== null;
+}
+/**
+ * Deliver a prompt to a specific session — the real send path, precisely
+ * targeted. Resolves once the sidecar has accepted (queued/sent) the message.
+ */
+export async function sidecarSendUserMessage(sessionId, text) {
+    await rpc('query', {
+        type: 'sendUserMessageRequest',
+        ...LOCAL_AUTH,
+        sessionId,
+        id: randomUUID(),
+        message: text,
+        agentMessage: text,
+        deliveryMode: 'default'
+    });
+}
+/**
+ * Read a session's context usage. Pure read — no turn is triggered — so it's the
+ * safe way to prove the socket + auth + framing work end to end.
+ */
+export function sidecarContextUsage(sessionId) {
+    return rpc('contextUsage', { ...LOCAL_AUTH, sessionId }, 5000);
+}

package/dist-node/src/transcript.js

@@ -0,0 +1,83 @@
+/**
+ * Conductor stores each turn's raw Claude Code SDK stream JSON in
+ * `session_messages.content`. User-typed prompts are stored as plain text.
+ * This turns a row into a compact, phone-renderable entry.
+ */
+function textFromBlocks(blocks) {
+    const parts = [];
+    let tool;
+    for (const b of blocks) {
+        if (b.type === 'text' && b.text)
+            parts.push(b.text);
+        else if (b.type === 'thinking' && typeof b.text === 'string')
+            parts.push(b.text);
+        else if (b.type === 'tool_use') {
+            tool = b.name;
+            const inputStr = summarizeToolInput(b.input);
+            parts.push(inputStr ? `▸ ${b.name}: ${inputStr}` : `▸ ${b.name}`);
+        }
+        else if (b.type === 'tool_result') {
+            parts.push(summarizeToolResult(b.content));
+        }
+    }
+    return { text: parts.join('\n').trim(), tool };
+}
+function summarizeToolInput(input) {
+    if (!input || typeof input !== 'object')
+        return '';
+    const o = input;
+    const key = o.command ?? o.file_path ?? o.path ?? o.pattern ?? o.description ?? o.prompt;
+    const s = typeof key === 'string' ? key : JSON.stringify(o);
+    return s.length > 140 ? `${s.slice(0, 140)}…` : s;
+}
+function summarizeToolResult(content) {
+    let s = '';
+    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('');
+    }
+    s = s.trim();
+    if (!s)
+        return '↳ (result)';
+    return `↳ ${s.length > 200 ? `${s.slice(0, 200)}…` : s}`;
+}
+export function parseMessage(row) {
+    const queued = row.queue_order !== null && row.sent_at === null;
+    const base = { id: row.id, rowid: row.rowid, ts: row.created_at, queued };
+    const content = row.content ?? '';
+    // Plain user prompt (not SDK JSON).
+    if (!content.startsWith('{')) {
+        if (!content.trim())
+            return null;
+        return { ...base, role: 'user', text: content };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return { ...base, role: 'system', text: content.slice(0, 200) };
+    }
+    // Skip pure bookkeeping frames (token accounting, etc.).
+    if (parsed.type === 'system' && parsed.subtype === 'thinking_tokens')
+        return null;
+    if (parsed.type === 'result')
+        return null;
+    const blocks = parsed.message?.content;
+    if (Array.isArray(blocks)) {
+        const { text, tool } = textFromBlocks(blocks);
+        if (!text)
+            return null;
+        if (tool)
+            return { ...base, role: 'tool', text, tool };
+        if (parsed.type === 'user')
+            return { ...base, role: 'user', text };
+        return { ...base, role: 'assistant', text };
+    }
+    if (parsed.type === 'system')
+        return null;
+    return { ...base, role: 'system', text: content.slice(0, 200) };
+}

package/dist-node/src/writes.js

@@ -0,0 +1,144 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { sidecarAvailable, sidecarSendUserMessage } from "./sidecar.js";
+const exec = promisify(execFile);
+/**
+ * The sidecar IPC path — the precise, per-session write. Delivers straight to
+ * `sessionId` over Conductor's own dispatch socket (see sidecar.ts), so it needs
+ * no window focus and the app UI reflects the turn correctly.
+ *
+ * Opt-in (WRITE_STRATEGY=sidecar) because it speaks a private, versioned IPC and
+ * hasn't been validated by an automated live send (that would inject a prompt
+ * into a running agent). It is the intended default once you've confirmed it on
+ * your setup.
+ */
+export class SidecarActuator {
+    name = 'sidecar';
+    caveat = 'Delivered straight to the target session over Conductor’s dispatch socket — precise per-workspace targeting.';
+    precise = true;
+    available() {
+        return sidecarAvailable();
+    }
+    async send(target, text) {
+        const sessionId = target.sessionId ?? target.workspace.active_session_id;
+        if (!sessionId)
+            return { ok: false, strategy: this.name, error: 'no session id to target' };
+        try {
+            await sidecarSendUserMessage(sessionId, text);
+            return { ok: true, strategy: this.name };
+        }
+        catch (err) {
+            return { ok: false, strategy: this.name, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}
+// AppleScript steps that focus a workspace via Conductor's command palette
+// (Esc → Cmd+K → branch → Enter). The branch is read from RELAY_WS_QUERY at run
+// time to dodge AppleScript escaping; the timing delays are load-bearing.
+const FOCUS_WORKSPACE_STEPS = `
+	key code 53
+	delay 0.25
+	keystroke "k" using {command down}
+	delay 0.7
+	keystroke (system attribute "RELAY_WS_QUERY")
+	delay 0.9
+	key code 36
+	delay 1.3`;
+/** Conductor's command palette matches workspaces by branch — its unique key. A
+ * looser query (directory name) can match a command like unarchive, so prefer
+ * branch and only fall back when it's absent. */
+function focusQuery(ws) {
+    return ws.branch || ws.workspace_name || ws.directory_name || '';
+}
+/**
+ * Drives Conductor's real send path via macOS Accessibility (AppleScript): focus
+ * the target workspace, paste the prompt, press Enter. Uses whatever model /
+ * permission mode the session already has (zero risk of altering the agent),
+ * which is why it's the default.
+ *
+ * Precise targeting comes from focusing the intended workspace first through
+ * Conductor's command palette (Cmd+K → branch → Enter) before pasting, so the
+ * prompt lands in the right session regardless of what was focused — no private
+ * IPC and nothing to rebreak on a Conductor update (unlike the sidecar).
+ */
+export class AppleScriptActuator {
+    name = 'applescript';
+    caveat = 'Focuses the target workspace via the command palette (Cmd+K) before sending.';
+    precise = true;
+    async send(target, text) {
+        const navQuery = focusQuery(target.workspace);
+        const navigate = navQuery ? FOCUS_WORKSPACE_STEPS : '';
+        // Paste beats keystroke for long/multibyte prompts. Stash the clipboard,
+        // focus the target workspace, paste, send, and restore.
+        const script = `
+set savedClipboard to the clipboard
+tell application "Conductor" to activate
+delay 0.4
+tell application "System Events"${navigate}
+	set the clipboard to (do shell script "cat" & " " & quoted form of (system attribute "RELAY_PROMPT_FILE"))
+	keystroke "v" using {command down}
+	delay 0.15
+	key code 36
+end tell
+delay 0.1
+set the clipboard to savedClipboard
+`.trim();
+        // Pass the prompt via a temp file + env to avoid AppleScript string escaping.
+        const os = await import('node:os');
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        const tmp = path.join(os.tmpdir(), `relay-prompt-${process.pid}-${Date.now()}.txt`);
+        await fs.writeFile(tmp, text, 'utf8');
+        try {
+            await exec('osascript', ['-e', script], {
+                env: { ...process.env, RELAY_PROMPT_FILE: tmp, RELAY_WS_QUERY: navQuery },
+                timeout: 15000
+            });
+            return { ok: true, strategy: this.name };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                strategy: this.name,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+        finally {
+            await fs.rm(tmp, { force: true }).catch(() => undefined);
+        }
+    }
+}
+/**
+ * Open a new chat in the target workspace — Conductor's "New chat, same files"
+ * (Cmd+T). Focuses the workspace first (command palette → branch), then Cmd+T; the
+ * caller detects the freshly-created session id from the DB.
+ */
+export async function newChat(workspace) {
+    const navQuery = focusQuery(workspace);
+    if (!navQuery)
+        return { ok: false, strategy: 'applescript', error: 'workspace has no branch to focus' };
+    const script = `
+tell application "Conductor" to activate
+delay 0.4
+tell application "System Events"${FOCUS_WORKSPACE_STEPS}
+	keystroke "t" using {command down}
+end tell`.trim();
+    try {
+        await exec('osascript', ['-e', script], {
+            env: { ...process.env, RELAY_WS_QUERY: navQuery },
+            timeout: 15000
+        });
+        return { ok: true, strategy: 'applescript' };
+    }
+    catch (err) {
+        return { ok: false, strategy: 'applescript', error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function pickActuator(strategy) {
+    return strategy === 'sidecar' ? new SidecarActuator() : new AppleScriptActuator();
+}
+/** Effective actuator description for the UI, factoring in runtime availability. */
+export async function describeActuator(actuator) {
+    const available = actuator.available ? await actuator.available().catch(() => false) : true;
+    return { name: actuator.name, caveat: actuator.caveat, precise: actuator.precise, available };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.9.0",
+	"version": "1.9.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.",
@@ -29,9 +29,8 @@
 	"bin": "bin/cli.js",
 	"files": [
 		"bin",
-		"src",
-		"scripts",
-		"dist"
+		"dist",
+		"dist-node"
 	],
 	"publishConfig": {
 		"access": "public",
@@ -43,6 +42,7 @@
 		"dev": "node scripts/dev.ts",
 		"dev:web": "vite",
 		"build": "vite build",
+		"build:node": "tsc -p tsconfig.build.json",
 		"preview": "yarn build && yarn start",
 		"gen:icons": "node scripts/gen-icons.ts",
 		"deploy": "yarn build && node bin/cli.js service install",
@@ -52,7 +52,7 @@
 		"fix": "biome check . --fix",
 		"verify": "yarn typecheck && yarn lint",
 		"release": "semantic-release",
-		"prepack": "yarn build",
+		"prepack": "yarn build && yarn build:node",
 		"postinstall": "husky || true"
 	},
 	"devDependencies": {

package/scripts/dev.ts

@@ -1,75 +0,0 @@
-import { spawn } from 'node:child_process'
-import net from 'node:net'
-
-// Run the Vite dev server (HMR PWA) and the relay (API + reads) together.
-// Vite proxies /api → the relay so the phone hits a single origin.
-//
-// Dev-only per-workspace ports: inside a Conductor workspace, $CONDUCTOR_PORT is
-// unique per workspace, so several `yarn dev`s can run concurrently. Vite (the
-// origin a browser/phone opens) takes that port; the relay gets a free ephemeral
-// port and Vite proxies /api to it on loopback. Outside Conductor, fall back to
-// the classic 5173 (web) / 8787 (relay) pair. Prod (`yarn start`/`deploy`/the
-// LaunchAgent) never runs through here, so its Tailscale bind and RELAY_PORT
-// default stay untouched — this clutters neither the prod path nor the build.
-
-/** Ask the OS for an unused TCP port so a Conductor workspace's relay never collides. */
-function freePort(): Promise<number> {
-	return new Promise((resolve, reject) => {
-		const srv = net.createServer()
-		srv.once('error', reject)
-		srv.listen(0, '127.0.0.1', () => {
-			const { port } = srv.address() as net.AddressInfo
-			srv.close(() => resolve(port))
-		})
-	})
-}
-
-const conductorPort = Number(process.env.CONDUCTOR_PORT) || 0
-const webPort = conductorPort || 5173
-// Loopback bind + Vite proxy target must match; only prod auto-binds the Tailscale NIC.
-const relayPort = conductorPort ? await freePort() : 8787
-
-const procs = [
-	{
-		name: 'web  ',
-		cmd: 'yarn',
-		args: ['dev:web'],
-		color: '\x1b[35m',
-		env: { ...process.env, WEB_PORT: String(webPort), RELAY_PORT: String(relayPort) }
-	},
-	{
-		name: 'relay',
-		cmd: 'node',
-		args: ['--watch', 'bin/cli.js'],
-		color: '\x1b[36m',
-		env: { ...process.env, RELAY_PORT: String(relayPort), RELAY_HOST: process.env.RELAY_HOST ?? '127.0.0.1' }
-	}
-]
-
-const children = procs.map(p => {
-	const child = spawn(p.cmd, p.args, { stdio: ['inherit', 'pipe', 'pipe'], env: p.env })
-	const tag = `${p.color}[${p.name}]\x1b[0m `
-	const pipe = (stream: NodeJS.ReadableStream) => {
-		let buf = ''
-		stream.on('data', (d: Buffer) => {
-			buf += d.toString()
-			let nl = buf.indexOf('\n')
-			while (nl >= 0) {
-				console.log(tag + buf.slice(0, nl))
-				buf = buf.slice(nl + 1)
-				nl = buf.indexOf('\n')
-			}
-		})
-	}
-	pipe(child.stdout)
-	pipe(child.stderr)
-	return child
-})
-
-const shutdown = () => {
-	for (const c of children) c.kill('SIGTERM')
-	process.exit(0)
-}
-process.on('SIGINT', shutdown)
-process.on('SIGTERM', shutdown)
-for (const c of children) c.on('exit', shutdown)

package/scripts/devtools-recon.js

@@ -1,42 +0,0 @@
-// ── Conductor IPC reconnaissance snippet ──────────────────────────────────
-//
-// PREREQUISITE (read FINDINGS.md first): this only works if Conductor's WKWeb
-// view is inspectable. On the shipped build it is NOT — the app is hardened/
-// notarized without `get-task-allow`, so Safari's Develop menu won't list it
-// and there is no console to paste this into. Injection is therefore blocked;
-// the relay drives writes via Accessibility instead. Keep this snippet for the
-// case where a future build ships with devtools enabled.
-//
-// IF a console is available (Safari ▸ Develop ▸ [Conductor] ▸ [webview]):
-// paste this, then perform the action you want to reverse-engineer (send a
-// prompt, approve a tool, stop a session). Every Tauri IPC call is logged with
-// its command name + payload — that is the undocumented write API.
-
-;(() => {
-	const internals = window.__TAURI_INTERNALS__
-	if (!internals || typeof internals.invoke !== 'function') {
-		console.warn('[recon] __TAURI_INTERNALS__.invoke not found — not a Tauri webview or not exposed.')
-		return
-	}
-	if (internals.__reconWrapped) {
-		console.info('[recon] already wrapped.')
-		return
-	}
-	const original = internals.invoke.bind(internals)
-	const log = []
-	window.__reconLog = log
-	internals.invoke = (cmd, payload, options) => {
-		// Stock Tauri plugin traffic is noise; Conductor's own commands are the signal.
-		const interesting = !String(cmd).startsWith('plugin:')
-		const record = { t: new Date().toISOString(), cmd, payload }
-		if (interesting) {
-			log.push(record)
-			console.info('%c[INVOKE]', 'color:#4a9eff', cmd, payload)
-		}
-		return original(cmd, payload, options)
-	}
-	internals.__reconWrapped = true
-	console.info(
-		'[recon] invoke wrapped. Reproduce an action, then run: copy(JSON.stringify(window.__reconLog, null, 2))'
-	)
-})()

package/scripts/gen-icons.ts

@@ -1,22 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import sharp from 'sharp'
-
-// Rasterize web/public/icon.svg into the PNG sizes the PWA manifest + iOS need.
-const pub = path.join(import.meta.dirname, '..', 'web', 'public')
-const svg = await readFile(path.join(pub, 'icon.svg'))
-
-const targets: { name: string; size: number; background?: string }[] = [
-	{ name: 'icon-192.png', size: 192 },
-	{ name: 'icon-512.png', size: 512 },
-	{ name: 'icon-maskable-512.png', size: 512 },
-	{ name: 'apple-touch-icon.png', size: 180, background: '#0a0b0e' }
-]
-
-for (const t of targets) {
-	let pipe = sharp(svg, { density: 384 }).resize(t.size, t.size, { fit: 'contain' })
-	if (t.background) pipe = pipe.flatten({ background: t.background })
-	const out = await pipe.png().toBuffer()
-	await writeFile(path.join(pub, t.name), out)
-	console.info(`wrote ${t.name} (${t.size}px)`)
-}