@exreve/exk 1.0.36 → 1.0.38

package/dist/index.js

@@ -13,6 +13,7 @@ import { agentSessionManager } from './agentSession.js';
 import { getProjectConfig, analyzeProjectWithClaude, saveProjectConfig } from './projectAnalyzer.js';
 import { generateRunnerCode } from './runnerGenerator.js';
 import { startApp, stopApp, restartApp, getAppStatuses, getAppLogs } from './appManager.js';
+import { startSending, startReceiving } from './transferService.js';
 import { spawn, execSync } from 'child_process';
 import readline from 'readline';
 import { fileURLToPath } from 'url';
@@ -1544,6 +1545,20 @@ async function runDaemon(foreground = false, email) {
                     console.log(`[CLI] Emitted error app:control:response`);
                 }
             });
+            // Handle folder transfer — this device is the source (pack & upload)
+            socket.on('transfer:pack', (data) => {
+                if (foreground) {
+                    console.log(`[transfer] Pack request: ${data.sourcePath} (${data.selectedItems?.length || 0} items) → device ${data.destDeviceId.slice(0, 8)}`);
+                }
+                startSending(socket, data, foreground);
+            });
+            // Handle folder transfer — this device is the destination (download & extract)
+            socket.on('transfer:pull', (data) => {
+                if (foreground) {
+                    console.log(`[transfer] Pull request: device ${data.sourceDeviceId.slice(0, 8)} → ${data.destPath} (${(data.totalBytes / (1024 * 1024)).toFixed(1)} MB)`);
+                }
+                startReceiving(socket, data, foreground);
+            });
             socket.on('connect', () => {
                 if (foreground) {
                     console.log(`✓ Connected to backend at ${config.apiUrl}`);

package/dist/transferService.js

@@ -0,0 +1,281 @@
+import { spawn } from 'child_process';
+import { mkdir, unlink } from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import { createHash } from 'crypto';
+import { Readable, Transform } from 'stream';
+// ============ Transfer Service (CLI side) ============
+// Two-phase transfer via HTTP:
+//   Phase 1 (source): tar selected items → HTTP POST to backend
+//   Phase 2 (dest):   HTTP GET from backend → tar extract
+// Socket.IO carries control events + progress/log.
+// ---- Sender ----
+export function startSending(socket, transfer, foreground) {
+    const { transferId, sourcePath, selectedItems } = transfer;
+    const startTime = Date.now();
+    const apiUrl = getApiUrl(socket);
+    const log = (message) => {
+        if (foreground)
+            console.log(`[transfer:send] ${message}`);
+        socket.emit('transfer:log', { transferId, side: 'source', level: 'info', message });
+    };
+    const sendProgress = (phase, bytesTransferred, totalBytes) => {
+        const elapsed = (Date.now() - startTime) / 1000;
+        const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
+        const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
+        socket.emit('transfer:progress', {
+            transferId,
+            side: 'source',
+            phase,
+            bytesTransferred,
+            totalBytes,
+            speed: Math.round(speed),
+            eta: Math.round(eta),
+        });
+    };
+    const sendError = (message) => {
+        console.error(`[transfer:send] Error: ${message}`);
+        socket.emit('transfer:error', { transferId, side: 'source', message });
+    };
+    const items = selectedItems || ['.'];
+    log(`Packing ${items.length} item(s) from ${sourcePath}`);
+    // Estimate size first
+    let totalBytes = 0;
+    const sizeEstimate = spawn('du', ['-sb', ...items.map(i => path.join(sourcePath, i))], { cwd: sourcePath });
+    let duOutput = '';
+    sizeEstimate.stdout.on('data', (d) => { duOutput += d.toString(); });
+    sizeEstimate.on('close', (code) => {
+        if (code === 0) {
+            const lines = duOutput.trim().split('\n');
+            for (const line of lines) {
+                const match = line.match(/^(\d+)/);
+                if (match)
+                    totalBytes += parseInt(match[1], 10);
+            }
+        }
+        log(`Estimated size: ${formatBytes(totalBytes)}`);
+        doPackAndUpload();
+    });
+    sizeEstimate.on('error', () => doPackAndUpload());
+    function doPackAndUpload() {
+        // Create tar with selected items
+        const tarArgs = ['cf', '-', '-C', sourcePath, ...items];
+        const tar = spawn('tar', tarArgs);
+        const hash = createHash('sha256');
+        let bytesTransferred = 0;
+        let lastProgressTime = Date.now();
+        let fileCount = 0;
+        // Count files as we go (approximate from tar output)
+        tar.stderr.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (msg)
+                log(`tar: ${msg}`);
+        });
+        tar.on('error', (err) => {
+            sendError(`tar process error: ${err.message}`);
+        });
+        tar.on('close', (code) => {
+            if (code !== 0) {
+                sendError(`tar exited with code ${code}`);
+                return;
+            }
+            log(`Packing complete. Final size: ${formatBytes(bytesTransferred)}`);
+            const sha256 = hash.digest('hex');
+            const duration = Date.now() - startTime;
+            // Notify backend that upload is done
+            socket.emit('transfer:uploaded', {
+                transferId,
+                totalBytes: bytesTransferred,
+                sha256,
+                fileCount,
+            });
+            log(`Upload complete: ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (sha256: ${sha256.slice(0, 12)}...)`);
+        });
+        // Stream tar output through hash, then HTTP POST
+        const uploadUrl = `${apiUrl}/transfer/${transferId}/upload`;
+        // Pipe tar stdout → hash transform → HTTP upload
+        const hashTransform = new Transform({
+            transform(chunk, _encoding, callback) {
+                hash.update(chunk);
+                bytesTransferred += chunk.length;
+                if (Date.now() - lastProgressTime > 500) {
+                    sendProgress('uploading', bytesTransferred, totalBytes || bytesTransferred);
+                    lastProgressTime = Date.now();
+                }
+                this.push(chunk);
+                callback();
+            },
+        });
+        // Use fetch with streaming body for the upload
+        const tarStream = tar.stdout.pipe(hashTransform);
+        // Node 18+ supports ReadableStream in fetch body
+        const nodeStream = Readable.toWeb(tarStream);
+        fetch(uploadUrl, {
+            method: 'POST',
+            body: nodeStream,
+            headers: {
+                'Content-Type': 'application/x-tar',
+                'Transfer-Encoding': 'chunked',
+            },
+            duplex: 'half',
+        }).then(async (res) => {
+            if (!res.ok) {
+                const text = await res.text();
+                sendError(`Upload failed: HTTP ${res.status} ${text}`);
+            }
+        }).catch((err) => {
+            sendError(`Upload network error: ${err.message}`);
+        });
+        // Handle cancellation
+        const cancelHandler = (data) => {
+            if (data.transferId === transferId) {
+                tar.kill('SIGKILL');
+                socket.off('transfer:cancel', cancelHandler);
+                log('Transfer cancelled');
+            }
+        };
+        socket.on('transfer:cancel', cancelHandler);
+    }
+}
+// ---- Receiver ----
+export function startReceiving(socket, transfer, foreground) {
+    const { transferId, destPath } = transfer;
+    const startTime = Date.now();
+    const apiUrl = getApiUrl(socket);
+    const expectedBytes = transfer.totalBytes || 0;
+    const expectedSha256 = transfer.sha256 || '';
+    const log = (message) => {
+        if (foreground)
+            console.log(`[transfer:recv] ${message}`);
+        socket.emit('transfer:log', { transferId, side: 'dest', level: 'info', message });
+    };
+    const sendProgress = (phase, bytesTransferred, totalBytes) => {
+        const elapsed = (Date.now() - startTime) / 1000;
+        const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
+        const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
+        socket.emit('transfer:progress', {
+            transferId,
+            side: 'dest',
+            phase,
+            bytesTransferred,
+            totalBytes,
+            speed: Math.round(speed),
+            eta: Math.round(eta),
+        });
+    };
+    const sendError = (message) => {
+        console.error(`[transfer:recv] Error: ${message}`);
+        socket.emit('transfer:error', { transferId, side: 'dest', message });
+    };
+    const tmpFile = path.join(os.tmpdir(), `ttc-transfer-${transferId}.tar`);
+    log(`Downloading from backend...`);
+    mkdir(destPath, { recursive: true }).then(async () => {
+        try {
+            const downloadUrl = `${apiUrl}/transfer/${transferId}/download`;
+            const res = await fetch(downloadUrl);
+            if (!res.ok) {
+                sendError(`Download failed: HTTP ${res.status}`);
+                return;
+            }
+            if (!res.body) {
+                sendError('Download failed: no response body');
+                return;
+            }
+            // Stream download to temp file while hashing
+            const writeStream = fsSync.createWriteStream(tmpFile);
+            const hash = createHash('sha256');
+            let bytesReceived = 0;
+            let lastProgressTime = Date.now();
+            const reader = res.body.getReader();
+            // Read chunks from the response stream
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                writeStream.write(value);
+                hash.update(value);
+                bytesReceived += value.length;
+                if (Date.now() - lastProgressTime > 500) {
+                    sendProgress('downloading', bytesReceived, expectedBytes || bytesReceived);
+                    lastProgressTime = Date.now();
+                }
+            }
+            writeStream.end();
+            log(`Downloaded ${formatBytes(bytesReceived)}. Verifying...`);
+            // Verify hash
+            const receivedHash = hash.digest('hex');
+            if (expectedSha256 && receivedHash !== expectedSha256) {
+                sendError(`Hash mismatch! Expected ${expectedSha256.slice(0, 16)}... got ${receivedHash.slice(0, 16)}...`);
+                try {
+                    await unlink(tmpFile);
+                }
+                catch { }
+                return;
+            }
+            log(`Hash verified ✓. Extracting to ${destPath}...`);
+            sendProgress('extracting', bytesReceived, bytesReceived);
+            // Extract tar
+            const extractProc = spawn('tar', ['xf', tmpFile, '-C', destPath]);
+            await new Promise((resolve, reject) => {
+                extractProc.on('close', (code) => {
+                    if (code !== 0)
+                        reject(new Error(`tar extraction failed with code ${code}`));
+                    else
+                        resolve();
+                });
+                extractProc.on('error', reject);
+            });
+            // Cleanup temp file
+            try {
+                await unlink(tmpFile);
+            }
+            catch { }
+            const duration = Date.now() - startTime;
+            socket.emit('transfer:complete', {
+                transferId,
+                totalBytes: bytesReceived,
+                sha256: receivedHash,
+                duration,
+                fileCount: 0,
+            });
+            log(`Complete! ${formatBytes(bytesReceived)} extracted to ${destPath} in ${(duration / 1000).toFixed(1)}s`);
+        }
+        catch (err) {
+            sendError(`Download/extract error: ${err.message}`);
+            try {
+                await unlink(tmpFile);
+            }
+            catch { }
+        }
+    }).catch((err) => {
+        sendError(`Failed to create destination directory: ${err.message}`);
+    });
+}
+// ---- Helpers ----
+function getApiUrl(socket) {
+    // Extract the base URL from the socket connection
+    const io = socket.io;
+    const opts = io.opts;
+    if (opts?.hostname) {
+        const protocol = opts.secure !== false ? 'https' : 'http';
+        const port = opts.port ? `:${opts.port}` : '';
+        return `${protocol}://${opts.hostname}${port}`;
+    }
+    // Fallback: read from config
+    try {
+        const configPath = path.join(os.homedir(), '.talk-to-code', 'config.json');
+        const config = JSON.parse(fsSync.readFileSync(configPath, 'utf-8'));
+        return config.apiUrl || 'https://api.talk-to-code.com';
+    }
+    catch {
+        return 'https://api.talk-to-code.com';
+    }
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {

package/dist/test-mcp-minimax.js

@@ -1,252 +0,0 @@
-/**
- * End-to-end test: verifies that a custom MCP tool is visible when using
- * the z.ai GLM-4.7 provider through the Claude Agent SDK.
- *
- * What it tests:
- *  1. z.ai API key is present in ai-config.json
- *  2. SDK query() connects to z.ai endpoint (api.z.ai/api/anthropic)
- *  3. Custom MCP tool (inspect_visual) is registered and visible to the model
- *  4. Model can invoke the custom tool and receive a response
- *
- * Usage:  cd cli && npx tsx test-mcp-minimax.ts
- */
-import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-// ── Config ──────────────────────────────────────────────────────────
-const AI_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'ai-config.json');
-const ZAI_BASE_URL = 'https://api.z.ai/api/anthropic';
-const ZAI_MODEL = 'glm-4.7';
-function loadConfig() {
-    try {
-        return JSON.parse(fs.readFileSync(AI_CONFIG_PATH, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-// ── MCP Server (mirrors moduleMcpServer.ts) ─────────────────────────
-const TOOL_INVOCATION_LOG = [];
-const mcpServer = createSdkMcpServer({
-    name: 'claude-voice-modules',
-    version: '1.0.0',
-    tools: [
-        tool('inspect_visual', 'Inspect a visual file (image/diagram) and answer a question about it.', {
-            file_path: z.string().describe('Path to the visual file to inspect'),
-            question: z.string().describe('Question about the visual content'),
-        }, async (args) => {
-            const msg = `[TEST TOOL INVOKED] file_path=${args.file_path}, question=${args.question}`;
-            TOOL_INVOCATION_LOG.push(msg);
-            console.log(`  >> ${msg}`);
-            return {
-                content: [{ type: 'text', text: `[TEST] Mock inspection of ${args.file_path}: This is a test visual response for "${args.question}".` }],
-            };
-        }),
-        // Extra sentinel tool to ensure multiple tools show up
-        tool('get_system_status', 'Return the current system status for debugging.', {}, async () => {
-            TOOL_INVOCATION_LOG.push('get_system_status invoked');
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ status: 'ok', timestamp: Date.now() }) }],
-            };
-        }),
-    ],
-});
-// ── Helpers ─────────────────────────────────────────────────────────
-const GREEN = '\x1b[32m';
-const RED = '\x1b[31m';
-const YELLOW = '\x1b[33m';
-const CYAN = '\x1b[36m';
-const RESET = '\x1b[0m';
-function pass(msg) { console.log(`${GREEN}  PASS${RESET} ${msg}`); }
-function fail(msg) { console.log(`${RED}  FAIL${RESET} ${msg}`); }
-function info(msg) { console.log(`${CYAN}  INFO${RESET} ${msg}`); }
-function warn(msg) { console.log(`${YELLOW}  WARN${RESET} ${msg}`); }
-// ── Main ────────────────────────────────────────────────────────────
-async function main() {
-    console.log('\n========================================');
-    console.log('  MCP + z.ai GLM-4.7 End-to-End Test');
-    console.log('========================================\n');
-    let passed = 0;
-    let failed = 0;
-    // ── Step 1: Load config ───────────────────────────────────────────
-    console.log('--- Step 1: Load ai-config.json ---');
-    const config = loadConfig();
-    const zaiKey = '5241b3b4c23d4711a59f620cb1b8b594.YLhxVGruW2LGreBH';
-    if (!zaiKey) {
-        fail('No z.ai API key found (ai-config.json apiKey or ZHIPU_API_KEY env)');
-        console.log('\nSet the key with:  ttc config --api-key <key>');
-        failed++;
-        process.exit(1);
-    }
-    else {
-        pass('z.ai API key found');
-        passed++;
-    }
-    // ── Step 2: Build env (mirrors envForClaudeCodeChild) ─────────────
-    console.log('\n--- Step 2: Build environment ---');
-    const env = {
-        ...process.env,
-        ANTHROPIC_API_KEY: zaiKey,
-        ANTHROPIC_BASE_URL: ZAI_BASE_URL,
-        ANTHROPIC_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_SONNET_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_OPUS_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_HAIKU_MODEL: ZAI_MODEL,
-        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
-        CLAUDE_CONFIG_DIR: path.join(os.homedir(), '.talk-to-code', 'empty-config-dir'),
-    };
-    // Strip host Anthropic vars that could interfere
-    delete process.env.ANTHROPIC_API_KEY;
-    delete process.env.ANTHROPIC_BASE_URL;
-    info(`ANTHROPIC_BASE_URL = ${env.ANTHROPIC_BASE_URL}`);
-    info(`ANTHROPIC_MODEL    = ${env.ANTHROPIC_MODEL}`);
-    info(`API key prefix     = ${zaiKey.slice(0, 8)}...`);
-    pass('Environment configured for z.ai GLM-4.7');
-    passed++;
-    // ── Step 3: Run query — ask model to list tools ──────────────────
-    console.log('\n--- Step 3: Query model (ask to list tools) ---');
-    info('Sending prompt to z.ai GLM-4.7 via SDK query()...');
-    const settingsEnv = {
-        ANTHROPIC_API_KEY: zaiKey,
-        ANTHROPIC_BASE_URL: ZAI_BASE_URL,
-        ANTHROPIC_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_SONNET_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_OPUS_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_HAIKU_MODEL: ZAI_MODEL,
-        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
-    };
-    let assistantText = '';
-    let resultReceived = false;
-    let sessionId;
-    let toolUseSeen = false;
-    let numTurns = 0;
-    try {
-        const q = query({
-            prompt: [
-                'List every MCP tool you have available by name.',
-                'Specifically check: do you have "inspect_visual" and "get_system_status"?',
-                'If you do, call the "get_system_status" tool to prove it works.',
-                'Keep your response concise.',
-            ].join(' '),
-            options: {
-                apiKey: zaiKey,
-                model: ZAI_MODEL,
-                cwd: '/tmp',
-                permissionMode: 'bypassPermissions',
-                allowDangerouslySkipPermissions: true,
-                disallowedTools: ['AskUserQuestion'],
-                mcpServers: { 'claude-voice-modules': mcpServer },
-                maxTurns: 5,
-                env,
-                settings: { env: settingsEnv },
-            },
-        });
-        for await (const event of q) {
-            if (event.type === 'system' && event.subtype === 'init') {
-                sessionId = event.session_id;
-                info(`Session started: ${sessionId}`);
-            }
-            if (event.type === 'assistant') {
-                const text = event.message?.content
-                    ?.filter((b) => b.type === 'text')
-                    ?.map((b) => b.text)
-                    ?.join('') || '';
-                // Detect tool_use blocks
-                const toolUses = event.message?.content
-                    ?.filter((b) => b.type === 'tool_use')
-                    ?.map((b) => b.name) || [];
-                if (toolUses.length > 0) {
-                    toolUseSeen = true;
-                    info(`Model requested tools: ${toolUses.join(', ')}`);
-                }
-                if (text) {
-                    assistantText += text;
-                    console.log(`\n${CYAN}[Assistant]${RESET} ${text}`);
-                }
-            }
-            if (event.type === 'result') {
-                numTurns = event.num_turns || 0;
-                resultReceived = true;
-                if (event.is_error) {
-                    warn('Result had is_error=true');
-                }
-            }
-        }
-    }
-    catch (err) {
-        fail(`Query threw error: ${err.message}`);
-        console.error(err);
-        failed++;
-    }
-    // ── Step 4: Validate results ─────────────────────────────────────
-    console.log('\n--- Step 4: Validate results ---');
-    if (resultReceived) {
-        pass('Query completed (result event received)');
-        passed++;
-    }
-    else {
-        fail('Query did not produce a result event');
-        failed++;
-    }
-    if (assistantText.length > 0) {
-        pass(`Model responded with text (${assistantText.length} chars)`);
-        passed++;
-    }
-    else {
-        fail('Model produced no text output');
-        failed++;
-    }
-    const textLower = assistantText.toLowerCase();
-    const sawInspectVisual = textLower.includes('inspect_visual');
-    const sawSystemStatus = textLower.includes('get_system_status') || textLower.includes('system_status');
-    if (sawInspectVisual) {
-        pass('Model acknowledges "inspect_visual" tool');
-        passed++;
-    }
-    else {
-        fail('Model did NOT mention "inspect_visual" in its response');
-        failed++;
-    }
-    if (sawSystemStatus) {
-        pass('Model acknowledges "get_system_status" tool');
-        passed++;
-    }
-    else {
-        warn('Model did not mention "get_system_status" (may be OK if it focused on inspect_visual)');
-    }
-    if (toolUseSeen) {
-        pass('Model issued at least one tool_use request');
-        passed++;
-    }
-    else {
-        fail('Model did not attempt any tool_use');
-        failed++;
-    }
-    if (TOOL_INVOCATION_LOG.length > 0) {
-        pass(`Custom tool was invoked! (${TOOL_INVOCATION_LOG.length} call(s))`);
-        passed++;
-        TOOL_INVOCATION_LOG.forEach((entry) => info(`  -> ${entry}`));
-    }
-    else {
-        fail('Custom tool was never invoked by the model');
-        failed++;
-    }
-    // ── Summary ───────────────────────────────────────────────────────
-    console.log('\n========================================');
-    const total = passed + failed;
-    if (failed === 0) {
-        console.log(`  ${GREEN}ALL ${passed}/${total} TESTS PASSED${RESET}`);
-    }
-    else {
-        console.log(`  ${RED}${failed}/${total} TESTS FAILED${RESET}`);
-    }
-    console.log(`  Turns: ${numTurns} | Session: ${sessionId || 'N/A'}`);
-    console.log('========================================\n');
-    process.exit(failed > 0 ? 1 : 0);
-}
-main().catch((err) => {
-    console.error('Unhandled error:', err);
-    process.exit(1);
-});

