tuna-agent 0.1.0 → 0.1.2

package/dist/mcp/knowledge-server.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Knowledge MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes knowledge tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node knowledge-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let apiUrl = '';
+    let token = '';
+    let agentId = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--api-url' && args[i + 1])
+            apiUrl = args[++i];
+        else if (args[i] === '--token' && args[i + 1])
+            token = args[++i];
+        else if (args[i] === '--agent-id' && args[i + 1])
+            agentId = args[++i];
+    }
+    if (!apiUrl || !token || !agentId) {
+        process.stderr.write('Usage: knowledge-server --api-url URL --token TOKEN --agent-id ID\n');
+        process.exit(1);
+    }
+    return { apiUrl, token, agentId };
+}
+// ===== API Client =====
+async function apiCall(config, method, path, body) {
+    const url = `${config.apiUrl}${path}`;
+    const headers = {
+        'Authorization': `Bearer ${config.token}`,
+        'Content-Type': 'application/json',
+    };
+    const options = { method, headers };
+    if (body)
+        options.body = JSON.stringify(body);
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!res.ok || (json.code && json.code >= 400)) {
+        throw new Error(json.message || `API error: ${res.status}`);
+    }
+    return json.data;
+}
+function sendResponse(res) {
+    // Claude Code uses newline-delimited JSON (not Content-Length framing)
+    process.stdout.write(JSON.stringify(res) + '\n');
+}
+function sendResult(id, result) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, result });
+}
+function sendError(id, code, message) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, error: { code, message } });
+}
+// ===== Tool Definitions =====
+const TOOLS = [
+    {
+        name: 'list_knowledge',
+        description: 'List knowledge items accessible to this agent. Can list root items or items inside a specific folder.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                parent_id: { type: 'string', description: 'Folder ID to list children of. Omit to list root-level items.' },
+            },
+        },
+    },
+    {
+        name: 'read_knowledge',
+        description: 'Read the full content of a knowledge document by its ID. Returns the markdown content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                knowledge_id: { type: 'string', description: 'The ID of the knowledge document to read' },
+            },
+            required: ['knowledge_id'],
+        },
+    },
+    {
+        name: 'create_knowledge',
+        description: 'Create a new knowledge document or folder. Content should be in markdown format for documents.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Name/title of the knowledge item' },
+                content: { type: 'string', description: 'Markdown content (required for documents, omit for folders)' },
+                description: { type: 'string', description: 'Short description of what this item contains' },
+                kind: { type: 'string', enum: ['document', 'folder'], description: 'Type of knowledge item. Default: document' },
+                parent_id: { type: 'string', description: 'Parent folder ID to create inside. Omit for root level.' },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'update_knowledge',
+        description: 'Update an existing knowledge document. Can update name, description, and/or content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                knowledge_id: { type: 'string', description: 'The ID of the knowledge document to update' },
+                name: { type: 'string', description: 'New name (optional)' },
+                content: { type: 'string', description: 'New markdown content (optional)' },
+                description: { type: 'string', description: 'New description (optional)' },
+            },
+            required: ['knowledge_id'],
+        },
+    },
+];
+// ===== Request Handler =====
+async function handleRequest(config, req) {
+    try {
+        switch (req.method) {
+            case 'initialize':
+                sendResult(req.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'tuna-knowledge', version: '1.0.0' },
+                });
+                break;
+            case 'notifications/initialized':
+                // No response needed for notifications
+                break;
+            case 'tools/list':
+                sendResult(req.id, { tools: TOOLS });
+                break;
+            case 'tools/call': {
+                const toolName = req.params?.name ?? '';
+                const args = req.params?.arguments ?? {};
+                const result = await handleToolCall(config, toolName, args);
+                sendResult(req.id, result);
+                break;
+            }
+            case 'ping':
+                sendResult(req.id, {});
+                break;
+            default:
+                if (req.id !== undefined) {
+                    sendError(req.id, -32601, `Method not found: ${req.method}`);
+                }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (req.id !== undefined) {
+            sendError(req.id, -32603, message);
+        }
+    }
+}
+async function handleToolCall(config, toolName, args) {
+    try {
+        switch (toolName) {
+            case 'list_knowledge': {
+                let url = `/agent-knowledge?agent_id=${config.agentId}`;
+                if (args.parent_id)
+                    url += `&parent_id=${args.parent_id}`;
+                const data = await apiCall(config, 'GET', url);
+                const items = data.items || [];
+                if (items.length === 0) {
+                    return { content: [{ type: 'text', text: 'No knowledge items found.' }] };
+                }
+                const listing = items.map((k) => {
+                    const icon = k.kind === 'folder' ? '📁' : '📄';
+                    const meta = k.kind === 'folder'
+                        ? `${k.children_count || 0} items`
+                        : `${k.file_size} bytes`;
+                    return `- ${icon} **${k.name}** (ID: ${k._id}) [${k.kind}]\n  ${k.description || 'No description'}\n  ${meta} | Updated: ${k.updated_at}`;
+                }).join('\n\n');
+                return { content: [{ type: 'text', text: `Found ${items.length} knowledge item(s):\n\n${listing}` }] };
+            }
+            case 'read_knowledge': {
+                if (!args.knowledge_id) {
+                    return { content: [{ type: 'text', text: 'Error: knowledge_id is required' }], isError: true };
+                }
+                const data = await apiCall(config, 'GET', `/agent-knowledge/${args.knowledge_id}`);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ${data.name}\n\n${data.description ? `> ${data.description}\n\n` : ''}${data.content}`,
+                        }],
+                };
+            }
+            case 'create_knowledge': {
+                const isFolder = args.kind === 'folder';
+                if (!args.name) {
+                    return { content: [{ type: 'text', text: 'Error: name is required' }], isError: true };
+                }
+                if (!isFolder && !args.content) {
+                    return { content: [{ type: 'text', text: 'Error: content is required for documents' }], isError: true };
+                }
+                const body = {
+                    name: args.name,
+                    agent_id: config.agentId,
+                };
+                if (args.kind)
+                    body.kind = args.kind;
+                if (args.content)
+                    body.content = args.content;
+                if (args.description)
+                    body.description = args.description;
+                if (args.parent_id)
+                    body.parent_id = args.parent_id;
+                const data = await apiCall(config, 'POST', '/agent-knowledge', body);
+                const label = isFolder ? 'Folder' : 'Knowledge';
+                return { content: [{ type: 'text', text: `${label} "${data.name}" created (ID: ${data._id})` }] };
+            }
+            case 'update_knowledge': {
+                if (!args.knowledge_id) {
+                    return { content: [{ type: 'text', text: 'Error: knowledge_id is required' }], isError: true };
+                }
+                const body = {};
+                if (args.name)
+                    body.name = args.name;
+                if (args.content)
+                    body.content = args.content;
+                if (args.description)
+                    body.description = args.description;
+                const data = await apiCall(config, 'PUT', `/agent-knowledge/${args.knowledge_id}`, body);
+                return { content: [{ type: 'text', text: `Knowledge "${data.name}" updated (ID: ${data._id})` }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${toolName}` }], isError: true };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+}
+// ===== Stdio Transport =====
+function startServer(config) {
+    process.stderr.write(`[knowledge-mcp] Starting with agent ${config.agentId}\n`);
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        // Claude Code sends newline-delimited JSON (one JSON object per line)
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? ''; // Keep incomplete last line in buffer
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const req = JSON.parse(trimmed);
+                handleRequest(config, req).catch((err) => {
+                    process.stderr.write(`[knowledge-mcp] Error handling ${req.method}: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write(`[knowledge-mcp] Failed to parse JSON: ${trimmed.slice(0, 100)}\n`);
+            }
+        }
+    });
+    process.stdin.on('end', () => {
+        process.stderr.write('[knowledge-mcp] stdin closed, shutting down\n');
+        process.exit(0);
+    });
+}
+// ===== Main =====
+const config = parseArgs();
+startServer(config);
+export {};

package/dist/mcp/setup.d.ts

@@ -0,0 +1,20 @@
+import type { AgentConfig } from '../types/index.js';
+/**
+ * Generate MCP server config file for Claude Code.
+ * This file is auto-detected by runClaude and passed via --mcp-config.
+ */
+export declare function setupMcpConfig(config: AgentConfig): string;
+/**
+ * Get the MCP config path if it exists.
+ */
+export declare function getMcpConfigPath(): string | undefined;
+/**
+ * Write MCP server config into agent's folder .mcp.json.
+ * Claude Code reads .mcp.json automatically for project-level MCPs.
+ * Note: .claude/settings.json mcpServers is NOT reliably read by Claude Code CLI.
+ */
+export declare function writeAgentFolderMcpConfig(agentFolderPath: string, config: AgentConfig): void;
+/**
+ * Clean up MCP config file.
+ */
+export declare function cleanupMcpConfig(): void;

package/dist/mcp/setup.js

@@ -0,0 +1,94 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const MCP_CONFIG_DIR = path.join(process.env.HOME || '', '.tuna-agent');
+const MCP_CONFIG_PATH = path.join(MCP_CONFIG_DIR, 'mcp-config.json');
+/**
+ * Generate MCP server config file for Claude Code.
+ * This file is auto-detected by runClaude and passed via --mcp-config.
+ */
+export function setupMcpConfig(config) {
+    const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const browserServerPath = path.join(__dirname, 'browser-server.js');
+    const mcpConfig = {
+        mcpServers: {
+            'tuna-knowledge': {
+                command: process.execPath, // full path to current node binary
+                args: [
+                    knowledgeServerPath,
+                    '--api-url', config.apiUrl,
+                    '--token', config.agentToken,
+                    '--agent-id', config.agentId,
+                ],
+            },
+            'tuna-browser': {
+                command: process.execPath,
+                args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
+            },
+        },
+    };
+    if (!fs.existsSync(MCP_CONFIG_DIR)) {
+        fs.mkdirSync(MCP_CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(MCP_CONFIG_PATH, JSON.stringify(mcpConfig, null, 2));
+    console.log(`[MCP] Config written to ${MCP_CONFIG_PATH}`);
+    return MCP_CONFIG_PATH;
+}
+/**
+ * Get the MCP config path if it exists.
+ */
+export function getMcpConfigPath() {
+    if (fs.existsSync(MCP_CONFIG_PATH)) {
+        return MCP_CONFIG_PATH;
+    }
+    return undefined;
+}
+/**
+ * Write MCP server config into agent's folder .mcp.json.
+ * Claude Code reads .mcp.json automatically for project-level MCPs.
+ * Note: .claude/settings.json mcpServers is NOT reliably read by Claude Code CLI.
+ */
+export function writeAgentFolderMcpConfig(agentFolderPath, config) {
+    const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const browserServerPath = path.join(__dirname, 'browser-server.js');
+    try {
+        const mcpJsonPath = path.join(agentFolderPath, '.mcp.json');
+        // Read existing .mcp.json to preserve other servers (e.g. playwright)
+        let existing = {};
+        if (fs.existsSync(mcpJsonPath)) {
+            existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+        }
+        const existingServers = existing.mcpServers ?? {};
+        existing.mcpServers = {
+            ...existingServers,
+            'tuna-knowledge': {
+                command: process.execPath,
+                args: [
+                    knowledgeServerPath,
+                    '--api-url', config.apiUrl,
+                    '--token', config.agentToken,
+                    '--agent-id', config.agentId,
+                ],
+            },
+            'tuna-browser': {
+                command: process.execPath,
+                args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
+            },
+        };
+        fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
+        console.log(`[MCP] Agent folder .mcp.json written to ${mcpJsonPath}`);
+    }
+    catch (err) {
+        console.warn(`[MCP] Failed to write agent folder .mcp.json:`, err);
+    }
+}
+/**
+ * Clean up MCP config file.
+ */
+export function cleanupMcpConfig() {
+    if (fs.existsSync(MCP_CONFIG_PATH)) {
+        fs.unlinkSync(MCP_CONFIG_PATH);
+    }
+}

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export interface AgentConfig {
     agentConfig?: {
         openclawGatewayUrl?: string;
     };
+    extensionCodes?: string[];
 }
 export interface AgentCapabilities {
     supports_teams: boolean;
@@ -41,6 +42,7 @@ export interface TaskAssignment {
     confirmBeforeEdit?: boolean;
     attachments?: ChatAttachment[];
     source?: 'manual' | 'skill' | 'scheduled' | 'workflow' | 'api';
+    agentId?: string;
 }
 export interface ConnectResponse {
     machine_id: string;

package/dist/utils/claude-cli.d.ts

@@ -20,6 +20,8 @@ export interface ClaudeCliOptions {
     onPermissionRequest?: (tool: string, detail: string) => Promise<boolean>;
     /** Local file paths to pass as input (e.g., images) via --input-file flags */
     inputFiles?: string[];
+    /** Path to MCP server config JSON file (passed via --mcp-config) */
+    mcpConfigPath?: string;
 }
 export interface ClaudeCliResult {
     result: string;

package/dist/utils/claude-cli.js

@@ -1,5 +1,6 @@
 import { spawn, execSync } from 'child_process';
 import { StringDecoder } from 'string_decoder';
+import { getMcpConfigPath } from '../mcp/setup.js';
 /** Cached absolute path to `claude` binary, resolved once at first use */
 let _claudeBinPath = null;
 function getClaudeBinPath() {
@@ -101,6 +102,11 @@ export function runClaude(options) {
             args.push('--tools', ''); // skip built-in tools
             args.push('--disable-slash-commands'); // skip skills/plugins
         }
+        // Auto-detect MCP config for knowledge server (skip if lightweight mode)
+        const mcpConfig = options.mcpConfigPath || (!options.lightweight ? getMcpConfigPath() : undefined);
+        if (mcpConfig) {
+            args.push('--mcp-config', mcpConfig);
+        }
         if (options.permissionMode) {
             args.push('--permission-mode', options.permissionMode);
         }
@@ -111,6 +117,7 @@ export function runClaude(options) {
             }
         }
         const useInteractiveStdin = !!options.permissionMode && !!options.onPermissionRequest;
+        console.log(`[claude-cli] Spawning with args: ${args.filter(a => !a.startsWith('sk-') && a.length < 200).join(' ')}`);
         const claudeBin = getClaudeBinPath();
         // Ensure PATH includes common bin dirs so shebang `#!/usr/bin/env node` resolves
         const spawnPath = [
@@ -120,18 +127,27 @@ export function runClaude(options) {
             `${process.env.HOME}/.local/bin`,
             `${process.env.HOME}/.nvm/versions/node/v20.10.0/bin`,
         ].filter(Boolean).join(':');
+        // Build env: inherit process.env but strip Claude Code session markers
+        // so the spawned claude process is not blocked by nested-session detection.
+        const spawnEnv = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                spawnEnv[k] = v;
+        }
+        // Remove nested-session markers
+        delete spawnEnv['CLAUDECODE'];
+        delete spawnEnv['CLAUDE_CODE_ENTRYPOINT'];
+        delete spawnEnv['CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING'];
+        spawnEnv['HOME'] = process.env.HOME || '';
+        spawnEnv['PATH'] = spawnPath;
+        if (options.agentTeam) {
+            spawnEnv['CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS'] = '1';
+            spawnEnv['CLAUDE_CODE_TEAMMATE_MODE'] = 'in-process';
+        }
         const proc = spawn(claudeBin, args, {
             cwd: options.cwd,
             stdio: [useInteractiveStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                HOME: process.env.HOME || '',
-                PATH: spawnPath,
-                ...(options.agentTeam ? {
-                    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-                    CLAUDE_CODE_TEAMMATE_MODE: 'in-process',
-                } : {}),
-            },
+            env: spawnEnv,
         });
         // 30-minute timeout by default
         const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
@@ -198,6 +214,10 @@ export function runClaude(options) {
         proc.stderr.on('data', (chunk) => {
             const text = stderrDecoder.write(chunk);
             stderr += text;
+            // Log stderr for debugging (MCP server startup errors, etc.)
+            if (text.trim()) {
+                console.log(`[claude-cli] stderr: ${text.trim().substring(0, 300)}`);
+            }
             // Detect permission prompts from Claude Code on stderr
             if (useInteractiveStdin) {
                 handlePermissionPrompt(text, proc, options.onPermissionRequest);

package/dist/utils/message-schemas.d.ts

@@ -29,10 +29,13 @@ export declare const CommandMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"command">;
     command: z.ZodString;
     workspace_path: z.ZodOptional<z.ZodString>;
+    agent_folders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    folder_path: z.ZodOptional<z.ZodString>;
     skill_id: z.ZodOptional<z.ZodString>;
     source_path: z.ZodOptional<z.ZodString>;
     skill_name: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, z.core.$loose>;
 export declare const TaskCancelledSchema: z.ZodObject<{
     type: z.ZodLiteral<"task_cancelled">;
     taskId: z.ZodString;

package/dist/utils/message-schemas.js

@@ -21,11 +21,16 @@ export const CommandMessageSchema = z.object({
     type: z.literal('command'),
     command: z.string().min(1),
     workspace_path: z.string().optional(),
+    // For scan_workspace command
+    agent_folders: z.array(z.string()).optional(),
+    // For rescan_agent_skills command
+    agent_id: z.string().optional(),
+    folder_path: z.string().optional(),
     // For analyze_skill command
     skill_id: z.string().optional(),
     source_path: z.string().optional(),
     skill_name: z.string().optional(),
-});
+}).passthrough();
 export const TaskCancelledSchema = z.object({
     type: z.literal('task_cancelled'),
     taskId: z.string().min(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"
@@ -16,6 +16,7 @@
   "dependencies": {
     "chalk": "^5.4.0",
     "commander": "^13.0.0",
+    "playwright-core": "^1.58.2",
     "ws": "^8.18.0",
     "zod": "^4.3.6"
   },