wave-code 1.0.0 → 1.0.1

package/dist/stdio/daemonServer.js

@@ -0,0 +1,191 @@
+/**
+ * DaemonServer — JSON-RPC server over a unix socket for remote background
+ * sessions (spec: docs/specs/ui/desktop-app.md 「SSH 远程后台会话」).
+ *
+ * The desktop app launches `wave --daemon <socket>` on the remote host via
+ * nohup/setsid, then tunnels the socket back with `ssh -L`. All connections
+ * share one AgentBridge, so sessions and pending tool permissions survive
+ * client detach/attach — the daemon keeps running (and generating) while no
+ * desktop is connected. The daemon never exits on a client disconnect; it
+ * only exits when killed (app quit / 删除会话 / remote reboot).
+ *
+ * Idle auto-exit (spec: 「远程 daemon 空闲自动退出」): once every session has
+ * settled and no client is connected, the daemon mirrors `wave -p`'s exit
+ * semantics — after a grace period it destroys the sessions (saving their
+ * transcripts), closes the socket, and exits, so the remote process doesn't
+ * linger forever after background work completes.
+ */
+import net from "net";
+import * as fs from "fs";
+import { AgentBridge } from "./agentBridge.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
+export class DaemonServer {
+    constructor(options) {
+        this.connections = new Set();
+        this.sockets = new Set();
+        this.shuttingDown = false;
+        this.stopped = false;
+        this.socketPath = options.socketPath;
+        this.graceMs = options.graceMs ?? DaemonServer.DEFAULT_IDLE_GRACE_MS;
+        this.bridge = new AgentBridge({
+            ...options.bridgeOptions,
+            // Notifications go to every attached client; a fully detached daemon
+            // has none, and the write is dropped silently (the attach snapshot
+            // re-syncs state on reconnect).
+            emit: (method, params, sessionId) => {
+                for (const conn of this.connections) {
+                    conn.sendNotification(method, params, sessionId);
+                }
+                // Any session activity can change the idle state — re-evaluate.
+                this.evaluateIdle();
+            },
+        });
+        this.server = net.createServer((socket) => {
+            if (this.shuttingDown) {
+                socket.destroy();
+                return;
+            }
+            const conn = new JsonRpcConnection(socket, socket, this.bridge);
+            this.connections.add(conn);
+            this.sockets.add(socket);
+            // A (re)attached client cancels a pending idle exit.
+            this.evaluateIdle();
+            socket.on("error", () => {
+                // The client (ssh tunnel) can reset the socket mid-detach; the daemon
+                // must keep running — 'close' below cleans up the connection.
+            });
+            socket.on("close", () => {
+                this.connections.delete(conn);
+                this.sockets.delete(socket);
+                // A client detach may leave the daemon idle — re-evaluate.
+                this.evaluateIdle();
+            });
+            conn.start();
+        });
+    }
+    get agentBridge() {
+        return this.bridge;
+    }
+    /**
+     * Listen on the socket path. Rejects when a live daemon already holds it. A
+     * stale socket file left by a crashed daemon would otherwise block the
+     * restart with EADDRINUSE, so it is cleaned up first: non-socket files are
+     * unlinked outright; socket files are probe-connected — ECONNREFUSED means
+     * no listener (stale → unlink and listen), anything else means a live
+     * daemon owns the path (reject).
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            const server = this.server;
+            if (!server)
+                return resolve();
+            try {
+                const st = fs.statSync(this.socketPath);
+                if (st.isSocket()) {
+                    const probe = net.connect(this.socketPath);
+                    probe.once("connect", () => {
+                        probe.destroy();
+                        reject(new Error(`另一个 wave daemon 已在 ${this.socketPath} 监听`));
+                    });
+                    probe.once("error", (err) => {
+                        probe.destroy();
+                        if (err.code === "ECONNREFUSED") {
+                            fs.unlinkSync(this.socketPath);
+                            this.listen(server, resolve, reject);
+                        }
+                        else {
+                            reject(err);
+                        }
+                    });
+                    return;
+                }
+                fs.unlinkSync(this.socketPath);
+            }
+            catch {
+                // ENOENT — no stale socket, listen directly.
+            }
+            this.listen(server, resolve, reject);
+        });
+    }
+    listen(server, resolve, reject) {
+        server.once("error", reject);
+        server.listen(this.socketPath, () => {
+            server.removeListener("error", reject);
+            resolve();
+            // A freshly started daemon may already be idle (no sessions) — start the
+            // idle watch so a zero-session daemon also auto-exits.
+            this.evaluateIdle();
+        });
+    }
+    stop() {
+        this.stopped = true;
+        this.clearIdleTimer();
+        return new Promise((resolve) => {
+            const server = this.server;
+            if (!server)
+                return resolve();
+            this.server = undefined;
+            server.close(() => resolve());
+        });
+    }
+    // ── Idle auto-exit ────────────────────────────────────────────
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = undefined;
+        }
+    }
+    /**
+     * Re-evaluate the idle condition after any state transition: sessions busy
+     * (loading / pending messages / background work) or any client attached →
+     * cancel the timer. Fully idle + detached → arm the grace timer once; when
+     * it fires, shut the daemon down. Evaluation is event-driven (every
+     * busy→idle transition emits a notification, every attach/detach fires a
+     * connection event), so nothing is polled. The failure mode is
+     * conservative: a missed transition just leaves the daemon running.
+     */
+    evaluateIdle() {
+        // A stopped/shutting-down daemon never (re)arms the idle timer — late
+        // socket 'close' events (which fire after server.close resolves) must not
+        // resurrect a timer after stop().
+        if (this.shuttingDown || this.stopped)
+            return;
+        if (this.connections.size > 0 || !this.bridge.isIdle()) {
+            this.clearIdleTimer();
+            return;
+        }
+        if (this.idleTimer)
+            return;
+        this.idleTimer = setTimeout(() => {
+            this.idleTimer = undefined;
+            void this.shutdown();
+        }, this.graceMs);
+    }
+    /**
+     * Destroy the sessions (each agent saves its transcript and drains
+     * auto-memory), close the listener, unlink the socket file, then exit.
+     * `shuttingDown` guards against re-entry: new connections are refused and
+     * further idle evaluations become no-ops.
+     */
+    async shutdown() {
+        if (this.shuttingDown)
+            return;
+        this.shuttingDown = true;
+        this.clearIdleTimer();
+        // Destroy client sockets first so server.close() can complete (an open
+        // socket keeps the close callback pending).
+        for (const socket of this.sockets)
+            socket.destroy();
+        this.sockets.clear();
+        await this.bridge.destroyAll();
+        await this.stop();
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch {
+            // Already gone — a stale file would be probed/unlinked on next start.
+        }
+        process.exit(0);
+    }
+}
+DaemonServer.DEFAULT_IDLE_GRACE_MS = 60000;

