pikiclaw 0.2.35

package/dist/process-control.js

@@ -0,0 +1,259 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+export const PROCESS_RESTART_EXIT_CODE = 75;
+export const PROCESS_RESTART_STATE_FILE_ENV = 'PIKICLAW_RESTART_STATE_FILE';
+const runtimes = new Map();
+let nextRuntimeId = 1;
+let restartInFlight = false;
+export function shellSplit(str) {
+    const args = [];
+    let cur = '';
+    let inSingle = false;
+    let inDouble = false;
+    for (const ch of str) {
+        if (ch === '\'' && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (ch === ' ' && !inSingle && !inDouble) {
+            if (cur)
+                args.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur)
+        args.push(cur);
+    return args;
+}
+function isNpxBinary(bin) {
+    return path.basename(bin, path.extname(bin)).toLowerCase() === 'npx';
+}
+export function ensureNonInteractiveRestartArgs(bin, args) {
+    if (!isNpxBinary(bin))
+        return args;
+    if (args.includes('--yes') || args.includes('-y'))
+        return args;
+    return ['--yes', ...args];
+}
+export function getDefaultRestartCmd() {
+    const argv1 = process.argv[1] ?? '';
+    if (argv1.endsWith('.ts') || argv1.includes('/tsx') || argv1.includes('/ts-node')) {
+        const isTsxLoader = !process.argv[0]?.includes('/tsx')
+            && process.execArgv?.some(arg => arg.includes('tsx'));
+        const parts = isTsxLoader ? ['tsx', argv1] : process.argv.slice(0, 2);
+        return parts.map(arg => arg.includes(' ') ? `"${arg}"` : arg).join(' ');
+    }
+    return 'npx --yes pikiclaw@latest';
+}
+export function buildRestartCommand(argv, restartCmd = process.env.PIKICLAW_RESTART_CMD || getDefaultRestartCmd()) {
+    const [bin, ...rawArgs] = shellSplit(restartCmd);
+    return {
+        bin,
+        args: [...ensureNonInteractiveRestartArgs(bin, rawArgs), ...argv],
+    };
+}
+export function registerProcessRuntime(runtime) {
+    const id = nextRuntimeId++;
+    runtimes.set(id, runtime);
+    return () => {
+        runtimes.delete(id);
+    };
+}
+export function getRegisteredRuntimeCount() {
+    return runtimes.size;
+}
+export function getActiveTaskCount() {
+    let total = 0;
+    for (const runtime of runtimes.values()) {
+        total += Math.max(0, runtime.getActiveTaskCount?.() || 0);
+    }
+    return total;
+}
+export function formatActiveTaskRestartError(activeTasks) {
+    return `${activeTasks} task(s) still running. Wait for them to finish or try again.`;
+}
+export function createRestartStateFilePath(ownerPid = process.pid) {
+    const dir = path.join(os.tmpdir(), 'pikiclaw');
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, `restart-${ownerPid}.json`);
+}
+export function clearRestartStateFile(filePath) {
+    if (!filePath)
+        return;
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { }
+}
+export function writeRestartStateFile(filePath, env) {
+    const payload = { version: 1, env };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(payload), 'utf8');
+}
+export function consumeRestartStateFile(filePath) {
+    if (!filePath)
+        return {};
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== 1 || !parsed.env || typeof parsed.env !== 'object')
+            return {};
+        return Object.fromEntries(Object.entries(parsed.env)
+            .filter((entry) => typeof entry[0] === 'string' && typeof entry[1] === 'string')
+            .map(([key, value]) => [key, value.trim()]));
+    }
+    catch {
+        return {};
+    }
+    finally {
+        clearRestartStateFile(filePath);
+    }
+}
+function mergeEnvValues(target, patch) {
+    for (const [key, rawValue] of Object.entries(patch)) {
+        const value = rawValue.trim();
+        if (!value)
+            continue;
+        if (!target[key]) {
+            target[key] = value;
+            continue;
+        }
+        const merged = new Set([
+            ...target[key].split(',').map(item => item.trim()).filter(Boolean),
+            ...value.split(',').map(item => item.trim()).filter(Boolean),
+        ]);
+        target[key] = [...merged].join(',');
+    }
+}
+function collectRestartEnv() {
+    const env = {};
+    for (const runtime of runtimes.values()) {
+        const patch = runtime.buildRestartEnv?.() || {};
+        mergeEnvValues(env, patch);
+    }
+    return env;
+}
+async function prepareRuntimesForRestart(log) {
+    for (const runtime of [...runtimes.values()]) {
+        const label = runtime.label ? `${runtime.label}: ` : '';
+        try {
+            await runtime.prepareForRestart?.();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`restart cleanup failed (${label}${message})`);
+        }
+    }
+}
+function buildRestartEnvForSpawn(extraEnv) {
+    const env = {
+        ...process.env,
+        ...extraEnv,
+        npm_config_yes: process.env.npm_config_yes || 'true',
+    };
+    delete env.PIKICLAW_DAEMON_CHILD;
+    delete env[PROCESS_RESTART_STATE_FILE_ENV];
+    return env;
+}
+function spawnReplacementProcess(bin, args, env, log) {
+    const child = spawn(bin, args, {
+        stdio: 'inherit',
+        detached: true,
+        env,
+    });
+    child.unref();
+    log?.(`restart: new process spawned (PID ${child.pid})`);
+    return child;
+}
+export async function requestProcessRestart(opts = {}) {
+    const activeTasks = getActiveTaskCount();
+    if (activeTasks > 0) {
+        return {
+            ok: false,
+            restarting: false,
+            error: formatActiveTaskRestartError(activeTasks),
+            activeTasks,
+        };
+    }
+    if (restartInFlight) {
+        return {
+            ok: true,
+            restarting: true,
+            error: null,
+            activeTasks: 0,
+        };
+    }
+    restartInFlight = true;
+    const log = opts.log;
+    const exit = opts.exit || process.exit;
+    try {
+        const extraEnv = collectRestartEnv();
+        await prepareRuntimesForRestart(log);
+        if (process.env.PIKICLAW_DAEMON_CHILD === '1') {
+            const restartStateFile = process.env[PROCESS_RESTART_STATE_FILE_ENV];
+            if (restartStateFile) {
+                if (Object.keys(extraEnv).length)
+                    writeRestartStateFile(restartStateFile, extraEnv);
+                else
+                    clearRestartStateFile(restartStateFile);
+            }
+            log?.('restart: handing off to daemon supervisor');
+            exit(PROCESS_RESTART_EXIT_CODE);
+            return { ok: true, restarting: true, error: null, activeTasks: 0 };
+        }
+        const { bin, args } = buildRestartCommand(opts.argv || process.argv.slice(2), opts.restartCmd);
+        log?.(`restart: spawning \`${bin} ${args.join(' ')}\``);
+        spawnReplacementProcess(bin, args, buildRestartEnvForSpawn(extraEnv), log);
+        exit(0);
+        return { ok: true, restarting: true, error: null, activeTasks: 0 };
+    }
+    catch (err) {
+        restartInFlight = false;
+        return {
+            ok: false,
+            restarting: false,
+            error: err instanceof Error ? err.message : String(err),
+            activeTasks: 0,
+        };
+    }
+}
+export function terminateProcessTree(target, opts = {}) {
+    const pid = typeof target === 'number' ? target : target?.pid;
+    if (!pid || pid <= 0)
+        return;
+    const signal = opts.signal ?? 'SIGTERM';
+    const forceSignal = opts.forceSignal ?? null;
+    const forceAfterMs = opts.forceAfterMs ?? 0;
+    const killPid = (targetPid, nextSignal) => {
+        try {
+            if (process.platform === 'win32') {
+                const args = ['/pid', String(targetPid), '/t'];
+                if (nextSignal === 'SIGKILL')
+                    args.push('/f');
+                const killer = spawn('taskkill', args, { stdio: 'ignore', windowsHide: true });
+                killer.unref();
+                return;
+            }
+            process.kill(-targetPid, nextSignal);
+        }
+        catch {
+            try {
+                process.kill(targetPid, nextSignal);
+            }
+            catch { }
+        }
+    };
+    killPid(pid, signal);
+    if (forceSignal == null || forceAfterMs <= 0 || forceSignal === signal)
+        return;
+    const timer = setTimeout(() => killPid(pid, forceSignal), forceAfterMs);
+    timer.unref?.();
+}

