wave-code 1.0.10 → 1.1.1

package/dist/contracts/status.d.ts

@@ -1,7 +0,0 @@
-export interface AgentStatus {
-    version: string;
-    sessionId: string;
-    cwd: string;
-    baseURL: string;
-    model: string;
-}

package/dist/contracts/status.js

@@ -1 +0,0 @@
-export {};

package/dist/daemon/commands.d.ts

@@ -1,49 +0,0 @@
-/**
- * `wave daemon` client subcommands — talk to the wave daemon's unix socket
- * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
- * progress, inject messages and respond to pending permission requests.
- *
- * All subcommands are non-interactive: results go to stdout, diagnostics to
- * stderr, and every handler calls process.exit() itself (yargs would fall
- * through to the TUI otherwise). Every command connects to the fixed default
- * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
- * `--socket` override is offered (spec: daemon-command.md).
- *
- * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
- * re-attach to a live session in the daemon's in-memory registry, or reload a
- * transcript from disk under the current working directory. A session that is
- * nowhere (live registry or disk) silently starts a FRESH session under a
- * different id — the only reliable existence check is the `restoreSession`
- * rejection ("Session not found: <id>"), after which the junk fresh session
- * must be destroyed via the envelope sessionId returned by `initialize`.
- */
-/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
-export declare const DEFAULT_DAEMON_SOCKET: string;
-export declare function daemonListCommand(socketPath: string): Promise<void>;
-export declare function daemonStatusCommand(socketPath: string, sessionId: string, lines?: number): Promise<void>;
-export interface SendOptions {
-    timeout: number;
-}
-/**
- * Send a message and wait for the reply that corresponds to it.
- *
- * Completion detection: `sendMessage` on an idle session resolves only after
- * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
- * busy session it enqueues and returns immediately — so stopping on a bare
- * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
- * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
- * is the user message added when OUR turn starts (userMessageAdded), and the
- * reply is the last assistantMessageAdded observed after it. A stale
- * loading:false can then never satisfy the wait condition early (the reply has
- * not been added yet).
- */
-export declare function daemonSendCommand(socketPath: string, sessionId: string, message: string, options?: SendOptions): Promise<void>;
-export interface RespondOptions {
-    allow?: boolean;
-    deny?: boolean;
-    reason?: string;
-    answer?: string;
-    rule?: string;
-    mode?: string;
-}
-export declare function daemonRespondCommand(socketPath: string, sessionId: string, requestId: string, options: RespondOptions): Promise<void>;

package/dist/daemon/commands.js

