codeclaw 0.1.0 → 0.2.2

package/dist/code-agent.js

@@ -0,0 +1,472 @@
+import { execSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import fs from 'node:fs';
+import path from 'node:path';
+const Q = (a) => /[^a-zA-Z0-9_./:=@-]/.test(a) ? `'${a.replace(/'/g, "'\\''")}'` : a;
+function agentLog(msg) {
+    const ts = new Date().toTimeString().slice(0, 8);
+    process.stdout.write(`[agent ${ts}] ${msg}\n`);
+}
+async function run(cmd, opts, parseLine) {
+    const start = Date.now();
+    const deadline = start + opts.timeout * 1000;
+    let stderr = '';
+    let lineCount = 0;
+    const s = {
+        sessionId: opts.sessionId, text: '', thinking: '', msgs: [], thinkParts: [],
+        model: opts.model, thinkingEffort: opts.thinkingEffort, errors: null,
+        inputTokens: null, outputTokens: null, cachedInputTokens: null,
+    };
+    const shellCmd = cmd.map(Q).join(' ');
+    agentLog(`[spawn] cmd: ${shellCmd}`);
+    agentLog(`[spawn] cwd: ${opts.workdir} timeout: ${opts.timeout}s session: ${opts.sessionId || '(new)'}`);
+    agentLog(`[spawn] prompt: "${opts.prompt.slice(0, 120)}"`);
+    const proc = spawn(shellCmd, { cwd: opts.workdir, stdio: ['pipe', 'pipe', 'pipe'], shell: true });
+    agentLog(`[spawn] pid=${proc.pid}`);
+    try {
+        proc.stdin.write(opts.prompt);
+        proc.stdin.end();
+    }
+    catch { }
+    proc.stderr?.on('data', (c) => {
+        const chunk = c.toString();
+        stderr += chunk;
+        agentLog(`[stderr] ${chunk.trim().slice(0, 200)}`);
+    });
+    const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+    rl.on('line', raw => {
+        if (Date.now() > deadline) {
+            agentLog(`[timeout] deadline exceeded, killing process`);
+            proc.kill('SIGKILL');
+            return;
+        }
+        const line = raw.trim();
+        if (!line || line[0] !== '{')
+            return;
+        lineCount++;
+        try {
+            const ev = JSON.parse(line);
+            const evType = ev.type || '?';
+            // Log key events (not every delta to avoid spam)
+            if (evType === 'system' || evType === 'result' || evType === 'assistant' ||
+                evType === 'thread.started' || evType === 'turn.completed' || evType === 'item.completed') {
+                agentLog(`[event] type=${evType} session=${ev.session_id || s.sessionId || '?'} model=${ev.model || s.model || '?'}`);
+            }
+            if (evType === 'stream_event') {
+                const inner = ev.event || {};
+                if (inner.type === 'message_start' || inner.type === 'message_delta') {
+                    agentLog(`[event] stream_event/${inner.type} session=${ev.session_id || '?'}`);
+                }
+            }
+            parseLine(ev, s);
+            opts.onText(s.text, s.thinking);
+        }
+        catch { }
+    });
+    const [ok, code] = await new Promise(resolve => {
+        proc.on('close', code => { agentLog(`[exit] code=${code} lines_parsed=${lineCount}`); resolve([code === 0, code]); });
+        proc.on('error', e => { agentLog(`[error] ${e.message}`); stderr += e.message; resolve([false, -1]); });
+    });
+    if (!s.text.trim() && s.msgs.length)
+        s.text = s.msgs.join('\n\n');
+    if (!s.thinking.trim() && s.thinkParts.length)
+        s.thinking = s.thinkParts.join('\n\n');
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    agentLog(`[result] ok=${ok && !s.errors} elapsed=${elapsed}s text=${s.text.length}chars thinking=${s.thinking.length}chars session=${s.sessionId || '?'}`);
+    if (s.errors)
+        agentLog(`[result] errors: ${s.errors.join('; ')}`);
+    if (stderr.trim() && !ok)
+        agentLog(`[result] stderr: ${stderr.trim().slice(0, 300)}`);
+    return {
+        ok: ok && !s.errors, sessionId: s.sessionId, model: s.model, thinkingEffort: s.thinkingEffort,
+        message: s.errors?.join('; ') || s.text.trim() || (ok ? '(no textual response)' : `Failed (exit=${code}).\n\n${stderr.trim() || '(no output)'}`),
+        thinking: s.thinking.trim() || null,
+        elapsedS: (Date.now() - start) / 1000,
+        inputTokens: s.inputTokens, outputTokens: s.outputTokens, cachedInputTokens: s.cachedInputTokens,
+    };
+}
+// --- codex ---
+function codexCmd(o) {
+    const args = ['codex', 'exec'];
+    if (o.sessionId)
+        args.push('resume');
+    args.push('--json');
+    if (o.codexModel)
+        args.push('-m', o.codexModel);
+    args.push('-c', `model_reasoning_effort="${o.thinkingEffort}"`);
+    if (o.codexFullAccess)
+        args.push('--dangerously-bypass-approvals-and-sandbox');
+    if (o.attachments?.length) {
+        for (const f of o.attachments)
+            args.push('--image', f);
+    }
+    if (o.codexExtraArgs?.length)
+        args.push(...o.codexExtraArgs);
+    if (o.sessionId)
+        args.push(o.sessionId);
+    args.push('-');
+    return args;
+}
+function codexParse(ev, s) {
+    const t = ev.type || '';
+    if (t === 'thread.started') {
+        s.sessionId = ev.thread_id ?? s.sessionId;
+        s.model = ev.model ?? s.model;
+    }
+    if (t === 'item.completed') {
+        const item = ev.item || {};
+        if (item.type === 'agent_message' && item.text?.trim()) {
+            s.msgs.push(item.text.trim());
+            s.text = s.msgs.join('\n\n');
+        }
+        if (item.type === 'reasoning' && (item.text || item.summary)?.trim()) {
+            s.thinkParts.push((item.text || item.summary).trim());
+            s.thinking = s.thinkParts.join('\n\n');
+        }
+    }
+    if (t === 'turn.completed') {
+        const u = ev.usage;
+        if (u) {
+            s.inputTokens = u.input_tokens ?? s.inputTokens;
+            s.cachedInputTokens = u.cached_input_tokens ?? s.cachedInputTokens;
+            s.outputTokens = u.output_tokens ?? s.outputTokens;
+        }
+        s.model = ev.model ?? s.model;
+    }
+}
+export function doCodexStream(opts) {
+    return run(codexCmd(opts), opts, codexParse);
+}
+// --- claude ---
+function claudeCmd(o) {
+    const args = ['claude', '-p', '--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
+    if (o.claudeModel)
+        args.push('--model', o.claudeModel);
+    if (o.claudePermissionMode)
+        args.push('--permission-mode', o.claudePermissionMode);
+    if (o.sessionId)
+        args.push('--resume', o.sessionId);
+    if (o.attachments?.length) {
+        for (const f of o.attachments)
+            args.push('--input-file', f);
+    }
+    if (o.claudeExtraArgs?.length)
+        args.push(...o.claudeExtraArgs);
+    return args;
+}
+function claudeParse(ev, s) {
+    const t = ev.type || '';
+    if (t === 'system') {
+        s.sessionId = ev.session_id ?? s.sessionId;
+        s.model = ev.model ?? s.model;
+        s.thinkingEffort = ev.thinking_level ?? s.thinkingEffort;
+    }
+    if (t === 'stream_event') {
+        const inner = ev.event || {};
+        if (inner.type === 'content_block_delta') {
+            const d = inner.delta || {};
+            if (d.type === 'thinking_delta')
+                s.thinking += d.thinking || '';
+            else if (d.type === 'text_delta')
+                s.text += d.text || '';
+        }
+        if (inner.type === 'message_delta') {
+            const u = inner.usage;
+            if (u) {
+                s.inputTokens = u.input_tokens ?? s.inputTokens;
+                s.cachedInputTokens = u.cache_read_input_tokens ?? s.cachedInputTokens;
+                s.outputTokens = u.output_tokens ?? s.outputTokens;
+            }
+        }
+        s.sessionId = ev.session_id ?? s.sessionId;
+        s.model = ev.model ?? s.model;
+    }
+    if (t === 'assistant') {
+        const contents = (ev.message || {}).content || [];
+        const th = contents.filter((b) => b?.type === 'thinking').map((b) => b.thinking || '').join('');
+        const tx = contents.filter((b) => b?.type === 'text').map((b) => b.text || '').join('');
+        if (th && !s.thinking.trim())
+            s.thinking = th;
+        if (tx && !s.text.trim())
+            s.text = tx;
+    }
+    if (t === 'result') {
+        s.sessionId = ev.session_id ?? s.sessionId;
+        s.model = ev.model ?? s.model;
+        if (ev.is_error && ev.errors?.length)
+            s.errors = ev.errors;
+        if (ev.result && !s.text.trim())
+            s.text = ev.result;
+        const u = ev.usage;
+        if (u) {
+            s.inputTokens = u.input_tokens ?? s.inputTokens;
+            s.cachedInputTokens = (u.cache_read_input_tokens ?? u.cached_input_tokens) ?? s.cachedInputTokens;
+            s.outputTokens = u.output_tokens ?? s.outputTokens;
+        }
+    }
+}
+export async function doClaudeStream(opts) {
+    const result = await run(claudeCmd(opts), opts, claudeParse);
+    // session not found → retry as new conversation
+    if (!result.ok && opts.sessionId && /no conversation found/i.test(result.message)) {
+        return run(claudeCmd({ ...opts, sessionId: null }), { ...opts, sessionId: null }, claudeParse);
+    }
+    return result;
+}
+// --- unified entry ---
+export function doStream(opts) {
+    return opts.agent === 'codex' ? doCodexStream(opts) : doClaudeStream(opts);
+}
+/**
+ * Encode a workdir path to the Claude project directory name.
+ * Claude replaces `/` with `-` and strips the leading `-`.
+ */
+function claudeProjectDirName(workdir) {
+    return workdir.replace(/\//g, '-');
+}
+function readLines(filePath, maxLines) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = [];
+        let start = 0;
+        for (let i = 0; i < maxLines; i++) {
+            const nl = content.indexOf('\n', start);
+            if (nl < 0) {
+                if (start < content.length)
+                    lines.push(content.slice(start));
+                break;
+            }
+            lines.push(content.slice(start, nl));
+            start = nl + 1;
+        }
+        return lines;
+    }
+    catch {
+        return [];
+    }
+}
+function parseClaudeSession(filePath, workdir) {
+    const lines = readLines(filePath, 10);
+    if (!lines.length)
+        return null;
+    try {
+        const sessionId = path.basename(filePath, '.jsonl');
+        const stat = fs.statSync(filePath);
+        let model = null;
+        let title = null;
+        for (const raw of lines) {
+            if (!raw || raw[0] !== '{')
+                continue;
+            try {
+                const ev = JSON.parse(raw);
+                if (ev.type === 'user' && !title) {
+                    const content = ev.message?.content;
+                    if (typeof content === 'string') {
+                        title = content.slice(0, 120);
+                    }
+                    else if (Array.isArray(content)) {
+                        const textBlock = content.find((b) => b?.type === 'text' && b.text && !b.text.startsWith('<'));
+                        if (textBlock)
+                            title = textBlock.text.slice(0, 120);
+                    }
+                }
+                if (ev.type === 'assistant' && !model) {
+                    model = ev.message?.model ?? null;
+                }
+            }
+            catch { /* skip unparseable lines */ }
+            if (model && title)
+                break;
+        }
+        return {
+            sessionId,
+            agent: 'claude',
+            workdir,
+            model,
+            createdAt: stat.birthtime?.toISOString() ?? stat.mtime?.toISOString() ?? null,
+            title,
+            running: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readLastLine(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trimEnd().split('\n');
+        return lines[lines.length - 1] || null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseCodexSession(filePath) {
+    const lines = readLines(filePath, 10);
+    const line = lines[0];
+    if (!line)
+        return null;
+    try {
+        const ev = JSON.parse(line);
+        if (ev.type !== 'session_meta')
+            return null;
+        const p = ev.payload || {};
+        let title = null;
+        for (const raw of lines.slice(1)) {
+            if (!raw || raw[0] !== '{')
+                continue;
+            try {
+                const item = JSON.parse(raw);
+                if (item.type === 'response_item' && item.payload?.role === 'user' && item.payload?.type === 'message') {
+                    const content = item.payload.content;
+                    if (Array.isArray(content)) {
+                        const textBlock = content.find((b) => b?.type === 'input_text' && b.text && !/^[<#]/.test(b.text));
+                        if (textBlock) {
+                            title = textBlock.text.slice(0, 120);
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+        // Codex writes task_complete as the last event when done
+        let running = false;
+        const last = readLastLine(filePath);
+        if (last) {
+            try {
+                const lastEv = JSON.parse(last);
+                running = !(lastEv.type === 'event_msg' && lastEv.payload?.type === 'task_complete');
+            }
+            catch { /* assume not running if unparseable */ }
+        }
+        return {
+            sessionId: p.id ?? path.basename(filePath, '.jsonl'),
+            agent: 'codex',
+            workdir: p.cwd ?? null,
+            model: p.model_provider ?? null,
+            createdAt: p.timestamp ?? null,
+            title,
+            running,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Collect session IDs from running `claude --resume <id>` processes. */
+function getRunningClaudeSessionIds() {
+    try {
+        const out = execSync('ps -eo args 2>/dev/null', { encoding: 'utf-8', timeout: 3000 });
+        const ids = new Set();
+        for (const m of out.matchAll(/--resume\s+(\S+)/g))
+            ids.add(m[1]);
+        return ids;
+    }
+    catch {
+        return new Set();
+    }
+}
+function getClaudeSessions(opts) {
+    const limit = opts.limit ?? 50;
+    const home = process.env.HOME || '';
+    const projectDir = path.join(home, '.claude', 'projects', claudeProjectDirName(opts.workdir));
+    if (!fs.existsSync(projectDir)) {
+        return { ok: true, sessions: [], error: null };
+    }
+    const sessions = [];
+    try {
+        const files = fs.readdirSync(projectDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => ({ name: f, full: path.join(projectDir, f), mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime)
+            .slice(0, limit);
+        const runningIds = getRunningClaudeSessionIds();
+        const now = Date.now();
+        for (const f of files) {
+            const info = parseClaudeSession(f.full, opts.workdir);
+            if (info) {
+                info.running = runningIds.has(info.sessionId) || (now - f.mtime < 10_000);
+                sessions.push(info);
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, sessions: [], error: e.message };
+    }
+    return { ok: true, sessions, error: null };
+}
+function getCodexSessions(opts) {
+    const limit = opts.limit ?? 50;
+    const home = process.env.HOME || '';
+    const sessionsRoot = path.join(home, '.codex', 'sessions');
+    if (!fs.existsSync(sessionsRoot)) {
+        return { ok: true, sessions: [], error: null };
+    }
+    const all = [];
+    try {
+        // Walk year/month/day directories
+        for (const year of fs.readdirSync(sessionsRoot)) {
+            const yp = path.join(sessionsRoot, year);
+            if (!fs.statSync(yp).isDirectory())
+                continue;
+            for (const month of fs.readdirSync(yp)) {
+                const mp = path.join(yp, month);
+                if (!fs.statSync(mp).isDirectory())
+                    continue;
+                for (const day of fs.readdirSync(mp)) {
+                    const dp = path.join(mp, day);
+                    if (!fs.statSync(dp).isDirectory())
+                        continue;
+                    for (const f of fs.readdirSync(dp)) {
+                        if (!f.endsWith('.jsonl'))
+                            continue;
+                        const full = path.join(dp, f);
+                        all.push({ path: full, mtime: fs.statSync(full).mtimeMs });
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        return { ok: false, sessions: [], error: e.message };
+    }
+    // Sort newest first, parse and filter by workdir
+    all.sort((a, b) => b.mtime - a.mtime);
+    const sessions = [];
+    for (const entry of all) {
+        if (sessions.length >= limit)
+            break;
+        const info = parseCodexSession(entry.path);
+        if (info && info.workdir === opts.workdir)
+            sessions.push(info);
+    }
+    return { ok: true, sessions, error: null };
+}
+export function getSessions(opts) {
+    return opts.agent === 'codex' ? getCodexSessions(opts) : getClaudeSessions(opts);
+}
+function detectAgent(cmd, agent) {
+    let binPath = null;
+    try {
+        binPath = execSync(`which ${cmd} 2>/dev/null`, { encoding: 'utf-8' }).trim() || null;
+    }
+    catch { /* */ }
+    let version = null;
+    if (binPath) {
+        try {
+            version = execSync(`${cmd} --version 2>/dev/null`, { encoding: 'utf-8' }).trim().split('\n')[0] || null;
+        }
+        catch { /* */ }
+    }
+    return { agent, installed: !!binPath, path: binPath, version };
+}
+export function listAgents() {
+    return {
+        agents: [
+            detectAgent('claude', 'claude'),
+            detectAgent('codex', 'codex'),
+        ],
+    };
+}

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "codeclaw",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "The best IM-driven remote coding experience. Bridge AI coding agents to any IM.",
   "type": "module",
   "bin": {
-    "codeclaw": "bin/codeclaw.js"
+    "codeclaw": "dist/cli.js"
   },
   "files": [
-    "bin/",
-    "src/",
+    "dist/",
     "LICENSE",
     "README.md"
   ],
@@ -28,6 +27,8 @@
     "url": "git+https://github.com/xiaotonng/codeclaw.git"
   },
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest"
   },
@@ -35,6 +36,9 @@
     "node": ">=18.0.0"
   },
   "devDependencies": {
+    "@types/node": "^25.3.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }
 }

package/bin/codeclaw.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { main } from '../src/codeclaw.js';
-main().then(code => process.exit(code)).catch(err => { console.error(err); process.exit(1); });