parawatch 0.3.14 → 0.3.15

package/dist/bin/cli.js

@@ -148,7 +148,8 @@ program
     .option("--copy", "also put a line about the card on the clipboard, to paste into that session")
     .option("--print", "print the link instead of opening it")
     .action((target, o) => {
-    const g = resolveGoto(target, readState());
+    const state = readState();
+    const g = resolveGoto(target, state, collectRuns(state, { sinceHours: 24, includeEnded: true }));
     if (o.copy && g.card) {
         const line = cardContextLine(g.card);
         try {
@@ -158,13 +159,19 @@ program
             process.stderr.write(`parawatch: could not copy to the clipboard; the line is: ${line}\n`);
         }
     }
+    if (!g.url && g.device)
+        throw new UserError(`${g.name} runs on ${g.device}. Open it there, or turn on Remote Control for it in the Claude app to open it from here.`);
     if (!g.url)
         throw new UserError(`${g.name} is not a Claude desktop session. In a terminal: claude --resume ${g.session}`);
     if (o.print) {
         process.stdout.write(g.url + "\n");
         return;
     }
-    execFileSync("open", [g.url]);
+    // cmd start would cut the link at its &
+    if (process.platform === "win32")
+        execFileSync("rundll32", ["url.dll,FileProtocolHandler", g.url]);
+    else
+        execFileSync(process.platform === "darwin" ? "open" : "xdg-open", [g.url]);
     process.stdout.write(`Opened ${g.name}${g.desktop?.archived ? " (archived)" : ""}\n`);
 });
 program

package/dist/core/chatTypes.js

@@ -0,0 +1,3 @@
+/** A Codex conversation as the app shows it. Types only, so the panel can share them. */
+export {};
+//# sourceMappingURL=chatTypes.js.map

package/dist/core/codexChat.js