@@ -1,341 +0,0 @@
-/**
- * `wave daemon` client subcommands — talk to the wave daemon's unix socket
- * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
- * progress, inject messages and respond to pending permission requests.
- *
- * All subcommands are non-interactive: results go to stdout, diagnostics to
- * stderr, and every handler calls process.exit() itself (yargs would fall
- * through to the TUI otherwise). Every command connects to the fixed default
- * socket `~/.wave/daemon.sock` — the daemon only runs on remote hosts, so no
- * `--socket` override is offered (spec: daemon-command.md).
- *
- * Attach semantics: `initialize {workdir, restoreSessionId}` + `restoreSession`
- * re-attach to a live session in the daemon's in-memory registry, or reload a
- * transcript from disk under the current working directory. A session that is
- * nowhere (live registry or disk) silently starts a FRESH session under a
- * different id — the only reliable existence check is the `restoreSession`
- * rejection ("Session not found: <id>"), after which the junk fresh session
- * must be destroyed via the envelope sessionId returned by `initialize`.
- */
-import net from "node:net";
-import os from "node:os";
-import path from "node:path";
-import { ASK_USER_QUESTION_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, getMessageContent, } from "wave-agent-sdk";
-import { SocketClient } from "./socketClient.js";
-/** Fixed default daemon socket (spec: 默认 socket 固定，无 --socket 覆盖). */
-export const DEFAULT_DAEMON_SOCKET = path.join(os.homedir(), ".wave", "daemon.sock");
-const PERMISSION_MODES = [
-    "default",
-    "bypassPermissions",
-    "acceptEdits",
-    "plan",
-    "dontAsk",
-];
-// ── Connection helpers ─────────────────────────────────────────
-function connectDaemon(socketPath) {
-    return new Promise((resolve, reject) => {
-        const socket = net.createConnection(socketPath);
-        socket.once("connect", () => resolve(new SocketClient(socket)));
-        socket.once("error", (err) => {
-            socket.destroy();
-            reject(err);
-        });
-    });
-}
-/** Connect or fail fast with the spec'd error; daemon idle-exits after 60s. */
-async function connectDaemonOrExit(socketPath) {
-    try {
-        return await connectDaemon(socketPath);
-    }
-    catch (err) {
-        const code = err.code;
-        console.error(`无法连接 daemon socket ${socketPath}：daemon 未运行？（daemon 空闲 60 秒自动退出）` +
-            (code ? ` (${code})` : ""));
-        process.exit(1);
-    }
-}
-function fail(message) {
-    console.error(message);
-    process.exit(1);
-}
-/**
- * Attach to a session; returns the initialized sessionId + working directory.
- * Exits (nonzero) with the spec'd error when the session exists neither in the
- * daemon registry nor on disk, destroying the fresh session that `initialize`
- * silently created.
- */
-async function attachSession(client, sessionId) {
-    const init = (await client.request("initialize", {
-        workdir: process.cwd(),
-        restoreSessionId: sessionId,
-    }));
-    const initId = init.sessionId;
-    try {
-        await client.request("restoreSession", { sessionId }, initId);
-    }
-    catch (err) {
-        if (err.message.includes("Session not found")) {
-            // initialize silently started a junk fresh session — remove it from the
-            // registry so the failed attach leaves no trace (spec: 会话不存在错误).
-            await client.request("destroy", undefined, initId).catch(() => { });
-            fail(`会话不存在或未被该 daemon 托管：${sessionId}`);
-        }
-        throw err;
-    }
-    return init;
-}
-async function listPendingPermissions(client) {
-    const result = (await client.request("listPendingPermissions"));
-    return result.requests ?? [];
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-// ── list ───────────────────────────────────────────────────────
-export async function daemonListCommand(socketPath) {
-    let client;
-    try {
-        client = await connectDaemonOrExit(socketPath);
-        const result = (await client.request("listDaemonSessions"));
-        const sessions = result.sessions ?? [];
-        if (sessions.length > 0) {
-            const rows = sessions.map((s) => ({
-                sessionId: s.sessionId,
-                status: s.isLoading ? "生成中" : "空闲",
-                messageCount: String(s.messageCount),
-                workingDirectory: s.workingDirectory,
-            }));
-            const width = (key) => Math.max(...rows.map((r) => r[key].length), key.length);
-            const pad = (value, w) => value.padEnd(w);
-            console.log(`${pad("会话", width("sessionId"))}  ${pad("状态", width("status"))}  ${pad("消息数", width("messageCount"))}  工作目录`);
-            for (const r of rows) {
-                console.log(`${pad(r.sessionId, width("sessionId"))}  ${pad(r.status, width("status"))}  ${pad(r.messageCount, width("messageCount"))}  ${r.workingDirectory}`);
-            }
-        }
-        else {
-            // Daemon idle-exit is normal — an empty registry is not an error.
-            console.log("无会话");
-        }
-    }
-    catch (err) {
-        fail(`wave daemon list 失败：${err.message}`);
-    }
-    finally {
-        await client?.dispose();
-    }
-    // Exits outside the try so the success path's exit is never re-wrapped by the
-    // error handler above.
-    process.exit(0);
-}
-// ── status ─────────────────────────────────────────────────────
-function summarizeToolInput(context) {
-    const input = context.toolInput;
-    if (!input || Object.keys(input).length === 0)
-        return "";
-    let text;
-    try {
-        text = JSON.stringify(input);
-    }
-    catch {
-        text = "";
-    }
-    return text.length > 80 ? `${text.slice(0, 80)}…` : text;
-}
-export async function daemonStatusCommand(socketPath, sessionId, lines = 20) {
-    let client;
-    try {
-        client = await connectDaemonOrExit(socketPath);
-        // Subscribe BEFORE initialize/restoreSession so the replayed loadingChange
-        // snapshot is captured (spec: 依据重放的 loadingChange 快照显示状态).
-        let loading = false;
-        client.onNotification("loadingChange", (params) => {
-            loading = params.loading;
-        });
-        const init = await attachSession(client, sessionId);
-        const initId = init.sessionId;
-        // listPendingPermissions is the authoritative "waiting for approval" signal
-        // (spec: 单凭消息无法区分等审批与执行中，须结合 listPendingPermissions).
-        const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === initId || r.sessionId === sessionId);
-        const messages = (await client.request("getMessages", undefined, initId));
-        const status = pending.length > 0 ? "等待审批" : loading ? "生成中" : "空闲";
-        console.log(`会话: ${initId}`);
-        console.log(`工作目录: ${init.workingDirectory}`);
-        console.log(`状态: ${status}`);
-        if (pending.length > 0) {
-            console.log("");
-            console.log("待审批请求:");
-            for (const r of pending) {
-                const params = summarizeToolInput(r.context);
-                console.log(`  ${r.requestId}  ${r.context.toolName}${params ? `  ${params}` : ""}`);
-            }
-        }
-        const recent = messages.messages.slice(-lines);
-        if (recent.length > 0) {
-            console.log("");
-            console.log(`最近消息 (${recent.length}):`);
-            for (const m of recent) {
-                const text = getMessageContent(m).replace(/\s+/g, " ").trim();
-                if (!text)
-                    continue; // tool-only messages carry no readable text
-                console.log(`  [${m.role}] ${text}`);
-            }
-        }
-    }
-    catch (err) {
-        fail(`wave daemon status 失败：${err.message}`);
-    }
-    finally {
-        await client?.dispose();
-    }
-    process.exit(0);
-}
-/**
- * Send a message and wait for the reply that corresponds to it.
- *
- * Completion detection: `sendMessage` on an idle session resolves only after
- * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
- * busy session it enqueues and returns immediately — so stopping on a bare
- * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
- * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
- * is the user message added when OUR turn starts (userMessageAdded), and the
- * reply is the last assistantMessageAdded observed after it. A stale
- * loading:false can then never satisfy the wait condition early (the reply has
- * not been added yet).
- */
-export async function daemonSendCommand(socketPath, sessionId, message, options = { timeout: 600 }) {
-    // connectDaemonOrExit exits on failure — no client to dispose in that case.
-    const client = await connectDaemonOrExit(socketPath);
-    let loading = false;
-    let sent = false;
-    let ourUserMessageId;
-    let replyMessageId;
-    client.onNotification("userMessageAdded", (params) => {
-        if (!sent)
-            return; // ignore messages added during attach
-        ourUserMessageId = params.message.id;
-    });
-    client.onNotification("assistantMessageAdded", (params) => {
-        if (!sent || ourUserMessageId === undefined)
-            return; // not our turn yet
-        replyMessageId = params.message.id;
-    });
-    client.onNotification("loadingChange", (params) => {
-        loading = params.loading;
-    });
-    let initId;
-    try {
-        initId = (await attachSession(client, sessionId)).sessionId;
-        sent = true;
-        await client.request("sendMessage", { text: message }, initId);
-    }
-    catch (err) {
-        client.dispose();
-        fail(`wave daemon send 失败：${err.message}`);
-    }
-    // Wait for the reply that corresponds to our message.
-    const started = Date.now();
-    const timeoutMs = options.timeout === 0 ? Infinity : options.timeout * 1000;
-    while (!(loading === false && replyMessageId !== undefined)) {
-        if (Date.now() - started > timeoutMs) {
-            // Timeout backstop: the most likely cause is a session waiting on a
-            // permission approval — point the user at respond (spec: 不无限期挂起).
-            const pending = (await listPendingPermissions(client)).filter((r) => r.sessionId === sessionId || r.sessionId === initId);
-            client.dispose();
-            if (pending.length > 0) {
-                fail(`会话等待权限审批，请通过 \`wave daemon respond ${sessionId} ${pending[0].requestId}\` 处理后重试`);
-            }
-            fail(options.timeout === 0
-                ? "等待回复超时"
-                : `等待回复超时（${options.timeout} 秒），未收到助手回复`);
-        }
-        await sleep(200);
-    }
-    try {
-        const result = (await client.request("getMessages", undefined, initId));
-        const reply = result.messages.find((m) => m.id === replyMessageId);
-        // Pure final-reply text only; streaming deltas / subagent internals never
-        // reach stdout (spec: send 输出纯净性).
-        if (reply) {
-            const content = getMessageContent(reply).replace(/\s+/g, " ").trim();
-            if (content)
-                console.log(content);
-        }
-    }
-    catch (err) {
-        fail(`wave daemon send 失败：${err.message}`);
-    }
-    finally {
-        client.dispose();
-    }
-    process.exit(0);
-}
-export async function daemonRespondCommand(socketPath, sessionId, requestId, options) {
-    if (!!options.allow === !!options.deny) {
-        fail("请指定 --allow 或 --deny（二选一）");
-    }
-    let client;
-    try {
-        client = await connectDaemonOrExit(socketPath);
-        // The server silently ignores permissionResponse for unknown requestIds —
-        // validate first so the user is never misled into thinking approval landed.
-        const pending = await listPendingPermissions(client);
-        const req = pending.find((r) => r.requestId === requestId);
-        if (!req) {
-            fail("该请求不存在或已处理");
-        }
-        if (req.sessionId && req.sessionId !== sessionId) {
-            // Cross-check before notifying; never touch another session's request.
-            fail("会话不存在或未被该 daemon 托管");
-        }
-        let decision;
-        if (options.deny) {
-            decision = { behavior: "deny", message: options.reason };
-        }
-        else {
-            // Per-tool auto-completion, mirroring the desktop ConfirmationDialog
-            // semantics (spec: 决策并非单一 allow/deny，须按工具智能补全).
-            const toolName = req.context.toolName;
-            if (toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-                decision = { behavior: "allow", newPermissionMode: "plan" };
-            }
-            else if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-                decision = { behavior: "allow", newPermissionMode: "default" };
-            }
-            else if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
-                if (!options.answer) {
-                    fail("AskUserQuestion 请求需要 --answer 提供答案 JSON");
-                }
-                let answers;
-                try {
-                    answers = JSON.parse(options.answer);
-                }
-                catch {
-                    fail("--answer 不是合法的 JSON");
-                }
-                decision = { behavior: "allow", message: JSON.stringify(answers) };
-            }
-            else {
-                decision = { behavior: "allow" };
-            }
-            if (options.rule)
-                decision.newPermissionRule = options.rule;
-            if (options.mode) {
-                if (!PERMISSION_MODES.includes(options.mode)) {
-                    fail(`无效的权限模式：${options.mode}（可选：${PERMISSION_MODES.join("、")}）`);
-                }
-                decision.newPermissionMode = options.mode;
-            }
-        }
-        // Mirror desktop stdioAgent.sendPermissionResponse: envelope sessionId
-        // present, decision built from the pending request's tool.
-        client.notify("permissionResponse", { requestId, decision }, sessionId);
-        console.log(`已处理审批请求：${requestId}`);
-    }
-    catch (err) {
-        fail(`wave daemon respond 失败：${err.message}`);
-    }
-    finally {
-        await client?.dispose();
-    }
-    process.exit(0);
-}

