pikiclaw 0.2.56 → 0.2.58

package/dist/agent-auto-update.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getAgentLabel, getAgentPackage } from './agent-npm.js';
+const AGENT_UPDATE_LOCK_STALE_MS = 60 * 60_000;
+const AGENT_UPDATE_COMMAND_TIMEOUT_MS = 15 * 60_000;
+function updaterLockPath() {
+    return path.join(os.homedir(), '.pikiclaw', 'agent-auto-update.lock');
+}
+function normalizeBooleanEnv(value) {
+    const text = String(value || '').trim();
+    if (!text)
+        return null;
+    if (/^(1|true|yes|on)$/i.test(text))
+        return true;
+    if (/^(0|false|no|off)$/i.test(text))
+        return false;
+    return null;
+}
+export function agentAutoUpdateEnabled(config) {
+    const env = normalizeBooleanEnv(process.env.PIKICLAW_AGENT_AUTO_UPDATE);
+    if (env != null)
+        return env;
+    if (typeof config.agentAutoUpdate === 'boolean')
+        return config.agentAutoUpdate;
+    return true;
+}
+export function extractAgentSemver(value) {
+    const text = String(value || '').trim();
+    if (!text)
+        return null;
+    const match = text.match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/);
+    return match?.[0] || null;
+}
+function isPathInside(parentDir, childPath) {
+    const parent = path.resolve(parentDir);
+    const child = path.resolve(childPath);
+    return child === parent || child.startsWith(`${parent}${path.sep}`);
+}
+export function resolveAgentUpdateStrategy(agent, npmPrefix) {
+    const id = String(agent.agent || '').trim();
+    const pkg = getAgentPackage(id);
+    if (!pkg)
+        return { kind: 'skip', reason: 'unsupported agent' };
+    const binPath = String(agent.path || '').trim();
+    const npmBinDir = npmPrefix ? path.join(path.resolve(npmPrefix), 'bin') : null;
+    const npmManaged = !!(binPath && npmBinDir && isPathInside(npmBinDir, binPath));
+    if (npmManaged)
+        return { kind: 'npm', pkg };
+    return { kind: 'skip', reason: 'non-npm install path' };
+}
+function labelForAgent(agent) {
+    return getAgentLabel(agent);
+}
+async function runCommand(cmd, args, opts = {}) {
+    return new Promise(resolve => {
+        let stdout = '';
+        let stderr = '';
+        let finished = false;
+        const child = spawn(cmd, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, npm_config_yes: 'true' },
+        });
+        const timeoutMs = Math.max(500, opts.timeoutMs ?? AGENT_UPDATE_COMMAND_TIMEOUT_MS);
+        const timer = setTimeout(() => {
+            if (finished)
+                return;
+            finished = true;
+            child.kill('SIGTERM');
+            resolve({ ok: false, code: null, stdout, stderr, error: `Timed out after ${Math.round(timeoutMs / 1000)}s` });
+        }, timeoutMs);
+        child.stdout?.on('data', chunk => { stdout += String(chunk); });
+        child.stderr?.on('data', chunk => { stderr += String(chunk); });
+        child.on('error', err => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            resolve({ ok: false, code: null, stdout, stderr, error: err.message });
+        });
+        child.on('close', code => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            resolve({
+                ok: code === 0,
+                code,
+                stdout,
+                stderr,
+                error: code === 0 ? null : (stderr.trim() || stdout.trim() || `Exited with code ${code}`),
+            });
+        });
+    });
+}
+async function getNpmGlobalPrefix() {
+    const result = await runCommand('npm', ['prefix', '-g'], { timeoutMs: 10_000 });
+    return result.ok ? result.stdout.trim().split('\n')[0] || null : null;
+}
+async function getLatestPackageVersion(pkg) {
+    const result = await runCommand('npm', ['view', pkg, 'version', '--json'], { timeoutMs: 20_000 });
+    if (!result.ok)
+        return null;
+    const raw = result.stdout.trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed.trim() || null : null;
+    }
+    catch {
+        return raw.replace(/^"+|"+$/g, '').trim() || null;
+    }
+}
+function acquireUpdateLock(log) {
+    const filePath = updaterLockPath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    try {
+        const stat = fs.statSync(filePath);
+        if (Date.now() - stat.mtimeMs > AGENT_UPDATE_LOCK_STALE_MS)
+            fs.rmSync(filePath, { force: true });
+    }
+    catch { }
+    try {
+        fs.writeFileSync(filePath, `${process.pid}\n`, { flag: 'wx' });
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            try {
+                fs.rmSync(filePath, { force: true });
+            }
+            catch { }
+        };
+    }
+    catch {
+        log('agent auto-update already running in another process; skipping this startup check');
+        return null;
+    }
+}
+async function updateViaNpm(pkg) {
+    const result = await runCommand('npm', ['install', '-g', `${pkg}@latest`]);
+    return { ok: result.ok, detail: result.ok ? result.stdout.trim() || null : result.error };
+}
+export function startAgentAutoUpdate(opts) {
+    if (!agentAutoUpdateEnabled(opts.config))
+        return;
+    const installedAgents = opts.agents.filter(agent => agent.installed && agent.path);
+    if (!installedAgents.length)
+        return;
+    const releaseLock = acquireUpdateLock(opts.log);
+    if (!releaseLock)
+        return;
+    void (async () => {
+        try {
+            opts.log(`agent auto-update: checking ${installedAgents.length} installed agent${installedAgents.length === 1 ? '' : 's'} in background`);
+            const npmPrefix = await getNpmGlobalPrefix();
+            for (const agent of installedAgents) {
+                const id = String(agent.agent || '').trim();
+                const pkg = getAgentPackage(id);
+                if (!pkg)
+                    continue;
+                const label = labelForAgent(id);
+                const currentVersion = extractAgentSemver(agent.version);
+                const latestVersion = await getLatestPackageVersion(pkg);
+                if (!latestVersion) {
+                    opts.log(`agent auto-update: ${label} latest version lookup failed`);
+                    continue;
+                }
+                if (currentVersion === latestVersion) {
+                    opts.log(`agent auto-update: ${label} is already up to date (${latestVersion})`);
+                    continue;
+                }
+                const strategy = resolveAgentUpdateStrategy(agent, npmPrefix);
+                if (strategy.kind === 'skip') {
+                    opts.log(`agent auto-update: ${label} is ${currentVersion || 'unknown'} and latest is ${latestVersion}, but update is skipped (${strategy.reason})`);
+                    continue;
+                }
+                opts.log(`agent auto-update: updating ${label} ${currentVersion || 'unknown'} -> ${latestVersion}`);
+                const result = await updateViaNpm(strategy.pkg);
+                if (result.ok)
+                    opts.log(`agent auto-update: ${label} update completed`);
+                else
+                    opts.log(`agent auto-update: ${label} update failed: ${result.detail || 'unknown error'}`);
+            }
+            opts.log('agent auto-update: finished');
+        }
+        finally {
+            releaseLock();
+        }
+    })();
+}

