@winmatrix/daemon 0.2.0

package/dist/wrapper/AgentWrapper.js

@@ -0,0 +1,873 @@
+/**
+ * @deprecated 方案 B 下不再使用（adapter 在 daemon 进程内直接运行，不再 spawn 子进程）。
+ * 保留供未来 multiprocess 模式参考，所有维护性修改应在此注明原因。
+ *
+ * Agent Wrapper - Daemon 子进程入口
+ *
+ * 由 Daemon 通过 agent.create 信令 spawn 启动。
+ * 通过 stdin/stdout JSON 帧与 Daemon 通信，Daemon 负责通过 WS 多路复用转发给 Server。
+ *
+ * 协议（stdin/stdout 均为 JSON Lines）：
+ *   stdin:  {"type":"fwd","data":<Server 发来的帧>}
+ *   stdout: {"type":"fwd","agentId":"...","data":<发往 Server 的帧>}
+ *   stdout: {"type":"event","event":"agent.ready","payload":{...}}
+ *   stdout: {"type":"event","event":"agent.stopped","payload":{...}}
+ *   stdout: {"type":"event","event":"agent.error","payload":{...}}
+ *
+ * 任务模型：按 agentType 分发到不同执行模式：
+ *   claude-code → spawn claude --print --output-format stream-json ...
+ *   hermes      → fetch() POST 到 HTTP endpoint
+ *   default     → spawn(runtime, ['--print', '--output-format', 'json', input])
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { unwrapOpenClawPayloads } from '@winmatrix/agent-sdk';
+import { parseClaudeLine, splitLines } from './ClaudeStreamParser.js';
+import { scanWorkDir, detectRuntimeInfo } from '../core/WorkspaceScanner.js';
+/* ── State ── */
+let config = null;
+const runningTasks = new Map();
+/* ── Helpers ── */
+function send(frame) {
+    process.stdout.write(JSON.stringify(frame) + '\n');
+}
+function parseStdin(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (parsed && typeof parsed === 'object') {
+            // Handle tool_result frames from daemon (Tool Proxy Fallback)
+            if (parsed.type === 'tool_result') {
+                handleToolResult(parsed);
+                return null; // Not a server frame, don't forward
+            }
+            if (parsed.type === 'fwd') {
+                return parsed;
+            }
+        }
+    }
+    catch {
+        // ignore malformed lines
+    }
+    return null;
+}
+function sendTaskError(taskId, error) {
+    if (!config)
+        return;
+    send({
+        type: 'fwd',
+        agentId: config.agentId,
+        data: {
+            type: 'event',
+            event: 'task.error',
+            payload: { taskId, error },
+        },
+    });
+}
+function sendTaskDelta(taskId, content, meta) {
+    if (!config)
+        return;
+    const payload = { taskId, content };
+    if (meta)
+        payload.meta = meta;
+    send({
+        type: 'fwd',
+        agentId: config.agentId,
+        data: {
+            type: 'event',
+            event: 'task.delta',
+            payload,
+        },
+    });
+}
+function sendTaskComplete(taskId, result, sessionId, usage) {
+    if (!config)
+        return;
+    const payload = { taskId, result };
+    if (sessionId)
+        payload.sessionId = sessionId;
+    if (usage)
+        payload.usage = usage;
+    send({
+        type: 'fwd',
+        agentId: config.agentId,
+        data: {
+            type: 'event',
+            event: 'task.complete',
+            payload,
+        },
+    });
+}
+function cleanupTask(taskId) {
+    const entry = runningTasks.get(taskId);
+    if (!entry)
+        return;
+    runningTasks.delete(taskId);
+}
+/* ── Task Routing ── */
+function routeTask(task) {
+    if (!config)
+        return;
+    const taskId = task.taskId;
+    if (runningTasks.has(taskId)) {
+        sendTaskError(taskId, 'Task already running');
+        return;
+    }
+    switch (config.agentType) {
+        case 'claude-code':
+            spawnClaudeCodeTask(task);
+            break;
+        case 'hermes':
+            spawnHermesTask(task);
+            break;
+        case 'openclaw':
+            spawnOpenClawTask(task);
+            break;
+        default:
+            spawnGenericTask(task);
+            break;
+    }
+}
+/* ── Claude Code Task ── */
+/**
+ * 在 workDir 下生成 .claude/mcp.json 配置，让 Claude Code 能通过 MCP Bridge 调用 WinMatrix 工具。
+ * 如果 .claude/mcp.json 已存在，使用 mcp.winmatrix.json 并通过 --mcp-config 指定。
+ */
+function generateClaudeMcpConfig(mcpBridgeUrl, mcpApiKey, workDir) {
+    const mcpConfig = {
+        mcpServers: {
+            winmatrix: {
+                type: 'http',
+                url: mcpBridgeUrl,
+                ...(mcpApiKey ? { headers: { Authorization: `Bearer ${mcpApiKey}` } } : {}),
+            },
+        },
+    };
+    const configDir = workDir ? join(workDir, '.claude') : join(homedir(), '.claude');
+    const primaryPath = join(configDir, 'mcp.json');
+    const fallbackPath = join(configDir, 'mcp.winmatrix.json');
+    try {
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        if (existsSync(primaryPath)) {
+            writeFileSync(fallbackPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+            return ['--mcp-config', fallbackPath];
+        }
+        writeFileSync(primaryPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+        return null;
+    }
+    catch (err) {
+        console.warn(`MCP 配置写入失败: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+const CLAUDE_BASE_ARGS = [
+    '--print',
+    '--verbose',
+    '--input-format', 'stream-json',
+    '--output-format', 'stream-json',
+    '--include-partial-messages',
+];
+function spawnClaudeCodeTask(task) {
+    if (!config)
+        return;
+    const taskId = task.taskId;
+    const workDir = task.workDir ?? config.workDir;
+    const claude = task.claude ?? {};
+    // Validate workDir
+    if (workDir && !existsSync(workDir)) {
+        sendTaskError(taskId, `Work directory does not exist: ${workDir}`);
+        return;
+    }
+    // Assemble CLI args
+    const args = [...CLAUDE_BASE_ARGS];
+    // Permission mode (from task config, default 'auto')
+    const permissionMode = claude.permissionMode ?? 'bypassPermissions';
+    args.push('--permission-mode', permissionMode);
+    // workDir → --add-dir
+    if (workDir) {
+        args.push('--add-dir', workDir);
+    }
+    // Session management: oneshot skips --session-id entirely
+    const isOneshot = task.mode === 'oneshot';
+    let sessionId;
+    if (!isOneshot) {
+        if (claude.forkSession) {
+            sessionId = randomUUID();
+            args.push('--session-id', sessionId);
+        }
+        else if (claude.resumeSession && claude.sessionId) {
+            sessionId = claude.sessionId;
+            args.push('--resume', sessionId);
+        }
+        else if (claude.sessionId) {
+            sessionId = claude.sessionId;
+            args.push('--session-id', sessionId);
+        }
+        else {
+            sessionId = randomUUID();
+            args.push('--session-id', sessionId);
+        }
+    }
+    // Tool restriction
+    if (claude.tools && claude.tools.length > 0) {
+        args.push('--allowedTools', claude.tools.join(','));
+    }
+    if (claude.disallowedTools && claude.disallowedTools.length > 0) {
+        args.push('--disallowedTools', claude.disallowedTools.join(','));
+    }
+    // Budget
+    if (claude.maxBudgetUsd !== undefined) {
+        args.push('--max-budget-usd', String(claude.maxBudgetUsd));
+    }
+    // System prompt: task.systemPrompt 优先于 claude.systemPrompt
+    const effectiveSystemPrompt = task.systemPrompt ?? claude.systemPrompt;
+    if (effectiveSystemPrompt) {
+        args.push('--append-system-prompt', effectiveSystemPrompt);
+    }
+    // MCP Bridge 配置：在 workDir 下生成 .claude/mcp.json 或 mcp.winmatrix.json
+    if (config.mcpBridgeUrl) {
+        const effectiveMcpKey = task.mcpToken ?? config.mcpApiKey;
+        const mcpArgs = generateClaudeMcpConfig(config.mcpBridgeUrl, effectiveMcpKey, workDir);
+        if (mcpArgs) {
+            args.push(...mcpArgs);
+        }
+    }
+    // Build env
+    const env = {
+        ...process.env,
+        WINMATRIX_AGENT_ID: config.agentId,
+        WINMATRIX_API_KEY: config.apiKey,
+        WINMATRIX_AGENT_NAME: config.name,
+        WINMATRIX_AGENT_TYPE: config.agentType,
+        WINMATRIX_TASK_ID: taskId,
+        ...task.env,
+    };
+    let proc;
+    try {
+        proc = spawn(config.runtime, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env,
+            cwd: workDir ?? process.cwd(),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendTaskError(taskId, `Failed to spawn Claude Code: ${message}`);
+        return;
+    }
+    const entry = {
+        taskId,
+        process: proc,
+        abortController: null,
+        startedAt: Date.now(),
+        stdoutChunks: [],
+        completed: false,
+    };
+    runningTasks.set(taskId, entry);
+    // Send user message via stdin (stream-json protocol)
+    const userMessage = JSON.stringify({
+        type: 'user',
+        message: { role: 'user', content: task.input },
+    }) + '\n';
+    proc.stdin?.write(userMessage);
+    proc.stdin?.end();
+    // Track extracted fields from result event for task.complete
+    let extractedSessionId;
+    let extractedResultText;
+    let extractedUsage;
+    // Parse stdout stream-json events
+    let stdoutBuffer = '';
+    proc.stdout?.on('data', (data) => {
+        const chunk = data.toString('utf-8');
+        const { lines, remainder } = splitLines(stdoutBuffer, chunk);
+        stdoutBuffer = remainder;
+        for (const line of lines) {
+            entry.stdoutChunks.push(line + '\n');
+            const action = parseClaudeLine(line);
+            switch (action.type) {
+                case 'delta':
+                    sendTaskDelta(taskId, action.text);
+                    break;
+                case 'tool_use':
+                    sendTaskDelta(taskId, `[调用工具: ${action.toolName}]`, { toolUse: { name: action.toolName, input: action.toolInput } });
+                    break;
+                case 'result':
+                    if (action.sessionId) {
+                        extractedSessionId = action.sessionId;
+                    }
+                    if (action.result) {
+                        extractedResultText = action.result;
+                    }
+                    if (action.usage) {
+                        extractedUsage = action.usage;
+                    }
+                    break;
+                case 'error':
+                    entry.completed = true;
+                    sendTaskError(taskId, action.message);
+                    return;
+                case 'skip':
+                    break;
+            }
+        }
+    });
+    // Forward stderr as task.delta with meta marker to distinguish from stdout content
+    proc.stderr?.on('data', (data) => {
+        const text = data.toString('utf-8').trimEnd();
+        if (!text)
+            return;
+        sendTaskDelta(taskId, text, { source: 'stderr' });
+    });
+    proc.on('exit', (code, signal) => {
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        if (extractedSessionId || code === 0) {
+            // Use result text extracted from stream-json result event
+            sendTaskComplete(taskId, { result: extractedResultText ?? null, exitCode: code ?? 0 }, isOneshot ? undefined : extractedSessionId, extractedUsage);
+        }
+        else {
+            sendTaskError(taskId, signal
+                ? `Claude Code killed by signal ${signal}`
+                : `Claude Code exited with code ${code ?? 'null'}`);
+        }
+        cleanupTask(taskId);
+    });
+    proc.on('error', (err) => {
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        sendTaskError(taskId, err.message);
+        cleanupTask(taskId);
+    });
+}
+/* ── HTTP Task (shared by hermes / openclaw) ── */
+const DEFAULT_HTTP_TIMEOUT_MS = 180000;
+/**
+ * Shared HTTP POST task execution.
+ * Hermes and OpenClaw both POST to an endpoint; OpenClaw additionally unwraps the payload.
+ *
+ * Tool Proxy Fallback: when the HTTP response contains "unsupported mcp biz type" or
+ * errcode 846610, the Wrapper sends tool_call IPC frames to the daemon for each
+ * fallback tool call, aggregates results, and completes the task with mode: 'fallback'.
+ */
+function spawnHttpTask(task, options) {
+    if (!config)
+        return;
+    const taskId = task.taskId;
+    // Task-level endpoint overrides config-level; fallback to deprecated hermesEndpoint
+    const endpoint = task.endpoint ?? config.endpoint ?? config.hermesEndpoint;
+    if (!endpoint) {
+        sendTaskError(taskId, 'HTTP endpoint not configured');
+        return;
+    }
+    const timeoutMs = task.hermes?.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+    const entry = {
+        taskId,
+        process: null,
+        abortController,
+        startedAt: Date.now(),
+        stdoutChunks: [],
+        completed: false,
+    };
+    runningTasks.set(taskId, entry);
+    // Build request headers
+    const headers = { 'Content-Type': 'application/json' };
+    const token = task.endpointToken ?? config.endpointToken;
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    // systemPrompt 拼接到 input 前方（Hermes/OpenClaw Gateway 不支持独立 system prompt 参数）
+    const effectiveInput = task.systemPrompt
+        ? `${task.systemPrompt}\n\n---\n\n${task.input}`
+        : task.input;
+    entry.completionPromise = fetch(endpoint, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            taskId: task.taskId,
+            input: effectiveInput,
+            context: task.context,
+            ...(task.systemPrompt ? { systemPrompt: task.systemPrompt } : {}),
+            ...(config.mcpBridgeUrl ? { mcpBridgeUrl: config.mcpBridgeUrl } : {}),
+            ...((task.mcpToken ?? config.mcpApiKey) ? { mcpToken: (task.mcpToken ?? config.mcpApiKey) } : {}),
+        }),
+        signal: abortController.signal,
+    })
+        .then(async (res) => {
+        clearTimeout(timeoutId);
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        if (!res.ok) {
+            sendTaskError(taskId, `HTTP ${res.status}: ${res.statusText}`);
+            cleanupTask(taskId);
+            return;
+        }
+        const bodyText = await res.text();
+        let parsed = bodyText;
+        try {
+            parsed = JSON.parse(bodyText);
+        }
+        catch {
+            // Non-JSON response, keep raw text
+        }
+        // Apply unwrap if configured (openclaw) — unwrap expects raw string, internally JSON.parses
+        if (options.unwrap && typeof parsed === 'object' && parsed !== null) {
+            try {
+                parsed = options.unwrap(bodyText);
+            }
+            catch {
+                // unwrap failed, keep original
+            }
+        }
+        // Tool Proxy Fallback detection
+        const responseStr = typeof parsed === 'string' ? parsed : JSON.stringify(parsed);
+        if (/unsupported mcp biz type|errcode.*846610/i.test(responseStr)) {
+            const fallbackCalls = extractFallbackToolCalls(parsed);
+            if (fallbackCalls.length > 0) {
+                await executeFallbackToolCalls(taskId, fallbackCalls);
+                cleanupTask(taskId);
+                return;
+            }
+        }
+        sendTaskComplete(taskId, parsed);
+        cleanupTask(taskId);
+    })
+        .catch((err) => {
+        clearTimeout(timeoutId);
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        const message = err instanceof Error ? err.message : String(err);
+        if (err.name === 'AbortError') {
+            sendTaskError(taskId, `HTTP request timed out after ${timeoutMs}ms`);
+        }
+        else {
+            sendTaskError(taskId, `HTTP request failed: ${message}`);
+        }
+        cleanupTask(taskId);
+    });
+}
+function spawnHermesTask(task) {
+    spawnHttpTask(task, {});
+}
+function spawnOpenClawTask(task) {
+    spawnHttpTask(task, { unwrap: unwrapOpenClawPayloads });
+}
+function extractFallbackToolCalls(parsed) {
+    const calls = [];
+    // Try to extract from common response shapes
+    let data = parsed;
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        }
+        catch {
+            return calls;
+        }
+    }
+    if (!data || typeof data !== 'object')
+        return calls;
+    // Shape: { tool_calls: [{ name, arguments }, ...] }
+    const rawCalls = data.tool_calls ?? data.toolCalls ?? data.calls;
+    if (Array.isArray(rawCalls)) {
+        for (const c of rawCalls) {
+            if (typeof c !== 'object' || c === null)
+                continue;
+            const name = c.name ?? c.tool_name ?? c.function;
+            if (typeof name !== 'string')
+                continue;
+            let args = {};
+            const rawArgs = c.arguments ?? c.args ?? c.parameters;
+            if (typeof rawArgs === 'string') {
+                try {
+                    args = JSON.parse(rawArgs);
+                }
+                catch {
+                    args = { raw: rawArgs };
+                }
+            }
+            else if (typeof rawArgs === 'object' && rawArgs !== null) {
+                args = rawArgs;
+            }
+            calls.push({ toolName: name, args });
+        }
+    }
+    // Shape: { tool_query: "..." } → single tool call
+    if (calls.length === 0 && typeof data.tool_query === 'string') {
+        calls.push({ toolName: 'tool_query', args: { query: data.tool_query } });
+    }
+    return calls;
+}
+async function executeFallbackToolCalls(taskId, calls) {
+    const results = [];
+    for (const call of calls) {
+        const callId = randomUUID();
+        // Send tool_call IPC to daemon
+        process.stdout.write(JSON.stringify({
+            type: 'tool_call',
+            callId,
+            taskId,
+            toolName: call.toolName,
+            args: call.args,
+        }) + '\n');
+        // Wait for tool_result from daemon via stdin
+        try {
+            const result = await waitForToolResult(callId, 30000);
+            results.push({ toolName: call.toolName, ok: true, result });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push({ toolName: call.toolName, ok: false, error: message });
+        }
+    }
+    sendTaskComplete(taskId, { mode: 'fallback', calls: results });
+}
+/** Pending tool_result resolvers keyed by callId */
+const toolResultPending = new Map();
+function waitForToolResult(callId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            toolResultPending.delete(callId);
+            reject(new Error('Tool call timed out'));
+        }, timeoutMs);
+        toolResultPending.set(callId, { resolve, reject, timer });
+    });
+}
+/** Called from stdin handler when a tool_result frame arrives from daemon */
+function handleToolResult(frame) {
+    const pending = toolResultPending.get(frame.callId);
+    if (!pending)
+        return;
+    clearTimeout(pending.timer);
+    toolResultPending.delete(frame.callId);
+    if (frame.ok) {
+        pending.resolve(frame.result);
+    }
+    else {
+        pending.reject(new Error(frame.error ?? 'Tool call failed'));
+    }
+}
+/* ── Generic Task (fallback) ── */
+function spawnGenericTask(task) {
+    if (!config)
+        return;
+    const taskId = task.taskId;
+    const workDir = task.workDir ?? config.workDir;
+    const args = ['--print', '--output-format', 'json', task.input];
+    let proc;
+    try {
+        proc = spawn(config.runtime, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                WINMATRIX_AGENT_ID: config.agentId,
+                WINMATRIX_API_KEY: config.apiKey,
+                WINMATRIX_AGENT_NAME: config.name,
+                WINMATRIX_AGENT_TYPE: config.agentType,
+                WINMATRIX_TASK_ID: taskId,
+                ...task.env,
+            },
+            cwd: workDir ?? process.cwd(),
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendTaskError(taskId, `Failed to spawn runtime: ${message}`);
+        return;
+    }
+    const entry = {
+        taskId,
+        process: proc,
+        abortController: null,
+        startedAt: Date.now(),
+        stdoutChunks: [],
+        completed: false,
+    };
+    runningTasks.set(taskId, entry);
+    proc.stdout?.on('data', (data) => {
+        const text = data.toString('utf-8');
+        entry.stdoutChunks.push(text);
+        const trimmed = text.trimEnd();
+        if (!trimmed)
+            return;
+        sendTaskDelta(taskId, trimmed);
+    });
+    proc.stderr?.on('data', (data) => {
+        const text = data.toString('utf-8').trimEnd();
+        if (!text)
+            return;
+        sendTaskDelta(taskId, text, { source: 'stderr' });
+    });
+    proc.on('exit', (code, signal) => {
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        if (code === 0) {
+            const rawOutput = entry.stdoutChunks.join('');
+            let parsedResult = rawOutput;
+            try {
+                parsedResult = JSON.parse(rawOutput);
+            }
+            catch {
+                // Non-JSON output, keep raw
+            }
+            sendTaskComplete(taskId, parsedResult);
+        }
+        else {
+            sendTaskError(taskId, signal
+                ? `Process killed by signal ${signal}`
+                : `Process exited with code ${code ?? 'null'}`);
+        }
+        cleanupTask(taskId);
+    });
+    proc.on('error', (err) => {
+        if (entry.completed)
+            return;
+        entry.completed = true;
+        sendTaskError(taskId, err.message);
+        cleanupTask(taskId);
+    });
+}
+/* ── Task Cancellation ── */
+function cancelTask(taskId) {
+    const entry = runningTasks.get(taskId);
+    if (!entry)
+        return;
+    if (entry.abortController) {
+        entry.abortController.abort();
+    }
+    if (entry.process) {
+        try {
+            entry.process.kill('SIGTERM');
+            setTimeout(() => {
+                try {
+                    entry.process?.kill('SIGKILL');
+                }
+                catch { /* already dead */ }
+            }, 10000);
+        }
+        catch {
+            // process already exited
+        }
+    }
+    cleanupTask(taskId);
+}
+/* ── Register Flow ── */
+function sendRegister() {
+    if (!config)
+        return;
+    send({
+        type: 'fwd',
+        agentId: config.agentId,
+        data: {
+            type: 'req',
+            id: `wrapper-reg-${config.agentId}`,
+            method: 'register',
+            params: {
+                agentId: config.agentId,
+                apiKey: config.apiKey,
+                name: config.name,
+                agentType: config.agentType,
+                capabilities: {
+                    streaming: true,
+                    toolCall: true,
+                    cancellation: true,
+                },
+            },
+        },
+    });
+}
+/* ── Stdin Event Handling ── */
+async function sendWorkspaceReport() {
+    if (!config?.workDir)
+        return;
+    try {
+        const workdir = await scanWorkDir(config.workDir);
+        // Detect key runtime versions
+        const runtimes = {};
+        const runtimeBinaries = config.runtime ? [config.runtime] : [];
+        for (const bin of runtimeBinaries) {
+            runtimes[bin] = await detectRuntimeInfo(bin);
+        }
+        const payload = {
+            agentId: config.agentId,
+            workdir,
+            runtimes: Object.keys(runtimes).length > 0 ? runtimes : undefined,
+        };
+        send({
+            type: 'fwd',
+            agentId: config.agentId,
+            data: {
+                type: 'event',
+                event: 'workspace.report',
+                payload,
+            },
+        });
+    }
+    catch {
+        // workspace scan failed silently - workDir may be inaccessible
+    }
+}
+function handleServerFrame(data) {
+    if (!config)
+        return;
+    // Handle register response
+    if (data.type === 'res' && data.ok === true) {
+        send({
+            type: 'event',
+            event: 'agent.ready',
+            payload: { agentId: config.agentId, pid: process.pid },
+        });
+        // Fire-and-forget workspace scan after agent is ready
+        if (config.workDir) {
+            sendWorkspaceReport();
+        }
+        return;
+    }
+    if (data.type === 'res' && data.ok === false) {
+        send({
+            type: 'event',
+            event: 'agent.error',
+            payload: {
+                agentId: config.agentId,
+                error: data.error ?? 'registration failed',
+            },
+        });
+        process.exit(1);
+        return;
+    }
+    // Handle task.assign event
+    if (data.type === 'event' && data.event === 'task.assign') {
+        const payload = (data.payload ?? {});
+        if (payload.taskId && payload.input) {
+            routeTask(payload);
+        }
+        return;
+    }
+    // Handle task.cancel event
+    if (data.type === 'event' && data.event === 'task.cancel') {
+        const payload = data.payload;
+        if (payload?.taskId) {
+            cancelTask(payload.taskId);
+        }
+        return;
+    }
+    // Handle reconnect event (Daemon reconnected, re-register)
+    if (data.type === 'event' && data.event === 'reconnect') {
+        sendRegister();
+        return;
+    }
+}
+/* ── Main ── */
+function main() {
+    const args = process.argv.slice(2);
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--') && i + 1 < args.length) {
+            parsed[args[i]] = args[++i];
+        }
+    }
+    const apiKey = process.env.WINMATRIX_API_KEY ?? '';
+    const endpointToken = process.env.WINMATRIX_ENDPOINT_TOKEN ?? undefined;
+    config = {
+        agentId: parsed['--agent-id'] ?? '',
+        apiKey,
+        name: parsed['--name'] ?? '',
+        agentType: parsed['--agent-type'] ?? '',
+        runtime: parsed['--runtime'] ?? '',
+        workDir: parsed['--work-dir'] ?? undefined,
+        hermesEndpoint: parsed['--hermes-endpoint'] ?? undefined,
+        endpoint: parsed['--endpoint'] ?? parsed['--hermes-endpoint'] ?? undefined,
+        endpointToken,
+        mcpBridgeUrl: parsed['--mcp-bridge-url'] ?? undefined,
+        mcpApiKey: parsed['--mcp-api-key'] ?? undefined,
+    };
+    if (!config.agentId || !config.apiKey) {
+        send({
+            type: 'event',
+            event: 'agent.error',
+            payload: {
+                error: 'Missing required --agent-id or WINMATRIX_API_KEY env',
+            },
+        });
+        process.exit(1);
+        return;
+    }
+    // Step 1: Send register frame via stdout (Daemon forwards to Server)
+    sendRegister();
+    // Step 2: Wait for register response and task events via stdin
+    process.stdin.setEncoding('utf-8');
+    let buffer = '';
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const frame = parseStdin(line);
+            if (!frame)
+                continue;
+            const data = frame.data;
+            if (data && typeof data === 'object') {
+                handleServerFrame(data);
+            }
+        }
+    });
+    process.stdin.on('end', () => {
+        shutdown();
+    });
+    process.stdin.resume();
+    // Handle termination signals
+    function shutdown() {
+        // First pass: abort fetch tasks and SIGTERM child processes
+        for (const [, entry] of runningTasks) {
+            if (entry.abortController) {
+                entry.abortController.abort();
+            }
+            if (entry.process) {
+                try {
+                    entry.process.kill('SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+        }
+        // Wait for in-flight fetch tasks to settle (with 5s timeout),
+        // then SIGKILL any remaining child processes.
+        const fetchPromises = [...runningTasks.values()]
+            .filter((e) => e.completionPromise)
+            .map((e) => e.completionPromise);
+        const finalize = () => {
+            for (const [, entry] of runningTasks) {
+                if (entry.process) {
+                    try {
+                        entry.process.kill('SIGKILL');
+                    }
+                    catch { /* already dead */ }
+                }
+            }
+            runningTasks.clear();
+            process.exit(0);
+        };
+        if (fetchPromises.length > 0) {
+            Promise.race([
+                Promise.allSettled(fetchPromises),
+                new Promise((resolve) => setTimeout(resolve, 5000)),
+            ]).finally(finalize);
+        }
+        else {
+            // No fetch tasks: 10s grace for child process SIGTERM → SIGKILL
+            setTimeout(finalize, 10000);
+        }
+    }
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+}
+main();
+//# sourceMappingURL=AgentWrapper.js.map