package/dist/run.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+/**
+ * run.ts — Standalone CLI commands for pikiclaw.
+ *
+ * Usage:
+ *   npm run command -- status
+ *   npm run command -- claude-models
+ *   npm run command -- codex-models
+ */
+import { formatThinkingForDisplay } from './bot.js';
+import { initializeProjectSkills, listAgents, listModels, listSkills, getUsage, doStream, getSessions, getSessionTail } from './code-agent.js';
+import { loadUserConfig, resolveUserWorkdir } from './user-config.js';
+function parseArgs(argv) {
+    const args = {
+        command: null, model: null, workdir: null, prompt: null, timeout: 1800, help: false,
+        session: null, n: 4,
+    };
+    const positional = [];
+    const it = argv[Symbol.iterator]();
+    for (const arg of it) {
+        switch (arg) {
+            case '-m':
+            case '--model':
+                args.model = it.next().value;
+                break;
+            case '-w':
+            case '--workdir':
+                args.workdir = it.next().value;
+                break;
+            case '-p':
+            case '--prompt':
+                args.prompt = it.next().value;
+                break;
+            case '-s':
+            case '--session':
+                args.session = it.next().value;
+                break;
+            case '-n':
+                args.n = parseInt(it.next().value ?? '', 10) || 4;
+                break;
+            case '--timeout':
+                args.timeout = parseInt(it.next().value ?? '', 10) || 1800;
+                break;
+            case '-h':
+            case '--help':
+                args.help = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    process.stderr.write(`Unknown option: ${arg}\n`);
+                    process.exit(1);
+                }
+                else
+                    positional.push(arg);
+        }
+    }
+    args.command = positional[0] ?? null;
+    // If no -p flag, treat remaining positional args as the prompt
+    if (!args.prompt && positional.length > 1)
+        args.prompt = positional.slice(1).join(' ');
+    return args;
+}
+const HELP = `pikiclaw run — standalone commands
+
+Usage:
+  npm run command -- <command> [options]
+
+Commands:
+  skills          List project-defined custom skills (.pikiclaw/skills)
+  claude-run      Run a single Claude prompt and print the result
+  codex-run       Run a single Codex prompt and print the result
+  claude-status   Show Claude agent info and API usage
+  codex-status    Show Codex agent info and API usage
+  claude-models   List available Claude models
+  codex-models    List available Codex models
+  claude-sessions List recent Claude sessions for the workdir
+  codex-sessions  List recent Codex sessions for the workdir
+  claude-tail     Show last N messages of a Claude session
+  codex-tail      Show last N messages of a Codex session
+
+Options:
+  -p, --prompt <text>   Prompt text (or pass after command as positional args)
+  -m, --model <model>   Model to use / highlight
+  -w, --workdir <dir>   Working directory  [default: current process cwd]
+  -s, --session <id>    Session ID (for tail; omit to use latest session)
+  -n <count>            Number of messages to show  [default: 4]
+  --timeout <seconds>   Max seconds per request  [default: 1800]
+  -h, --help            Print this help
+
+Examples:
+  npm run command -- claude-run -p "Hello world"
+  npm run command -- codex-run -m o3 "Explain this repo"
+  npm run command -- claude-run -m sonnet --timeout 60 -p "What is 1+1?"
+  npm run command -- claude-tail
+  npm run command -- claude-tail -n 10 -s <session-id>
+`;
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const userConfig = loadUserConfig();
+    const workdir = resolveUserWorkdir({ workdir: args.workdir, config: userConfig });
+    initializeProjectSkills(workdir);
+    if (args.help || !args.command) {
+        process.stdout.write(HELP);
+        process.exit(0);
+    }
+    switch (args.command) {
+        case 'skills': {
+            const result = listSkills(workdir);
+            if (!result.skills.length) {
+                process.stdout.write(`No custom skills found in ${workdir} (.pikiclaw/skills, .claude/commands)\n`);
+                break;
+            }
+            process.stdout.write(`Project skills (${result.skills.length}):\n\n`);
+            for (const sk of result.skills) {
+                const src = sk.source === 'skills' ? 'skill' : 'command';
+                const desc = sk.description ? `  ${sk.description}` : '';
+                process.stdout.write(`  ${sk.name}  [${src}]${desc}\n`);
+            }
+            break;
+        }
+        case 'claude-status': {
+            const info = listAgents({ includeVersion: true }).agents.find(a => a.agent === 'claude');
+            const mark = info.installed ? '\u2713' : '\u2717';
+            process.stdout.write(`${mark} claude  ${info.version ?? 'not installed'}  ${info.path ?? ''}\n`);
+            const usage = getUsage({ agent: 'claude' });
+            if (usage.error) {
+                process.stdout.write(`  ${usage.error}\n`);
+            }
+            else {
+                for (const w of usage.windows) {
+                    process.stdout.write(`  [${w.label}] ${w.usedPercent ?? '?'}% used  status=${w.status ?? 'n/a'}\n`);
+                }
+            }
+            break;
+        }
+        case 'codex-status': {
+            const info = listAgents({ includeVersion: true }).agents.find(a => a.agent === 'codex');
+            const mark = info.installed ? '\u2713' : '\u2717';
+            process.stdout.write(`${mark} codex  ${info.version ?? 'not installed'}  ${info.path ?? ''}\n`);
+            const usage = getUsage({ agent: 'codex' });
+            if (usage.error) {
+                process.stdout.write(`  ${usage.error}\n`);
+            }
+            else {
+                for (const w of usage.windows) {
+                    process.stdout.write(`  [${w.label}] ${w.usedPercent ?? '?'}% used  status=${w.status ?? 'n/a'}\n`);
+                }
+            }
+            break;
+        }
+        case 'claude-models': {
+            const result = await listModels('claude', { workdir, currentModel: args.model });
+            process.stdout.write(`Claude models${result.note ? ` (${result.note})` : ''}:\n`);
+            for (const m of result.models) {
+                process.stdout.write(`  ${m.id}${m.alias ? ` (${m.alias})` : ''}\n`);
+            }
+            break;
+        }
+        case 'codex-models': {
+            const result = await listModels('codex', { workdir, currentModel: args.model });
+            process.stdout.write(`Codex models${result.note ? ` (${result.note})` : ''}:\n`);
+            for (const m of result.models) {
+                process.stdout.write(`  ${m.id}${m.alias ? ` (${m.alias})` : ''}\n`);
+            }
+            break;
+        }
+        case 'claude-sessions':
+        case 'codex-sessions': {
+            const agent = args.command === 'codex-sessions' ? 'codex' : 'claude';
+            const limit = 20;
+            const result = await getSessions({ agent, workdir, limit });
+            if (!result.ok) {
+                process.stderr.write(`Error: ${result.error}\n`);
+                process.exit(1);
+            }
+            if (!result.sessions.length) {
+                process.stdout.write(`No ${agent} sessions found for ${workdir}\n`);
+                break;
+            }
+            process.stdout.write(`${agent} sessions (${result.sessions.length}) for ${workdir}:\n\n`);
+            for (const s of result.sessions) {
+                const run = s.running ? ' [RUNNING]' : '';
+                const date = s.createdAt ? s.createdAt.replace('T', ' ').slice(0, 19) : '?';
+                const model = s.model ? ` model=${s.model}` : '';
+                const title = s.title ? `  ${s.title}` : '';
+                const displayId = s.sessionId || '(none)';
+                process.stdout.write(`  ${displayId}  ${date}${model}${run}\n`);
+                if (title)
+                    process.stdout.write(`    ${title}\n`);
+            }
+            process.exit(0);
+        }
+        case 'claude-tail':
+        case 'codex-tail': {
+            const agent = args.command === 'codex-tail' ? 'codex' : 'claude';
+            let sessionId = args.session;
+            // Default: find the latest session
+            if (!sessionId) {
+                const sessions = await getSessions({ agent, workdir, limit: 1 });
+                if (!sessions.ok || !sessions.sessions.length) {
+                    process.stderr.write(`No ${agent} sessions found for ${workdir}\n`);
+                    process.exit(1);
+                }
+                sessionId = sessions.sessions[0].sessionId;
+                if (!sessionId) {
+                    process.stderr.write(`Latest ${agent} session has no usable session ID\n`);
+                    process.exit(1);
+                }
+            }
+            const tail = await getSessionTail({ agent, sessionId, workdir, limit: args.n });
+            if (!tail.ok) {
+                process.stderr.write(`Error: ${tail.error}\n`);
+                process.exit(1);
+            }
+            if (!tail.messages.length) {
+                process.stdout.write(`No messages found in session ${sessionId}\n`);
+                break;
+            }
+            process.stdout.write(`${agent} session ${sessionId.slice(0, 16)}  (last ${tail.messages.length} messages)\n\n`);
+            for (const m of tail.messages) {
+                const icon = m.role === 'user' ? '👤 User' : '🤖 Assistant';
+                const preview = m.text.length > 300 ? m.text.slice(0, 300) + '...' : m.text;
+                process.stdout.write(`${icon}:\n${preview}\n\n`);
+            }
+            process.exit(0);
+        }
+        case 'claude-run':
+        case 'codex-run': {
+            const agent = args.command === 'codex-run' ? 'codex' : 'claude';
+            const prompt = args.prompt;
+            if (!prompt) {
+                process.stderr.write(`Missing prompt. Use -p "..." or pass text after the command.\n`);
+                process.exit(1);
+            }
+            const opts = {
+                agent, prompt, workdir, timeout: args.timeout,
+                sessionId: null, model: null, thinkingEffort: 'max',
+                onText: (text, _thinking) => {
+                    process.stdout.write(`\r\x1b[K${text.slice(-120)}`);
+                },
+                claudeModel: agent === 'claude' ? (args.model || undefined) : undefined,
+                claudePermissionMode: agent === 'claude' ? 'bypassPermissions' : undefined,
+                codexModel: agent === 'codex' ? (args.model || undefined) : undefined,
+                codexFullAccess: agent === 'codex' ? true : undefined,
+            };
+            process.stdout.write(`Running ${agent}${args.model ? ` (model: ${args.model})` : ''}...\n`);
+            const result = await doStream(opts);
+            // Clear the streaming line and print final result
+            process.stdout.write('\r\x1b[K');
+            process.stdout.write(`--- ${agent} result ---\n`);
+            process.stdout.write(`ok:        ${result.ok}\n`);
+            process.stdout.write(`model:     ${result.model ?? '(unknown)'}\n`);
+            process.stdout.write(`session:   ${result.sessionId ?? '(none)'}\n`);
+            process.stdout.write(`elapsed:   ${result.elapsedS.toFixed(1)}s\n`);
+            process.stdout.write(`tokens:    in=${result.inputTokens ?? '?'} out=${result.outputTokens ?? '?'} cached=${result.cachedInputTokens ?? '?'} cacheCreate=${result.cacheCreationInputTokens ?? '?'}\n`);
+            if (result.contextPercent != null) {
+                process.stdout.write(`context:   ${result.contextUsedTokens}/${result.contextWindow} (${result.contextPercent}%)\n`);
+            }
+            process.stdout.write(`stop:      ${result.stopReason ?? 'n/a'}\n`);
+            if (result.error)
+                process.stdout.write(`error:     ${result.error}\n`);
+            process.stdout.write(`---\n`);
+            if (result.thinking) {
+                process.stdout.write(`\n<thinking>\n${formatThinkingForDisplay(result.thinking, 800)}\n</thinking>\n`);
+            }
+            process.stdout.write(`\n${result.message}\n`);
+            process.exit(result.ok ? 0 : 1);
+        }
+        default:
+            process.stderr.write(`Unknown command: ${args.command}\n`);
+            process.stderr.write(`Available commands: skills, claude-run, codex-run, claude-status, codex-status, claude-models, codex-models, claude-sessions, codex-sessions, claude-tail, codex-tail\n`);
+            process.exit(1);
+    }
+}
+main().catch(err => { console.error(err); process.exit(1); });

