@co0ontty/wand 0.2.1 → 0.4.0

package/dist/claude-stream-adapter.js

@@ -0,0 +1,153 @@
+function normalizeToolInput(block) {
+    if (typeof block._partialJson === "string" && block._partialJson.length > 0) {
+        try {
+            const parsed = JSON.parse(block._partialJson);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Keep original input if partial JSON is incomplete.
+        }
+    }
+    if (block.input && typeof block.input === "object" && !Array.isArray(block.input)) {
+        return block.input;
+    }
+    return {};
+}
+function appendAssistantBlock(target, block) {
+    if (!block.type) {
+        return;
+    }
+    if (block.type === "text") {
+        target.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+        return;
+    }
+    if (block.type === "thinking") {
+        target.push({ type: "thinking", thinking: typeof block.thinking === "string" ? block.thinking : "" });
+        return;
+    }
+    if (block.type === "tool_use") {
+        target.push({
+            type: "tool_use",
+            id: typeof block.id === "string" ? block.id : "",
+            name: typeof block.name === "string" ? block.name : "",
+            description: typeof block.description === "string" ? block.description : undefined,
+            input: normalizeToolInput({ input: block.input, _partialJson: block._partialJson }),
+        });
+        return;
+    }
+    if (block.type === "tool_result") {
+        const content = typeof block.content === "string"
+            ? block.content
+            : Array.isArray(block.content)
+                ? block.content
+                : "";
+        target.push({
+            type: "tool_result",
+            tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+            content,
+            is_error: block.is_error === true,
+        });
+    }
+}
+function buildUsage(event) {
+    if (!event.usage && event.total_cost_usd === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens: typeof event.usage?.input_tokens === "number" ? event.usage.input_tokens : undefined,
+        outputTokens: typeof event.usage?.output_tokens === "number" ? event.usage.output_tokens : undefined,
+        cacheReadInputTokens: typeof event.usage?.cache_read_input_tokens === "number"
+            ? event.usage.cache_read_input_tokens
+            : undefined,
+        cacheCreationInputTokens: typeof event.usage?.cache_creation_input_tokens === "number"
+            ? event.usage.cache_creation_input_tokens
+            : undefined,
+        totalCostUsd: typeof event.total_cost_usd === "number" ? event.total_cost_usd : undefined,
+    };
+}
+export function updateClaudeStreamState(state, event) {
+    if (typeof event.session_id === "string" && event.session_id.length > 0) {
+        state.sessionId = event.session_id;
+    }
+    switch (event.type) {
+        case "assistant": {
+            const content = Array.isArray(event.message?.content) ? event.message?.content : [];
+            for (const block of content) {
+                if (block && typeof block === "object" && "type" in block) {
+                    appendAssistantBlock(state.blocks, block);
+                }
+            }
+            break;
+        }
+        case "content_block_start": {
+            if (event.content_block && typeof event.content_block === "object") {
+                appendAssistantBlock(state.blocks, event.content_block);
+            }
+            break;
+        }
+        case "content_block_delta": {
+            const lastBlock = state.blocks[state.blocks.length - 1];
+            if (!lastBlock || !event.delta) {
+                break;
+            }
+            if (lastBlock.type === "text" && event.delta.type === "text_delta" && typeof event.delta.text === "string") {
+                lastBlock.text += event.delta.text;
+            }
+            else if (lastBlock.type === "thinking" &&
+                event.delta.type === "thinking_delta" &&
+                typeof event.delta.thinking === "string") {
+                lastBlock.thinking += event.delta.thinking;
+            }
+            else if (lastBlock.type === "tool_use" &&
+                typeof event.delta.partial_json === "string") {
+                const nextPartial = (lastBlock._partialJson ?? "") + event.delta.partial_json;
+                lastBlock._partialJson = nextPartial;
+                lastBlock.input = normalizeToolInput({
+                    input: lastBlock.input,
+                    _partialJson: nextPartial,
+                });
+            }
+            break;
+        }
+        case "user": {
+            const content = Array.isArray(event.message?.content) ? event.message?.content : [];
+            for (const block of content) {
+                if (block &&
+                    typeof block === "object" &&
+                    "type" in block &&
+                    block.type === "tool_result") {
+                    appendAssistantBlock(state.blocks, block);
+                }
+            }
+            break;
+        }
+        case "result": {
+            const usage = buildUsage(event);
+            if (usage) {
+                state.usage = usage;
+            }
+            if (typeof event.result === "string") {
+                const hasAssistantText = state.blocks.some((block) => block.type === "text");
+                if (!hasAssistantText && event.result.trim().length > 0) {
+                    state.blocks.push({ type: "text", text: event.result });
+                }
+            }
+            else if (event.result && typeof event.result === "object") {
+                const resultContent = event.result.content;
+                if (Array.isArray(resultContent)) {
+                    for (const block of resultContent) {
+                        if (block && typeof block === "object" && "type" in block) {
+                            appendAssistantBlock(state.blocks, block);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return state;
+}

package/dist/claude-structured-runner.d.ts

@@ -0,0 +1,27 @@
+import { ChildProcess } from "node:child_process";
+import type { ContentBlock, ConversationTurn } from "./types.js";
+export interface ClaudeStructuredRunnerCallbacks {
+    onOutput: (text: string) => void;
+    onBlocks: (blocks: ContentBlock[], usage?: ConversationTurn["usage"]) => void;
+    onSessionId: (sessionId: string) => void;
+    onClose: (exitCode: number | null, state: ClaudeStructuredRunnerState) => void;
+    onError: (error: Error) => void;
+}
+export interface ClaudeStructuredRunnerState {
+    stdoutBuffer: string;
+    assistantBlocks: ContentBlock[];
+    usage?: ConversationTurn["usage"];
+    sessionId: string | null;
+}
+export interface StartClaudeStructuredRunnerOptions {
+    command: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    callbacks: ClaudeStructuredRunnerCallbacks;
+}
+export interface ClaudeStructuredRunnerHandle {
+    child: ChildProcess;
+    getState: () => ClaudeStructuredRunnerState;
+    kill: () => void;
+}
+export declare function startClaudeStructuredRunner(options: StartClaudeStructuredRunnerOptions): ClaudeStructuredRunnerHandle;

package/dist/claude-structured-runner.js

@@ -0,0 +1,106 @@
+import { spawn } from "node:child_process";
+import { updateClaudeStreamState } from "./claude-stream-adapter.js";
+function toContentBlocks(blocks) {
+    return blocks.map((block) => {
+        switch (block.type) {
+            case "text":
+                return { type: "text", text: typeof block.text === "string" ? block.text : "" };
+            case "thinking":
+                return { type: "thinking", thinking: typeof block.thinking === "string" ? block.thinking : "" };
+            case "tool_use":
+                return {
+                    type: "tool_use",
+                    id: typeof block.id === "string" ? block.id : "",
+                    name: typeof block.name === "string" ? block.name : "",
+                    description: typeof block.description === "string" ? block.description : undefined,
+                    input: block.input && typeof block.input === "object" && !Array.isArray(block.input)
+                        ? block.input
+                        : {},
+                };
+            case "tool_result":
+                return {
+                    type: "tool_result",
+                    tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+                    content: typeof block.content === "string"
+                        ? block.content
+                        : Array.isArray(block.content)
+                            ? block.content
+                            : "",
+                    is_error: block.is_error === true,
+                };
+            default:
+                return { type: "text", text: JSON.stringify(block) };
+        }
+    });
+}
+export function startClaudeStructuredRunner(options) {
+    const state = {
+        stdoutBuffer: "",
+        assistantBlocks: [],
+        usage: undefined,
+        sessionId: null,
+    };
+    const child = spawn(options.command, [], {
+        cwd: options.cwd,
+        env: options.env,
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    child.stdout?.on("data", (chunk) => {
+        state.stdoutBuffer += chunk.toString();
+        const lines = state.stdoutBuffer.split("\n");
+        state.stdoutBuffer = lines.pop() || "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const event = JSON.parse(trimmed);
+                const nextState = updateClaudeStreamState({
+                    blocks: state.assistantBlocks,
+                    usage: state.usage,
+                    sessionId: state.sessionId,
+                }, event);
+                state.assistantBlocks = nextState.blocks.map((block) => ({ ...block }));
+                state.usage = nextState.usage;
+                if (nextState.sessionId && nextState.sessionId !== state.sessionId) {
+                    state.sessionId = nextState.sessionId;
+                    options.callbacks.onSessionId(nextState.sessionId);
+                }
+                options.callbacks.onBlocks(state.assistantBlocks, state.usage);
+            }
+            catch {
+                options.callbacks.onOutput(trimmed + "\n");
+            }
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        options.callbacks.onOutput(chunk.toString());
+    });
+    child.on("close", (code) => {
+        options.callbacks.onClose(code, {
+            stdoutBuffer: state.stdoutBuffer,
+            assistantBlocks: [...state.assistantBlocks],
+            usage: state.usage,
+            sessionId: state.sessionId,
+        });
+    });
+    child.on("error", (error) => {
+        options.callbacks.onError(error);
+    });
+    return {
+        child,
+        getState: () => ({
+            stdoutBuffer: state.stdoutBuffer,
+            assistantBlocks: [...state.assistantBlocks],
+            usage: state.usage,
+            sessionId: state.sessionId,
+        }),
+        kill: () => {
+            if (!child.killed) {
+                child.kill();
+            }
+        },
+    };
+}

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 export {};

package/dist/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 import process from "node:process";
 import { ensureConfig, hasConfigFile, isExecutionMode, resolveConfigPath, saveConfig } from "./config.js";
 import { startServer } from "./server.js";
@@ -105,12 +105,20 @@ function setConfigValue(config, key, value) {
             };
         case "defaultMode":
             if (!isExecutionMode(value)) {
-                throw new Error("defaultMode must be auto-edit, default, or full-access");
+                throw new Error(`defaultMode must be one of: assist, agent, agent-max, auto-edit, default, full-access, managed, native`);
             }
             return {
                 ...config,
                 defaultMode: value
             };
+        case "https":
+            if (value !== "true" && value !== "false") {
+                throw new Error("https must be 'true' or 'false'");
+            }
+            return {
+                ...config,
+                https: value === "true"
+            };
         default:
             throw new Error(`Unsupported config key: ${key}`);
     }

package/dist/config.js

@@ -5,9 +5,9 @@ import process from "node:process";
 const DEFAULT_CONFIG_DIR = ".wand";
 const DEFAULT_CONFIG_FILE = "config.json";
 export const defaultConfig = () => ({
-    host: "0.0.0.0",
+    host: "127.0.0.1",
     port: 8443,
-    https: true,
+    https: false,
     password: "change-me",
     defaultMode: "default",
     shell: process.env.SHELL || "/bin/bash",
@@ -60,7 +60,11 @@ export async function ensureConfig(configPath) {
     try {
         const raw = await readFile(configPath, "utf8");
         const merged = mergeWithDefaults(JSON.parse(raw));
-        await writeFile(configPath, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+        const normalized = `${JSON.stringify(merged, null, 2)}\n`;
+        // Only write if the file content actually changed
+        if (raw.trimEnd() !== normalized.trimEnd()) {
+            await writeFile(configPath, normalized, "utf8");
+        }
         return merged;
     }
     catch {
@@ -102,7 +106,7 @@ function mergeWithDefaults(input) {
     };
 }
 export function isExecutionMode(value) {
-    return value === "auto-edit" || value === "default" || value === "full-access" || value === "native" || value === "managed";
+    return value === "assist" || value === "agent" || value === "agent-max" || value === "auto-edit" || value === "default" || value === "full-access" || value === "native" || value === "managed";
 }
 function normalizePresetCommand(command) {
     const trimmed = command.trim();

package/dist/message-parser.js

@@ -1,158 +1,22 @@
-/** Strip ANSI escape sequences from raw PTY output */
-function stripAnsi(text) {
-    let stripped = "";
-    for (let i = 0; i < text.length; i++) {
-        const ch = text.charCodeAt(i);
-        if (ch === 27) {
-            i++;
-            if (i >= text.length)
-                break;
-            const next = text.charCodeAt(i);
-            if (next === 91) {
-                // CSI sequence: skip until final byte (64-126)
-                i++;
-                while (i < text.length) {
-                    const c = text.charCodeAt(i);
-                    if (c >= 64 && c <= 126)
-                        break;
-                    i++;
-                }
-            }
-            else if (next === 93) {
-                // OSC sequence: skip until BEL (7) or ESC\ (27 92)
-                i++;
-                while (i < text.length) {
-                    if (text.charCodeAt(i) === 7)
-                        break;
-                    if (text.charCodeAt(i) === 27 && i + 1 < text.length && text.charCodeAt(i + 1) === 92) {
-                        i++;
-                        break;
-                    }
-                    i++;
-                }
-            }
-            // Other escape sequences: skip the next character
-            continue;
-        }
-        // Skip control characters except \n, \r, \t
-        if (ch < 32 && ch !== 10 && ch !== 13 && ch !== 9)
-            continue;
-        stripped += text.charAt(i);
-    }
-    return stripped;
-}
-/** Check if a line is noise from Claude TUI */
-function isNoiseLine(line) {
-    if (!line)
-        return true;
-    if (line.startsWith("────"))
-        return true;
-    if (line === "❯")
-        return true;
-    if (line.includes("esc to interrupt"))
-        return true;
-    if (line.includes("Claude Code v"))
-        return true;
-    if (/^Sonnet\b/.test(line))
-        return true;
-    if (line.startsWith("~/"))
-        return true;
-    if (line.includes("● high"))
-        return true;
-    if (line.includes("Failed to install Anthropic"))
-        return true;
-    if (line.includes("Claude Code has switched"))
-        return true;
-    if (line.includes("Fluttering"))
-        return true;
-    if (line.includes("? for shortcuts"))
-        return true;
-    if (line.startsWith("0;") || line.startsWith("9;"))
-        return true;
-    if (line.includes("Claude is waiting"))
-        return true;
-    if (/[✢✳✶✻✽]/.test(line))
-        return true;
-    if (/^[▐▝▘]/.test(line))
-        return true;
-    const singleCharNoise = ["lu", "ue", "tr", "ti", "g", "n", "i…", "…", "uts", "lt", "rg", "·"];
-    if (singleCharNoise.includes(line) && line.length < 4)
-        return true;
-    if (line.startsWith("✽F") || line.startsWith("✻F"))
-        return true;
-    if (line.includes("[wand]"))
-        return true;
-    if (line.includes("⏵"))
-        return true;
-    if (line.includes("acceptedit"))
-        return true;
-    if (line.includes("shift+tab"))
-        return true;
-    if (line.includes("tabtocycle"))
-        return true;
-    if (line.includes("ctrl+g"))
-        return true;
-    if (line.includes("/effort"))
-        return true;
-    if (line.includes("Haiku"))
-        return true;
-    if (line.includes("to cycle"))
-        return true;
-    if (/\bhigh\s*·/.test(line) || /\bmedium\s*·/.test(line) || /\blow\s*·/.test(line))
-        return true;
-    if (line.includes("npm WARN") || line.includes("npm notice"))
-        return true;
-    if (/^Using .* for .* session/.test(line))
-        return true;
-    if (line.includes("Permissions") && line.includes("mode"))
-        return true;
-    if (line.startsWith("Press ") && line.includes(" for"))
-        return true;
-    if (line.startsWith("type ") && line.includes(" to "))
-        return true;
-    if (line.length < 3 && !/^[a-zA-Z]{3}$/.test(line))
-        return true;
-    return false;
-}
-/** Filter assistant content line */
-function isAssistantContent(line) {
-    if (line.includes("⏺"))
-        return true;
-    if (line.length < 8)
-        return false;
-    if (/[✢✳✶✻✽]/.test(line))
-        return false;
-    if (/^[▐▝▘]/.test(line))
-        return false;
-    if (line.startsWith("❯"))
-        return false;
-    if (line.includes("esctointerrupt"))
-        return false;
-    if (line.startsWith("?for") || line.startsWith("? for"))
-        return false;
-    return true;
-}
+import { stripAnsi, isNoiseLine } from "./pty-text-utils.js";
 export function parseMessages(output) {
     const messages = [];
     if (!output)
         return messages;
-    // Strip ANSI and normalize
     const stripped = stripAnsi(output).replace(/\r/g, "\n");
-    const lines = stripped.split("\n").map((l) => l.trim()).filter(Boolean);
-    // Filter noise
-    const cleaned = lines.filter((line) => !isNoiseLine(line));
+    const lines = stripped.split("\n");
+    const cleaned = lines.filter((line) => !isNoiseLine(line.trim()));
     if (!cleaned.length)
         return messages;
     const turns = [];
     let currentUserText = null;
     let currentAssistantLines = [];
-    for (const line of cleaned) {
+    for (const rawLine of cleaned) {
+        const line = rawLine.trim();
         if (line.startsWith("❯")) {
             const afterPrompt = line.replace(/^❯\s*/, "").trim();
-            // Skip prompt suggestions
             if (afterPrompt.startsWith("Try"))
                 continue;
-            // Finalize previous turn
             if (currentUserText !== null && currentAssistantLines.length > 0) {
                 turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
                 currentAssistantLines = [];
@@ -161,7 +25,6 @@ export function parseMessages(output) {
                 currentUserText = afterPrompt;
             }
             else {
-                // Standalone ❯ — finalize and reset
                 if (currentUserText !== null && currentAssistantLines.length > 0) {
                     turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
                     currentAssistantLines = [];
@@ -169,21 +32,24 @@ export function parseMessages(output) {
                 currentUserText = null;
             }
         }
-        else if (currentUserText !== null && isAssistantContent(line)) {
-            // Clean ⏺ prefix
-            const cleanLine = line.startsWith("⏺") ? line.slice(1).trim() : line;
-            if (cleanLine)
-                currentAssistantLines.push(cleanLine);
+        else if (currentUserText !== null) {
+            const contentLine = rawLine.startsWith("⏺") ? rawLine.slice(1) : rawLine;
+            currentAssistantLines.push(contentLine);
         }
     }
-    // Finalize last turn
     if (currentUserText !== null && currentAssistantLines.length > 0) {
         turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
     }
-    // Convert to messages
+    else if (currentUserText !== null) {
+        // User input exists but no assistant response yet — still record the turn
+        turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
+    }
     for (const turn of turns) {
         messages.push({ role: "user", content: turn.user });
-        messages.push({ role: "assistant", content: turn.assistantLines.join("\n") });
+        const content = turn.assistantLines.join("\n").replace(/[ \t]+\n/g, "\n").replace(/[\n\s]+$/, "");
+        if (content) {
+            messages.push({ role: "assistant", content });
+        }
     }
     return messages;
 }

package/dist/message-queue.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Message Queue for managing user inputs
+ * Inspired by Happy's MessageQueue2 implementation
+ */
+import type { QueuedMessage, AutonomyPolicy, ApprovalPolicy, EscalationScope } from "./types.js";
+export interface MessageQueueOptions {
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+}
+export declare class MessageQueue {
+    private queue;
+    private processing;
+    private onMessageCallback;
+    private lastMessageId;
+    /**
+     * Add a message to the queue
+     */
+    enqueue(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Add a high-priority message (like /compact, /clear)
+     */
+    enqueuePriority(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Clear the queue and add a new message
+     * Used for /compact and /clear commands
+     */
+    clearAndEnqueue(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Set the message handler
+     */
+    onMessage(handler: (message: QueuedMessage) => Promise<void>): void;
+    /**
+     * Process the next message in the queue
+     */
+    private processNext;
+    /**
+     * Get the current queue length
+     */
+    get length(): number;
+    /**
+     * Check if the queue is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if a message is being processed
+     */
+    get isProcessing(): boolean;
+    /**
+     * Clear all pending messages
+     */
+    clear(): void;
+    /**
+     * Get all pending messages (for debugging)
+     */
+    getPending(): QueuedMessage[];
+}