package/dist/agent-npm.js

@@ -0,0 +1,20 @@
+const AGENT_PACKAGES = {
+    claude: '@anthropic-ai/claude-code',
+    codex: '@openai/codex',
+    gemini: '@google/gemini-cli',
+};
+const AGENT_LABELS = {
+    claude: 'Claude Code',
+    codex: 'Codex',
+    gemini: 'Gemini CLI',
+};
+export function getAgentPackage(agent) {
+    return AGENT_PACKAGES[agent] || null;
+}
+export function getAgentLabel(agent) {
+    return AGENT_LABELS[agent] || agent;
+}
+export function getAgentInstallCommand(agent) {
+    const pkg = getAgentPackage(agent);
+    return pkg ? `npm install -g ${pkg}` : null;
+}

package/dist/bot-commands.js

@@ -10,7 +10,7 @@
  */
 import path from 'node:path';
 import { fmtTokens, fmtUptime, fmtBytes } from './bot.js';
-import { getProjectSkillPaths } from './code-agent.js';
+import { getProjectSkillPaths, normalizeClaudeModelId } from './code-agent.js';
 import { getDriver } from './agent-driver.js';
 import { buildWelcomeIntro, buildSkillCommandName, indexSkillsByCommand, SKILL_CMD_PREFIX } from './bot-menu.js';
 import { buildBotMenuState } from './bot-orchestration.js';
