tuna-agent 0.1.0

package/dist/agents/openclaw-adapter.js

@@ -0,0 +1,217 @@
+import WebSocket from 'ws';
+export class OpenClawAdapter {
+    type = 'openclaw';
+    displayName = 'OpenClaw';
+    gatewayUrl;
+    gatewayWs = null;
+    constructor(config) {
+        this.gatewayUrl = config.openclawGatewayUrl || 'ws://127.0.0.1:18789';
+    }
+    async checkHealth() {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve({ ok: false, message: `OpenClaw Gateway not reachable at ${this.gatewayUrl}` });
+            }, 5000);
+            try {
+                const ws = new WebSocket(this.gatewayUrl);
+                ws.on('open', () => {
+                    clearTimeout(timeout);
+                    ws.close();
+                    resolve({ ok: true, message: `OpenClaw Gateway reachable at ${this.gatewayUrl}` });
+                });
+                ws.on('error', () => {
+                    clearTimeout(timeout);
+                    resolve({ ok: false, message: `OpenClaw Gateway not reachable at ${this.gatewayUrl}` });
+                });
+            }
+            catch {
+                clearTimeout(timeout);
+                resolve({ ok: false, message: `Failed to connect to OpenClaw Gateway at ${this.gatewayUrl}` });
+            }
+        });
+    }
+    async handleTask(task, ws, pendingInputResolvers, signal, _pendingPermissionResolvers) {
+        console.log(`[OpenClaw] Handling task ${task.id}`);
+        // Connect to OpenClaw Gateway
+        const gateway = await this.connectToGateway();
+        if (!gateway) {
+            ws.sendTaskFailed(task.id, `Cannot connect to OpenClaw Gateway at ${this.gatewayUrl}`);
+            return;
+        }
+        // Emit synthetic plan for UI consistency
+        ws.sendProgress(task.id, 'planning', { startedAt: new Date().toISOString() });
+        ws.sendPMMessage(task.id, {
+            sender: 'pm',
+            content: 'Forwarding task to OpenClaw...',
+        });
+        ws.sendPlanReady(task.id, {
+            summary: task.description,
+            subtasks: [{
+                    id: 'openclaw-main',
+                    role: 'fullstack',
+                    description: task.description,
+                    cwd: task.repoPath || '.',
+                    dependencies: [],
+                    status: 'pending',
+                }],
+        });
+        ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
+        ws.sendSubtaskStart(task.id, {
+            id: 'openclaw-main',
+            role: 'fullstack',
+            description: task.description,
+        });
+        // Send task to OpenClaw via Gateway WebSocket
+        try {
+            const result = await this.sendTaskToGateway(gateway, task, ws, pendingInputResolvers);
+            ws.sendSubtaskDone(task.id, {
+                subtaskId: 'openclaw-main',
+                status: 'done',
+                result: result,
+            });
+            ws.sendTaskDone(task.id, {
+                result: result,
+                sessions: [{
+                        session_id: `openclaw-${Date.now()}`,
+                        subtask_id: 'openclaw-main',
+                        status: 'done',
+                        result: result,
+                        cost_usd: 0,
+                        duration_ms: 0,
+                    }],
+            });
+            ws.sendPMMessage(task.id, {
+                sender: 'pm',
+                content: 'OpenClaw completed the task.',
+            });
+            console.log(`[OpenClaw] Task ${task.id} completed`);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            ws.sendSubtaskDone(task.id, {
+                subtaskId: 'openclaw-main',
+                status: 'failed',
+                result: errMsg,
+            });
+            ws.sendTaskFailed(task.id, errMsg);
+            console.error(`[OpenClaw] Task ${task.id} failed:`, errMsg);
+        }
+        finally {
+            gateway.close();
+        }
+    }
+    async dispose() {
+        if (this.gatewayWs) {
+            this.gatewayWs.close();
+            this.gatewayWs = null;
+        }
+    }
+    connectToGateway() {
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => resolve(null), 10000);
+            try {
+                const ws = new WebSocket(this.gatewayUrl);
+                ws.on('open', () => {
+                    clearTimeout(timeout);
+                    resolve(ws);
+                });
+                ws.on('error', () => {
+                    clearTimeout(timeout);
+                    resolve(null);
+                });
+            }
+            catch {
+                clearTimeout(timeout);
+                resolve(null);
+            }
+        });
+    }
+    sendTaskToGateway(gateway, task, ws, pendingInputResolvers) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('OpenClaw Gateway response timeout (5 min)'));
+            }, 5 * 60 * 1000);
+            // Send task message to OpenClaw
+            gateway.send(JSON.stringify({
+                type: 'sessions_send',
+                message: task.description,
+                cwd: task.repoPath,
+            }));
+            let result = '';
+            gateway.on('message', (raw) => {
+                try {
+                    const msg = JSON.parse(raw.toString());
+                    const msgType = msg.type;
+                    switch (msgType) {
+                        case 'thinking':
+                        case 'tool_use':
+                            // Forward as subtask log
+                            ws.sendProgress(task.id, 'subtask_log', {
+                                subtaskId: 'openclaw-main',
+                                log: { type: msgType, message: msg.content || '' },
+                            });
+                            break;
+                        case 'response':
+                        case 'result':
+                            result = msg.content || msg.result || '';
+                            break;
+                        case 'complete':
+                        case 'done':
+                            clearTimeout(timeout);
+                            resolve(result || msg.content || 'Task completed');
+                            break;
+                        case 'error':
+                            clearTimeout(timeout);
+                            reject(new Error(msg.message || msg.error || 'OpenClaw error'));
+                            break;
+                        case 'needs_input': {
+                            const question = msg.question || 'OpenClaw needs input';
+                            ws.sendNeedsInput(task.id, {
+                                subtaskId: 'openclaw-main',
+                                question,
+                            });
+                            ws.sendPMMessage(task.id, {
+                                sender: 'pm',
+                                content: `OpenClaw is asking: ${question}`,
+                            });
+                            // Wait for user answer and forward to gateway
+                            const waitForAnswer = new Promise((resolveInput) => {
+                                pendingInputResolvers.set(task.id, resolveInput);
+                            });
+                            waitForAnswer.then((response) => {
+                                gateway.send(JSON.stringify({
+                                    type: 'input_response',
+                                    answer: response.text,
+                                }));
+                                ws.sendPMMessage(task.id, {
+                                    sender: 'user',
+                                    content: response.text,
+                                });
+                            });
+                            break;
+                        }
+                        default:
+                            // Log unknown messages for debugging
+                            console.log(`[OpenClaw] Gateway message: ${msgType}`);
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            });
+            gateway.on('close', () => {
+                clearTimeout(timeout);
+                if (!result) {
+                    reject(new Error('OpenClaw Gateway connection closed unexpectedly'));
+                }
+                else {
+                    resolve(result);
+                }
+            });
+            gateway.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`OpenClaw Gateway error: ${err.message}`));
+            });
+        });
+    }
+}

