@ohmaseclaro/fleetwatch 0.1.0

package/dist/server/index.js

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { loadEnv, envFlag, envString } from "./env.js";
+// Load .env BEFORE any other module reads process.env.
+loadEnv();
+import { SessionRegistry } from "./registry.js";
+import { Watcher } from "./watcher.js";
+import { ProviderManager } from "./providers/types.js";
+import { CursorProvider } from "./providers/cursor.js";
+import { loadOrInitConfig, buildPairingPayload, pickLanIp, saveConfig } from "./pairing.js";
+import { startServer } from "./server.js";
+import { startTunnel, stopTunnel, activeTunnel } from "./tunnel.js";
+import { initAuth, isPasswordRequired } from "./auth.js";
+import { findNgrokAuthtoken } from "./ngrokConfig.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const AGENT_VERSION = "0.1.0";
+function parseArgs(argv) {
+    const args = {
+        port: parseInt(process.env.PORT ?? "7878", 10),
+        host: process.env.HOST ?? "0.0.0.0",
+        quiet: false,
+    };
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--port" || a === "-p")
+            args.port = parseInt(argv[++i] ?? "7878", 10);
+        else if (a === "--host")
+            args.host = argv[++i] ?? "0.0.0.0";
+        else if (a === "--include-cowork")
+            args.includeCowork = true;
+        else if (a === "--quiet" || a === "-q")
+            args.quiet = true;
+        else if (a === "--ngrok-authtoken")
+            args.ngrokAuthtoken = argv[++i];
+        else if (a === "--no-ngrok")
+            args.ngrokDisabled = true;
+        else if (a === "--ngrok")
+            args.ngrokForceOn = true;
+        else if (a === "--reset-ngrok")
+            args.ngrokReset = true;
+        else if (a === "--no-cursor")
+            args.cursorDisabled = true;
+        else if (a === "--help" || a === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`fleetwatch v${AGENT_VERSION}
+
+Usage: fleetwatch [options]
+
+Options:
+  --port, -p <port>       Port to listen on (default 7878)
+  --host <host>           Bind address (default 0.0.0.0 — your LAN)
+  --include-cowork        Also surface Cowork desktop sessions
+  --quiet, -q             Suppress QR / banner output
+  --ngrok-authtoken <t>   ngrok authtoken for auto-started HTTPS tunnel (free tier OK)
+  --no-ngrok              Disable the ngrok tunnel for THIS run (ephemeral)
+  --ngrok                 Force-enable ngrok for this run, overriding stored config
+  --reset-ngrok           Clear the persisted "ngrok disabled" flag so it stays on
+  --no-cursor             Skip the Cursor IDE provider (Claude only)
+  --help, -h              Show this help
+
+Environment / .env (reads ./.env then ~/.config/fleetwatch/.env):
+  NGROK_AUTHTOKEN         ngrok free-tier authtoken (required for tunnel)
+  NGROK_DISABLED=1        Disable ngrok tunnel
+  CURSOR_DISABLED=1       Disable Cursor IDE provider
+  PASSWORD                Optional password (bcrypt-hashed in memory only)
+  JWT_SECRET              Optional JWT signing secret (auto-generated otherwise)
+
+The daemon serves a mobile-friendly web UI. ngrok is enabled by default so
+you can reach it from anywhere; set NGROK_AUTHTOKEN once (free at
+https://dashboard.ngrok.com/get-started/your-authtoken) or use --no-ngrok
+to stay LAN-only.`);
+}
+/**
+ * Resolve the ngrok authtoken in priority order:
+ *   1. CLI `--ngrok-authtoken`
+ *   2. env `NGROK_AUTHTOKEN`
+ *   3. fleetwatch's own config (Settings UI / past CLI saves)
+ *   4. ngrok's own config file (~/Library/Application Support/ngrok/ngrok.yml)
+ *      — so users who've run `ngrok config add-authtoken` get it for free.
+ *
+ * Returns null when no token is reachable anywhere.
+ */
+function resolveNgrokAuthtoken(args, config) {
+    if (args.ngrokAuthtoken)
+        return { token: args.ngrokAuthtoken, source: "cli" };
+    const envToken = envString("NGROK_AUTHTOKEN");
+    if (envToken)
+        return { token: envToken, source: "env" };
+    if (config.ngrokAuthtoken)
+        return { token: config.ngrokAuthtoken, source: "config" };
+    const fromNgrok = findNgrokAuthtoken();
+    if (fromNgrok)
+        return { token: fromNgrok.authtoken, source: "ngrok-config", sourcePath: fromNgrok.source };
+    return null;
+}
+/**
+ * Decide whether ngrok is disabled and report which source disabled it.
+ * Precedence: --ngrok force-on > CLI --no-ngrok > env NGROK_DISABLED > config.
+ * Returning `null` means ngrok is enabled.
+ */
+function resolveNgrokDisabled(args, config) {
+    if (args.ngrokForceOn)
+        return null; // explicit override wins
+    if (args.ngrokDisabled)
+        return "cli";
+    if (envFlag("NGROK_DISABLED"))
+        return "env";
+    if (config.ngrokDisabled)
+        return "config";
+    return null;
+}
+async function main() {
+    const args = parseArgs(process.argv);
+    const config = await loadOrInitConfig();
+    if (args.includeCowork !== undefined) {
+        config.preferences.includeCowork = args.includeCowork;
+        await saveConfig(config);
+    }
+    // CLI-supplied authtoken IS persisted (one-time setup convenience).
+    if (args.ngrokAuthtoken) {
+        config.ngrokAuthtoken = args.ngrokAuthtoken;
+        // Setting an authtoken implies you want ngrok on — clear any stale disable.
+        config.ngrokDisabled = undefined;
+        await saveConfig(config);
+    }
+    // `--reset-ngrok` or `--ngrok`: clear the persisted disabled flag so the
+    // user recovers from a stuck state without editing config.json by hand.
+    if (args.ngrokReset || args.ngrokForceOn) {
+        if (config.ngrokDisabled) {
+            config.ngrokDisabled = undefined;
+            await saveConfig(config);
+        }
+    }
+    // NOTE: `--no-ngrok` is intentionally NOT persisted to config. It's an
+    // ephemeral, single-run override. Persistent disable should be set via
+    // the Settings UI or NGROK_DISABLED=1 env var.
+    // --- Initialize auth: optional password (from env) + JWT signing ---
+    initAuth({
+        password: envString("PASSWORD"),
+        jwtSecret: envString("JWT_SECRET") ?? config.jwtSecret,
+        pairingToken: config.token,
+    });
+    const log = (msg) => { if (!args.quiet)
+        console.error(msg); };
+    const registry = new SessionRegistry();
+    registry.setMaxListeners(64);
+    // --- Providers: assemble all data sources behind a single manager ---
+    const providers = new ProviderManager();
+    providers.add(new Watcher({ registry, onLog: log }));
+    const cursorDisabled = args.cursorDisabled || envFlag("CURSOR_DISABLED");
+    if (!cursorDisabled) {
+        try {
+            providers.add(new CursorProvider({ registry, onLog: log }));
+        }
+        catch (err) {
+            log(`[cursor] disabled: ${err.message}`);
+        }
+    }
+    else {
+        log(`[cursor] disabled (--no-cursor or CURSOR_DISABLED=1)`);
+    }
+    // Locate web bundle.
+    const candidates = [
+        path.join(__dirname, "..", "web"), // dist/server/index.js -> dist/web
+        path.join(__dirname, "..", "..", "dist", "web"),
+        path.join(process.cwd(), "dist", "web"),
+    ];
+    const webRoot = candidates.find((p) => existsSync(p)) ?? candidates[0];
+    await providers.startAll();
+    /** (Re)start the ngrok tunnel; called at boot and when the token changes. */
+    async function restartTunnel(authtoken) {
+        await startTunnel({ port: args.port, authtoken, onLog: log });
+    }
+    const fastify = await startServer({
+        port: args.port,
+        host: args.host,
+        config,
+        registry,
+        providers,
+        webRoot,
+        agentVersion: AGENT_VERSION,
+        onLog: log,
+        onConfigChanged: (_cfg) => { },
+        onTunnelAuthtoken: async (authtoken) => {
+            config.ngrokAuthtoken = authtoken;
+            await restartTunnel(authtoken);
+        },
+    });
+    // --- Start the ngrok tunnel (non-blocking; QR is printed first with LAN URL,
+    //     then re-printed once the tunnel URL is known). ---
+    const resolved = resolveNgrokAuthtoken(args, config);
+    const ngrokToken = resolved?.token;
+    const disableSource = resolveNgrokDisabled(args, config);
+    const ngrokDisabled = disableSource !== null;
+    const passwordOn = isPasswordRequired();
+    const printBanner = async () => {
+        if (args.quiet)
+            return;
+        const lan = pickLanIp() ?? "127.0.0.1";
+        const tunnel = activeTunnel();
+        const payload = await buildPairingPayload(lan, args.port, config.token, tunnel?.url);
+        const url = payload.url;
+        console.log("");
+        console.log("  \x1b[1m\x1b[38;5;208mfleetwatch\x1b[0m  v" + AGENT_VERSION);
+        console.log("  ─────────────────────────────────────────");
+        console.log("");
+        if (tunnel) {
+            console.log("  Open this on your phone \x1b[32m(works anywhere — via ngrok)\x1b[0m:");
+        }
+        else {
+            console.log("  Open this on your phone (same Wi-Fi):");
+        }
+        console.log("");
+        console.log(`     \x1b[1m\x1b[38;5;208m${url}\x1b[0m`);
+        console.log("");
+        console.log("  Or scan the QR code below:");
+        console.log("");
+        process.stdout.write(payload.qrAscii);
+        console.log("");
+        console.log(`  Host:    ${config.hostLabel}`);
+        console.log(`  Port:    ${args.port}`);
+        if (tunnel) {
+            const src = tokenSourceLabel(resolved);
+            console.log(`  Tunnel:  \x1b[32m${tunnel.url}\x1b[0m${src ? `   \x1b[90m(${src})\x1b[0m` : ""}`);
+        }
+        else if (disableSource === "cli") {
+            console.log(`  Tunnel:  \x1b[90mdisabled\x1b[0m (--no-ngrok)`);
+        }
+        else if (disableSource === "env") {
+            console.log(`  Tunnel:  \x1b[90mdisabled\x1b[0m (NGROK_DISABLED=1 in env)`);
+        }
+        else if (disableSource === "config") {
+            console.log(`  Tunnel:  \x1b[33mdisabled by stored config\x1b[0m`);
+            console.log(`           Run with \x1b[1m--reset-ngrok\x1b[0m to clear, or toggle in Settings.`);
+        }
+        else if (ngrokToken) {
+            const src = tokenSourceLabel(resolved);
+            console.log(`  Tunnel:  connecting…${src ? `   \x1b[90m(${src})\x1b[0m` : ""}`);
+        }
+        else {
+            console.log(`  Tunnel:  \x1b[33mnot configured\x1b[0m (LAN-only — same Wi-Fi required)`);
+        }
+        console.log(`  Auth:    ${passwordOn ? "\x1b[32mpassword required\x1b[0m" : "\x1b[33mpairing token only\x1b[0m (set PASSWORD to add a password)"}`);
+        console.log(`  Cowork:  ${config.preferences.includeCowork ? "on" : "off"} (toggle in Settings)`);
+        console.log("");
+        // Onboarding panel — only shown when ngrok isn't set up yet.
+        if (!tunnel && !ngrokDisabled && !ngrokToken) {
+            printNgrokSetupHelp(args.port);
+        }
+        console.log("  Press Ctrl+C to stop.");
+        console.log("");
+    };
+    // Print initial banner immediately with LAN URL.
+    await printBanner();
+    // Then start ngrok in background; re-print banner when ready.
+    if (ngrokToken && !ngrokDisabled) {
+        restartTunnel(ngrokToken).then(() => {
+            if (activeTunnel()) {
+                // Clear last N lines and reprint (simple approach: just print again).
+                console.log("  \x1b[33m↻ ngrok tunnel ready — updated QR:\x1b[0m");
+                printBanner();
+            }
+        });
+    }
+    const shutdown = async () => {
+        console.log("\nShutting down…");
+        await stopTunnel().catch(() => { });
+        await providers.stopAll();
+        await fastify.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+/**
+ * Short human label for where the ngrok authtoken came from, shown in the
+ * banner so users understand why a tunnel is/isn't starting.
+ */
+function tokenSourceLabel(r) {
+    if (!r)
+        return "";
+    switch (r.source) {
+        case "cli": return "token via --ngrok-authtoken";
+        case "env": return "token via NGROK_AUTHTOKEN env";
+        case "config": return "token via stored config";
+        case "ngrok-config":
+            return r.sourcePath
+                ? `token via ngrok.yml (${shortenHome(r.sourcePath)})`
+                : "token via ngrok.yml";
+    }
+}
+function shortenHome(p) {
+    const home = process.env.HOME;
+    return home && p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+/**
+ * Print a friendly onboarding panel for first-time ngrok setup.
+ * Uses OSC-8 terminal hyperlinks where supported (iTerm2, modern terminals)
+ * — degrades to plain text in older terminals.
+ */
+function printNgrokSetupHelp(port) {
+    const link = (url, label) => `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\`;
+    const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+    const dim = (s) => `\x1b[90m${s}\x1b[0m`;
+    const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+    console.log(`  ${yellow("┌──────── Make this reachable from anywhere ────────┐")}`);
+    console.log(`  ${yellow("│")}`);
+    console.log(`  ${yellow("│")}  ngrok creates a public HTTPS URL so your phone`);
+    console.log(`  ${yellow("│")}  works on cellular, coffee shops, anywhere.`);
+    console.log(`  ${yellow("│")}  ${dim("(Free tier, no credit card required.)")}`);
+    console.log(`  ${yellow("│")}`);
+    console.log(`  ${yellow("│")}  ${bold("1.")} Sign up:`);
+    console.log(`  ${yellow("│")}     ${link("https://dashboard.ngrok.com/signup", "https://dashboard.ngrok.com/signup")}`);
+    console.log(`  ${yellow("│")}`);
+    console.log(`  ${yellow("│")}  ${bold("2.")} Copy your authtoken:`);
+    console.log(`  ${yellow("│")}     ${link("https://dashboard.ngrok.com/get-started/your-authtoken", "https://dashboard.ngrok.com/get-started/your-authtoken")}`);
+    console.log(`  ${yellow("│")}`);
+    console.log(`  ${yellow("│")}  ${bold("3.")} Restart with the token:`);
+    console.log(`  ${yellow("│")}     ${bold("fleetwatch --ngrok-authtoken <your-token>")}`);
+    console.log(`  ${yellow("│")}     ${dim("or set NGROK_AUTHTOKEN=... in .env")}`);
+    console.log(`  ${yellow("│")}     ${dim("or paste it in Settings once paired locally")}`);
+    console.log(`  ${yellow("│")}`);
+    console.log(`  ${yellow("└────────────────────────────────────────────────────┘")}`);
+    console.log("");
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/server/jsonl.js

@@ -0,0 +1,345 @@
+/**
+ * Liberal JSONL line parser.
+ *
+ * Real Claude Code lines come in many shapes. Rather than modeling each
+ * variant exhaustively, we extract the fields we care about and tolerate
+ * everything else. Unknown line shapes still yield a usable SessionEvent.
+ */
+// Lines we drop entirely — pure metadata, not user-facing events.
+const META_TYPES = new Set(["last-prompt", "queue-operation", "todo-update", "ai-title", "custom-title"]);
+/**
+ * Extract session title metadata from a raw JSONL line if present.
+ * Returns null when the line isn't a title line.
+ */
+export function parseTitleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    if (raw.type === "ai-title" && typeof raw.aiTitle === "string") {
+        return { aiTitle: raw.aiTitle };
+    }
+    if (raw.type === "custom-title" && typeof raw.customTitle === "string") {
+        return { customTitle: raw.customTitle };
+    }
+    return null;
+}
+export function parseLine(line, sessionId, opts = {}) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    if (typeof raw.type === "string" && META_TYPES.has(raw.type))
+        return null;
+    const parsedTs = parseTimestamp(raw.timestamp);
+    // Drop lines with no timestamp — they pollute lastEventAt. Real conversation
+    // events always carry one.
+    if (parsedTs === null)
+        return null;
+    const ts = parsedTs;
+    const type = normalizeType(raw.type);
+    const ev = {
+        sessionId,
+        ts,
+        type,
+        uuid: typeof raw.uuid === "string" ? raw.uuid : undefined,
+    };
+    // user messages can carry plain string content or assistant-style content arrays
+    if (type === "user") {
+        ev.text = extractMessageText(raw.message) ?? extractMessageText(raw);
+        const images = extractImages(raw.message, opts.storeImage);
+        if (images.length > 0)
+            ev.images = images;
+        // a user line may also bundle tool_result blocks inside message.content
+        const toolResults = extractToolResults(raw.message);
+        if (toolResults.length > 0) {
+            // promote to a tool_result event (use the first; others rare)
+            const first = toolResults[0];
+            ev.type = "tool_result";
+            ev.toolUseRef = first.tool_use_id;
+            ev.toolResultText = first.text;
+            ev.toolResultIsError = first.is_error;
+            // keep the user text only if there's something beyond the tool_result
+            if (!ev.text || ev.text.length < 4)
+                ev.text = undefined;
+        }
+    }
+    else if (type === "assistant") {
+        const { text, toolUses, thinking, usage, model } = extractAssistantBlocks(raw.message);
+        ev.text = text;
+        ev.thinking = thinking;
+        ev.model = model ?? (typeof raw.message?.model === "string" ? raw.message.model : undefined);
+        if (usage) {
+            ev.inputTokens = usage.input_tokens;
+            ev.outputTokens = usage.output_tokens;
+            ev.cacheReadTokens = usage.cache_read_input_tokens;
+        }
+        if (toolUses.length > 0) {
+            // emit the first tool_use here; additional tool_uses in the same line
+            // are returned by parseLineMulti below
+            const first = toolUses[0];
+            ev.toolName = first.name;
+            ev.toolInput = first.input;
+            ev.toolUseId = first.id;
+            // we keep the assistant text alongside if present
+        }
+    }
+    else if (type === "tool_use") {
+        ev.toolName = raw.name;
+        ev.toolInput = raw.input;
+        ev.toolUseId = raw.id;
+    }
+    else if (type === "tool_result") {
+        ev.toolUseRef = raw.tool_use_id;
+        ev.toolResultText = stringifyMaybe(raw.content);
+        ev.toolResultIsError = raw.is_error === true;
+    }
+    else if (type === "attachment") {
+        ev.attachmentKind = raw.attachment?.type;
+        if (typeof raw.attachment?.content === "string") {
+            ev.text = raw.attachment.content;
+        }
+    }
+    else if (type === "summary") {
+        ev.text = typeof raw.summary === "string" ? raw.summary : stringifyMaybe(raw);
+    }
+    else if (type === "system") {
+        ev.text = typeof raw.content === "string" ? raw.content : stringifyMaybe(raw);
+    }
+    else if (type === "thinking") {
+        ev.thinking = typeof raw.thinking === "string" ? raw.thinking : stringifyMaybe(raw);
+    }
+    return ev;
+}
+/**
+ * Split a single assistant JSONL line into multiple semantic events when
+ * the message bundles text + multiple tool_uses. Callers can render each
+ * piece in chronological order in the UI.
+ */
+export function parseLineMulti(line, sessionId, opts = {}) {
+    const primary = parseLine(line, sessionId, opts);
+    if (!primary)
+        return [];
+    let raw;
+    try {
+        raw = JSON.parse(line.trim());
+    }
+    catch {
+        return [primary];
+    }
+    if (primary.type === "assistant") {
+        const { toolUses } = extractAssistantBlocks(raw.message);
+        if (toolUses.length <= 1)
+            return [primary];
+        const events = [];
+        // The primary already includes the first tool_use; emit the rest separately
+        events.push(primary);
+        for (let i = 1; i < toolUses.length; i++) {
+            const tu = toolUses[i];
+            events.push({
+                sessionId,
+                ts: primary.ts + i,
+                type: "tool_use",
+                toolName: tu.name,
+                toolInput: tu.input,
+                toolUseId: tu.id,
+                uuid: `${primary.uuid ?? ""}-${i}`,
+            });
+        }
+        return events;
+    }
+    return [primary];
+}
+function normalizeType(t) {
+    if (typeof t !== "string")
+        return "system";
+    if (t === "user" ||
+        t === "assistant" ||
+        t === "tool_use" ||
+        t === "tool_result" ||
+        t === "system" ||
+        t === "summary" ||
+        t === "attachment" ||
+        t === "thinking") {
+        return t;
+    }
+    // queue-operation, etc. -> treat as system
+    return "system";
+}
+function parseTimestamp(t) {
+    if (typeof t === "number")
+        return t > 1e12 ? t : t * 1000;
+    if (typeof t === "string") {
+        const parsed = Date.parse(t);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function extractMessageText(msg) {
+    if (!msg)
+        return undefined;
+    if (typeof msg === "string")
+        return msg;
+    if (typeof msg.content === "string")
+        return msg.content;
+    if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+            if (!block)
+                continue;
+            if (typeof block === "string")
+                parts.push(block);
+            else if (block.type === "text" && typeof block.text === "string")
+                parts.push(block.text);
+        }
+        return parts.length ? parts.join("\n") : undefined;
+    }
+    return undefined;
+}
+/**
+ * Pull image attachments out of a message's content tree. Images can appear
+ * in two places in Claude Code's JSONL:
+ *
+ *   (1) Direct user paste — top-level user.message.content[]:
+ *       { type: "image", source: { type: "base64", media_type, data } }
+ *
+ *   (2) Tool result with image — nested inside a tool_result block:
+ *       { type: "tool_result", content: [ { type: "image", source: {...} } ] }
+ *
+ * We walk the tree (one level deep is enough — Anthropic doesn't nest deeper)
+ * and surface every image we find. The storeImage callback caches the bytes
+ * in AttachmentStore and returns a content hash so events stay lightweight.
+ */
+function extractImages(msg, storeImage) {
+    if (!storeImage || !msg)
+        return [];
+    const out = [];
+    const visit = (blocks) => {
+        if (!Array.isArray(blocks))
+            return;
+        for (const block of blocks) {
+            if (!block || typeof block !== "object")
+                continue;
+            const b = block;
+            if (b.type === "image") {
+                const src = b.source;
+                if (!src || src.type !== "base64" || typeof src.data !== "string" || !src.media_type)
+                    continue;
+                let buf;
+                try {
+                    buf = Buffer.from(src.data, "base64");
+                }
+                catch {
+                    continue;
+                }
+                const hash = storeImage(buf, src.media_type);
+                if (!hash)
+                    continue;
+                out.push({ hash, mediaType: src.media_type, sizeBytes: buf.byteLength });
+            }
+            else if (b.type === "tool_result" && Array.isArray(b.content)) {
+                // Recurse into tool_result content — that's where screenshot-tool images live.
+                visit(b.content);
+            }
+        }
+    };
+    visit(msg.content);
+    return out;
+}
+function extractToolResults(msg) {
+    if (!msg || !Array.isArray(msg.content))
+        return [];
+    const results = [];
+    for (const block of msg.content) {
+        if (block?.type === "tool_result") {
+            results.push({
+                tool_use_id: String(block.tool_use_id ?? ""),
+                text: stringifyMaybe(block.content) ?? "",
+                is_error: block.is_error === true,
+            });
+        }
+    }
+    return results;
+}
+function extractAssistantBlocks(msg) {
+    const out = {
+        text: undefined,
+        thinking: undefined,
+        toolUses: [],
+        usage: undefined,
+        model: undefined,
+    };
+    if (!msg)
+        return out;
+    out.model = typeof msg.model === "string" ? msg.model : undefined;
+    out.usage = msg.usage;
+    if (typeof msg.content === "string") {
+        out.text = msg.content;
+        return out;
+    }
+    if (!Array.isArray(msg.content))
+        return out;
+    const textParts = [];
+    const thinkingParts = [];
+    for (const block of msg.content) {
+        if (!block)
+            continue;
+        if (block.type === "text" && typeof block.text === "string")
+            textParts.push(block.text);
+        else if (block.type === "thinking" && typeof block.thinking === "string")
+            thinkingParts.push(block.thinking);
+        else if (block.type === "tool_use") {
+            out.toolUses.push({
+                id: String(block.id ?? ""),
+                name: String(block.name ?? "unknown"),
+                input: block.input,
+            });
+        }
+    }
+    if (textParts.length)
+        out.text = textParts.join("\n");
+    if (thinkingParts.length)
+        out.thinking = thinkingParts.join("\n");
+    return out;
+}
+function stringifyMaybe(v) {
+    if (v === null || v === undefined)
+        return undefined;
+    if (typeof v === "string")
+        return v;
+    if (Array.isArray(v)) {
+        const parts = [];
+        for (const item of v) {
+            if (typeof item === "string")
+                parts.push(item);
+            else if (item?.type === "text" && typeof item.text === "string")
+                parts.push(item.text);
+            else
+                parts.push(JSON.stringify(item));
+        }
+        return parts.join("\n");
+    }
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+//# sourceMappingURL=jsonl.js.map