@infomity/remogent 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { networkInterfaces } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Bonjour } from "bonjour-service";
+import qrcode from "qrcode-terminal";
+import { DEFAULT_PORT, loadOrCreateIdentity, savedPort } from "./identity.js";
+import { isPortFree, pickFreePort } from "./port.js";
+import { createClaudeAdapter, findClaude } from "./adapters/claude.js";
+import { createCodexAdapter, findCodex } from "./adapters/codex.js";
+import { createGeminiAdapter, findGemini } from "./adapters/gemini.js";
+import { killTree, spawnCli } from "./adapters/util.js";
+import { SessionManager } from "./sessions.js";
+import { SESSIONS_FILE, SessionStore } from "./store.js";
+import { logToFile } from "./logfile.js";
+import { LOG_FILE, installService, probeHealth, serviceStatus, stopService, uninstallService, waitHealthy } from "./service.js";
+import { ELEVATE_HINT, elevateFirewallRule, ensureFirewallRule, firewallState, removeFirewallRule } from "./firewall.js";
+import { startServer } from "./server.js";
+const VIRTUAL_IFACE = /vethernet|vmware|virtualbox|vbox|docker|wsl|hyper-v|veth|br-|virbr|utun|tailscale|zerotier|loopback/i;
+function ipv4Rank(address, iface) {
+    const [a, b] = address.split(".").map(Number);
+    const rfc1918 = a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
+    const cgnat = a === 100 && b >= 64 && b <= 127; // Tailscale / carrier-grade NAT
+    if (a === 169 && b === 254)
+        return -1; // link-local: never advertise
+    if (rfc1918 && !VIRTUAL_IFACE.test(iface))
+        return 0; // real private LAN
+    if (rfc1918)
+        return 1; // private but virtual (WSL, Hyper-V, Docker)
+    if (cgnat)
+        return 2; // Tailscale
+    return 3;
+}
+export function lanAddress() {
+    let best;
+    for (const [iface, addrs] of Object.entries(networkInterfaces())) {
+        for (const a of addrs ?? []) {
+            if (a.family !== "IPv4" || a.internal)
+                continue;
+            const rank = ipv4Rank(a.address, iface);
+            if (rank < 0)
+                continue;
+            if (!best || rank < best.rank)
+                best = { address: a.address, rank };
+        }
+    }
+    return best?.address ?? "127.0.0.1";
+}
+/** Other addresses the phone can try if the primary one is unreachable (e.g. Wi-Fi changed, or away from home over
+ *  Tailscale): real private LAN addresses and Tailscale. Virtual adapters (WSL, Docker, Hyper-V) are left out. */
+export function alternateAddresses(primary) {
+    const out = [];
+    for (const [iface, addrs] of Object.entries(networkInterfaces())) {
+        for (const a of addrs ?? []) {
+            if (a.family !== "IPv4" || a.internal || a.address === primary || out.includes(a.address))
+                continue;
+            const rank = ipv4Rank(a.address, iface);
+            if (rank === 0 || rank === 2)
+                out.push(a.address);
+        }
+    }
+    return out.slice(0, 4);
+}
+/** Explicit `--host IP` means exactly that address; otherwise the QR also carries the other usable addresses. */
+function altsFor(flags, host) {
+    return typeof flags.get("host") === "string" ? [] : alternateAddresses(host);
+}
+export function pairingUrl(id, host, alt = []) {
+    const q = new URLSearchParams({
+        host,
+        port: String(id.port),
+        token: id.token,
+        fp: id.fingerprint,
+        name: id.name,
+    });
+    if (alt.length > 0)
+        q.set("alt", alt.join(","));
+    return `remogent://pair?${q.toString()}`;
+}
+function parseArgs(argv) {
+    const flags = new Map();
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (!a.startsWith("--"))
+            continue;
+        const next = argv[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags.set(a.slice(2), next);
+            i++;
+        }
+        else
+            flags.set(a.slice(2), true);
+    }
+    return flags;
+}
+async function start(flags) {
+    // Under the autostart service there is no console: send output to the log file (before anything else prints).
+    const logFile = flags.get("log");
+    if (typeof logFile === "string")
+        logToFile(logFile);
+    const port = portOf(flags);
+    const identity = loadOrCreateIdentity({ port, rotate: flags.has("rotate") });
+    const host = typeof flags.get("host") === "string" ? flags.get("host") : lanAddress();
+    const persist = !flags.has("no-persist");
+    const sessions = new SessionManager(persist ? new SessionStore(SESSIONS_FILE, console.log) : undefined);
+    const geminiBin = findGemini();
+    if (geminiBin)
+        sessions.registerAdapter(createGeminiAdapter(geminiBin));
+    const claudeBin = findClaude();
+    if (claudeBin)
+        sessions.registerAdapter(createClaudeAdapter(claudeBin));
+    const codexBin = findCodex();
+    if (codexBin)
+        sessions.registerAdapter(createCodexAdapter(codexBin));
+    console.log(`Engines: ${sessions.engines().join(", ") || "none found (install gemini, claude or codex CLI)"}`);
+    if (persist) {
+        const restored = await sessions.restore();
+        console.log(`Sessions: ${restored} restored from ${SESSIONS_FILE} (--no-persist disables saving)`);
+    }
+    else {
+        console.log("Sessions: persistence disabled (--no-persist); chats are lost when the daemon stops");
+    }
+    const server = await startServer(identity, console.log, { sessions });
+    const bonjour = new Bonjour();
+    const svc = bonjour.publish({
+        name: `remogent-${identity.name}`,
+        type: "remogent",
+        protocol: "tcp",
+        port: identity.port,
+        txt: { fp: identity.fingerprint.slice(0, 16), v: "1" },
+    });
+    const url = pairingUrl(identity, host, altsFor(flags, host));
+    console.log(`\nRemogent host "${identity.name}" listening on wss://${host}:${identity.port}`);
+    console.log(`TLS fingerprint (SHA-256): ${identity.fingerprint}\n`);
+    if (!flags.has("no-qr"))
+        qrcode.generate(url, { small: true });
+    if (flags.has("show-url"))
+        console.log(`\n${url}`);
+    console.log("\nScan the QR code with the Remogent Android app. Ctrl+C to stop.");
+    const shutdown = async () => {
+        svc.stop?.();
+        bonjour.destroy();
+        await server.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+function portOf(flags) {
+    // --port wins, then the port stored with the identity (what the installed host and paired phones use), then the default.
+    return typeof flags.get("port") === "string" ? Number(flags.get("port")) : savedPort() ?? DEFAULT_PORT;
+}
+/** One-time PC setup: register autostart, start now, and show the pairing QR. Safe to re-run (it replaces the registration). */
+async function install(flags) {
+    const explicit = typeof flags.get("port") === "string";
+    const previousPort = savedPort();
+    let port = portOf(flags);
+    stopService(); // an earlier registration, so the port is free for the new one
+    const squatter = await probeHealth(port);
+    if (squatter) {
+        console.log(`Warning: something already answers on port ${port} (a daemon started by hand?). Stop it (Ctrl+C) so the autostart service can take over.`);
+    }
+    else if (!(await isPortFree(port))) {
+        if (explicit) {
+            console.error(`Port ${port} is in use by another program. Pick another with --port N, or stop that program.`);
+            process.exit(1);
+        }
+        const next = await pickFreePort(port + 1);
+        if (next === undefined) {
+            console.error(`Port ${port} is in use and no free port was found above it. Pass --port N.`);
+            process.exit(1);
+        }
+        console.log(`Port ${port} is in use by another program; using ${next} instead.`);
+        port = next;
+    }
+    // Create/load the identity here, once, so the service and this command agree on the same token, certificate and port.
+    const identity = loadOrCreateIdentity({ port, rotate: flags.has("rotate"), persistPort: true });
+    const host = typeof flags.get("host") === "string" ? flags.get("host") : lanAddress();
+    if (previousPort !== undefined && previousPort !== identity.port && !flags.has("rotate")) {
+        console.log(`The host port changed (${previousPort} -> ${identity.port}), so phones paired before must scan the QR below once more.`);
+    }
+    const r = installService(port);
+    console.log(r.message);
+    if (!r.ok)
+        process.exit(1);
+    console.log(ensureFirewallRule(port).message); // never fatal: needs admin, and USB / an open firewall still work
+    if (!squatter) {
+        console.log(`Waiting for the host to come up (log: ${LOG_FILE}) ...`);
+        if (!(await waitHealthy(port, 20_000)))
+            console.log("It is not answering yet. Check the log above; `remogent status` shows the service state.");
+    }
+    console.log(`\nRemogent host "${identity.name}" on wss://${host}:${identity.port} will now start whenever you sign in.`);
+    console.log(`TLS fingerprint (SHA-256): ${identity.fingerprint}\n`);
+    const url = pairingUrl(identity, host, altsFor(flags, host));
+    if (!flags.has("no-qr"))
+        qrcode.generate(url, { small: true });
+    if (flags.has("show-url"))
+        console.log(`\n${url}`);
+    console.log("\nScan the QR code with the Remogent Android app (skip this if the phone is already paired).");
+}
+async function status(flags) {
+    const port = portOf(flags);
+    const s = serviceStatus();
+    console.log(`Autostart: ${s.detail}`);
+    const h = await probeHealth(port);
+    console.log(`Host on port ${port}: ${h ? `answering (${h.name ?? "unnamed"})` : "not answering"}`);
+    console.log(`Log: ${LOG_FILE}`);
+    process.exit(s.registered && h ? 0 : 1);
+}
+/** Shows the pairing QR again for the already-installed host (the service runs hidden, so nothing else ever prints it).
+ *  Waits for the phone to connect, then exits so a window opened just for the QR closes itself (--no-wait keeps it open). */
+async function pair(flags) {
+    const port = portOf(flags);
+    const identity = loadOrCreateIdentity({ port, rotate: false });
+    const host = typeof flags.get("host") === "string" ? flags.get("host") : lanAddress();
+    const url = pairingUrl(identity, host, altsFor(flags, host));
+    const baseline = (await probeHealth(port))?.connections; // undefined: host not running or an older host without the counter
+    console.log(`Remogent host "${identity.name}" at ${host}:${identity.port}\n`);
+    console.log('Open the Remogent app and tap "Scan QR to pair", then scan this code:\n');
+    qrcode.generate(url, { small: true });
+    if (flags.has("show-url"))
+        console.log(`\n${url}`);
+    if (flags.has("no-wait") || baseline === undefined) {
+        console.log("\nThe code contains your pairing secret: close this window when you are done.");
+        return;
+    }
+    const timeoutMin = typeof flags.get("timeout") === "string" ? Number(flags.get("timeout")) : 5;
+    console.log(`\nWaiting for the phone to connect (this window closes by itself; gives up after ${timeoutMin} min). Ctrl+C to close now.`);
+    const deadline = Date.now() + timeoutMin * 60_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 1000));
+        const now = (await probeHealth(port))?.connections;
+        if (now !== undefined && now > baseline) {
+            console.log("\nPhone connected. Paired! Closing ...");
+            await new Promise((r) => setTimeout(r, 1500));
+            process.exit(0);
+        }
+    }
+    console.log("\nTimed out waiting for the phone; closing so the pairing secret is not left on screen. Run `npm run pair` to show it again.");
+    await new Promise((r) => setTimeout(r, 3000));
+    process.exit(1);
+}
+/** `--version` of an engine CLI (best effort, 8 s cap), so `doctor` proves the resolved path actually runs. */
+function engineVersion(file) {
+    return new Promise((resolve) => {
+        let out = "";
+        let done = false;
+        const finish = (v) => { if (!done) {
+            done = true;
+            clearTimeout(timer);
+            resolve(v);
+        } };
+        const child = spawnCli(file, ["--version"], process.cwd());
+        const timer = setTimeout(() => { killTree(child); finish(undefined); }, 8000);
+        child.stdout.on("data", (d) => { out += d.toString(); });
+        child.on("error", () => finish(undefined));
+        child.on("close", (code) => finish(code === 0 ? out.trim().split(/\r?\n/)[0] || undefined : undefined));
+    });
+}
+/** Checks everything first-run setup depends on and says how to fix what is missing. Exit code 1 only for blockers. */
+async function doctor(flags) {
+    const port = portOf(flags);
+    let blockers = 0;
+    const ok = (m) => console.log(`  ok    ${m}`);
+    const warn = (m) => console.log(`  warn  ${m}`);
+    const bad = (m) => { blockers++; console.log(`  FAIL  ${m}`); };
+    console.log("Remogent doctor\n");
+    const major = Number(process.versions.node.split(".")[0]);
+    if (major >= 20)
+        ok(`Node.js ${process.versions.node} (${process.execPath})`);
+    else
+        bad(`Node.js ${process.versions.node} is too old; install Node.js 20 or newer from https://nodejs.org`);
+    const claude = findClaude();
+    const gemini = findGemini();
+    const codex = findCodex();
+    for (const [name, file, install] of [
+        ["Claude Code", claude, "install it from https://claude.com/product/claude-code, then run `claude` once to sign in"],
+        ["Gemini CLI", gemini, "install it with `npm i -g @google/gemini-cli`, then run `gemini` once to sign in"],
+        ["Codex CLI", codex, "install it with `npm i -g @openai/codex`, then run `codex login` once to sign in"],
+    ]) {
+        if (!file) {
+            warn(`${name} not found (${install})`);
+            continue;
+        }
+        const v = await engineVersion(file);
+        if (v)
+            ok(`${name} ${v} (${file})`);
+        else
+            warn(`${name} found at ${file} but \`--version\` did not answer; run it in a terminal once to sign in or repair it`);
+    }
+    if (!claude && !gemini && !codex)
+        bad("no engine found: the app has nothing to drive. Install Claude Code, Gemini CLI or Codex CLI (see above), then run `doctor` again");
+    const addrs = [];
+    for (const [iface, list] of Object.entries(networkInterfaces())) {
+        for (const a of list ?? []) {
+            if (a.family === "IPv4" && !a.internal && ipv4Rank(a.address, iface) >= 0)
+                addrs.push({ address: a.address, iface, rank: ipv4Rank(a.address, iface) });
+        }
+    }
+    addrs.sort((x, y) => x.rank - y.rank);
+    if (addrs.length === 0)
+        warn("no network address found; the phone can only connect over USB (`adb reverse`) until this PC is on Wi-Fi or Ethernet");
+    else
+        ok(`address the QR will use: ${lanAddress()} (candidates: ${addrs.map((a) => `${a.address} on ${a.iface}`).join(", ")}); override with --host IP`);
+    const s = serviceStatus();
+    if (s.registered)
+        ok(`autostart: ${s.detail}`);
+    else
+        warn(`autostart not set up (${s.detail}); run \`node dist/index.js install\` so the host is always there`);
+    const h = await probeHealth(port);
+    if (h)
+        ok(`host answering on port ${port} (${h.name ?? "unnamed"})`);
+    else
+        warn(`nothing answering on port ${port} yet`);
+    const fw = firewallState(port);
+    if (fw.state === "open")
+        ok(`firewall: ${fw.detail}`);
+    else if (fw.state === "missing" || fw.state === "stale")
+        warn(`firewall: ${fw.detail}; Windows may block the phone on Wi-Fi. Fix: \`${ELEVATE_HINT}\``);
+    else if (fw.state === "unknown")
+        warn(`firewall: ${fw.detail}`);
+    console.log(blockers ? `\n${blockers} problem(s) to fix above.` : "\nAll set.");
+    process.exit(blockers ? 1 : 0);
+}
+/** True when this copy runs from a throw-away package cache (`npx`, `pnpm dlx`, `yarn dlx`): an autostart entry that points
+ *  here would break as soon as the cache is cleaned. */
+function isTransientCopy() {
+    return /[\\/](_npx|dlx-[^\\/]*|\.pnpm-dlx|dlx)[\\/]/i.test(fileURLToPath(import.meta.url));
+}
+/** One command for everything: check this PC (`doctor`), then register autostart + show the QR (`install`).
+ *  From an `npx` cache it first installs the package globally and runs from that stable copy. */
+function setup(args) {
+    let entry = fileURLToPath(import.meta.url);
+    if (isTransientCopy()) {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        console.log(`Running from a temporary npx copy: installing ${pkg.name}@${pkg.version} globally first, so the autostart service points at a stable path ...\n`);
+        const r = spawnSync(`npm install -g ${pkg.name}@${pkg.version}`, { stdio: "inherit", shell: true });
+        if (r.status !== 0) {
+            console.error(`\nThe global install failed (permissions?). Run \`npm install -g ${pkg.name}\` yourself, then \`remogent setup\`.`);
+            process.exit(1);
+        }
+        const root = String(spawnSync("npm root -g", { shell: true, encoding: "utf8" }).stdout ?? "").trim();
+        const stable = join(root, ...pkg.name.split("/"), "dist", "index.js");
+        if (!root || !existsSync(stable)) {
+            console.error(`\nInstalled, but ${stable || "the global package folder"} was not found. Run \`remogent setup\` from a new terminal.`);
+            process.exit(1);
+        }
+        entry = stable;
+    }
+    const run = (cmdName) => spawnSync(process.execPath, [entry, cmdName, ...args], { stdio: "inherit" }).status ?? 1;
+    console.log("Step 1/2: checking this PC\n");
+    if (run("doctor") !== 0) {
+        console.error("\nFix the problem(s) above, then run `remogent setup` again.");
+        process.exit(1);
+    }
+    console.log("\nStep 2/2: starting the host and showing the pairing QR\n");
+    process.exit(run("install"));
+}
+const [cmd = "start", ...rest] = process.argv.slice(2);
+const flags = parseArgs(rest);
+if (cmd === "start") {
+    start(flags).catch((err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`Port ${portOf(flags)} is already in use: is another Remogent host running (check \`remogent status\`)?`);
+        }
+        else {
+            console.error(err);
+        }
+        process.exit(1);
+    });
+}
+else if (cmd === "install") {
+    install(flags).catch((err) => { console.error(err); process.exit(1); });
+}
+else if (cmd === "uninstall") {
+    const r = uninstallService();
+    console.log(r.message);
+    const fw = removeFirewallRule();
+    if (fw.message)
+        console.log(fw.message);
+    process.exit(r.ok ? 0 : 1);
+}
+else if (cmd === "firewall") {
+    const port = portOf(flags);
+    const r = flags.has("elevate") ? elevateFirewallRule(port) : ensureFirewallRule(port);
+    console.log(r.message);
+    process.exit(r.ok ? 0 : 1);
+}
+else if (cmd === "status") {
+    status(flags).catch((err) => { console.error(err); process.exit(1); });
+}
+else if (cmd === "doctor") {
+    doctor(flags).catch((err) => { console.error(err); process.exit(1); });
+}
+else if (cmd === "setup") {
+    setup(rest);
+}
+else if (cmd === "pair") {
+    pair(flags).catch((err) => { console.error(err); process.exit(1); });
+}
+else {
+    console.log("Usage: remogent <command> [options]\n" +
+        "  setup       First-time setup in one step: doctor, then install (from npx it installs itself globally first)\n" +
+        "  install     Start the host at every sign-in (restarts on crash), start it now and show the pairing QR\n" +
+        "  uninstall   Stop and remove the autostart registration (and the Windows firewall rule, if allowed)\n" +
+        "  firewall    Windows: allow the phone through Defender Firewall on private networks (add --elevate to get the permission prompt)\n" +
+        "  status      Show autostart state and whether the host answers\n" +
+        "  pair        Show the pairing QR again (for a new phone), close itself once the phone connects; the installed host keeps running\n" +
+        "  doctor      Check Node, the Claude/Gemini/Codex CLIs (found automatically), network address and autostart, and say how to fix gaps\n" +
+        "  start       Run the host in this terminal (no autostart)\n" +
+        "Options: [--port N] [--host IP] [--rotate] [--no-qr] [--show-url] [--no-persist] [--log FILE] [--no-wait] [--timeout MIN]");
+    process.exit(cmd === "help" || cmd === "--help" ? 0 : 1);
+}
+//# sourceMappingURL=index.js.map