package/dist/agents/types.d.ts

@@ -0,0 +1,31 @@
+import type { TaskAssignment, InputResponse } from '../types/index.js';
+import type { AgentWebSocketClient } from '../daemon/ws-client.js';
+export type AgentType = 'claude-code' | 'openclaw';
+export interface AgentConfig {
+    type: AgentType;
+    openclawGatewayUrl?: string;
+}
+/**
+ * AgentAdapter abstracts how a task gets executed.
+ * Each agent type implements this interface.
+ */
+export interface AgentAdapter {
+    readonly type: AgentType;
+    readonly displayName: string;
+    /**
+     * Check if this agent is available/reachable on this machine.
+     */
+    checkHealth(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    /**
+     * Handle a task assignment end-to-end:
+     * plan → execute → report progress/results via ws.
+     */
+    handleTask(task: TaskAssignment, ws: AgentWebSocketClient, pendingInputResolvers: Map<string, (response: InputResponse) => void>, signal?: AbortSignal, pendingPermissionResolvers?: Map<string, (approved: boolean) => void>): Promise<void>;
+    /**
+     * Clean up resources on shutdown.
+     */
+    dispose(): Promise<void>;
+}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/commands/connect.d.ts

@@ -0,0 +1,8 @@
+interface ConnectOptions {
+    apiUrl: string;
+    agentType?: string;
+    openclawPort?: string;
+    force?: boolean;
+}
+export declare function connect(code: string, options: ConnectOptions): Promise<void>;
+export {};

package/dist/cli/commands/connect.js

@@ -0,0 +1,163 @@
+import chalk from 'chalk';
+import readline from 'readline';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getSystemInfo } from '../../system/info.js';
+import { loadConfig, saveConfig } from '../../config/store.js';
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Detect which agent types are available on this machine.
+ */
+function detectAvailableAgents(cliTools) {
+    const agents = [];
+    if (cliTools.includes('claude')) {
+        agents.push({ type: 'claude-code', displayName: 'Claude Code' });
+    }
+    if (cliTools.includes('openclaw')) {
+        agents.push({ type: 'openclaw', displayName: 'OpenClaw' });
+    }
+    // Default: at least offer claude-code
+    if (agents.length === 0) {
+        agents.push({ type: 'claude-code', displayName: 'Claude Code' });
+    }
+    return agents;
+}
+export async function connect(code, options) {
+    const apiUrl = options.apiUrl;
+    // Check if already connected
+    const existing = loadConfig();
+    if (existing && !options.force) {
+        console.log(chalk.yellow('This machine is already connected as:'));
+        console.log(`  Name:   ${existing.name}`);
+        console.log(`  Agent ID: ${existing.agentId}`);
+        console.log(`  Agent:    ${existing.agentType || 'claude-code'}`);
+        console.log(`  Since:    ${existing.connectedAt}`);
+        console.log();
+        const ok = await confirm('Reconnect with a new code? This will replace the current config. (y/N) ');
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+        console.log();
+    }
+    console.log(chalk.cyan('Tuna Agent') + ' — Connecting to Tuna...\n');
+    // Step 1: Detect CLI tools first (need for agent type selection)
+    console.log('Detecting system info...');
+    const preInfo = getSystemInfo();
+    console.log(`  Machine: ${preInfo.hostname}`);
+    console.log(`  OS:      ${preInfo.os}`);
+    console.log(`  CLIs:    ${preInfo.cliTools.length > 0 ? preInfo.cliTools.join(', ') : 'none detected'}`);
+    // Step 2: Determine agent type
+    let agentType = 'claude-code';
+    let agentConfig = undefined;
+    if (options.agentType) {
+        // Explicit via CLI flag
+        if (options.agentType !== 'claude-code' && options.agentType !== 'openclaw') {
+            console.error(chalk.red(`\nInvalid agent type: ${options.agentType}`));
+            console.error('Supported types: claude-code, openclaw');
+            process.exit(1);
+        }
+        agentType = options.agentType;
+    }
+    else {
+        // Auto-detect
+        const detected = detectAvailableAgents(preInfo.cliTools);
+        if (detected.length > 1) {
+            console.log('\n  Available agents:');
+            detected.forEach((a, i) => console.log(`    ${i + 1}. ${a.displayName} (${a.type})`));
+            const choice = await prompt(`\n  Select agent type [1-${detected.length}]: `);
+            const idx = parseInt(choice, 10) - 1;
+            if (idx >= 0 && idx < detected.length) {
+                agentType = detected[idx].type;
+            }
+            else {
+                agentType = detected[0].type;
+            }
+        }
+        else {
+            agentType = detected[0].type;
+        }
+    }
+    // OpenClaw-specific config
+    if (agentType === 'openclaw') {
+        const port = options.openclawPort || '18789';
+        agentConfig = {
+            openclawGatewayUrl: `ws://127.0.0.1:${port}`,
+        };
+    }
+    console.log(`  Agent:   ${agentType}`);
+    // Re-collect system info with correct agent type (for capabilities)
+    const systemInfo = getSystemInfo(agentType);
+    console.log(`  Teams:   ${systemInfo.capabilities.supports_teams ? 'yes' : 'no'}`);
+    console.log();
+    // Step 3: Send connection request to API
+    console.log(`Connecting with code ${chalk.bold(code.toUpperCase())}...`);
+    try {
+        const res = await fetch(`${apiUrl}/machine/connect`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                code: code.trim().toUpperCase(),
+                system_info: systemInfo,
+                agent_type: agentType,
+            }),
+        });
+        const body = await res.json();
+        if (!res.ok || !body.data) {
+            console.error(chalk.red(`\nFailed: ${body.message || 'Unknown error'}`));
+            console.error('Make sure the connection code is valid and not expired (5 min TTL).');
+            process.exit(1);
+        }
+        const { machine_id, machine_token, name } = body.data;
+        // Step 4: Save config
+        const wsUrl = apiUrl.replace(/^http/, 'ws') + '/ws/agent';
+        const config = {
+            agentId: machine_id,
+            agentToken: machine_token,
+            apiUrl,
+            wsUrl,
+            name,
+            connectedAt: new Date().toISOString(),
+            agentType,
+            agentConfig,
+        };
+        saveConfig(config);
+        // Create default workspace folder
+        const workspaceDir = path.join(os.homedir(), 'tuna-workspace');
+        if (!fs.existsSync(workspaceDir)) {
+            fs.mkdirSync(workspaceDir, { recursive: true });
+            console.log(`\nCreated workspace: ${workspaceDir}`);
+        }
+        console.log(chalk.green(`\nConnected successfully!`));
+        console.log(`  Machine ID: ${machine_id}`);
+        console.log(`  Name:       ${name}`);
+        console.log(`  Agent:    ${agentType}`);
+        console.log(`  Config:   ~/.tuna-agent/config.json`);
+        console.log();
+        console.log(`Run ${chalk.cyan('tuna-agent start')} to start the daemon.`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`\nConnection failed: ${msg}`));
+        console.error(`Make sure the API server is running at ${apiUrl}`);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/start.d.ts