package/dist/daemon/jsonRpcClient.d.ts

@@ -1,38 +0,0 @@
-/**
- * JsonRpcClient — minimal JSON-RPC transport over a line-delimited duplex
- * stream (one JSON object per line).
- *
- * Used by `wave daemon` subcommands to talk to the wave daemon's unix socket.
- * Mirrors packages/desktop/src/main/stdio/jsonRpcClient.ts (packages/code
- * cannot import from packages/desktop). Subclasses own the transport and hook
- * in:
- * - `writeLine(message)` writes one JSON line to the peer.
- * - `attachReadable(readable)` wires the inbound half (socket).
- * - `handleClosed(reason)` marks the transport dead and rejects every pending
- *   request. Idempotent — safe to call from both dispose() and an exit/close
- *   event on the underlying transport.
- */
-import type { Readable } from "stream";
-export type NotificationHandler = (params: unknown, sessionId?: string) => void;
-export declare abstract class JsonRpcClient {
-    private nextId;
-    private pending;
-    private handlers;
-    private closedHandlers;
-    private closed;
-    protected abstract writeLine(message: string): void;
-    /** Wire an inbound Readable (socket) to the line parser. */
-    protected attachReadable(readable: Readable): void;
-    /** Mark the transport closed: reject every pending request. Idempotent. */
-    protected handleClosed(reason: string): void;
-    protected get isClosed(): boolean;
-    /** Close the transport and reject pending requests (subclass tears down its stream). */
-    abstract dispose(): void;
-    /** Observe transport teardown (dispose or unexpected close), fired once. */
-    onClosed(handler: () => void): void;
-    request(method: string, params?: unknown, sessionId?: string): Promise<unknown>;
-    notify(method: string, params?: unknown, sessionId?: string): void;
-    onNotification(method: string, handler: NotificationHandler): void;
-    offNotification(method: string, handler: NotificationHandler): void;
-    private handleLine;
-}