package/dist/stdio/index.d.ts

@@ -1,3 +1,5 @@
 export { StdioServer, type StdioServerOptions } from "./stdioServer.js";
+export { JsonRpcConnection } from "./jsonRpcConnection.js";
+export { DaemonServer, type DaemonServerOptions } from "./daemonServer.js";
 export { AgentBridge, type AgentBridgeOptions, RpcError, } from "./agentBridge.js";
 export * from "./protocol.js";

package/dist/stdio/index.js

@@ -1,3 +1,5 @@
 export { StdioServer } from "./stdioServer.js";
+export { JsonRpcConnection } from "./jsonRpcConnection.js";
+export { DaemonServer } from "./daemonServer.js";
 export { AgentBridge, RpcError, } from "./agentBridge.js";
 export * from "./protocol.js";

package/dist/stdio/jsonRpcConnection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * JsonRpcConnection — one JSON-RPC connection over a Readable/Writable pair,
+ * dispatching to a shared AgentBridge.
+ *
+ * Shared by StdioServer (process stdin/stdout) and DaemonServer (each unix
+ * socket connection). The AgentBridge owns all session/agent state, so any
+ * number of connections can share it — a detached client loses nothing and
+ * every session keeps running on the daemon side.
+ */
+import type { Readable, Writable } from "stream";
+import { AgentBridge } from "./agentBridge.js";
+export declare class JsonRpcConnection {
+    private input;
+    private output;
+    private bridge;
+    private rl;
+    private started;
+    constructor(input: Readable, output: Writable, bridge: AgentBridge);
+    start(): void;
+    stop(): void;
+    handleLine(line: string): Promise<void>;
+    private handleRequest;
+    private handleNotification;
+    sendResponse(id: number | string | null, result?: unknown, error?: {
+        code: number;
+        message: string;
+    }): void;
+    sendNotification(method: string, params?: unknown, sessionId?: string): void;
+    private write;
+}

