wave-code 1.0.10 → 1.1.1

package/dist/stdio/daemonServer.d.ts

@@ -1,67 +0,0 @@
-/**
- * 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 { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
-export interface DaemonServerOptions {
-    socketPath: string;
-    bridgeOptions?: AgentBridgeOptions;
-    /** Idle grace period before the daemon auto-exits (default 60s). */
-    graceMs?: number;
-}
-export declare class DaemonServer {
-    static readonly DEFAULT_IDLE_GRACE_MS = 60000;
-    private socketPath;
-    private server;
-    private bridge;
-    private connections;
-    private sockets;
-    private graceMs;
-    private idleTimer;
-    private shuttingDown;
-    private stopped;
-    constructor(options: DaemonServerOptions);
-    get agentBridge(): AgentBridge;
-    /**
-     * 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(): Promise<void>;
-    private listen;
-    stop(): Promise<void>;
-    private clearIdleTimer;
-    /**
-     * 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.
-     */
-    private evaluateIdle;
-    /**
-     * 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.
-     */
-    private shutdown;
-}

package/dist/stdio/daemonServer.js

@@ -1,191 +0,0 @@
-/**
- * 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,5 +0,0 @@
-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,5 +0,0 @@
-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

@@ -1,39 +0,0 @@
-/**
- * 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 interface JsonRpcConnectionOptions {
-    /** Called when the input stream reaches EOF (parent closed the pipe). Only
-     * stdio mode passes it — it must exit the process when its client dies;
-     * daemon mode never passes it (a detached client must not kill the daemon,
-     * see daemonServer.ts). */
-    onClose?: () => void;
-}
-export declare class JsonRpcConnection {
-    private input;
-    private output;
-    private bridge;
-    private rl;
-    private started;
-    private stoppedByOwner;
-    private onClose?;
-    constructor(input: Readable, output: Writable, bridge: AgentBridge, options?: JsonRpcConnectionOptions);
-    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

@@ -1,135 +0,0 @@
-/**
- * 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, options = {}) {
-        this.input = input;
-        this.output = output;
-        this.bridge = bridge;
-        this.started = false;
-        this.stoppedByOwner = false;
-        this.onClose = options.onClose;
-    }
-    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;
-            // stdin EOF from the owning client — not a deliberate stop(). stdio
-            // mode reacts by exiting the process (its parent is gone); daemon mode
-            // has no onClose so a detached client reset never kills the daemon.
-            if (!this.stoppedByOwner)
-                this.onClose?.();
-        });
-    }
-    stop() {
-        this.stoppedByOwner = true;
-        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

@@ -1,41 +0,0 @@
-/**
- * JSON-RPC 2.0-compatible protocol types for stdio communication.
- *
- * Each line on stdin/stdout is one JSON object.
- * - Requests have `id` (number|string) and expect a response.
- * - Responses match the request `id` with either `result` or `error`.
- * - Notifications have no `id` and expect no response.
- */
-export interface JsonRpcRequest {
-    id: number | string;
-    method: string;
-    params?: unknown;
-    /** Session-scoped requests carry sessionId for routing to the right Agent. */
-    sessionId?: string;
-}
-export interface JsonRpcResponse {
-    id: number | string | null;
-    result?: unknown;
-    error?: JsonRpcError;
-}
-export interface JsonRpcError {
-    code: number;
-    message: string;
-    data?: unknown;
-}
-export interface JsonRpcNotification {
-    method: string;
-    params?: unknown;
-    /** Session-scoped notifications carry sessionId for demultiplexing on the client. */
-    sessionId?: string;
-}
-export declare const PARSE_ERROR = -32700;
-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" | "askBtw" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "writeArtifactFile" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getConfiguredModels" | "setModel" | "listPendingPermissions" | "listDaemonSessions" | "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 = "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/protocol.js

@@ -1,26 +0,0 @@
-/**
- * JSON-RPC 2.0-compatible protocol types for stdio communication.
- *
- * Each line on stdin/stdout is one JSON object.
- * - Requests have `id` (number|string) and expect a response.
- * - Responses match the request `id` with either `result` or `error`.
- * - Notifications have no `id` and expect no response.
- */
-// ── Error codes (JSON-RPC 2.0 standard) ────────────────────────
-export const PARSE_ERROR = -32700;
-export const INVALID_REQUEST = -32600;
-export const METHOD_NOT_FOUND = -32601;
-export const INVALID_PARAMS = -32602;
-export const INTERNAL_ERROR = -32603;
-// ── Helper: is this a request (has id)? ─────────────────────────
-export function isRequest(msg) {
-    return (typeof msg === "object" &&
-        msg !== null &&
-        "method" in msg &&
-        "id" in msg &&
-        (typeof msg.id === "number" ||
-            typeof msg.id === "string"));
-}
-export function isNotification(msg) {
-    return (typeof msg === "object" && msg !== null && "method" in msg && !("id" in msg));
-}

package/dist/stdio/stdioServer.d.ts

@@ -1,36 +0,0 @@
-/**
- * StdioServer — reads JSON-RPC messages from stdin, dispatches to AgentBridge,
- * 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";
-export interface StdioServerOptions {
-    input?: Readable;
-    output?: Writable;
-    bridgeOptions?: AgentBridgeOptions;
-}
-export declare class StdioServer {
-    private bridge;
-    private conn;
-    constructor(options?: StdioServerOptions);
-    get agentBridge(): AgentBridge;
-    start(): void;
-    stop(): void;
-    /**
-     * The owning client closed stdin (EOF) — it's gone, so this process must
-     * follow it. destroyAll() saves each session's transcript and drains
-     * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
-     * exit. This is the real-world "parent died" path: without it the process
-     * lingers forever whenever an agent keeps event-loop handles alive.
-     */
-    private onConnectionClosed;
-    handleLine(line: string): Promise<void>;
-    sendResponse(id: number | string | null, result?: unknown, error?: {
-        code: number;
-        message: string;
-    }): void;
-    sendNotification(method: string, params?: unknown, sessionId?: string): void;
-}