package/dist/daemon/jsonRpcClient.js

@@ -1,129 +0,0 @@
-/**
- * JsonRpcClient — minimal JSON-RPC transport over a line-delimited duplex
- * stream (one JSON object per line).
- *
- * Used by `wave daemon` subcommands to talk to the wave daemon's unix socket.
- * Mirrors packages/desktop/src/main/stdio/jsonRpcClient.ts (packages/code
- * cannot import from packages/desktop). Subclasses own the transport and hook
- * in:
- * - `writeLine(message)` writes one JSON line to the peer.
- * - `attachReadable(readable)` wires the inbound half (socket).
- * - `handleClosed(reason)` marks the transport dead and rejects every pending
- *   request. Idempotent — safe to call from both dispose() and an exit/close
- *   event on the underlying transport.
- */
-import { createInterface } from "readline";
-export class JsonRpcClient {
-    constructor() {
-        this.nextId = 1;
-        this.pending = new Map();
-        this.handlers = new Map();
-        this.closedHandlers = [];
-        this.closed = false;
-    }
-    /** Wire an inbound Readable (socket) to the line parser. */
-    attachReadable(readable) {
-        const rl = createInterface({ input: readable });
-        rl.on("line", (line) => this.handleLine(line));
-        // readline re-emits input errors on the Interface; the transport subclass
-        // already handles errors on the underlying stream, swallow them here so
-        // they never surface as an uncaught 'error' on the Interface.
-        rl.on("error", () => { });
-    }
-    /** Mark the transport closed: reject every pending request. Idempotent. */
-    handleClosed(reason) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        const error = new Error(reason);
-        for (const p of this.pending.values())
-            p.reject(error);
-        this.pending.clear();
-        for (const handler of this.closedHandlers)
-            handler();
-        this.closedHandlers = [];
-    }
-    get isClosed() {
-        return this.closed;
-    }
-    /** Observe transport teardown (dispose or unexpected close), fired once. */
-    onClosed(handler) {
-        this.closedHandlers.push(handler);
-    }
-    async request(method, params, sessionId) {
-        if (this.closed) {
-            throw new Error("连接已断开。wave 进程已退出，请重启编辑器或检查 CLI 安装。");
-        }
-        const id = this.nextId++;
-        const envelope = { id, method, params };
-        if (sessionId)
-            envelope.sessionId = sessionId;
-        const message = JSON.stringify(envelope) + "\n";
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.writeLine(message);
-        });
-    }
-    notify(method, params, sessionId) {
-        if (this.closed)
-            return;
-        const envelope = { method, params };
-        if (sessionId)
-            envelope.sessionId = sessionId;
-        this.writeLine(JSON.stringify(envelope) + "\n");
-    }
-    onNotification(method, handler) {
-        let set = this.handlers.get(method);
-        if (!set) {
-            set = new Set();
-            this.handlers.set(method, set);
-        }
-        set.add(handler);
-    }
-    offNotification(method, handler) {
-        this.handlers.get(method)?.delete(handler);
-    }
-    // ── Internal ──────────────────────────────────────────────────
-    handleLine(line) {
-        let msg;
-        try {
-            msg = JSON.parse(line);
-        }
-        catch {
-            console.error("[wave-jsonrpc] Failed to parse:", line);
-            return;
-        }
-        if (typeof msg !== "object" || msg === null)
-            return;
-        const obj = msg;
-        // Response (has id + result/error)
-        if ("id" in obj && ("result" in obj || "error" in obj)) {
-            const id = Number(obj.id);
-            const pending = this.pending.get(id);
-            if (pending) {
-                this.pending.delete(id);
-                if (obj.error) {
-                    const err = obj.error;
-                    pending.reject(new Error(err.message));
-                }
-                else {
-                    pending.resolve(obj.result);
-                }
-            }
-            return;
-        }
-        // Notification (has method, no id)
-        if ("method" in obj && !("id" in obj)) {
-            const method = obj.method;
-            const params = obj.params;
-            const sessionId = typeof obj.sessionId === "string" ? obj.sessionId : undefined;
-            const set = this.handlers.get(method);
-            if (set) {
-                for (const handler of set) {
-                    handler(params, sessionId);
-                }
-            }
-            return;
-        }
-    }
-}