package/dist/stdio/jsonRpcConnection.js

@@ -0,0 +1,127 @@
+/**
+ * JsonRpcConnection — one JSON-RPC connection over a Readable/Writable pair,
+ * dispatching to a shared AgentBridge.
+ *
+ * Shared by StdioServer (process stdin/stdout) and DaemonServer (each unix
+ * socket connection). The AgentBridge owns all session/agent state, so any
+ * number of connections can share it — a detached client loses nothing and
+ * every session keeps running on the daemon side.
+ */
+import readline from "readline";
+import { PARSE_ERROR, INVALID_REQUEST, INTERNAL_ERROR, isRequest, isNotification, } from "./protocol.js";
+export class JsonRpcConnection {
+    constructor(input, output, bridge) {
+        this.input = input;
+        this.output = output;
+        this.bridge = bridge;
+        this.started = false;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.rl = readline.createInterface({
+            input: this.input,
+            crlfDelay: Infinity,
+        });
+        // readline re-emits input errors on the Interface; error handling on the
+        // underlying stream is the owner's job (the daemon keeps running on a
+        // client reset), so swallow them here.
+        this.rl.on("error", () => { });
+        this.rl.on("line", (line) => {
+            this.handleLine(line).catch((err) => {
+                // Should never reach here — handleLine catches internally
+                this.sendResponse(null, undefined, {
+                    code: INTERNAL_ERROR,
+                    message: `Unhandled error: ${err.message}`,
+                });
+            });
+        });
+        this.rl.on("close", () => {
+            this.started = false;
+        });
+    }
+    stop() {
+        this.rl?.close();
+        this.rl = undefined;
+        this.started = false;
+    }
+    async handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            this.sendResponse(null, undefined, {
+                code: PARSE_ERROR,
+                message: "Parse error: invalid JSON",
+            });
+            return;
+        }
+        if (isRequest(msg)) {
+            await this.handleRequest(msg);
+        }
+        else if (isNotification(msg)) {
+            this.handleNotification(msg);
+        }
+        else {
+            // Echo back the id if the message has one, otherwise null
+            const id = typeof msg === "object" &&
+                msg !== null &&
+                "id" in msg &&
+                (typeof msg.id === "number" ||
+                    typeof msg.id === "string")
+                ? msg.id
+                : null;
+            this.sendResponse(id, undefined, {
+                code: INVALID_REQUEST,
+                message: "Invalid request: must have 'method' field",
+            });
+        }
+    }
+    async handleRequest(msg) {
+        try {
+            const result = await this.bridge.handleRequest(msg.method, msg.params, msg.sessionId);
+            this.sendResponse(msg.id, result);
+        }
+        catch (err) {
+            const code = err && typeof err === "object" && "code" in err
+                ? err.code
+                : INTERNAL_ERROR;
+            const message = err instanceof Error ? err.message : String(err);
+            this.sendResponse(msg.id, undefined, { code, message });
+        }
+    }
+    handleNotification(msg) {
+        try {
+            this.bridge.handleNotification(msg.method, msg.params);
+        }
+        catch (err) {
+            // Notifications don't get responses, but we log to stderr
+            process.stderr.write(`Error handling notification ${msg.method}: ${err.message}\n`);
+        }
+    }
+    // ── Output helpers ────────────────────────────────────────────
+    sendResponse(id, result, error) {
+        const response = { id };
+        if (error) {
+            response.error = error;
+        }
+        else {
+            response.result = result ?? null;
+        }
+        this.write(response);
+    }
+    sendNotification(method, params, sessionId) {
+        const notification = { method, params };
+        if (sessionId)
+            notification.sessionId = sessionId;
+        this.write(notification);
+    }
+    write(obj) {
+        this.output.write(JSON.stringify(obj) + "\n");
+    }
+}

