pikiclaw 0.2.35

package/dist/driver-gemini.js

@@ -0,0 +1,230 @@
+/**
+ * driver-gemini.ts — Gemini CLI agent driver.
+ *
+ * Requires `gemini` CLI installed (https://github.com/google-gemini/gemini-cli).
+ * Stream protocol: spawns `gemini` with JSON output and parses stdout line-by-line.
+ */
+import { registerDriver } from './agent-driver.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { run, agentLog, detectAgentBin, pushRecentActivity, listPikiclawSessions, isPendingSessionId, emptyUsage, } from './code-agent.js';
+// ---------------------------------------------------------------------------
+// Command & parser
+// ---------------------------------------------------------------------------
+function geminiCmd(o) {
+    const args = ['gemini', '--output-format', 'stream-json'];
+    if (o.geminiModel)
+        args.push('--model', o.geminiModel);
+    if (o.sessionId)
+        args.push('--resume', o.sessionId);
+    if (o.mcpConfigPath)
+        args.push('--mcp-config', o.mcpConfigPath);
+    if (o.geminiExtraArgs?.length)
+        args.push(...o.geminiExtraArgs);
+    // gemini's -p requires the prompt as its value (not via stdin)
+    args.push('-p', o.prompt);
+    return args;
+}
+function geminiParse(ev, s) {
+    const t = ev.type || '';
+    // init event: {"type":"init","session_id":"...","model":"..."}
+    if (t === 'init') {
+        s.sessionId = ev.session_id ?? s.sessionId;
+        s.model = ev.model ?? s.model;
+    }
+    // message delta: {"type":"message","role":"assistant","content":"...","delta":true}
+    if (t === 'message' && ev.role === 'assistant' && ev.delta) {
+        s.text += ev.content || '';
+    }
+    // tool_call event (if gemini uses tools)
+    if (t === 'tool_call') {
+        const name = ev.name || ev.tool || 'tool';
+        pushRecentActivity(s.recentActivity, `Using ${name}...`);
+        s.activity = s.recentActivity.join('\n');
+    }
+    // tool_result event
+    if (t === 'tool_result') {
+        const name = ev.name || ev.tool || 'tool';
+        pushRecentActivity(s.recentActivity, `${name} done`);
+        s.activity = s.recentActivity.join('\n');
+    }
+    // result event: {"type":"result","status":"success","stats":{...}}
+    if (t === 'result') {
+        s.sessionId = ev.session_id ?? s.sessionId;
+        if (ev.status === 'error' || ev.status === 'failure') {
+            s.errors = [ev.error || ev.message || `Gemini returned status: ${ev.status}`];
+        }
+        s.stopReason = ev.status === 'success' ? 'end_turn' : ev.status;
+        const u = ev.stats;
+        if (u) {
+            s.inputTokens = u.input_tokens ?? u.input ?? s.inputTokens;
+            s.outputTokens = u.output_tokens ?? u.output ?? s.outputTokens;
+            s.cachedInputTokens = u.cached ?? s.cachedInputTokens;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Stream
+// ---------------------------------------------------------------------------
+export async function doGeminiStream(opts) {
+    // Prompt is passed as -p argument; send empty stdin so run() doesn't duplicate it
+    const streamOpts = { ...opts, _stdinOverride: '' };
+    return run(geminiCmd(opts), streamOpts, geminiParse);
+}
+// ---------------------------------------------------------------------------
+// Sessions / Tail
+// ---------------------------------------------------------------------------
+/** Resolve Gemini project name for a workdir from ~/.gemini/projects.json */
+function geminiProjectName(workdir) {
+    const home = process.env.HOME || '';
+    if (!home)
+        return null;
+    const projectsPath = path.join(home, '.gemini', 'projects.json');
+    try {
+        const data = JSON.parse(fs.readFileSync(projectsPath, 'utf8'));
+        const projects = data?.projects;
+        if (!projects || typeof projects !== 'object')
+            return null;
+        const resolved = path.resolve(workdir);
+        // Exact match first, then check entries
+        if (projects[resolved])
+            return projects[resolved];
+        for (const [dir, name] of Object.entries(projects)) {
+            if (path.resolve(dir) === resolved)
+                return name;
+        }
+    }
+    catch { /* skip */ }
+    return null;
+}
+/** Read native Gemini CLI sessions from ~/.gemini/tmp/{projectName}/chats/ */
+function getNativeGeminiSessions(workdir) {
+    const home = process.env.HOME || '';
+    if (!home)
+        return [];
+    const projectName = geminiProjectName(workdir);
+    if (!projectName)
+        return [];
+    const chatsDir = path.join(home, '.gemini', 'tmp', projectName, 'chats');
+    if (!fs.existsSync(chatsDir))
+        return [];
+    const sessions = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(chatsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith('session-') || !entry.name.endsWith('.json'))
+            continue;
+        const filePath = path.join(chatsDir, entry.name);
+        try {
+            const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (!data.sessionId)
+                continue;
+            // Extract title from first user message
+            let title = null;
+            const messages = Array.isArray(data.messages) ? data.messages : [];
+            for (const msg of messages) {
+                if (msg.type === 'user') {
+                    const content = Array.isArray(msg.content) ? msg.content : [];
+                    const text = content.map((c) => c?.text || '').join(' ').replace(/\s+/g, ' ').trim();
+                    if (text) {
+                        title = text.length <= 120 ? text : `${text.slice(0, 117).trimEnd()}...`;
+                    }
+                    break;
+                }
+            }
+            sessions.push({
+                sessionId: data.sessionId,
+                agent: 'gemini',
+                workdir,
+                workspacePath: null,
+                model: null,
+                createdAt: data.startTime || null,
+                title,
+                running: data.lastUpdated ? Date.now() - Date.parse(data.lastUpdated) < 10_000 : false,
+            });
+        }
+        catch { /* skip */ }
+    }
+    return sessions;
+}
+function getGeminiSessions(workdir, limit) {
+    const resolvedWorkdir = path.resolve(workdir);
+    // Merge pikiclaw-tracked sessions with native Gemini sessions
+    const pikiclawSessions = listPikiclawSessions(resolvedWorkdir, 'gemini').map(record => ({
+        sessionId: record.sessionId,
+        agent: 'gemini',
+        workdir: record.workdir,
+        workspacePath: record.workspacePath,
+        model: record.model,
+        createdAt: record.createdAt,
+        title: record.title,
+        running: Date.now() - Date.parse(record.updatedAt) < 10_000,
+    }));
+    const nativeSessions = getNativeGeminiSessions(resolvedWorkdir);
+    // Merge: pikiclaw records take precedence
+    // Filter out pending sessions — they haven't been confirmed by the agent yet
+    const seen = new Set();
+    const merged = [];
+    for (const s of pikiclawSessions) {
+        if (isPendingSessionId(s.sessionId))
+            continue;
+        if (s.sessionId)
+            seen.add(s.sessionId);
+        merged.push(s);
+    }
+    for (const s of nativeSessions) {
+        if (s.sessionId && !seen.has(s.sessionId))
+            merged.push(s);
+    }
+    merged.sort((a, b) => Date.parse(b.createdAt || '') - Date.parse(a.createdAt || ''));
+    const sessions = typeof limit === 'number' ? merged.slice(0, limit) : merged;
+    const projectName = geminiProjectName(resolvedWorkdir);
+    const chatsDir = projectName ? path.join(process.env.HOME || '', '.gemini', 'tmp', projectName, 'chats') : '';
+    agentLog(`[sessions:gemini] workdir=${resolvedWorkdir} projectName=${projectName || '(none)'} chatsDir=${chatsDir || '(none)'} ` +
+        `chatsDirExists=${chatsDir ? fs.existsSync(chatsDir) : false} pikiclaw=${pikiclawSessions.length} native=${nativeSessions.length} merged=${sessions.length}`);
+    return { ok: true, sessions, error: null };
+}
+// ---------------------------------------------------------------------------
+// Models — static list for now, can be extended with `gemini models list`
+// ---------------------------------------------------------------------------
+// Model IDs from gemini-cli-core (no CLI command to list them dynamically)
+const GEMINI_MODELS = [
+    { id: 'auto-gemini-3', alias: 'auto-3' },
+    { id: 'auto-gemini-2.5', alias: 'auto' },
+    { id: 'gemini-3.1-pro-preview', alias: '3.1-pro' },
+    { id: 'gemini-3-pro-preview', alias: '3-pro' },
+    { id: 'gemini-3-flash-preview', alias: '3-flash' },
+    { id: 'gemini-2.5-pro', alias: 'pro' },
+    { id: 'gemini-2.5-flash', alias: 'flash' },
+    { id: 'gemini-2.5-flash-lite', alias: 'flash-lite' },
+];
+// ---------------------------------------------------------------------------
+// Driver
+// ---------------------------------------------------------------------------
+class GeminiDriver {
+    id = 'gemini';
+    cmd = 'gemini';
+    thinkLabel = 'Thinking';
+    detect() { return detectAgentBin('gemini', 'gemini'); }
+    async doStream(opts) { return doGeminiStream(opts); }
+    async getSessions(workdir, limit) {
+        return getGeminiSessions(workdir, limit);
+    }
+    async getSessionTail(opts) {
+        // TODO: implement gemini session tail reading once protocol is known
+        return { ok: true, messages: [], error: null };
+    }
+    async listModels(_opts) {
+        return { agent: 'gemini', models: [...GEMINI_MODELS], sources: [], note: null };
+    }
+    getUsage(_opts) {
+        return emptyUsage('gemini', 'Gemini usage inspection not yet implemented.');
+    }
+    shutdown() { }
+}
+registerDriver(new GeminiDriver());

package/dist/mcp-bridge.js

@@ -0,0 +1,192 @@
+/**
+ * mcp-bridge.ts — MCP session bridge orchestrator.
+ *
+ * Runs inside the main pikiclaw process. For each agent stream:
+ *   1. Starts a tiny HTTP callback server on localhost (random port).
+ *   2. Writes an MCP config JSON pointing to `pikiclaw --mcp-serve`.
+ *   3. The agent CLI spawns the MCP server via --mcp-config.
+ *   4. When the agent calls `send_file`, the MCP server POSTs to our callback.
+ *   5. We forward the request to the IM channel and respond with success/failure.
+ *
+ * Lifecycle: one bridge per stream, created before spawn, stopped after stream ends.
+ */
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+// ---------------------------------------------------------------------------
+// Resolve the MCP server entry script path
+// ---------------------------------------------------------------------------
+/**
+ * Find the compiled mcp-session-server.js next to this file's compiled output.
+ * Falls back to running via the CLI entry point with --mcp-serve.
+ */
+function resolveMcpServerCommand() {
+    // Try to find the compiled JS file in the same directory as this module
+    const thisDir = path.dirname(new URL(import.meta.url).pathname);
+    const serverScript = path.join(thisDir, 'mcp-session-server.js');
+    if (fs.existsSync(serverScript)) {
+        return { command: 'node', args: [serverScript] };
+    }
+    // Fallback: use pikiclaw CLI with --mcp-serve flag
+    const cliScript = path.join(thisDir, 'cli.js');
+    if (fs.existsSync(cliScript)) {
+        return { command: 'node', args: [cliScript, '--mcp-serve'] };
+    }
+    // Last resort: assume pikiclaw is in PATH
+    return { command: 'pikiclaw', args: ['--mcp-serve'] };
+}
+// ---------------------------------------------------------------------------
+// Bridge implementation
+// ---------------------------------------------------------------------------
+const ARTIFACT_MAX_BYTES = 20 * 1024 * 1024;
+const PHOTO_EXTS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+function isPhotoFile(filePath) {
+    return PHOTO_EXTS.has(path.extname(filePath).toLowerCase());
+}
+/** Check if realFile is inside any of the allowed root directories. */
+function isInsideAllowedRoot(realFile, allowedRoots) {
+    for (const root of allowedRoots) {
+        try {
+            const realRoot = fs.realpathSync(root);
+            const rel = path.relative(realRoot, realFile);
+            if (rel && !rel.startsWith('..') && !path.isAbsolute(rel))
+                return true;
+        }
+        catch { /* root doesn't exist, skip */ }
+    }
+    return false;
+}
+export async function startMcpBridge(opts) {
+    const { sessionDir, workspacePath, stagedFiles, sendFile } = opts;
+    // Build allowed roots: workspace + workdir + /tmp
+    const allowedRoots = [workspacePath];
+    if (opts.workdir)
+        allowedRoots.push(opts.workdir);
+    allowedRoots.push('/tmp');
+    // ── HTTP callback server ──
+    const server = http.createServer((req, res) => {
+        if (req.method !== 'POST' || req.url !== '/send-file') {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', async () => {
+            try {
+                const data = JSON.parse(body);
+                const relPath = String(data.path || '').trim();
+                if (!relPath) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'path is required' }));
+                    return;
+                }
+                // Resolve and validate path
+                const absPath = path.isAbsolute(relPath) ? relPath : path.resolve(workspacePath, relPath);
+                let realFile;
+                try {
+                    realFile = fs.realpathSync(absPath);
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: `file not found: ${relPath}` }));
+                    return;
+                }
+                if (!isInsideAllowedRoot(realFile, allowedRoots)) {
+                    res.writeHead(403, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'file must be inside the workspace, workdir, or /tmp' }));
+                    return;
+                }
+                // Size check
+                const stat = fs.statSync(realFile);
+                if (!stat.isFile()) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: 'not a regular file' }));
+                    return;
+                }
+                if (stat.size > ARTIFACT_MAX_BYTES) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: `file too large (${stat.size} bytes, max ${ARTIFACT_MAX_BYTES})` }));
+                    return;
+                }
+                // Auto-detect kind
+                const kind = data.kind === 'photo' ? 'photo'
+                    : data.kind === 'document' ? 'document'
+                        : isPhotoFile(realFile) ? 'photo'
+                            : 'document';
+                const caption = typeof data.caption === 'string' ? data.caption.trim().slice(0, 1024) || undefined : undefined;
+                const result = await sendFile(realFile, { caption, kind });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+            }
+            catch (e) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: e?.message || 'internal error' }));
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve());
+    });
+    const port = server.address().port;
+    // ── Register MCP server with the agent ──
+    const { command, args } = resolveMcpServerCommand();
+    const envVars = {
+        MCP_WORKSPACE_PATH: workspacePath,
+        MCP_STAGED_FILES: JSON.stringify(stagedFiles),
+        MCP_CALLBACK_URL: `http://127.0.0.1:${port}`,
+    };
+    let configPath = '';
+    let codexRegistered = false;
+    if (opts.agent === 'codex') {
+        // Codex: register MCP server via `codex mcp add/remove`
+        const codexArgs = ['mcp', 'add', 'pikiclaw'];
+        for (const [k, v] of Object.entries(envVars))
+            codexArgs.push('--env', `${k}=${v}`);
+        codexArgs.push('--', command, ...args);
+        try {
+            execFileSync('codex', codexArgs, { stdio: 'pipe', timeout: 10_000 });
+            codexRegistered = true;
+        }
+        catch (e) {
+            // If already exists, remove and retry
+            try {
+                execFileSync('codex', ['mcp', 'remove', 'pikiclaw'], { stdio: 'pipe', timeout: 5_000 });
+            }
+            catch { }
+            execFileSync('codex', codexArgs, { stdio: 'pipe', timeout: 10_000 });
+            codexRegistered = true;
+        }
+    }
+    else {
+        // Claude/Gemini: write MCP config JSON for --mcp-config
+        configPath = path.join(sessionDir, 'mcp-config.json');
+        const config = {
+            mcpServers: {
+                pikiclaw: { command, args, env: envVars },
+            },
+        };
+        fs.mkdirSync(sessionDir, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    return {
+        configPath,
+        stop: async () => {
+            await new Promise(resolve => server.close(() => resolve()));
+            if (codexRegistered) {
+                try {
+                    execFileSync('codex', ['mcp', 'remove', 'pikiclaw'], { stdio: 'pipe', timeout: 5_000 });
+                }
+                catch { }
+            }
+            if (configPath) {
+                try {
+                    fs.rmSync(configPath, { force: true });
+                }
+                catch { }
+            }
+        },
+    };
+}