@@ -0,0 +1,5 @@
+interface StartOptions {
+    foreground?: boolean;
+}
+export declare function start(options: StartOptions): Promise<void>;
+export {};

package/dist/cli/commands/start.js

@@ -0,0 +1,54 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { loadConfig, isConfigured, isDaemonRunning, savePid } from '../../config/store.js';
+import { startDaemon } from '../../daemon/index.js';
+export async function start(options) {
+    if (!isConfigured()) {
+        console.error(chalk.red('Agent is not configured.'));
+        console.error(`Run ${chalk.cyan('tuna-agent connect <code>')} first.`);
+        process.exit(1);
+    }
+    if (!options.foreground && isDaemonRunning()) {
+        console.log(chalk.yellow('Agent daemon is already running.'));
+        console.log(`Use ${chalk.cyan('tuna-agent stop')} to stop it first.`);
+        return;
+    }
+    const config = loadConfig();
+    if (options.foreground) {
+        // Run in foreground
+        console.log(chalk.cyan('Tuna Agent') + ` — Starting in foreground mode...`);
+        console.log(`  Agent: ${config.name} (${config.agentId})`);
+        console.log(`  API:  ${config.apiUrl}`);
+        console.log();
+        savePid(process.pid);
+        await startDaemon(config);
+    }
+    else {
+        // Daemonize: spawn detached child process
+        console.log(chalk.cyan('Tuna Agent') + ` — Starting daemon...`);
+        const logFile = path.join(os.homedir(), '.tuna-agent', 'daemon.log');
+        const logFd = fs.openSync(logFile, 'a');
+        const child = spawn(process.execPath, [process.argv[1], 'start', '--foreground'], {
+            detached: true,
+            stdio: ['ignore', logFd, logFd],
+            env: { ...process.env },
+        });
+        child.unref();
+        if (child.pid) {
+            savePid(child.pid);
+            console.log(chalk.green(`Daemon started (PID: ${child.pid})`));
+            console.log(`  Agent: ${config.name}`);
+            console.log(`  API:   ${config.apiUrl}`);
+            console.log();
+            console.log(`Use ${chalk.cyan('tuna-agent status')} to check status.`);
+            console.log(`Use ${chalk.cyan('tuna-agent stop')} to stop.`);
+        }
+        else {
+            console.error(chalk.red('Failed to start daemon.'));
+            process.exit(1);
+        }
+    }
+}