package/dist/stdio/protocol.d.ts

@@ -34,8 +34,8 @@ export declare const INVALID_REQUEST = -32600;
 export declare const METHOD_NOT_FOUND = -32601;
 export declare const INVALID_PARAMS = -32602;
 export declare const INTERNAL_ERROR = -32603;
-export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun" | "listGitBranches" | "createWorktree" | "removeWorktree";
+export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "askBtw" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "listPendingPermissions" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun" | "listGitBranches" | "createWorktree" | "removeWorktree";
 export type ClientNotificationMethod = "permissionResponse";
-export type ServerNotificationMethod = "messagesChange" | "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "workdirChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl" | "compactBlockAdded" | "compactionStateChange" | "backgroundTasksChange";
+export type ServerNotificationMethod = "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "workdirChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl" | "compactBlockAdded" | "compactionStateChange" | "backgroundTasksChange" | "btwContent";
 export declare function isRequest(msg: unknown): msg is JsonRpcRequest;
 export declare function isNotification(msg: unknown): msg is JsonRpcNotification;

package/dist/stdio/stdioServer.d.ts

@@ -3,6 +3,7 @@
  * and writes responses / notifications to stdout.
  *
  * One JSON object per line. stderr is reserved for logger output.
+ * Line handling lives in JsonRpcConnection (shared with DaemonServer).
  */
 import type { Readable, Writable } from "stream";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
@@ -12,22 +13,16 @@ export interface StdioServerOptions {
     bridgeOptions?: AgentBridgeOptions;
 }
 export declare class StdioServer {
-    private rl;
     private bridge;
-    private input;
-    private output;
-    private started;
+    private conn;
     constructor(options?: StdioServerOptions);
     get agentBridge(): AgentBridge;
     start(): void;
     stop(): void;
     handleLine(line: string): Promise<void>;
-    private handleRequest;
-    private handleNotification;
     sendResponse(id: number | string | null, result?: unknown, error?: {
         code: number;
         message: string;
     }): void;
     sendNotification(method: string, params?: unknown, sessionId?: string): void;
-    private write;
 }

package/dist/stdio/stdioServer.js

@@ -3,125 +3,34 @@
  * and writes responses / notifications to stdout.
  *
  * One JSON object per line. stderr is reserved for logger output.
+ * Line handling lives in JsonRpcConnection (shared with DaemonServer).
  */
-import readline from "readline";
 import { AgentBridge } from "./agentBridge.js";