package/dist/logfile.js

@@ -0,0 +1,39 @@
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { format } from "node:util";
+const ROTATE_AT_BYTES = 2 * 1024 * 1024;
+/**
+ * Sends console output to a file (used when the daemon runs without a console, e.g. started by the autostart service).
+ * The previous log is kept as `<file>.old` once it exceeds 2 MiB (checked at startup only; the daemon logs very little).
+ * Fatal errors are written to the log too, then the process exits non-zero so a supervisor restarts it.
+ * Never log secrets here: the pairing token is only printed by `--show-url` / the QR, which the service does not use.
+ */
+export function logToFile(file) {
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        if (statSync(file).size > ROTATE_AT_BYTES)
+            renameSync(file, `${file}.old`);
+    }
+    catch {
+        /* no log yet, or not rotatable: just append */
+    }
+    const write = (level, args) => {
+        try {
+            appendFileSync(file, `${new Date().toISOString()} ${level} ${format(...args)}\n`);
+        }
+        catch {
+            /* logging must never take the daemon down */
+        }
+    };
+    console.log = (...a) => write("INFO", a);
+    console.info = (...a) => write("INFO", a);
+    console.warn = (...a) => write("WARN", a);
+    console.error = (...a) => write("ERROR", a);
+    const fatal = (e) => {
+        write("FATAL", [e instanceof Error ? (e.stack ?? e.message) : String(e)]);
+        process.exit(1);
+    };
+    process.on("uncaughtException", fatal);
+    process.on("unhandledRejection", fatal);
+}
+//# sourceMappingURL=logfile.js.map