package/dist/session-status.js

@@ -0,0 +1,43 @@
+function getSessionRuntime(bot, session) {
+    const sessionId = session.sessionId || null;
+    if (!sessionId)
+        return null;
+    return bot.sessionStates.get(`${session.agent}:${sessionId}`) || null;
+}
+export function getSessionStatusForChat(bot, chat, session) {
+    const runtime = getSessionRuntime(bot, session);
+    const sessionId = session.sessionId || null;
+    const isCurrent = !!sessionId && (runtime
+        ? chat.activeSessionKey === runtime.key
+        : chat.agent === session.agent && chat.sessionId === sessionId);
+    return {
+        runtime,
+        isCurrent,
+        isRunning: !!runtime?.runningTaskIds.size || !!session.running,
+    };
+}
+export function getSessionStatusForBot(bot, session) {
+    const runtime = getSessionRuntime(bot, session);
+    const sessionId = session.sessionId || null;
+    let isCurrent = false;
+    if (sessionId) {
+        for (const [, chat] of bot.chats) {
+            if (runtime) {
+                if (chat.activeSessionKey === runtime.key) {
+                    isCurrent = true;
+                    break;
+                }
+                continue;
+            }
+            if (chat.agent === session.agent && chat.sessionId === sessionId) {
+                isCurrent = true;
+                break;
+            }
+        }
+    }
+    return {
+        runtime,
+        isCurrent,
+        isRunning: !!runtime?.runningTaskIds.size || !!session.running,
+    };
+}