@nowcrew/daemon 0.5.26 → 0.5.27

package/dist/remote/protocol.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+export const REMOTE_PROTOCOL_VERSION = 1;
+export const MAX_REMOTE_PROMPT_BYTES = 64 * 1024;
+export const RemoteRuntimeSchema = z.enum(["claude", "codex"]);
+export const RemoteControlStateSchema = z.enum([
+    "live",
+    "read_only",
+    "offline",
+    "unsupported",
+]);
+export const RemoteSessionSourceSchema = z.enum(["channel", "app_server", "history"]);
+export const RemoteSessionSummarySchema = z.object({
+    id: z.string().min(1).max(128),
+    runtime: RemoteRuntimeSchema,
+    title: z.string().min(1).max(240),
+    cwd: z.string().max(4096),
+    updatedAt: z.string().datetime(),
+    controlState: RemoteControlStateSchema,
+    busy: z.boolean(),
+    source: RemoteSessionSourceSchema,
+}).strict();
+const TimelineBaseSchema = z.object({
+    id: z.string().min(1).max(256),
+    createdAt: z.string().datetime(),
+});
+export const RemoteQuestionsSchema = z.array(z.object({
+    id: z.string().min(1).max(160),
+    header: z.string().max(160),
+    question: z.string().min(1).max(4_000),
+    isSecret: z.boolean(),
+    options: z.array(z.object({
+        label: z.string().min(1).max(240),
+        description: z.string().max(1_000),
+    }).strict()).max(32).nullable(),
+}).strict()).min(1).max(4);
+export const RemoteTimelineItemSchema = z.discriminatedUnion("kind", [
+    TimelineBaseSchema.extend({
+        kind: z.literal("message"),
+        role: z.enum(["user", "assistant"]),
+        text: z.string().min(1),
+    }).strict(),
+    TimelineBaseSchema.extend({
+        kind: z.literal("tool"),
+        name: z.string().min(1).max(160),
+        summary: z.string().max(12_000),
+        status: z.string().min(1).max(80),
+    }).strict(),
+    TimelineBaseSchema.extend({
+        kind: z.literal("approval"),
+        requestId: z.string().min(1).max(160),
+        tool: z.string().min(1).max(160),
+        preview: z.string().max(12_000),
+    }).strict(),
+    TimelineBaseSchema.extend({
+        kind: z.literal("question"),
+        requestId: z.string().uuid(),
+        questions: RemoteQuestionsSchema,
+    }).strict(),
+    TimelineBaseSchema.extend({
+        kind: z.literal("status"),
+        text: z.string().min(1).max(2_000),
+    }).strict(),
+]);
+export const SubmitRemoteInputSchema = z.object({
+    text: z.string().trim().min(1).refine((value) => Buffer.byteLength(value, "utf8") <= MAX_REMOTE_PROMPT_BYTES, `prompt must not exceed ${MAX_REMOTE_PROMPT_BYTES} UTF-8 bytes`),
+    idempotencyKey: z.string().uuid(),
+}).strict();
+export const ResolveRemoteApprovalSchema = z.object({
+    decision: z.enum(["allow", "deny"]),
+}).strict();
+export const ResolveRemoteQuestionSchema = z.object({
+    answers: z.record(z.array(z.string().max(4_000)).max(16)),
+}).strict();
+export const ChannelRegistrationSchema = z.object({
+    type: z.literal("channel.register"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    cwd: z.string().min(1).max(4096),
+    pid: z.number().int().positive(),
+    generation: z.string().uuid(),
+    title: z.string().min(1).max(240).optional(),
+}).strict();
+export const ChannelReplySchema = z.object({
+    type: z.literal("channel.reply"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    requestId: z.string().uuid(),
+    text: z.string().min(1).max(200_000),
+}).strict();
+export const ChannelPermissionRequestSchema = z.object({
+    type: z.literal("channel.permission"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    requestId: z.string().regex(/^[a-km-z]{5}$/),
+    tool: z.string().min(1).max(160),
+    description: z.string().max(4_000),
+    preview: z.string().max(16_000),
+}).strict();
+export const BridgeApprovalRequestSchema = z.object({
+    type: z.literal("bridge.approval"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    requestId: z.string().uuid(),
+    tool: z.string().min(1).max(160),
+    preview: z.string().max(16_000),
+}).strict();
+export const BridgeQuestionRequestSchema = z.object({
+    type: z.literal("bridge.question"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    requestId: z.string().uuid(),
+    questions: RemoteQuestionsSchema,
+}).strict();
+export const BridgeStatusSchema = z.object({
+    type: z.literal("bridge.status"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    busy: z.boolean(),
+}).strict();
+export const BridgeResolvedSchema = z.object({
+    type: z.literal("bridge.resolved"),
+    protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    sessionId: z.string().uuid(),
+    requestId: z.string().uuid(),
+}).strict();
+export const ChannelToGatewaySchema = z.discriminatedUnion("type", [
+    ChannelRegistrationSchema,
+    ChannelReplySchema,
+    ChannelPermissionRequestSchema,
+    BridgeApprovalRequestSchema,
+    BridgeQuestionRequestSchema,
+    BridgeStatusSchema,
+    BridgeResolvedSchema,
+]);
+export const GatewayToChannelSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("channel.prompt"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        requestId: z.string().uuid(),
+        text: z.string().min(1).max(MAX_REMOTE_PROMPT_BYTES),
+    }).strict(),
+    z.object({
+        type: z.literal("bridge.approval_response"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        requestId: z.string().uuid(),
+        decision: z.enum(["allow", "deny"]),
+    }).strict(),
+    z.object({
+        type: z.literal("bridge.question_response"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        requestId: z.string().uuid(),
+        answers: ResolveRemoteQuestionSchema.shape.answers,
+    }).strict(),
+    z.object({
+        type: z.literal("channel.permission_response"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        requestId: z.string().regex(/^[a-km-z]{5}$/),
+        decision: z.enum(["allow", "deny"]),
+    }).strict(),
+]);
+export const GatewayClientEventSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("sessions.changed"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+    }).strict(),
+    z.object({
+        type: z.literal("timeline.appended"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        sessionId: z.string().min(1).max(128),
+        item: RemoteTimelineItemSchema,
+    }).strict(),
+    z.object({
+        type: z.literal("interaction.resolved"),
+        protocolVersion: z.literal(REMOTE_PROTOCOL_VERSION),
+        sessionId: z.string().min(1).max(128),
+        requestId: z.string().min(1).max(160),
+    }).strict(),
+]);

package/dist/remote/remote-cli.js

@@ -0,0 +1,233 @@
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { readFile, unlink } from "node:fs/promises";
+import { networkInterfaces } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import spawn from "cross-spawn";
+import { runClaudeBridge } from "./claude-bridge.js";
+import { loadOrCreateRemoteConfig, updateRemoteBinding, writeRemoteLock, } from "./config.js";
+import { startRemoteGateway } from "./gateway.js";
+import { startCodexRuntime } from "./codex-runtime.js";
+import { buildCodexWrappedInvocation } from "./wrapper.js";
+function bundledUiDir() {
+    try {
+        const require = createRequire(import.meta.url);
+        return join(dirname(require.resolve("@nowcrew/remote-web/package.json")), "dist");
+    }
+    catch {
+        return null;
+    }
+}
+function displayHost(host) {
+    if (host !== "0.0.0.0" && host !== "::")
+        return host;
+    for (const values of Object.values(networkInterfaces())) {
+        const address = values?.find((value) => value.family === "IPv4" && !value.internal)?.address;
+        if (address)
+            return address;
+    }
+    return "127.0.0.1";
+}
+function baseUrl(config) {
+    return `http://${displayHost(config.host)}:${config.port}`;
+}
+function localBaseUrl(config) {
+    const host = config.host === "0.0.0.0" || config.host === "::" ? "127.0.0.1" : config.host;
+    return `http://${host}:${config.port}`;
+}
+function pairingUrl(config) {
+    return `${baseUrl(config)}/#token=${encodeURIComponent(config.token)}`;
+}
+async function identity(config) {
+    try {
+        const response = await fetch(`${localBaseUrl(config)}/api/v1/identity`, {
+            headers: { authorization: `Bearer ${config.token}` },
+            signal: AbortSignal.timeout(700),
+        });
+        if (!response.ok)
+            return null;
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+function currentDaemonInvocation() {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error("Unable to locate the crew-daemon entrypoint");
+    return { command: process.execPath, args: [...process.execArgv, entry] };
+}
+function spawnAndWait(bin, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, [...args], { env, stdio: "inherit" });
+        child.once("error", reject);
+        child.once("close", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+    });
+}
+async function ensureGateway(config) {
+    if (await identity(config))
+        return;
+    const invocation = currentDaemonInvocation();
+    const child = spawn(invocation.command, [...invocation.args, "remote", "serve", "--background"], {
+        env: process.env,
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (await identity(config))
+            return;
+    }
+    throw new Error(`NowCrew remote gateway did not start at ${localBaseUrl(config)}`);
+}
+function usage() {
+    return [
+        "NowCrew mobile runtime control:",
+        "  crew-daemon remote setup [--host 127.0.0.1|0.0.0.0] [--port 4317]",
+        "  crew-daemon remote serve [--host ...] [--port ...] [--ui-dir <path>]",
+        "  crew-daemon remote status|url",
+        "  crew-daemon remote run claude -- [claude options]",
+        "  crew-daemon remote run codex -- [codex options]",
+    ].join("\n") + "\n";
+}
+async function serveCommand(argv) {
+    const parsed = parseArgs({
+        args: [...argv],
+        strict: true,
+        options: {
+            host: { type: "string" },
+            port: { type: "string" },
+            "ui-dir": { type: "string" },
+            background: { type: "boolean", default: false },
+        },
+    });
+    const port = parsed.values.port === undefined ? undefined : Number(parsed.values.port);
+    const config = await loadOrCreateRemoteConfig({
+        ...(parsed.values.host === undefined ? {} : { host: parsed.values.host }),
+        ...(port === undefined ? {} : { port }),
+    });
+    const codexRuntime = await startCodexRuntime(config.paths.codexSocket).catch((error) => {
+        process.stderr.write(`NowCrew remote: Codex live control unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+        return null;
+    });
+    const gatewayId = randomUUID();
+    let gateway;
+    try {
+        gateway = await startRemoteGateway({
+            config,
+            gatewayId,
+            ...(codexRuntime === null ? {} : { codex: codexRuntime.adapter }),
+            uiDir: parsed.values["ui-dir"] ?? process.env.NOWCREW_REMOTE_UI_DIR ?? bundledUiDir(),
+        });
+    }
+    catch (error) {
+        await codexRuntime?.close();
+        throw error;
+    }
+    await writeRemoteLock(config.paths.lock, {
+        version: 1,
+        gatewayId,
+        pid: process.pid,
+        host: gateway.host,
+        port: gateway.port,
+        startedAt: new Date().toISOString(),
+    });
+    if (!parsed.values.background)
+        process.stdout.write(`NowCrew remote listening at ${baseUrl(config)}\n`);
+    await new Promise((resolve) => {
+        process.once("SIGINT", resolve);
+        process.once("SIGTERM", resolve);
+    });
+    await gateway.close();
+    await codexRuntime?.close();
+    try {
+        const lock = JSON.parse(await readFile(config.paths.lock, "utf8"));
+        if (lock.gatewayId === gatewayId)
+            await unlink(config.paths.lock);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return 0;
+}
+async function setupCommand(argv) {
+    const parsed = parseArgs({
+        args: [...argv],
+        strict: true,
+        options: {
+            host: { type: "string" },
+            port: { type: "string" },
+            help: { type: "boolean", short: "h", default: false },
+        },
+    });
+    if (parsed.values.help) {
+        process.stdout.write(usage());
+        return 0;
+    }
+    let config = await loadOrCreateRemoteConfig();
+    if (parsed.values.host !== undefined || parsed.values.port !== undefined) {
+        config = await updateRemoteBinding(config, {
+            host: parsed.values.host ?? config.host,
+            port: parsed.values.port === undefined ? config.port : Number(parsed.values.port),
+        });
+    }
+    process.stdout.write([
+        `Phone URL: ${pairingUrl(config)}`,
+        "",
+        "Add these shell functions to your zsh configuration:",
+        "claude() { crew-daemon remote run claude -- \"$@\"; }",
+        "codex() { crew-daemon remote run codex -- \"$@\"; }",
+        "",
+        config.host === "127.0.0.1"
+            ? "Loopback mode is enabled. Use --host 0.0.0.0 for a trusted LAN, or expose this URL through private HTTPS."
+            : "LAN mode is enabled. Keep the capability URL private and do not expose this HTTP port to the public internet.",
+    ].join("\n") + "\n");
+    return 0;
+}
+export async function runRemoteCommand(argv) {
+    if (argv[0] !== "remote")
+        return null;
+    const action = argv[1];
+    if (!action || action === "help" || action === "--help" || action === "-h") {
+        process.stdout.write(usage());
+        return 0;
+    }
+    if (action === "serve")
+        return serveCommand(argv.slice(2));
+    if (action === "setup")
+        return setupCommand(argv.slice(2));
+    const config = await loadOrCreateRemoteConfig();
+    if (action === "status") {
+        const current = await identity(config);
+        process.stdout.write(`${JSON.stringify({
+            running: current !== null,
+            url: baseUrl(config),
+            ...(current ?? {}),
+        }, null, 2)}\n`);
+        return current ? 0 : 3;
+    }
+    if (action === "url") {
+        process.stdout.write(`${pairingUrl(config)}\n`);
+        return 0;
+    }
+    if (action !== "run" || !["claude", "codex"].includes(argv[2] ?? "")) {
+        process.stderr.write(usage());
+        return 2;
+    }
+    await ensureGateway(config);
+    const separator = argv.indexOf("--", 3);
+    const runtimeArgs = argv.slice(separator >= 0 ? separator + 1 : 3);
+    if (argv[2] === "claude") {
+        return runClaudeBridge(runtimeArgs, {
+            gatewayUrl: localBaseUrl(config),
+            token: config.token,
+            cwd: process.cwd(),
+        });
+    }
+    const invocation = buildCodexWrappedInvocation(runtimeArgs, config.paths.codexSocket);
+    return spawnAndWait(invocation.bin, invocation.args, invocation.env);
+}

package/dist/remote/session-discovery.js

@@ -0,0 +1,249 @@
+import { open, readdir, stat } from "node:fs/promises";
+import { basename, join } from "node:path";
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const DEFAULT_HISTORY_BYTES = 4 * 1024 * 1024;
+const DEFAULT_TIMELINE_ITEMS = 400;
+async function collectJsonl(root, depth, cap) {
+    const result = [];
+    const walk = async (dir, remaining) => {
+        if (remaining < 0 || result.length >= cap)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (result.length >= cap)
+                return;
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(path, remaining - 1);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                const name = basename(entry.name, ".jsonl");
+                const id = name.startsWith("rollout-") ? name.slice(name.lastIndexOf("-") + 1) : name;
+                const match = entry.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.jsonl$/i);
+                const sessionId = match?.[1] ?? id;
+                if (!SESSION_ID.test(sessionId))
+                    continue;
+                const info = await stat(path);
+                result.push({ path, id: sessionId, mtimeMs: info.mtimeMs, updatedAt: info.mtime.toISOString() });
+            }
+        }
+    };
+    await walk(root, depth);
+    return result.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+async function readTailLines(path, maxBytes) {
+    const file = await open(path, "r");
+    try {
+        const info = await file.stat();
+        const length = Math.min(info.size, maxBytes);
+        if (length === 0)
+            return [];
+        const buffer = Buffer.allocUnsafe(length);
+        await file.read(buffer, 0, length, info.size - length);
+        const text = buffer.toString("utf8");
+        const lines = text.split("\n");
+        if (info.size > length)
+            lines.shift();
+        return lines.filter(Boolean);
+    }
+    finally {
+        await file.close();
+    }
+}
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function string(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function textFromContent(value) {
+    if (typeof value === "string")
+        return string(value);
+    if (!Array.isArray(value))
+        return null;
+    const parts = [];
+    for (const raw of value) {
+        const block = object(raw);
+        if (!block)
+            continue;
+        if (["text", "input_text", "output_text"].includes(String(block.type))) {
+            const text = string(block.text);
+            if (text)
+                parts.push(text);
+        }
+    }
+    return parts.length ? parts.join("\n") : null;
+}
+function cleanChannelText(value) {
+    return value
+        .replace(/^<channel\b[^>]*>\s*/i, "")
+        .replace(/\s*<\/channel>$/i, "")
+        .trim();
+}
+function parseLine(line) {
+    try {
+        return object(JSON.parse(line));
+    }
+    catch {
+        return null;
+    }
+}
+function claudeItems(lines, fallbackAt) {
+    let cwd = "";
+    let title = null;
+    const items = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const row = parseLine(lines[index]);
+        if (!row)
+            continue;
+        cwd = string(row.cwd) ?? cwd;
+        const message = object(row.message);
+        const role = row.type === "user" || row.type === "assistant" ? row.type : null;
+        const text = message ? textFromContent(message.content) : null;
+        const createdAt = string(row.timestamp) ?? fallbackAt;
+        const id = string(row.uuid) ?? `claude:${index}`;
+        if (role && text) {
+            const cleaned = cleanChannelText(text);
+            if (!cleaned)
+                continue;
+            if (role === "user")
+                title = cleaned.slice(0, 120);
+            items.push({ id, kind: "message", role, text: cleaned, createdAt });
+        }
+        if (role !== "assistant" || !message || !Array.isArray(message.content))
+            continue;
+        for (let blockIndex = 0; blockIndex < message.content.length; blockIndex += 1) {
+            const block = object(message.content[blockIndex]);
+            if (!block || block.type !== "tool_use")
+                continue;
+            const name = string(block.name) ?? "tool";
+            const summary = JSON.stringify(block.input ?? {}).slice(0, 12_000);
+            items.push({
+                id: `${id}:tool:${blockIndex}`,
+                kind: "tool",
+                name,
+                summary,
+                status: "requested",
+                createdAt,
+            });
+        }
+    }
+    return { cwd, title, items };
+}
+function codexItems(lines, fallbackAt) {
+    let cwd = "";
+    let title = null;
+    const items = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const row = parseLine(lines[index]);
+        if (!row)
+            continue;
+        const payload = object(row.payload);
+        if (!payload)
+            continue;
+        if (row.type === "session_meta")
+            cwd = string(payload.cwd) ?? cwd;
+        if (row.type !== "response_item" || payload.type !== "message")
+            continue;
+        const role = payload.role === "user" || payload.role === "assistant" ? payload.role : null;
+        const text = textFromContent(payload.content);
+        if (!role || !text)
+            continue;
+        const createdAt = string(row.timestamp) ?? fallbackAt;
+        const id = `codex:${index}:${createdAt}`;
+        if (role === "user")
+            title = text.slice(0, 120);
+        items.push({ id, kind: "message", role, text, createdAt });
+    }
+    return { cwd, title, items };
+}
+function capItems(items, max) {
+    return items.length <= max ? [...items] : items.slice(items.length - max);
+}
+export class RemoteSessionDiscovery {
+    options;
+    files = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async list() {
+        const maxSessions = this.options.maxSessions ?? 100;
+        const historyBytes = this.options.maxHistoryBytes ?? DEFAULT_HISTORY_BYTES;
+        const [claude, codex] = await Promise.all([
+            collectJsonl(this.options.claudeProjectsRoot, 2, maxSessions * 4),
+            collectJsonl(this.options.codexSessionsRoot, 4, maxSessions * 4),
+        ]);
+        this.files.clear();
+        const summaries = [];
+        for (const [runtime, candidates] of [["claude", claude], ["codex", codex]]) {
+            for (const candidate of candidates.slice(0, maxSessions)) {
+                const key = `${runtime}:${candidate.id}`;
+                if (this.files.has(key))
+                    continue;
+                this.files.set(key, candidate);
+                const lines = await readTailLines(candidate.path, historyBytes);
+                const parsed = runtime === "claude"
+                    ? claudeItems(lines, candidate.updatedAt)
+                    : codexItems(lines, candidate.updatedAt);
+                const active = runtime === "claude"
+                    ? this.options.activeClaude?.get(candidate.id)
+                    : this.options.activeCodex?.get(candidate.id);
+                summaries.push({
+                    id: candidate.id,
+                    runtime,
+                    title: active?.title ?? parsed.title ?? `${runtime === "claude" ? "Claude" : "Codex"} session`,
+                    cwd: active?.cwd ?? parsed.cwd,
+                    updatedAt: active?.updatedAt ?? candidate.updatedAt,
+                    controlState: active ? "live" : "read_only",
+                    busy: active?.busy ?? false,
+                    source: active ? (runtime === "claude" ? "channel" : "app_server") : "history",
+                });
+            }
+        }
+        for (const [runtime, activeSessions] of [["claude", this.options.activeClaude], ["codex", this.options.activeCodex]]) {
+            for (const [id, active] of activeSessions ?? []) {
+                if (summaries.some((session) => session.runtime === runtime && session.id === id))
+                    continue;
+                summaries.push({
+                    id,
+                    runtime,
+                    title: active.title ?? `${runtime === "claude" ? "Claude" : "Codex"} session`,
+                    cwd: active.cwd,
+                    updatedAt: active.updatedAt ?? new Date().toISOString(),
+                    controlState: "live",
+                    busy: active.busy,
+                    source: runtime === "claude" ? "channel" : "app_server",
+                });
+            }
+        }
+        return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, maxSessions);
+    }
+    async timeline(runtime, sessionId) {
+        if (!SESSION_ID.test(sessionId))
+            return null;
+        let candidate = this.files.get(`${runtime}:${sessionId}`);
+        if (!candidate) {
+            await this.list();
+            candidate = this.files.get(`${runtime}:${sessionId}`);
+        }
+        if (!candidate) {
+            const active = runtime === "claude" ? this.options.activeClaude?.has(sessionId) : this.options.activeCodex?.has(sessionId);
+            return active ? [] : null;
+        }
+        const lines = await readTailLines(candidate.path, this.options.maxHistoryBytes ?? DEFAULT_HISTORY_BYTES);
+        const parsed = runtime === "claude"
+            ? claudeItems(lines, candidate.updatedAt)
+            : codexItems(lines, candidate.updatedAt);
+        return capItems(parsed.items, this.options.maxTimelineItems ?? DEFAULT_TIMELINE_ITEMS);
+    }
+}