-import { PARSE_ERROR, INVALID_REQUEST, INTERNAL_ERROR, isRequest, isNotification, } from "./protocol.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
 export class StdioServer {
     constructor(options = {}) {
-        this.started = false;
-        this.input = options.input ?? process.stdin;
-        this.output = options.output ?? process.stdout;
         this.bridge = new AgentBridge({
             ...options.bridgeOptions,
             emit: (method, params, sessionId) => this.sendNotification(method, params, sessionId),
         });
+        this.conn = new JsonRpcConnection(options.input ?? process.stdin, options.output ?? process.stdout, this.bridge);
     }
     get agentBridge() {
         return this.bridge;
     }
     start() {
-        if (this.started)
-            return;
-        this.started = true;
-        this.rl = readline.createInterface({
-            input: this.input,
-            crlfDelay: Infinity,
-        });
-        this.rl.on("line", (line) => {
-            this.handleLine(line).catch((err) => {
-                // Should never reach here — handleLine catches internally
-                this.sendResponse(null, undefined, {
-                    code: INTERNAL_ERROR,
-                    message: `Unhandled error: ${err.message}`,
-                });
-            });
-        });
-        this.rl.on("close", () => {
-            this.started = false;
-        });
+        this.conn.start();
     }
     stop() {
-        this.rl?.close();
-        this.rl = undefined;
-        this.started = false;
+        this.conn.stop();
     }
-    async handleLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return;
-        let msg;
-        try {
-            msg = JSON.parse(trimmed);
-        }
-        catch {
-            this.sendResponse(null, undefined, {
-                code: PARSE_ERROR,
-                message: "Parse error: invalid JSON",
-            });
-            return;
-        }
-        if (isRequest(msg)) {
-            await this.handleRequest(msg);
-        }
-        else if (isNotification(msg)) {
-            this.handleNotification(msg);
-        }
-        else {
-            // Echo back the id if the message has one, otherwise null
-            const id = typeof msg === "object" &&
-                msg !== null &&
-                "id" in msg &&
-                (typeof msg.id === "number" ||
-                    typeof msg.id === "string")
-                ? msg.id
-                : null;
-            this.sendResponse(id, undefined, {
-                code: INVALID_REQUEST,
-                message: "Invalid request: must have 'method' field",
-            });
-        }
+    handleLine(line) {
+        return this.conn.handleLine(line);
     }
-    async handleRequest(msg) {
-        try {
-            const result = await this.bridge.handleRequest(msg.method, msg.params, msg.sessionId);
-            this.sendResponse(msg.id, result);
-        }
-        catch (err) {
-            const code = err && typeof err === "object" && "code" in err
-                ? err.code
-                : INTERNAL_ERROR;
-            const message = err instanceof Error ? err.message : String(err);
-            this.sendResponse(msg.id, undefined, { code, message });
-        }
-    }
-    handleNotification(msg) {
-        try {
-            this.bridge.handleNotification(msg.method, msg.params);
-        }
-        catch (err) {
-            // Notifications don't get responses, but we log to stderr
-            process.stderr.write(`Error handling notification ${msg.method}: ${err.message}\n`);
-        }
-    }
-    // ── Output helpers ────────────────────────────────────────────
     sendResponse(id, result, error) {
-        const response = { id };
-        if (error) {
-            response.error = error;
-        }
-        else {
-            response.result = result ?? null;
-        }
-        this.write(response);
+        this.conn.sendResponse(id, result, error);
     }
     sendNotification(method, params, sessionId) {
-        const notification = { method, params };
-        if (sessionId)
-            notification.sessionId = sessionId;
-        this.write(notification);
-    }
-    write(obj) {
-        this.output.write(JSON.stringify(obj) + "\n");
+        this.conn.sendNotification(method, params, sessionId);
     }
 }

package/dist/utils/bracketedPaste.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bracketed paste (DECSET 2004) detector.
+ *
+ * When bracketed paste is enabled, terminals wrap pasted text in
+ * `\x1b[200~` (start) and `\x1b[201~` (end) markers, which lets the input
+ * pipeline distinguish "text was pasted" from "user typed keys" — most
+ * importantly, a pasted trailing `\r` must NOT be treated as an Enter key.
+ *
+ * ink delivers each stdin chunk through useInput after stripping ONE leading
+ * ESC from the parsed sequence (see use-input.js), so markers may arrive in
+ * either the raw form (`\x1b[200~`) or the stripped form (`[200~`), and may
+ * be split across chunks. The detector normalizes both forms and buffers
+ * partial markers until they complete (deferral is safe: a deferred partial
+ * is flushed unchanged if the next chunk does not complete a marker).
+ */
+export type PasteProcessResult = {
+    kind: "input";
+    input: string;
+} | {
+    kind: "paste";
+    text: string;
+    leadingInput?: string;
+} | {
+    kind: "consume";
+};
+export interface BracketedPasteDetector {
+    /**
+     * Feed one input chunk (as delivered by ink's useInput callback).
+     * - `input`: regular keystrokes, pass through to normal handling.
+     * - `paste`: completed bracketed paste; insert `text` without submitting.
+     *   `leadingInput` (rare) is content that preceded the start marker in the
+     *   same chunk and should be handled as regular input first.
+     * - `consume`: content of an in-flight paste (or an empty paste); do
+     *   nothing with this chunk.
+     */
+    process(chunk: string): PasteProcessResult;
+    reset(): void;
+}
+export declare function createBracketedPasteDetector(): BracketedPasteDetector;