@@ -156,15 +156,13 @@ export function getSkillsListData(bot, chatId) {
     return { agent: cs.agent, workdir: bot.workdir, skills };
 }
 function claudeModelSelectionKey(modelId) {
-    const value = String(modelId || '').trim().toLowerCase();
+    const value = normalizeClaudeModelId(modelId).toLowerCase();
     if (!value)
         return null;
-    if (value === 'opus' || value === 'opus-1m' || value.startsWith('claude-opus-')) {
-        return value === 'opus-1m' || value.endsWith('[1m]') ? 'opus-1m' : 'opus';
-    }
-    if (value === 'sonnet' || value === 'sonnet-1m' || value.startsWith('claude-sonnet-')) {
-        return value === 'sonnet-1m' || value.endsWith('[1m]') ? 'sonnet-1m' : 'sonnet';
-    }
+    if (value === 'opus' || value.startsWith('claude-opus-'))
+        return 'opus';
+    if (value === 'sonnet' || value.startsWith('claude-sonnet-'))
+        return 'sonnet';
     if (value === 'haiku' || value.startsWith('claude-haiku-'))
         return 'haiku';
     return null;

package/dist/bot.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync, spawn } from 'node:child_process';
 import { getActiveUserConfig, onUserConfigChange, resolveUserWorkdir, setUserWorkdir } from './user-config.js';
-import { doStream, getSessions, getSessionTail, getUsage, initializeProjectSkills, listAgents, listModels, listSkills, stageSessionFiles, isPendingSessionId, } from './code-agent.js';
+import { doStream, getSessions, getSessionTail, getUsage, initializeProjectSkills, listAgents, listModels, listSkills, stageSessionFiles, isPendingSessionId, normalizeClaudeModelId, } from './code-agent.js';
 import { getDriver, hasDriver, allDriverIds } from './agent-driver.js';
 import { terminateProcessTree } from './process-control.js';
 import { VERSION } from './version.js';
@@ -221,7 +221,7 @@ function buildMcpDeliveryPrompt() {
 }
 function configModelValue(config, agent) {
     switch (agent) {
-        case 'claude': return String(config.claudeModel || process.env.CLAUDE_MODEL || 'claude-opus-4-6').trim();
+        case 'claude': return normalizeClaudeModelId(config.claudeModel || process.env.CLAUDE_MODEL || 'claude-opus-4-6');
         case 'codex': return String(config.codexModel || process.env.CODEX_MODEL || 'gpt-5.4').trim();
         case 'gemini': return String(config.geminiModel || process.env.GEMINI_MODEL || 'gemini-3.1-pro-preview').trim();
     }

package/dist/cli.js

@@ -4,6 +4,7 @@
  */
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+import { startAgentAutoUpdate } from './agent-auto-update.js';
 import { envBool } from './bot.js';
 import { TelegramBot } from './bot-telegram.js';
 import { hasConfiguredChannelToken, resolveConfiguredChannels } from './cli-channels.js';
@@ -434,6 +435,11 @@ Docs: https://github.com/xiaotonng/pikiclaw
     if (args.allowedIds && channel === 'telegram')
         runtimeConfig.telegramAllowedChatIds = args.allowedIds;
     applyUserConfig(runtimeConfig, undefined, { overwrite: true, clearMissing: true });
+    startAgentAutoUpdate({
+        config: runtimeConfig,
+        agents: listAgents({ includeVersion: true, refresh: true }).agents,
+        log: processLog,
+    });
     if (args.model) {
         const ag = args.agent || runtimeConfig.defaultAgent || 'codex';
         if (ag === 'codex')

package/dist/code-agent.js

@@ -315,6 +315,9 @@ export function modelFamily(model) {
         return 'sonnet';
     return null;
 }
+export function normalizeClaudeModelId(model) {
+    return typeof model === 'string' ? model.trim() : '';
+}
 export function emptyUsage(agent, error) {
     return { ok: false, agent, source: null, capturedAt: null, status: null, windows: [], error };
 }