package/dist/stdio/stdioServer.js

@@ -1,51 +0,0 @@
-/**
- * StdioServer — reads JSON-RPC messages from stdin, dispatches to AgentBridge,
- * 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 { AgentBridge } from "./agentBridge.js";
-import { JsonRpcConnection } from "./jsonRpcConnection.js";
-export class StdioServer {
-    constructor(options = {}) {
-        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, { onClose: () => this.onConnectionClosed() });
-    }
-    get agentBridge() {
-        return this.bridge;
-    }
-    start() {
-        this.conn.start();
-    }
-    stop() {
-        this.conn.stop();
-    }
-    /**
-     * The owning client closed stdin (EOF) — it's gone, so this process must
-     * follow it. destroyAll() saves each session's transcript and drains
-     * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
-     * exit. This is the real-world "parent died" path: without it the process
-     * lingers forever whenever an agent keeps event-loop handles alive.
-     */
-    async onConnectionClosed() {
-        const SHUTDOWN_TIMEOUT_MS = 5000;
-        await Promise.race([
-            this.bridge.destroyAll(),
-            new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
-        ]);
-        process.exit(0);
-    }
-    handleLine(line) {
-        return this.conn.handleLine(line);
-    }
-    sendResponse(id, result, error) {
-        this.conn.sendResponse(id, result, error);
-    }
-    sendNotification(method, params, sessionId) {
-        this.conn.sendNotification(method, params, sessionId);
-    }
-}

package/dist/stdio-cli.d.ts

@@ -1,8 +0,0 @@
-/**
- * stdio-cli.ts — Entry point for `wave --stdio` mode.
- *
- * Starts a StdioServer that reads JSON-RPC messages from stdin and writes
- * responses/notifications to stdout. The server creates an Agent lazily when
- * the client sends an "initialize" request.
- */
-export declare function startStdioCli(): Promise<void>;

package/dist/stdio-cli.js

@@ -1,15 +0,0 @@
-/**
- * stdio-cli.ts — Entry point for `wave --stdio` mode.
- *
- * Starts a StdioServer that reads JSON-RPC messages from stdin and writes
- * responses/notifications to stdout. The server creates an Agent lazily when
- * the client sends an "initialize" request.
- */
-import { StdioServer } from "./stdio/stdioServer.js";
-export async function startStdioCli() {
-    const server = new StdioServer();
-    server.start();
-    // Keep the process alive — readline on stdin handles the event loop.
-    // When stdin closes (EOF), the readline interface emits 'close' and
-    // the process will exit naturally.
-}

package/dist/types.d.ts

@@ -1,20 +0,0 @@
-import { WorktreeSession } from "./utils/worktree.js";
-import { PermissionMode, McpServerConfig } from "wave-agent-sdk";
-export interface BaseAppProps {
-    bypassPermissions?: boolean;
-    permissionMode?: PermissionMode;
-    pluginDirs?: string[];
-    /** Additional directories to add to the session Safe Zone (from --add-dir). */
-    additionalDirectories?: string[];
-    tools?: string[];
-    allowedTools?: string[];
-    disallowedTools?: string[];
-    worktreeSession?: WorktreeSession;
-    workdir?: string;
-    /** The working directory before entering a worktree (CLI -w); injected into the agent's container. */
-    originalCwd?: string;
-    version?: string;
-    model?: string;
-    /** Optional MCP server configs to pass to Agent.create() */
-    mcpServers?: Record<string, McpServerConfig>;
-}

package/dist/types.js

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