@co0ontty/wand 4.57.0 → 4.58.0

package/dist/structured-exec-host.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
 /**
  * Ownership seam for structured CLI runs, mirroring TerminalHost for PTYs.
  * Persistent adapters (terminald) outlive web restarts; the in-process adapter
@@ -7,6 +8,26 @@ import { randomUUID } from "node:crypto";
  */
 /** Per-stream replay log cap inside the daemon. Reducers need full history. */
 export const STRUCTURED_RUN_LOG_MAX_CHARS = 8 * 1024 * 1024;
+export function createUtf8TextDecoder() {
+    const decoder = new StringDecoder("utf8");
+    let ended = false;
+    return {
+        write(chunk) {
+            if (ended)
+                return "";
+            if (typeof chunk === "string")
+                return chunk;
+            return decoder.write(chunk);
+        },
+        end() {
+            if (ended)
+                return "";
+            ended = true;
+            decoder.end();
+            return "";
+        },
+    };
+}
 /** Resolve a stable daemon-side key for a session's active structured run. */
 export function structuredRunId(sessionId) {
     return `structured:${sessionId}`;
@@ -17,9 +38,46 @@ class InProcessStructuredExecProcess {
     incarnationId = randomUUID();
     stdoutSeq = 0;
     stderrSeq = 0;
+    stdoutDecoder = createUtf8TextDecoder();
+    stderrDecoder = createUtf8TextDecoder();
+    streamEvents = [];
+    streamListeners = new Set();
+    exitListeners = new Set();
+    exitEvent = null;
     constructor(runId, child) {
         this.runId = runId;
         this.child = child;
+        const emit = (stream, data) => {
+            if (!data)
+                return;
+            const event = {
+                stream,
+                data,
+                seq: stream === "stdout" ? ++this.stdoutSeq : ++this.stderrSeq,
+            };
+            this.streamEvents.push(event);
+            for (const listener of this.streamListeners)
+                listener(event);
+        };
+        this.child.stdout?.on("data", (chunk) => emit("stdout", this.stdoutDecoder.write(chunk)));
+        this.child.stderr?.on("data", (chunk) => emit("stderr", this.stderrDecoder.write(chunk)));
+        const settleExit = (event) => {
+            if (this.exitEvent)
+                return;
+            // Flush pending bytes before announcing exit; decoders no-op once ended.
+            emit("stdout", this.stdoutDecoder.end());
+            emit("stderr", this.stderrDecoder.end());
+            this.exitEvent = event;
+            for (const listener of this.exitListeners)
+                listener(event);
+        };
+        this.child.on("close", (code, signal) => {
+            settleExit({
+                exitCode: code,
+                signal: signal === null || signal === undefined ? null : osSignalNumber(signal),
+            });
+        });
+        this.child.on("error", () => settleExit({ exitCode: null, signal: null }));
     }
     get pid() {
         return this.child.pid ?? -1;
@@ -31,39 +89,18 @@ class InProcessStructuredExecProcess {
         catch { /* best-effort */ }
     }
     onStream(listener) {
-        const stdoutHandler = (chunk) => listener({ stream: "stdout", data: chunk.toString(), seq: ++this.stdoutSeq });
-        const stderrHandler = (chunk) => listener({ stream: "stderr", data: chunk.toString(), seq: ++this.stderrSeq });
-        this.child.stdout?.on("data", stdoutHandler);
-        this.child.stderr?.on("data", stderrHandler);
-        return {
-            dispose: () => {
-                this.child.stdout?.off("data", stdoutHandler);
-                this.child.stderr?.off("data", stderrHandler);
-            },
-        };
+        for (const event of this.streamEvents)
+            listener(event);
+        this.streamListeners.add(listener);
+        return { dispose: () => { this.streamListeners.delete(listener); } };
     }
     onExit(listener) {
-        let settled = false;
-        const closeHandler = (code, signal) => {
-            if (settled)
-                return;
-            settled = true;
-            listener({ exitCode: code, signal: signal === null || signal === undefined ? null : osSignalNumber(signal) });
-        };
-        const errorHandler = () => {
-            if (settled)
-                return;
-            settled = true;
-            listener({ exitCode: null, signal: null });
-        };
-        this.child.on("close", closeHandler);
-        this.child.on("error", errorHandler);
-        return {
-            dispose: () => {
-                this.child.off("close", closeHandler);
-                this.child.off("error", errorHandler);
-            },
-        };
+        if (this.exitEvent) {
+            listener(this.exitEvent);
+            return { dispose: () => { } };
+        }
+        this.exitListeners.add(listener);
+        return { dispose: () => { this.exitListeners.delete(listener); } };
     }
 }
 /** Legacy/local adapter and deterministic test adapter for the structured seam. */
@@ -83,16 +120,14 @@ export class InProcessStructuredExecHost {
         if (wantsStdin)
             child.stdin?.end(request.stdinData);
         const wrapped = new InProcessStructuredExecProcess(request.runId, child);
+        // Keep exited records until forgetRun so a late attach can still answer.
         this.processes.set(request.runId, wrapped);
-        wrapped.onExit(() => {
-            // Keep exited records until forgetRun so attachRun can still answer.
-        });
         return wrapped;
     }
-    async attachRun() {
+    async attachRun(_runId) {
         return null;
     }
-    async adoptRun() {
+    async adoptRun(_runId) {
         return null;
     }
     async listRuns() {

package/dist/structured-exec-pump.d.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import type { StructuredExecHost } from "./structured-exec-host.js";
+import { type StructuredExecHost } from "./structured-exec-host.js";
 import type { StructuredRunnerExecution, StructuredRunnerObserver, StructuredRunnerResult, StructuredRunnerTurnState } from "./structured-runner.js";
 /**
  * Shared pump for CLI-backed structured runners. One implementation drives both

package/dist/structured-exec-pump.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { createUtf8TextDecoder, } from "./structured-exec-host.js";
 export function startStructuredCli(options) {
     const spawnedAt = new Date().toISOString();
     const observer = options.observer;
@@ -26,7 +27,7 @@ export function startStructuredCli(options) {
         resolveCompletion(options.finalize(ctx, exitCode, signal, spawnError));
     };
     const handleStdoutText = (text) => {
-        if (!observer.isActive())
+        if (!text || !observer.isActive())
             return;
         observer.onStdout?.(text);
         options.onStdoutText?.(text);
@@ -37,14 +38,13 @@ export function startStructuredCli(options) {
             options.processLine(line, ctx);
     };
     const handleStderrText = (text) => {
-        if (!observer.isActive())
+        if (!text || !observer.isActive())
             return;
         observer.onStderr?.(text);
         ctx.stderr += text;
     };
-    const useRemoteHost = options.execHost?.persistent === true;
-    if (useRemoteHost) {
-        const host = options.execHost;
+    const host = options.execHost;
+    if (host?.persistent) {
         const request = {
             runId: `structured:${options.sessionId}`,
             file: options.file,
@@ -82,10 +82,16 @@ export function startStructuredCli(options) {
         if (wantsStdin)
             child.stdin?.end(options.stdinData);
         source = { pid: child.pid ?? null, interrupt: () => child.kill("SIGTERM") };
-        child.stdout?.on("data", (chunk) => handleStdoutText(chunk.toString()));
-        child.stderr?.on("data", (chunk) => handleStderrText(chunk.toString()));
+        const stdoutDecoder = createUtf8TextDecoder();
+        const stderrDecoder = createUtf8TextDecoder();
+        child.stdout?.on("data", (chunk) => handleStdoutText(stdoutDecoder.write(chunk)));
+        child.stderr?.on("data", (chunk) => handleStderrText(stderrDecoder.write(chunk)));
         child.on("error", (error) => finish(null, null, error));
-        child.on("close", (exitCode, signalName) => finish(exitCode, signalName === null || signalName === undefined ? null : signalName));
+        child.on("close", (exitCode, signalName) => {
+            handleStdoutText(stdoutDecoder.end());
+            handleStderrText(stderrDecoder.end());
+            finish(exitCode, signalName === null || signalName === undefined ? null : signalName);
+        });
         sourceReady = Promise.resolve();
     }
     return {

package/dist/task-types.d.ts

@@ -1,8 +1,21 @@
 export type WandTaskStatus = "todo" | "doing" | "done";
 export type WandTaskPriority = "none" | "low" | "medium" | "high" | "urgent";
+/** 任务派发时选择的 CLI 工具；空串表示尚未指定。 */
+export type WandTaskAgentProvider = "claude" | "codex" | "opencode" | "grok" | "qoder" | "pi";
+export type WandTaskAgentModel = string;
+export type WandTaskAgentEffort = "off" | "standard" | "deep" | "max";
+/** 任务上的默认派发配置：先选工具 / 模型 / 思考深度，再一键交给 Agent。 */
+export interface WandTaskAgent {
+    provider: WandTaskAgentProvider;
+    /** 具体模型 ID；"default" 表示跟随服务端为该 provider 选择的默认模型。 */
+    model: WandTaskAgentModel;
+    thinkingEffort: WandTaskAgentEffort;
+}
 export interface WandTask {
     id: string;
     workspaceId: string | null;
+    /** 关联的侧栏工作任务；归档/新建时用来对账，不随 WorkspaceTask 删除而消失。 */
+    workspaceTaskId: string | null;
     identifier: string;
     title: string;
     description: string;
@@ -11,6 +24,8 @@ export interface WandTask {
     labels: string[];
     dueDate: string | null;
     sortOrder: number;
+    /** 该任务绑定的执行 Agent；null 表示还没指定。 */
+    agent: WandTaskAgent | null;
     createdAt: string;
     updatedAt: string;
 }

package/dist/terminal-daemon-client.d.ts

@@ -7,6 +7,8 @@ export declare class TerminalDaemonClient implements TerminalHost, StructuredExe
     readonly persistent = true;
     private socket;
     private buffer;
+    /** Decodes daemon NDJSON frames without splitting multi-byte chars. */
+    private decoder;
     private nextRequestId;
     private readonly pending;
     private readonly inventory;

package/dist/terminal-daemon-client.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import net from "node:net";
 import { spawn } from "node:child_process";
 import process from "node:process";
+import { StringDecoder } from "node:string_decoder";
 import { TERMINAL_DAEMON_PROTOCOL_VERSION, terminalDaemonPaths, } from "./terminal-daemon-protocol.js";
 import { appendTerminalChunkWindow, InProcessTerminalHost, } from "./terminal-host.js";
 import { STRUCTURED_RUN_LOG_MAX_CHARS, } from "./structured-exec-host.js";
@@ -223,6 +224,8 @@ export class TerminalDaemonClient {
     persistent = true;
     socket = null;
     buffer = "";
+    /** Decodes daemon NDJSON frames without splitting multi-byte chars. */
+    decoder = new StringDecoder("utf8");
     nextRequestId = 1;
     pending = new Map();
     inventory = new Map();
@@ -257,7 +260,10 @@ export class TerminalDaemonClient {
             socket.once("connect", onConnect);
             socket.once("error", onError);
         });
-        socket.on("data", (data) => this.consume(data.toString("utf8")));
+        // Each socket decodes from a clean slate; a half-written character from a
+        // previous connection must not leak into the next frame.
+        this.decoder = new StringDecoder("utf8");
+        socket.on("data", (data) => this.consume(this.decoder.write(data)));
         socket.on("close", () => this.handleDisconnect());
         socket.on("error", (error) => {
             this.rejectPending(error instanceof Error ? error : new Error(String(error)));

package/dist/terminal-daemon-server.js

@@ -3,9 +3,10 @@ import { spawn as nodeSpawn } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import net from "node:net";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import pty from "node-pty";
 import { ensureNodePtyHelperExecutable } from "./ensure-node-pty-helper.js";
-import { STRUCTURED_RUN_LOG_MAX_CHARS, } from "./structured-exec-host.js";
+import { STRUCTURED_RUN_LOG_MAX_CHARS, createUtf8TextDecoder, } from "./structured-exec-host.js";
 import { TERMINAL_DAEMON_PROTOCOL_VERSION, terminalDaemonPaths, } from "./terminal-daemon-protocol.js";
 import { appendTerminalChunkWindow, } from "./terminal-host.js";
 import { PtyTerminalState } from "./pty-terminal-state.js";
@@ -213,34 +214,30 @@ export async function runTerminalDaemon(configPath) {
             stderrLog: "",
             stdoutTruncated: false,
             stderrTruncated: false,
+            stdoutDecoder: createUtf8TextDecoder(),
+            stderrDecoder: createUtf8TextDecoder(),
         };
         structuredRuns.set(request.runId, run);
         evictStaleStructuredRuns();
-        child.stdout?.on("data", (chunk) => {
-            const text = chunk.toString();
-            const seq = appendRunLog(run, "stdout", text);
+        const emitDecoded = (stream, text) => {
+            if (!text)
+                return;
+            const seq = appendRunLog(run, stream, text);
             broadcast({
                 kind: "event",
                 event: "sdata",
                 sessionId: run.request.runId,
                 incarnationId: run.incarnationId,
-                stream: "stdout",
+                stream,
                 data: text,
                 seq,
             });
+        };
+        child.stdout?.on("data", (chunk) => {
+            emitDecoded("stdout", run.stdoutDecoder.write(chunk));
         });
         child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            const seq = appendRunLog(run, "stderr", text);
-            broadcast({
-                kind: "event",
-                event: "sdata",
-                sessionId: run.request.runId,
-                incarnationId: run.incarnationId,
-                stream: "stderr",
-                data: text,
-                seq,
-            });
+            emitDecoded("stderr", run.stderrDecoder.write(chunk));
         });
         child.on("error", () => {
             // Spawn failures surface via close with no exit code; keep the record so
@@ -249,6 +246,8 @@ export async function runTerminalDaemon(configPath) {
         child.on("close", (code, signalName) => {
             if (structuredRuns.get(run.request.runId) !== run || run.child !== child)
                 return;
+            emitDecoded("stdout", run.stdoutDecoder.end());
+            emitDecoded("stderr", run.stderrDecoder.end());
             run.child = null;
             run.status = "exited";
             run.exitCode = code;
@@ -380,11 +379,11 @@ export async function runTerminalDaemon(configPath) {
         }
     };
     const server = net.createServer((socket) => {
-        const client = { socket, authenticated: false, buffer: "" };
+        const client = { socket, authenticated: false, buffer: "", decoder: new StringDecoder("utf8") };
         clients.add(client);
         socket.setNoDelay(true);
         socket.on("data", (data) => {
-            client.buffer += data.toString("utf8");
+            client.buffer += client.decoder.write(data);
             if (client.buffer.length > MAX_REQUEST_BUFFER) {
                 socket.destroy();
                 return;

package/dist/tui/ipc-server.js

@@ -5,6 +5,7 @@
  */
 import net from "node:net";
 import { chmodSync, chownSync, existsSync, statSync, unlinkSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import path from "node:path";
 import { getErrorMessage } from "../error-utils.js";
 export function startIpcServer(deps) {
@@ -19,8 +20,9 @@ export function startIpcServer(deps) {
     }
     const server = net.createServer((conn) => {
         let buf = "";
+        const decoder = new StringDecoder("utf8");
         conn.on("data", (chunk) => {
-            buf += chunk.toString("utf8");
+            buf += decoder.write(chunk);
             let idx;
             while ((idx = buf.indexOf("\n")) >= 0) {
                 const line = buf.slice(0, idx).trim();

package/dist/types.d.ts

@@ -685,6 +685,7 @@ export interface WorkspaceTask {
     status: WorkspaceTaskStatus;
     createdAt: string;
     lastOpenedAt: string | null;
+    layoutRevision?: number;
 }
 /** Unified event type emitted by ClaudePtyBridge for WebSocket broadcast */
 type SessionEventType = "output.raw" | "output.chat" | "chat.turn" | "permission.prompt" | "permission.resolved" | "session.id" | "task" | "ended";

package/dist/wand-task-sync.d.ts

@@ -0,0 +1,9 @@
+import type { WandStorage } from "./storage.js";
+import type { WandTask } from "./task-types.js";
+import type { Workspace, WorkspaceTask } from "./types.js";
+/** 侧栏工作任务与看板卡片对账：已关联则复用，同项目同名未关联则挂上，否则新建。 */
+export declare function ensureBoardTaskForWorkspaceTask(storage: WandStorage, task: WorkspaceTask, workspace: Workspace): WandTask;
+/** 看板归档：卡片进入已完成，并同步把关联的侧栏工作任务标成 done（不删会话）。 */
+export declare function archiveBoardTask(storage: WandStorage, id: string): WandTask | null;
+/** 侧栏工作任务完成/删除时，把对应看板卡片标成已完成。 */
+export declare function archiveBoardTaskForWorkspaceTask(storage: WandStorage, workspaceTaskId: string): void;

package/dist/wand-task-sync.js

@@ -0,0 +1,50 @@
+function boardDescriptionFor(task, workspace) {
+    const lines = [`项目：${workspace.name}`];
+    const cwd = task.worktree?.path || task.cwd || workspace.cwd;
+    if (cwd)
+        lines.push(`目录：${cwd}`);
+    if (task.worktree?.branch)
+        lines.push(`分支：${task.worktree.branch}`);
+    return lines.join("\n");
+}
+/** 侧栏工作任务与看板卡片对账：已关联则复用，同项目同名未关联则挂上，否则新建。 */
+export function ensureBoardTaskForWorkspaceTask(storage, task, workspace) {
+    const linked = storage.getWandTaskByWorkspaceTaskId(task.id);
+    if (linked)
+        return linked;
+    const reusable = storage.findUnlinkedWandTask(workspace.id, task.name);
+    if (reusable) {
+        return storage.updateWandTask(reusable.id, {
+            workspaceTaskId: task.id,
+            workspaceId: workspace.id,
+        }) ?? reusable;
+    }
+    return storage.createWandTask({
+        workspaceId: workspace.id,
+        workspaceTaskId: task.id,
+        title: task.name,
+        description: boardDescriptionFor(task, workspace),
+        status: task.status === "done" ? "done" : "todo",
+    });
+}
+/** 看板归档：卡片进入已完成，并同步把关联的侧栏工作任务标成 done（不删会话）。 */
+export function archiveBoardTask(storage, id) {
+    const current = storage.getWandTask(id);
+    if (!current)
+        return null;
+    const archived = storage.updateWandTask(id, { status: "done" });
+    if (current.workspaceTaskId) {
+        const workspaceTask = storage.getWorkspaceTask(current.workspaceTaskId);
+        if (workspaceTask && workspaceTask.status !== "done") {
+            storage.updateWorkspaceTask(workspaceTask.id, { status: "done" });
+        }
+    }
+    return archived;
+}
+/** 侧栏工作任务完成/删除时，把对应看板卡片标成已完成。 */
+export function archiveBoardTaskForWorkspaceTask(storage, workspaceTaskId) {
+    const linked = storage.getWandTaskByWorkspaceTaskId(workspaceTaskId);
+    if (!linked || linked.status === "done")
+        return;
+    storage.updateWandTask(linked.id, { status: "done" });
+}