package/dist/daemon/socketClient.d.ts

@@ -1,13 +0,0 @@
-/**
- * SocketClient — JSON-RPC transport over a unix socket connection to the wave
- * daemon. Mirrors packages/desktop/src/main/stdio/socketClient.ts (packages/code
- * cannot import from packages/desktop).
- */
-import type { Socket } from "net";
-import { JsonRpcClient } from "./jsonRpcClient.js";
-export declare class SocketClient extends JsonRpcClient {
-    private socket;
-    constructor(socket: Socket);
-    protected writeLine(message: string): void;
-    dispose(): void;
-}

package/dist/daemon/socketClient.js

@@ -1,26 +0,0 @@
-/**
- * SocketClient — JSON-RPC transport over a unix socket connection to the wave
- * daemon. Mirrors packages/desktop/src/main/stdio/socketClient.ts (packages/code
- * cannot import from packages/desktop).
- */
-import { JsonRpcClient } from "./jsonRpcClient.js";
-export class SocketClient extends JsonRpcClient {
-    constructor(socket) {
-        super();
-        this.socket = socket;
-        this.attachReadable(socket);
-        socket.on("close", () => {
-            this.handleClosed("远端连接已断开。");
-        });
-        socket.on("error", (err) => {
-            console.error("[wave-daemon] Socket error:", err.message);
-        });
-    }
-    writeLine(message) {
-        this.socket.write(message);
-    }
-    dispose() {
-        this.handleClosed("远端连接已断开。");
-        this.socket.destroy();
-    }
-}

package/dist/daemon-cli.d.ts

@@ -1,10 +0,0 @@
-/**
- * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
- *
- * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
- * app launches this on a remote host via nohup/setsid and tunnels the socket
- * back with `ssh -L`; multiple attach/detach cycles share one process, so
- * sessions and pending permissions survive client disconnects. The net server
- * keeps the process alive — there is no stdin to wait on.
- */
-export declare function startDaemonCli(socketPath: string): Promise<void>;

package/dist/daemon-cli.js

@@ -1,15 +0,0 @@
-/**
- * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
- *
- * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
- * app launches this on a remote host via nohup/setsid and tunnels the socket
- * back with `ssh -L`; multiple attach/detach cycles share one process, so
- * sessions and pending permissions survive client disconnects. The net server
- * keeps the process alive — there is no stdin to wait on.
- */
-import { DaemonServer } from "./stdio/daemonServer.js";
-export async function startDaemonCli(socketPath) {
-    const server = new DaemonServer({ socketPath });
-    await server.start();
-    // Ready — any error that follows goes to the daemon log via stderr.
-}