@@ -0,0 +1,310 @@
+/**
+ * A Codex session as a conversation: read from its rollout log (what `codex exec` and the Codex
+ * app write under ~/.codex/sessions), and continued with `codex exec resume`, under the same
+ * sandbox and model the session last ran with.
+ */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isObj, readHeadLines, readTailLines, str } from "../adapters/jsonl.js";
+const OUTPUT_CHARS = 6000;
+const DIFF_CHARS = 12000;
+const MAX_ITEMS = 400;
+// a log with inline images can be hundreds of MB; the conversation is in its last part
+const TAIL_BYTES = 48 * 1024 * 1024;
+const HEAD_BYTES = 256 * 1024;
+const clip = (s, max) => (s.length > max ? `…${s.slice(s.length - max)}` : s);
+const clipHead = (s, max) => (s.length > max ? `${s.slice(0, max)}\n…` : s);
+const fileUrl = (p) => (p.startsWith("file://") ? decodeURIComponent(p.slice(7)) : p);
+function texts(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter(isObj)
+        .map((b) => str(b.text) ?? "")
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+}
+function commandLine(cmd) {
+    if (typeof cmd === "string")
+        return cmd;
+    if (!Array.isArray(cmd))
+        return "";
+    const parts = cmd.map(String);
+    // ["/bin/zsh", "-lc", "<the command>"]: show the command
+    if (parts.length === 3 && /^-[a-z]*c$/.test(parts[1]))
+        return parts[2];
+    return parts.join(" ");
+}
+/** One item of the log's `item_completed` events, as the conversation shows it. */
+export function chatItem(it, at) {
+    const id = str(it.id) ?? `${str(it.type)}-${at}`;
+    switch (it.type) {
+        case "UserMessage": {
+            const content = Array.isArray(it.content) ? it.content.filter(isObj) : [];
+            const images = content.filter((b) => /image/i.test(str(b.type) ?? "")).length;
+            const text = texts(content);
+            if (!text && !images)
+                return undefined;
+            return { kind: "user", id, text, ...(images ? { images } : {}), at };
+        }
+        case "AgentMessage": {
+            const text = texts(it.content);
+            if (!text)
+                return undefined;
+            return { kind: "agent", id, text, ...(it.phase === "commentary" ? { commentary: true } : {}), at };
+        }
+        case "CommandExecution": {
+            const output = str(it.aggregated_output) ?? [str(it.stdout), str(it.stderr)].filter(Boolean).join("\n");
+            const d = isObj(it.duration) ? Number(it.duration.secs ?? 0) + Number(it.duration.nanos ?? 0) / 1e9 : undefined;
+            return {
+                kind: "command",
+                id,
+                command: commandLine(it.command),
+                ...(output ? { output: clip(output.trimEnd(), OUTPUT_CHARS) } : {}),
+                ...(typeof it.exit_code === "number" ? { exit: it.exit_code } : {}),
+                status: str(it.status),
+                ...(d !== undefined && Number.isFinite(d) ? { seconds: Math.round(d * 10) / 10 } : {}),
+                at,
+            };
+        }
+        case "FileChange": {
+            const changes = isObj(it.changes) ? it.changes : {};
+            const files = Object.entries(changes).map(([p, c]) => {
+                const ch = isObj(c) ? c : {};
+                const diff = str(ch.unified_diff);
+                return { path: p, change: str(ch.type) ?? "update", ...(diff ? { diff: clipHead(diff, DIFF_CHARS) } : {}) };
+            });
+            return files.length ? { kind: "files", id, files, at } : undefined;
+        }
+        case "McpToolCall": {
+            const name = [str(it.appName) ?? str(it.server), str(it.actionName) ?? str(it.tool)].filter(Boolean).join(" ");
+            let detail;
+            try {
+                detail = it.arguments === undefined ? undefined : JSON.stringify(it.arguments);
+            }
+            catch {
+                detail = undefined;
+            }
+            return { kind: "tool", id, name: name || "tool", ...(detail ? { detail: clipHead(detail, 400) } : {}), status: str(it.status), at };
+        }
+        case "ImageView": {
+            const p = str(it.path);
+            return p ? { kind: "image", id, path: fileUrl(p), at } : undefined;
+        }
+        case "ContextCompaction":
+            return { kind: "note", id, text: "Earlier conversation compacted", tone: "info", at };
+        case "Reasoning":
+        case "Extension":
+            return undefined;
+        default:
+            return typeof it.type === "string" ? { kind: "tool", id, name: it.type, at } : undefined;
+    }
+}
+function sandboxOf(tc, cwd) {
+    const sp = isObj(tc.sandbox_policy) ? tc.sandbox_policy : undefined;
+    const sandbox = typeof tc.sandbox_policy === "string" ? tc.sandbox_policy : str(sp?.type);
+    const network = typeof sp?.network_access === "boolean" ? sp.network_access : undefined;
+    const roots = new Set();
+    for (const r of Array.isArray(sp?.writable_roots) ? sp.writable_roots : [])
+        if (typeof r === "string")
+            roots.add(r);
+    const fsp = isObj(tc.file_system_sandbox_policy) ? tc.file_system_sandbox_policy : undefined;
+    for (const e of Array.isArray(fsp?.entries) ? fsp.entries.filter(isObj) : []) {
+        const p = isObj(e.path) && e.path.type === "path" ? str(e.path.path) : undefined;
+        if (p && e.access === "write")
+            roots.add(p);
+    }
+    if (cwd)
+        roots.delete(cwd);
+    return { sandbox, ...(network !== undefined ? { network } : {}), roots: [...roots] };
+}
+/** The conversation in a rollout log's lines. */
+export function readChatLines(head, tail, file = "") {
+    const meta = head.find((r) => isObj(r) && r.type === "session_meta");
+    const m = isObj(meta?.payload) ? meta.payload : {};
+    const id = str(m.id) ?? str(m.session_id) ?? path.basename(file);
+    const source = str(m.source);
+    const origin = str(m.originator) === "codex_exec" || source === "exec" ? "exec" : source === "vscode" ? "app" : source;
+    const settings = { cwd: str(m.cwd), roots: [] };
+    const items = new Map();
+    let started = -1;
+    let ended = -1;
+    let structured = false;
+    const fallback = [];
+    tail.forEach((r, i) => {
+        if (!isObj(r) || !isObj(r.payload))
+            return;
+        const p = r.payload;
+        const at = str(r.timestamp);
+        if (r.type === "turn_context") {
+            settings.cwd = str(p.cwd) ?? settings.cwd;
+            settings.model = str(p.model) ?? settings.model;
+            settings.effort = str(p.effort) ?? (isObj(p.collaboration_mode) && isObj(p.collaboration_mode.settings) ? str(p.collaboration_mode.settings.reasoning_effort) : undefined) ?? settings.effort;
+            settings.approval = str(p.approval_policy) ?? settings.approval;
+            Object.assign(settings, sandboxOf(p, settings.cwd));
+            return;
+        }
+        if (r.type === "event_msg") {
+            if (p.type === "task_started")
+                started = i;
+            else if (p.type === "task_complete")
+                ended = i;
+            else if (p.type === "turn_aborted") {
+                ended = i;
+                items.set(`aborted-${i}`, { kind: "note", id: `aborted-${i}`, text: "Stopped", tone: "info", at });
+            }
+            else if (p.type === "error") {
+                items.set(`error-${i}`, { kind: "note", id: `error-${i}`, text: str(p.message) ?? "Codex reported an error", tone: "error", at });
+            }
+            else if (p.type === "item_completed" && isObj(p.item)) {
+                structured = true;
+                const item = chatItem(p.item, at);
+                if (item) {
+                    items.delete(item.id); // a repeat moves to where it was seen last
+                    items.set(item.id, item);
+                }
+            }
+            return;
+        }
+        // logs from versions without item events: messages only
+        if (r.type === "response_item" && p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+            const text = texts(p.content);
+            if (!text || (p.role === "user" && (text.startsWith("<") || text.startsWith("# AGENTS.md"))))
+                return;
+            fallback.push(p.role === "user" ? { kind: "user", id: `m${i}`, text, at } : { kind: "agent", id: `m${i}`, text, at });
+        }
+    });
+    const all = structured ? [...items.values()] : [...fallback, ...[...items.values()].filter((x) => x.kind === "note")];
+    const firstUser = all.find((x) => x.kind === "user");
+    return {
+        id,
+        file,
+        ...(origin ? { origin } : {}),
+        ...(firstUser ? { title: firstUser.text.split("\n")[0].slice(0, 80) } : {}),
+        settings,
+        working: started > ended,
+        items: all.slice(-MAX_ITEMS),
+        earlier: Math.max(0, all.length - MAX_ITEMS),
+    };
+}
+export function readChat(file) {
+    return readChatLines(readHeadLines(file, HEAD_BYTES), readTailLines(file, TAIL_BYTES), file);
+}
+const toml = (s) => JSON.stringify(s);
+/**
+ * The arguments for `codex` to send one message to the session, read from stdin, with the
+ * sandbox, folders and model it last ran with. `codex exec resume` takes no sandbox flags and
+ * would otherwise fall back to the user's config, which may allow more than the session had.
+ */
+export function resumeArgs(id, s) {
+    const sandbox = s.sandbox;
+    if (sandbox !== "read-only" && sandbox !== "workspace-write" && sandbox !== "danger-full-access") {
+        throw new Error(`this session ran with a sandbox parawatch does not know (${sandbox ?? "none recorded"}); continue it in Codex`);
+    }
+    const args = ["exec", "resume", "--json", "--skip-git-repo-check"];
+    args.push("-c", `sandbox_mode=${toml(sandbox)}`);
+    // a message sent from here has no one to ask, so it never waits for an approval
+    args.push("-c", `approval_policy="never"`);
+    if (sandbox === "workspace-write") {
+        if (s.network !== undefined)
+            args.push("-c", `sandbox_workspace_write.network_access=${s.network}`);
+        if (s.roots.length)
+            args.push("-c", `sandbox_workspace_write.writable_roots=[${s.roots.map(toml).join(",")}]`);
+    }
+    if (s.model)
+        args.push("-m", s.model);
+    if (s.effort)
+        args.push("-c", `model_reasoning_effort=${toml(s.effort)}`);
+    args.push(id, "-");
+    return args;
+}
+/** Where the codex command is. An app started from the Dock does not get the shell's PATH. */
+export function findCodex(env = process.env, platform = process.platform) {
+    if (env.PARAWATCH_CODEX_BIN)
+        return env.PARAWATCH_CODEX_BIN;
+    const names = platform === "win32" ? ["codex.cmd", "codex.exe", "codex"] : ["codex"];
+    const home = os.homedir();
+    const dirs = [
+        ...(env.PATH ?? "").split(path.delimiter),
+        ...(platform === "win32"
+            ? [env.APPDATA && path.join(env.APPDATA, "npm"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "codex")]
+            : ["/opt/homebrew/bin", "/usr/local/bin", path.join(home, ".local", "bin"), path.join(home, ".npm-global", "bin"), path.join(home, ".volta", "bin"), path.join(home, ".bun", "bin")]),
+    ].filter((d) => !!d);
+    for (const d of dirs) {
+        for (const n of names) {
+            const p = path.join(d, n);
+            try {
+                if (fs.statSync(p).isFile())
+                    return p;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    if (platform === "win32")
+        return undefined;
+    try {
+        const shell = env.SHELL || "/bin/zsh";
+        const out = execFileSync(shell, ["-lc", "command -v codex"], { encoding: "utf8", timeout: 5000 }).trim().split("\n").pop();
+        return out && path.isAbsolute(out) ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Processes that have the log open: a Codex app or terminal that has the session loaded. Unknown on Windows. */
+export function logOpenBy(file, platform = process.platform) {
+    if (platform === "win32")
+        return undefined;
+    try {
+        const out = execFileSync("lsof", ["-t", "--", file], { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] });
+        return out
+            .split("\n")
+            .map((l) => Number(l.trim()))
+            .filter((n) => n > 0);
+    }
+    catch (err) {
+        // lsof exits 1 when no process has it open
+        return err.status === 1 ? [] : undefined;
+    }
+}
+/** Why a message cannot be sent now, or undefined when it can. */
+export function cannotSend(view, openBy, mine = []) {
+    if (view.working)
+        return "Codex is working on this session. Wait until it finishes.";
+    if (openBy?.some((p) => !mine.includes(p)))
+        return "This session is open in Codex (the app or a terminal). Continue it there, or close it there first.";
+    const s = view.settings.sandbox;
+    if (s !== "read-only" && s !== "workspace-write" && s !== "danger-full-access")
+        return `This session ran with a sandbox parawatch does not know (${s ?? "none recorded"}). Continue it in Codex.`;
+    return undefined;
+}
+/** A line of `codex exec --json` that says what Codex is doing now, if it is one. */
+export function liveLine(line) {
+    let e;
+    try {
+        e = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isObj(e) || e.type !== "item.started" || !isObj(e.item))
+        return undefined;
+    const it = e.item;
+    if (it.type === "command_execution")
+        return `Running ${commandLine(it.command)}`.slice(0, 200);
+    if (it.type === "file_change")
+        return "Editing files";
+    if (it.type === "mcp_tool_call")
+        return `Using ${[str(it.server), str(it.tool)].filter(Boolean).join(" ")}`;
+    if (it.type === "web_search")
+        return "Searching the web";
+    if (it.type === "reasoning")
+        return "Thinking";
+    return undefined;
+}
+//# sourceMappingURL=codexChat.js.map

package/dist/core/desktop.js

@@ -6,11 +6,33 @@ import { UserError } from "./errors.js";
 import { sessionTitle } from "./state.js";
 /**
  * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
- * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`).
+ * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`). On Windows the
+ * Store build keeps them under `%LOCALAPPDATA%\Claude-Data\claude_<package>`, the installer build
+ * under `%APPDATA%\Claude`.
  */
-export function desktopSessionsDir() {
-    return (process.env.PARAWATCH_CLAUDE_DESKTOP_DIR ||
-        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"));
+export function desktopSessionsDirs() {
+    const env = process.env.PARAWATCH_CLAUDE_DESKTOP_DIR;
+    if (env)
+        return [env];
+    const home = os.homedir();
+    if (process.platform === "win32") {
+        const roaming = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+        const out = [path.join(roaming, "Claude", "claude-code-sessions")];
+        const data = path.join(local, "Claude-Data");
+        try {
+            for (const e of fs.readdirSync(data, { withFileTypes: true }))
+                if (e.isDirectory() && /^claude_/i.test(e.name))
+                    out.push(path.join(data, e.name, "claude-code-sessions"));
+        }
+        catch {
+            // no Store build here
+        }
+        return out;
+    }
+    if (process.platform === "darwin")
+        return [path.join(home, "Library", "Application Support", "Claude", "claude-code-sessions")];
+    return [path.join(process.env.XDG_CONFIG_HOME || path.join(home, ".config"), "Claude", "claude-code-sessions")];
 }
 function* sessionFiles(dir, depth = 0) {
     let entries;
@@ -31,9 +53,9 @@ function* sessionFiles(dir, depth = 0) {
 /** Session files read before, by path; a file is read again only when it changes. */
 const readCache = new Map();
 /** Every desktop app session in the folder, read once per change of its file. */
-function desktopSessions(dir) {
+function desktopSessions(dirs) {
     const out = [];
-    for (const file of sessionFiles(dir)) {
+    for (const file of [dirs].flat().flatMap((d) => [...sessionFiles(d)])) {
         let mtimeMs;
         try {
             mtimeMs = fs.statSync(file).mtimeMs;
@@ -70,10 +92,12 @@ function readSessionFile(file) {
         cwd: typeof d.cwd === "string" ? d.cwd : undefined,
         archived: d.isArchived === true,
         lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
+        remote: Array.isArray(d.bridgeSessionIds) ? d.bridgeSessionIds.find((x) => typeof x === "string" && REMOTE_ID.test(x)) : undefined,
     };
 }
 /** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
-export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
+const REMOTE_ID = /^session_[A-Za-z0-9]+$/;
+export function findDesktopSession(cliSession, dir = desktopSessionsDirs()) {
     if (cliSession.length < 6)
         return undefined;
     let best;
@@ -91,7 +115,7 @@ export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
  * (full or a prefix of 6+ characters). Such a session never takes another turn, however its log
  * ends. A CLI session that a live desktop session also runs is not archived.
  */
-export function archivedSessions(dir = desktopSessionsDir()) {
+export function archivedSessions(dir = desktopSessionsDirs()) {
     const archived = new Set();
     const live = new Set();
     for (const s of desktopSessions(dir))
@@ -112,6 +136,27 @@ export function archivedSessions(dir = desktopSessionsDir()) {
 export function desktopSessionUrl(s) {
     return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;
 }
+/** A Remote Control session on claude.ai, which opens from any machine signed in to the account. */
+export function remoteSessionUrl(id) {
+    return `https://claude.ai/code/${encodeURIComponent(id)}`;
+}
+/** Give each Claude Code session of this machine its Remote Control link, when it has one. */
+export function withRemote(runs, dir = desktopSessionsDirs()) {
+    const sessions = runs.filter((r) => r.runtime === "claude-code" && r.kind === "session" && !r.device);
+    if (!sessions.length)
+        return runs;
+    const remote = new Map();
+    for (const s of desktopSessions(dir))
+        if (s.remote && !s.archived)
+            for (const id of s.ids)
+                remote.set(id, s.remote);
+    for (const r of sessions) {
+        const id = remote.get(r.id);
+        if (id)
+            r.remote = remoteSessionUrl(id);
+    }
+    return runs;
+}
 /** The session that owns a pull request: by URL, `owner/repo#N`, or `#N` / `repo#N` when only one matches. */
 function prSession(target, state) {
     const ref = parsePrRef(target);
@@ -136,15 +181,23 @@ function prSession(target, state) {
     return hits[0].session;
 }
 /** Where `goto` leads for a card id, a pull request, or a session id (prefix). */
-export function resolveGoto(target, state) {
+export function resolveGoto(target, state, runs = []) {
     const card = state.cards.get(target);
-    const session = card ? card.session : (prSession(target, state) ?? target);
+    let session = card ? card.session : (prSession(target, state) ?? target);
     if (!session) {
         throw new UserError(`card ${target} does not say which session opened it (set one with: parawatch edit ${target} --session <id>)`);
     }
-    const desktop = findDesktopSession(session);
-    const name = sessionTitle(state.claims, session) ?? desktop?.title ?? session.slice(0, 8);
-    return { name, session, card, desktop, url: desktop ? desktopSessionUrl(desktop) : undefined };
+    // a subagent has no window of its own: open the session it works under
+    const byId = new Map(runs.map((r) => [r.id, r]));
+    let run = runs.find((r) => r.id === session || (session.length >= 6 && r.id.startsWith(session)));
+    for (let i = 0; run?.parent && byId.has(run.parent) && i < 8; i++)
+        run = byId.get(run.parent);
+    if (run)
+        session = run.id;
+    const desktop = run?.device ? undefined : findDesktopSession(session);
+    const name = sessionTitle(state.claims, session) ?? run?.title ?? desktop?.title ?? session.slice(0, 8);
+    const url = desktop ? desktopSessionUrl(desktop) : run?.remote;
+    return { name, session, card, desktop, device: run?.device, url };
 }
 /** A line to paste into the session so it knows which card the human means. */
 export function cardContextLine(card) {

package/dist/core/runs.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { scanAll } from "../adapters/index.js";
 import { ACTIVITY_MINUTES, activeMinutes } from "../adapters/jsonl.js";
-import { archivedSessions } from "./desktop.js";
+import { archivedSessions, withRemote } from "./desktop.js";
 import { canonicalPath, insidePath, namesPath, samePath } from "./paths.js";
 import { applyPrompts } from "./prompts.js";
 import { deviceName, sharedDir } from "./store.js";
@@ -392,7 +392,7 @@ export function collectRuns(state, q, now = Date.now()) {
     const sinceMs = now - q.sinceHours * 3_600_000;
     // a log file can be touched (title records, snapshots) long after its last real activity
     const recent = (r) => !r.lastActivity || Date.parse(r.lastActivity) >= sinceMs;
-    let runs = applyPrompts(endArchived(attribute(scanAll({ sinceMs, now }, q.runtimes), state), archivedSessions())).filter(recent);
+    let runs = withRemote(applyPrompts(endArchived(attribute(scanAll({ sinceMs, now }, q.runtimes), state), archivedSessions())).filter(recent));
     // a narrower reading (one runtime) would hide the rest from the other machines
     if (!q.runtimes)
         shareRuns(runs, now);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parawatch",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "A control tower for people running many AI coding agents in parallel: see what is running, what needs you, and wake the right agent when you answer.",
   "keywords": [
     "ai-agents",