package/dist/cli/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/cli/commands/status.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import { loadConfig, isConfigured, isDaemonRunning, readPid } from '../../config/store.js';
+export async function status() {
+    if (!isConfigured()) {
+        console.log(chalk.yellow('Agent is not configured.'));
+        console.log(`Run ${chalk.cyan('tuna-agent connect <code>')} to set up.`);
+        return;
+    }
+    const config = loadConfig();
+    const running = isDaemonRunning();
+    console.log(chalk.cyan('Tuna Agent Status\n'));
+    console.log(`  Name:       ${config.name}`);
+    console.log(`  Agent ID:   ${config.agentId}`);
+    console.log(`  Agent:      ${config.agentType || 'claude-code'}`);
+    if (config.agentType === 'openclaw' && config.agentConfig?.openclawGatewayUrl) {
+        console.log(`  Gateway:    ${config.agentConfig.openclawGatewayUrl}`);
+    }
+    console.log(`  API:        ${config.apiUrl}`);
+    console.log(`  Connected:  ${config.connectedAt}`);
+    console.log(`  Daemon:     ${running ? chalk.green('running') + ` (PID: ${readPid()})` : chalk.red('stopped')}`);
+}

package/dist/cli/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare function stop(): Promise<void>;

package/dist/cli/commands/stop.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { readPid, removePid, isDaemonRunning } from '../../config/store.js';
+export async function stop() {
+    if (!isDaemonRunning()) {
+        console.log(chalk.yellow('Hub daemon is not running.'));
+        return;
+    }
+    const pid = readPid();
+    if (!pid) {
+        console.log(chalk.yellow('No PID file found.'));
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        removePid();
+        console.log(chalk.green(`Hub daemon stopped (PID: ${pid}).`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Failed to stop daemon: ${msg}`));
+        removePid();
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { connect } from './commands/connect.js';
+import { start } from './commands/start.js';
+import { stop } from './commands/stop.js';
+import { status } from './commands/status.js';
+const program = new Command()
+    .name('tuna-agent')
+    .description('Tuna Agent - Run AI coding tasks on your machine')
+    .version('0.1.0');
+program
+    .command('connect <code>')
+    .description('Connect this machine to your Tuna account')
+    .option('-a, --api-url <url>', 'API server URL', 'https://api.dev.tunasm.art')
+    .option('-t, --agent-type <type>', 'Agent type: claude-code or openclaw')
+    .option('--openclaw-port <port>', 'OpenClaw Gateway port', '18789')
+    .option('--force', 'Skip confirmation if already connected')
+    .action(connect);
+program
+    .command('start')
+    .description('Start the agent daemon')
+    .option('-f, --foreground', 'Run in foreground (don\'t daemonize)')
+    .action(start);
+program
+    .command('stop')
+    .description('Stop the agent daemon')
+    .action(stop);
+program
+    .command('status')
+    .description('Show agent connection status')
+    .action(status);
+program.parse();

package/dist/config/store.d.ts

@@ -0,0 +1,29 @@
+import type { AgentConfig } from '../types/index.js';
+/**
+ * Save agent configuration.
+ */
+export declare function saveConfig(config: AgentConfig): void;
+/**
+ * Load agent configuration.
+ */
+export declare function loadConfig(): AgentConfig | null;
+/**
+ * Check if agent is configured.
+ */
+export declare function isConfigured(): boolean;
+/**
+ * Save daemon PID.
+ */
+export declare function savePid(pid: number): void;
+/**
+ * Read daemon PID.
+ */
+export declare function readPid(): number | null;
+/**
+ * Remove daemon PID file.
+ */
+export declare function removePid(): void;
+/**
+ * Check if daemon process is running.
+ */
+export declare function isDaemonRunning(): boolean;