package/dist/test-mcp-spawn-repro.js

@@ -1,187 +0,0 @@
-/**
- * Final verification: full project options with FIXED hooks format.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { spawn } from 'child_process';
-import path from 'path';
-import os from 'os';
-import { createModuleMcpServer } from './moduleMcpServer.js';
-const ZAI_BASE_URL = 'https://api.z.ai/api/anthropic';
-const ZAI_MODEL = 'glm-4.7';
-const ZAI_KEY = '5241b3b4c23d4711a59f620cb1b8b594.YLhxVGruW2LGreBH';
-const C = '\x1b[36m', X = '\x1b[0m', G = '\x1b[32m', R = '\x1b[31m';
-const info = (m) => console.log(`${C}  INFO${X} ${m}`);
-const pass = (m) => console.log(`${G}  PASS${X} ${m}`);
-const fail = (m) => console.log(`${R}  FAIL${X} ${m}`);
-async function main() {
-    console.log(`\n${'='.repeat(50)}`);
-    console.log('  Final verification: full project options + fixed hooks');
-    console.log(`${'='.repeat(50)}\n`);
-    let passed = 0, failed = 0;
-    // Real module MCP server
-    const moduleServer = createModuleMcpServer({ attachmentDir: '/tmp' });
-    // Custom spawn (mirrors agentSession.ts)
-    const customSpawn = (spawnOptions) => {
-        const { command, args, cwd, env, signal } = spawnOptions;
-        const spawnEnv = {
-            ...env,
-            PATH: env.PATH || process.env.PATH || '/usr/local/bin:/usr/bin:/bin',
-            HOME: env.HOME || process.env.HOME || os.homedir(),
-            USER: env.USER || process.env.USER || 'user',
-        };
-        try {
-            const nodePath = require('child_process').execSync('which node', { encoding: 'utf-8', env: spawnEnv }).trim();
-            if (nodePath) {
-                return spawn(nodePath, args, {
-                    cwd: cwd || process.cwd(),
-                    stdio: ['pipe', 'pipe', 'ignore'],
-                    signal,
-                    env: spawnEnv,
-                    windowsHide: true,
-                    detached: true,
-                });
-            }
-        }
-        catch { }
-        return spawn(command, args, {
-            cwd: cwd || process.cwd(),
-            stdio: ['pipe', 'pipe', 'ignore'],
-            signal,
-            env: spawnEnv,
-            windowsHide: true,
-            detached: true,
-        });
-    };
-    // Env (mirrors envForClaudeCodeChild)
-    const env = { ...process.env };
-    delete env.ANTHROPIC_API_KEY;
-    delete env.ANTHROPIC_BASE_URL;
-    delete env.ANTHROPIC_AUTH_TOKEN;
-    delete env.ANTHROPIC_MODEL;
-    delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
-    delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
-    delete env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
-    env.ANTHROPIC_API_KEY = ZAI_KEY;
-    env.ANTHROPIC_BASE_URL = ZAI_BASE_URL;
-    env.ANTHROPIC_MODEL = ZAI_MODEL;
-    env.ANTHROPIC_DEFAULT_SONNET_MODEL = ZAI_MODEL;
-    env.ANTHROPIC_DEFAULT_OPUS_MODEL = ZAI_MODEL;
-    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = ZAI_MODEL;
-    env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = '1';
-    env.CLAUDE_CONFIG_DIR = path.join(os.homedir(), '.talk-to-code', 'empty-config-dir');
-    const settingsEnv = {
-        ANTHROPIC_API_KEY: ZAI_KEY, ANTHROPIC_BASE_URL: ZAI_BASE_URL,
-        ANTHROPIC_MODEL: ZAI_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL: ZAI_MODEL,
-        ANTHROPIC_DEFAULT_OPUS_MODEL: ZAI_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL: ZAI_MODEL,
-        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
-    };
-    // Full project options with FIXED hooks
-    const opts = {
-        apiKey: ZAI_KEY,
-        model: ZAI_MODEL,
-        cwd: '/tmp',
-        tools: { type: 'preset', preset: 'claude_code' },
-        disallowedTools: ['AskUserQuestion', 'analyze_image'],
-        settingSources: ['project'],
-        permissionMode: 'bypassPermissions',
-        allowDangerouslySkipPermissions: true,
-        mcpServers: { 'claude-voice-modules': moduleServer },
-        spawnClaudeCodeProcess: customSpawn,
-        env,
-        settings: { env: settingsEnv },
-        maxTurns: 5,
-        hooks: {
-            // FIXED: HookCallbackMatcher format — each entry is { hooks: [callback] }
-            PostToolUse: [{
-                    hooks: [(_r) => ({ continue: true })]
-                }],
-            Notification: [{
-                    hooks: [(n) => ({ continue: true })]
-                }],
-        },
-    };
-    info('Running query with ALL project options + fixed hooks...');
-    let assistantText = '';
-    let resultReceived = false;
-    let toolUseSeen = false;
-    try {
-        const q = query({
-            prompt: 'List all MCP tools. Do you see claude-voice-modules tools? Call analyze_image with image_path="/tmp/test.png" question="test".',
-            options: opts,
-        });
-        for await (const event of q) {
-            if (event.type === 'system' && event.subtype === 'init') {
-                info(`Session: ${event.session_id}`);
-            }
-            if (event.type === 'assistant') {
-                const text = event.message?.content
-                    ?.filter((b) => b.type === 'text')
-                    ?.map((b) => b.text)
-                    ?.join('') || '';
-                const toolUses = event.message?.content
-                    ?.filter((b) => b.type === 'tool_use')
-                    ?.map((b) => b.name) || [];
-                if (toolUses.length > 0) {
-                    toolUseSeen = true;
-                    info(`Tool use: ${toolUses.join(', ')}`);
-                }
-                if (text) {
-                    assistantText += text;
-                    console.log(`\n${C}[Asst]${X} ${text}`);
-                }
-            }
-            if (event.type === 'result') {
-                resultReceived = true;
-                if (event.is_error)
-                    info('Result had is_error=true');
-            }
-        }
-    }
-    catch (err) {
-        fail(`Query error: ${err.message}`);
-        console.error(err);
-        failed++;
-    }
-    console.log('\n--- Results ---');
-    if (resultReceived) {
-        pass('Query completed');
-        passed++;
-    }
-    else {
-        fail('No result event');
-        failed++;
-    }
-    if (assistantText.length > 0) {
-        pass(`Model responded (${assistantText.length} chars)`);
-        passed++;
-    }
-    else {
-        fail('No text output');
-        failed++;
-    }
-    const seesOurTools = assistantText.includes('claude-voice-modules');
-    if (seesOurTools) {
-        pass('Model sees claude-voice-modules MCP server');
-        passed++;
-    }
-    else {
-        fail('Model does NOT see our MCP server');
-        failed++;
-    }
-    if (toolUseSeen) {
-        pass('Model issued tool_use');
-        passed++;
-    }
-    else {
-        fail('No tool_use from model');
-        failed++;
-    }
-    console.log(`\n${'='.repeat(50)}`);
-    const total = passed + failed;
-    console.log(failed === 0
-        ? `  ${G}ALL ${passed}/${total} PASSED${X}`
-        : `  ${R}${failed}/${total} FAILED${X}`);
-    console.log(`${'='.repeat(50)}\n`);
-    process.exit(failed > 0 ? 1 : 0);
-}
-main().catch(err => { console.error(err); process.exit(1); });

package/dist/test-mcp-tool.js

@@ -1,50 +0,0 @@
-/**
- * Test: verify that a custom MCP tool is visible to the Claude Agent SDK.
- * Usage: npx tsx test-mcp-tool.ts
- */
-import { query, createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-const AI_CONFIG = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.talk-to-code', 'ai-config.json'), 'utf-8'));
-// Create a trivial test tool
-const mcpServer = createSdkMcpServer({
-    name: 'test-tools',
-    version: '1.0.0',
-    tools: [
-        tool('analyze_image', 'Analyze an image file. Returns a text description.', {
-            image_path: z.string().describe('Path to image'),
-            question: z.string().describe('What to answer about the image'),
-        }, async (args) => ({
-            content: [{ type: 'text', text: `[TEST] Would analyze ${args.image_path} with question: ${args.question}` }],
-        })),
-    ],
-});
-console.log('=== MCP server created ===');
-// Now run a query with the CORRECT format (Record<string, config>)
-console.log('\n--- Running query (mcpServers as Record) ---');
-const q = query({
-    prompt: 'List every tool you have available by name. Specifically, do you have an "analyze_image" tool? Just answer with the list.',
-    options: {
-        apiKey: AI_CONFIG.authToken,
-        model: AI_CONFIG.model,
-        cwd: '/tmp',
-        permissionMode: 'bypassPermissions',
-        allowDangerouslySkipPermissions: true,
-        disallowedTools: ['AskUserQuestion', 'analyze_image'],
-        mcpServers: { 'claude-voice-modules': mcpServer },
-        maxTurns: 2,
-    },
-});
-for await (const event of q) {
-    if (event.type === 'assistant') {
-        const text = event.message?.content
-            ?.filter((b) => b.type === 'text')
-            ?.map((b) => b.text)
-            ?.join('') || '';
-        if (text)
-            console.log('Agent:', text);
-    }
-}
-console.log('\n--- Done ---');