@co0ontty/wand 1.39.1 → 1.40.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "1.39.1",
+  "version": "1.40.1",
   "description": "A web terminal for local CLI tools like Claude.",
   "type": "module",
   "bin": {

package/dist/acp-protocol.d.ts

@@ -1,67 +0,0 @@
-/**
- * ACP (Agent Communication Protocol) implementation
- * Inspired by Happy's unified agent communication format
- */
-import type { ACPMessage, ACPTextMessage, ACPReasoningMessage, ACPToolCallMessage, ACPToolResultMessage, ACPFileEditMessage, ACPTerminalOutputMessage, ACPPermissionRequestMessage, ACPSessionStartMessage, ACPSessionEndMessage, ACPErrorMessage, ConversationTurn } from "./types.js";
-/**
- * Create a text message
- */
-export declare function createTextMessage(sessionId: string, role: "user" | "assistant" | "system", content: string): ACPTextMessage;
-/**
- * Create a reasoning message
- */
-export declare function createReasoningMessage(sessionId: string, content: string, isStreaming?: boolean): ACPReasoningMessage;
-/**
- * Create a tool call message
- */
-export declare function createToolCallMessage(sessionId: string, toolCallId: string, name: string, input: Record<string, unknown>, description?: string): ACPToolCallMessage;
-/**
- * Create a tool result message
- */
-export declare function createToolResultMessage(sessionId: string, toolCallId: string, output: string | Array<{
-    type: string;
-    [key: string]: unknown;
-}>, isError?: boolean): ACPToolResultMessage;
-/**
- * Create a file edit message
- */
-export declare function createFileEditMessage(sessionId: string, filePath: string, description: string, options?: {
-    oldContent?: string;
-    newContent?: string;
-    diff?: string;
-}): ACPFileEditMessage;
-/**
- * Create a terminal output message
- */
-export declare function createTerminalOutputMessage(sessionId: string, data: string, toolCallId?: string): ACPTerminalOutputMessage;
-/**
- * Create a permission request message
- */
-export declare function createPermissionRequestMessage(sessionId: string, permissionId: string, toolName: string, description: string): ACPPermissionRequestMessage;
-/**
- * Create a session start message
- */
-export declare function createSessionStartMessage(sessionId: string, workingDirectory: string, agent?: string): ACPSessionStartMessage;
-/**
- * Create a session end message
- */
-export declare function createSessionEndMessage(sessionId: string, exitCode: number | null): ACPSessionEndMessage;
-/**
- * Create an error message
- */
-export declare function createErrorMessage(sessionId: string, error: string, details?: string): ACPErrorMessage;
-/**
- * Convert ConversationTurn to ACP messages
- */
-export declare function conversationTurnToACP(sessionId: string, turn: ConversationTurn): ACPMessage[];
-/**
- * Convert ACP messages to ConversationTurn
- */
-export declare function acpToConversationTurns(messages: ACPMessage[]): ConversationTurn[];
-/**
- * Parse Claude stream-json event to ACP message
- */
-export declare function parseClaudeStreamEvent(sessionId: string, event: {
-    type?: string;
-    [key: string]: unknown;
-}): ACPMessage | null;

package/dist/acp-protocol.js

@@ -1,291 +0,0 @@
-/**
- * ACP (Agent Communication Protocol) implementation
- * Inspired by Happy's unified agent communication format
- */
-/**
- * Generate a unique message ID
- */
-function generateId() {
-    return `acp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-}
-/**
- * Create a text message
- */
-export function createTextMessage(sessionId, role, content) {
-    return {
-        id: generateId(),
-        type: "message",
-        timestamp: Date.now(),
-        sessionId,
-        role,
-        content,
-    };
-}
-/**
- * Create a reasoning message
- */
-export function createReasoningMessage(sessionId, content, isStreaming = false) {
-    return {
-        id: generateId(),
-        type: "reasoning",
-        timestamp: Date.now(),
-        sessionId,
-        content,
-        isStreaming,
-    };
-}
-/**
- * Create a tool call message
- */
-export function createToolCallMessage(sessionId, toolCallId, name, input, description) {
-    return {
-        id: generateId(),
-        type: "tool-call",
-        timestamp: Date.now(),
-        sessionId,
-        toolCallId,
-        name,
-        input,
-        description,
-    };
-}
-/**
- * Create a tool result message
- */
-export function createToolResultMessage(sessionId, toolCallId, output, isError = false) {
-    return {
-        id: generateId(),
-        type: "tool-result",
-        timestamp: Date.now(),
-        sessionId,
-        toolCallId,
-        output,
-        isError,
-    };
-}
-/**
- * Create a file edit message
- */
-export function createFileEditMessage(sessionId, filePath, description, options = {}) {
-    return {
-        id: generateId(),
-        type: "file-edit",
-        timestamp: Date.now(),
-        sessionId,
-        filePath,
-        description,
-        ...options,
-    };
-}
-/**
- * Create a terminal output message
- */
-export function createTerminalOutputMessage(sessionId, data, toolCallId) {
-    return {
-        id: generateId(),
-        type: "terminal-output",
-        timestamp: Date.now(),
-        sessionId,
-        data,
-        toolCallId,
-    };
-}
-/**
- * Create a permission request message
- */
-export function createPermissionRequestMessage(sessionId, permissionId, toolName, description) {
-    return {
-        id: generateId(),
-        type: "permission-request",
-        timestamp: Date.now(),
-        sessionId,
-        permissionId,
-        toolName,
-        description,
-    };
-}
-/**
- * Create a session start message
- */
-export function createSessionStartMessage(sessionId, workingDirectory, agent) {
-    return {
-        id: generateId(),
-        type: "session-start",
-        timestamp: Date.now(),
-        sessionId,
-        workingDirectory,
-        agent,
-    };
-}
-/**
- * Create a session end message
- */
-export function createSessionEndMessage(sessionId, exitCode) {
-    return {
-        id: generateId(),
-        type: "session-end",
-        timestamp: Date.now(),
-        sessionId,
-        exitCode,
-    };
-}
-/**
- * Create an error message
- */
-export function createErrorMessage(sessionId, error, details) {
-    return {
-        id: generateId(),
-        type: "error",
-        timestamp: Date.now(),
-        sessionId,
-        error,
-        details,
-    };
-}
-/**
- * Convert ConversationTurn to ACP messages
- */
-export function conversationTurnToACP(sessionId, turn) {
-    const messages = [];
-    for (const block of turn.content) {
-        switch (block.type) {
-            case "text":
-                messages.push(createTextMessage(sessionId, turn.role, block.text));
-                break;
-            case "thinking":
-                messages.push(createReasoningMessage(sessionId, block.thinking));
-                break;
-            case "tool_use":
-                messages.push(createToolCallMessage(sessionId, block.id, block.name, block.input, block.description));
-                break;
-            case "tool_result":
-                messages.push(createToolResultMessage(sessionId, block.tool_use_id, block.content, block.is_error ?? false));
-                break;
-        }
-    }
-    return messages;
-}
-/**
- * Convert ACP messages to ConversationTurn
- */
-export function acpToConversationTurns(messages) {
-    const turns = [];
-    let currentTurn = null;
-    for (const msg of messages) {
-        switch (msg.type) {
-            case "message":
-                if (msg.role === "user") {
-                    // Start a new user turn
-                    if (currentTurn) {
-                        turns.push(currentTurn);
-                    }
-                    currentTurn = {
-                        role: "user",
-                        content: [{ type: "text", text: msg.content }],
-                    };
-                }
-                else if (msg.role === "assistant") {
-                    if (currentTurn?.role === "assistant") {
-                        // Add to existing assistant turn
-                        currentTurn.content.push({ type: "text", text: msg.content });
-                    }
-                    else {
-                        // Start new assistant turn
-                        if (currentTurn) {
-                            turns.push(currentTurn);
-                        }
-                        currentTurn = {
-                            role: "assistant",
-                            content: [{ type: "text", text: msg.content }],
-                        };
-                    }
-                }
-                break;
-            case "reasoning":
-                if (currentTurn?.role === "assistant") {
-                    currentTurn.content.push({ type: "thinking", thinking: msg.content });
-                }
-                break;
-            case "tool-call":
-                if (currentTurn?.role === "assistant") {
-                    currentTurn.content.push({
-                        type: "tool_use",
-                        id: msg.toolCallId,
-                        name: msg.name,
-                        input: msg.input,
-                        description: msg.description,
-                    });
-                }
-                break;
-            case "tool-result":
-                if (currentTurn?.role === "assistant") {
-                    currentTurn.content.push({
-                        type: "tool_result",
-                        tool_use_id: msg.toolCallId,
-                        content: msg.output,
-                        is_error: msg.isError,
-                    });
-                }
-                break;
-        }
-    }
-    if (currentTurn) {
-        turns.push(currentTurn);
-    }
-    return turns;
-}
-/**
- * Parse Claude stream-json event to ACP message
- */
-export function parseClaudeStreamEvent(sessionId, event) {
-    switch (event.type) {
-        case "content_block_start": {
-            const block = event.content_block;
-            if (!block)
-                return null;
-            if (block.type === "text") {
-                return createTextMessage(sessionId, "assistant", "");
-            }
-            if (block.type === "thinking") {
-                return createReasoningMessage(sessionId, "", true);
-            }
-            if (block.type === "tool_use") {
-                return createToolCallMessage(sessionId, block.id ?? "", block.name ?? "", block.input ?? {});
-            }
-            return null;
-        }
-        case "content_block_delta": {
-            const delta = event.delta;
-            if (!delta)
-                return null;
-            if (delta.type === "text_delta" && delta.text) {
-                return createTextMessage(sessionId, "assistant", delta.text);
-            }
-            if (delta.type === "thinking_delta" && delta.thinking) {
-                return createReasoningMessage(sessionId, delta.thinking, true);
-            }
-            return null;
-        }
-        case "content_block_stop": {
-            // Block completed - could emit a completion event
-            return null;
-        }
-        case "message_start": {
-            const message = event.message;
-            if (message?.role === "assistant") {
-                return createTextMessage(sessionId, "assistant", "");
-            }
-            return null;
-        }
-        case "message_stop": {
-            // Message completed
-            return null;
-        }
-        case "error": {
-            const error = event.error;
-            return createErrorMessage(sessionId, error?.message ?? "Unknown error");
-        }
-        default:
-            return null;
-    }
-}

package/dist/claude-stream-adapter.d.ts

@@ -1,35 +0,0 @@
-import type { ContentBlock } from "./types.js";
-export interface ClaudeStreamAdapterState {
-    blocks: ContentBlock[];
-    usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cacheReadInputTokens?: number;
-        cacheCreationInputTokens?: number;
-        totalCostUsd?: number;
-    };
-    sessionId: string | null;
-}
-type ClaudeStreamEvent = {
-    type?: string;
-    session_id?: string;
-    message?: {
-        role?: string;
-        content?: unknown[];
-    };
-    content_block?: {
-        type?: string;
-        [key: string]: unknown;
-    };
-    delta?: {
-        type?: string;
-        text?: string;
-        thinking?: string;
-        partial_json?: string;
-    };
-    result?: unknown;
-    usage?: Record<string, unknown>;
-    total_cost_usd?: number;
-};
-export declare function updateClaudeStreamState(state: ClaudeStreamAdapterState, event: ClaudeStreamEvent): ClaudeStreamAdapterState;
-export {};

package/dist/claude-stream-adapter.js

@@ -1,153 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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/message-parser.d.ts

@@ -1,2 +0,0 @@
-import type { ChatMessage } from "./types.js";
-export declare function parseMessages(output: string, command?: string): ChatMessage[];