package/dist/port.js

@@ -0,0 +1,19 @@
+import { createServer } from "node:net";
+/** True when nothing is listening on this TCP port on any interface (we bind 0.0.0.0, as the host does). */
+export function isPortFree(port) {
+    return new Promise((resolve) => {
+        const srv = createServer();
+        srv.once("error", () => resolve(false));
+        srv.once("listening", () => srv.close(() => resolve(true)));
+        srv.listen(port, "0.0.0.0");
+    });
+}
+/** `preferred` if free, otherwise the next free port above it (up to `span` tries). Undefined when none is free. */
+export async function pickFreePort(preferred, span = 50) {
+    for (let p = preferred; p < preferred + span && p <= 65535; p++) {
+        if (await isPortFree(p))
+            return p;
+    }
+    return undefined;
+}
+//# sourceMappingURL=port.js.map

package/dist/protocol.js

@@ -0,0 +1,142 @@
+// Types and runtime validation for docs/PROTOCOL.md (WS protocol v1).
+export const PROTOCOL_VERSION = 1;
+export class ProtocolError extends Error {
+    code;
+    reqId;
+    constructor(code, message, reqId) {
+        super(message);
+        this.code = code;
+        this.reqId = reqId;
+    }
+}
+const ENGINES = ["gemini", "claude", "codex"];
+const MODES = ["ask", "plan", "auto_edit", "auto"];
+const DECISIONS = ["deny", "allow_once", "allow_session"];
+const MAX_MODEL_ID = 200;
+function isObj(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function reqStr(o, k, reqId) {
+    const v = o[k];
+    if (typeof v !== "string" || v.length === 0) {
+        throw new ProtocolError("invalid_message", `field "${k}" must be a non-empty string`, reqId);
+    }
+    return v;
+}
+function reqIdOf(o) {
+    const v = o["reqId"];
+    if (typeof v !== "string" || v.length === 0) {
+        throw new ProtocolError("invalid_message", 'field "reqId" must be a non-empty string');
+    }
+    return v;
+}
+/** Validate an already-JSON-parsed value. Throws ProtocolError (carrying reqId when known). */
+export function parseClientMessage(raw) {
+    if (!isObj(raw))
+        throw new ProtocolError("invalid_message", "message must be a JSON object");
+    const type = raw["type"];
+    if (typeof type !== "string")
+        throw new ProtocolError("invalid_message", 'missing "type"');
+    const rid = typeof raw["reqId"] === "string" ? raw["reqId"] : undefined;
+    switch (type) {
+        case "ping": {
+            const t = raw["t"];
+            return { type, ...(typeof t === "number" ? { t } : {}) };
+        }
+        case "client_hello": {
+            const protocol = raw["protocol"];
+            if (typeof protocol !== "number")
+                throw new ProtocolError("invalid_message", '"protocol" must be a number');
+            const app = typeof raw["app"] === "string" ? raw["app"] : undefined;
+            return { type, protocol, ...(app ? { app } : {}) };
+        }
+        case "models_list": {
+            const reqId = reqIdOf(raw);
+            const engine = reqStr(raw, "engine", reqId);
+            if (!ENGINES.includes(engine))
+                throw new ProtocolError("invalid_message", `unknown engine "${engine}"`, reqId);
+            return { type, reqId, engine: engine };
+        }
+        case "session_create": {
+            const reqId = reqIdOf(raw);
+            const engine = reqStr(raw, "engine", reqId);
+            if (!ENGINES.includes(engine))
+                throw new ProtocolError("invalid_message", `unknown engine "${engine}"`, reqId);
+            const cwd = reqStr(raw, "cwd", reqId);
+            const pm = raw["permissionMode"] ?? "ask";
+            if (typeof pm !== "string" || !MODES.includes(pm)) {
+                throw new ProtocolError("invalid_message", "invalid permissionMode", reqId);
+            }
+            const model = raw["model"];
+            if (model !== undefined && model !== null && (typeof model !== "string" || model.length === 0 || model.length > MAX_MODEL_ID)) {
+                throw new ProtocolError("invalid_message", '"model" must be a non-empty string', reqId);
+            }
+            return {
+                type,
+                reqId,
+                engine: engine,
+                cwd,
+                permissionMode: pm,
+                ...(typeof model === "string" ? { model } : {}),
+            };
+        }
+        case "session_list":
+            return { type, reqId: reqIdOf(raw) };
+        case "session_resume":
+        case "session_close":
+        case "session_delete": {
+            const reqId = reqIdOf(raw);
+            return { type, reqId, sessionId: reqStr(raw, "sessionId", reqId) };
+        }
+        case "session_rename": {
+            const reqId = reqIdOf(raw);
+            const sessionId = reqStr(raw, "sessionId", reqId);
+            const title = raw["title"];
+            if (typeof title !== "string")
+                throw new ProtocolError("invalid_message", '"title" must be a string', reqId);
+            return { type, reqId, sessionId, title };
+        }
+        case "session_set_model": {
+            const reqId = reqIdOf(raw);
+            const sessionId = reqStr(raw, "sessionId", reqId);
+            const model = reqStr(raw, "model", reqId);
+            if (model.length > MAX_MODEL_ID)
+                throw new ProtocolError("invalid_message", '"model" is too long', reqId);
+            return { type, reqId, sessionId, model };
+        }
+        case "session_attach": {
+            const reqId = reqIdOf(raw);
+            const sessionId = reqStr(raw, "sessionId", reqId);
+            const afterSeq = raw["afterSeq"] ?? 0;
+            if (typeof afterSeq !== "number" || !Number.isInteger(afterSeq) || afterSeq < 0) {
+                throw new ProtocolError("invalid_message", '"afterSeq" must be a non-negative integer', reqId);
+            }
+            return { type, reqId, sessionId, afterSeq };
+        }
+        case "session_detach":
+            return { type, sessionId: reqStr(raw, "sessionId") };
+        case "session_prompt": {
+            const reqId = reqIdOf(raw);
+            const sessionId = reqStr(raw, "sessionId", reqId);
+            const text = raw["text"];
+            if (typeof text !== "string" || text.length === 0) {
+                throw new ProtocolError("invalid_message", '"text" must be a non-empty string', reqId);
+            }
+            return { type, reqId, sessionId, text };
+        }
+        case "session_cancel":
+            return { type, sessionId: reqStr(raw, "sessionId", rid), ...(rid ? { reqId: rid } : {}) };
+        case "permission_response": {
+            const sessionId = reqStr(raw, "sessionId");
+            const requestId = reqStr(raw, "requestId");
+            const decision = raw["decision"];
+            if (typeof decision !== "string" || !DECISIONS.includes(decision)) {
+                throw new ProtocolError("invalid_message", "invalid decision");
+            }
+            return { type, sessionId, requestId, decision: decision };
+        }
+        default:
+            throw new ProtocolError("unknown_type", `unknown type "${type}"`, rid);
+    }
+}
+//# sourceMappingURL=protocol.js.map