pikiclaw 0.2.35

package/dist/setup-wizard.js

@@ -0,0 +1,231 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { buildSetupGuide, collectSetupState } from './onboarding.js';
+import { getUserConfigPath, saveUserConfig } from './user-config.js';
+function createTerminalIO() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return {
+        ask(prompt) {
+            return rl.question(prompt);
+        },
+        write(text) {
+            process.stdout.write(text);
+        },
+        runCommand(command, args = []) {
+            return new Promise(resolve => {
+                const child = spawn(command, args, {
+                    stdio: 'inherit',
+                    env: process.env,
+                });
+                child.on('exit', code => resolve(code ?? 1));
+                child.on('error', () => resolve(1));
+            });
+        },
+        close() {
+            void rl.close();
+        },
+    };
+}
+function parseChoice(raw) {
+    return String(raw || '').trim().toLowerCase();
+}
+async function askYesNo(io, prompt, def) {
+    const suffix = def ? ' [Y/n] ' : ' [y/N] ';
+    for (;;) {
+        const answer = parseChoice(await io.ask(`${prompt}${suffix}`));
+        if (!answer)
+            return def;
+        if (['y', 'yes'].includes(answer))
+            return true;
+        if (['n', 'no'].includes(answer))
+            return false;
+        io.write('Please answer y or n.\n');
+    }
+}
+async function askAgentChoice(io, installed) {
+    io.write('Choose your local coding agent:\n');
+    io.write(`  1. Codex${installed.some(a => a.agent === 'codex' && a.installed) ? ' (installed)' : ''}\n`);
+    io.write(`  2. Claude Code${installed.some(a => a.agent === 'claude' && a.installed) ? ' (installed)' : ''}\n`);
+    io.write('  q. Quit setup\n');
+    for (;;) {
+        const answer = parseChoice(await io.ask('Selection [1/2/q]: '));
+        if (answer === '1' || answer === 'codex')
+            return 'codex';
+        if (answer === '2' || answer === 'claude')
+            return 'claude';
+        if (answer === 'q' || answer === 'quit')
+            return null;
+        io.write('Please choose 1, 2, or q.\n');
+    }
+}
+function preferredInstalledAgent(agents) {
+    if (agents.some(agent => agent.agent === 'codex' && agent.installed))
+        return 'codex';
+    if (agents.some(agent => agent.agent === 'claude' && agent.installed))
+        return 'claude';
+    return null;
+}
+function parseAgent(value) {
+    return value === 'claude' || value === 'codex' ? value : null;
+}
+function title(label) {
+    return `\n${label}\n${'-'.repeat(label.length)}\n`;
+}
+export async function validateTelegramToken(token) {
+    const value = String(token || '').trim();
+    if (!value)
+        return { ok: false, bot: null, error: 'The token was empty.' };
+    try {
+        const resp = await fetch(`https://api.telegram.org/bot${value}/getMe`, {
+            method: 'POST',
+            signal: AbortSignal.timeout(8_000),
+        });
+        const raw = await resp.text();
+        let parsed = null;
+        try {
+            parsed = raw ? JSON.parse(raw) : null;
+        }
+        catch {
+            return { ok: false, bot: null, error: `Telegram returned invalid JSON (${resp.status}).` };
+        }
+        if (!resp.ok || parsed?.ok !== true || !parsed?.result) {
+            const detail = typeof parsed?.description === 'string' ? parsed.description : `HTTP ${resp.status}`;
+            return { ok: false, bot: null, error: `Telegram rejected this token: ${detail}` };
+        }
+        return {
+            ok: true,
+            bot: {
+                id: parsed.result.id,
+                username: parsed.result.username || null,
+                displayName: parsed.result.first_name || null,
+            },
+            error: null,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err ?? 'unknown error');
+        return { ok: false, bot: null, error: `Failed to reach Telegram: ${msg}` };
+    }
+}
+export async function runSetupWizard(options) {
+    const io = options.io || createTerminalIO();
+    const validate = options.validateTelegramToken || validateTelegramToken;
+    const persistConfig = options.persistConfig || saveUserConfig;
+    let state = options.initialState;
+    let selectedAgent = parseAgent(options.argsAgent);
+    let token = String(options.currentToken || '').trim() || null;
+    let tokenCheck = null;
+    let configPath = null;
+    const refreshState = () => {
+        state = collectSetupState({
+            agents: options.listAgents(),
+            channel: options.channel,
+            tokenProvided: !!token,
+        });
+        return state;
+    };
+    try {
+        io.write(title(`pikiclaw v${options.version} setup`));
+        if (options.channel !== 'telegram') {
+            io.write(buildSetupGuide(state, options.version));
+            io.write('\nInteractive setup is currently only available for Telegram.\n');
+            return { completed: false, token, agent: null, configPath: null, tokenCheck: null };
+        }
+        io.write('This wizard will help you install or verify a local agent, validate your Telegram bot token, and optionally save the setup for next time.\n');
+        refreshState();
+        io.write(title('Step 1: Local agent'));
+        if (!selectedAgent) {
+            const installedAgent = preferredInstalledAgent(state.agents);
+            if (state.agents.filter(agent => agent.installed).length > 1) {
+                selectedAgent = await askAgentChoice(io, state.agents);
+            }
+            else {
+                selectedAgent = installedAgent || await askAgentChoice(io, state.agents);
+            }
+        }
+        if (!selectedAgent) {
+            io.write('Setup cancelled.\n');
+            return { completed: false, token, agent: null, configPath: null, tokenCheck: null };
+        }
+        let selectedState = refreshState().agents.find(agent => agent.agent === selectedAgent) || null;
+        if (!selectedState?.installed) {
+            io.write(`${selectedState?.label || selectedAgent} is not installed.\n`);
+            const installNow = await askYesNo(io, `Install ${selectedAgent === 'claude' ? 'Claude Code' : 'Codex'} now?`, true);
+            if (!installNow) {
+                io.write('Setup cancelled. Install the agent first, then run `npx pikiclaw@latest` again.\n');
+                return { completed: false, token, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+            io.write(`Running: ${selectedState?.installCommand || `npm install -g ${selectedAgent}`}\n`);
+            const exitCode = await io.runCommand('npm', ['install', '-g', selectedAgent === 'claude' ? '@anthropic-ai/claude-code' : '@openai/codex']);
+            selectedState = refreshState().agents.find(agent => agent.agent === selectedAgent) || null;
+            if (exitCode !== 0 || !selectedState?.installed) {
+                io.write(`Install did not complete successfully. You can try manually: ${selectedState?.installCommand || ''}\n`);
+                return { completed: false, token, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+        }
+        io.write(`Using ${selectedState.label}.\n`);
+        io.write(title('Step 2: Telegram bot token'));
+        if (token) {
+            tokenCheck = await validate(token);
+            if (tokenCheck.ok) {
+                io.write(`Existing token looks valid for @${tokenCheck.bot?.username || 'unknown_bot'}.\n`);
+            }
+            else {
+                io.write(`The existing token could not be verified: ${tokenCheck.error}\n`);
+                token = null;
+            }
+        }
+        if (!token) {
+            io.write('Get a bot token from Telegram first:\n');
+            io.write('  1. Open Telegram and search for @BotFather\n');
+            io.write('  2. Send /newbot\n');
+            io.write('  3. Choose a display name and a username\n');
+            io.write('  4. Paste the token here\n');
+        }
+        while (!token) {
+            const answer = String(await io.ask('Paste your Telegram bot token (or type q to quit): ')).trim();
+            if (!answer)
+                continue;
+            if (parseChoice(answer) === 'q') {
+                io.write('Setup cancelled.\n');
+                return { completed: false, token: null, agent: selectedAgent, configPath: null, tokenCheck: null };
+            }
+            const check = await validate(answer);
+            if (!check.ok) {
+                io.write(`${check.error}\n`);
+                continue;
+            }
+            token = answer;
+            tokenCheck = check;
+            io.write(`Telegram bot verified: @${check.bot?.username || 'unknown_bot'}${check.bot?.displayName ? ` (${check.bot.displayName})` : ''}\n`);
+        }
+        io.write(title('Step 3: Save setup'));
+        const configFile = getUserConfigPath();
+        const saveIt = await askYesNo(io, `Save this setup to ${configFile}?`, true);
+        if (saveIt) {
+            configPath = persistConfig({
+                channel: 'telegram',
+                defaultAgent: selectedAgent,
+                telegramBotToken: token,
+            });
+            io.write(`Saved config to ${configPath}\n`);
+        }
+        else {
+            io.write('Skipping config save. This run will still start now, but you may need to provide the token again next time.\n');
+        }
+        io.write(title('Ready'));
+        io.write(`Agent: ${selectedAgent}\n`);
+        io.write(`Telegram bot: @${tokenCheck?.bot?.username || 'unknown_bot'}\n`);
+        io.write('Starting pikiclaw now...\n');
+        return {
+            completed: true,
+            token,
+            agent: selectedAgent,
+            configPath,
+            tokenCheck,
+        };
+    }
+    finally {
+        io.close();
+    }
+}

package/dist/user-config.js

@@ -0,0 +1,195 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const MANAGED_ENV_KEYS = [
+    'PIKICLAW_CHANNEL',
+    'PIKICLAW_WORKDIR',
+    'DEFAULT_AGENT',
+    'TELEGRAM_BOT_TOKEN',
+    'TELEGRAM_ALLOWED_CHAT_IDS',
+    'FEISHU_APP_ID',
+    'FEISHU_APP_SECRET',
+];
+let activeUserConfig = {};
+const userConfigListeners = new Set();
+let userConfigSyncTimer = null;
+let userConfigSyncRefCount = 0;
+let userConfigSyncRaw = '';
+let userConfigSyncOverrides = {};
+function expandHomeDir(value) {
+    return value.replace(/^~/, process.env.HOME || '');
+}
+/**
+ * Single canonical config path: ~/.pikiclaw/setting.json
+ * Both CLI and dashboard read/write this file exclusively.
+ */
+export function getUserConfigPath() {
+    const custom = (process.env.PIKICLAW_CONFIG || '').trim();
+    if (custom)
+        return path.resolve(custom);
+    return path.join(os.homedir(), '.pikiclaw', 'setting.json');
+}
+function loadJsonFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed ? normalizeUserConfig(parsed) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeUserConfig(config) {
+    const next = { ...config };
+    const workdir = typeof next.workdir === 'string' && next.workdir.trim() ? next.workdir.trim() : '';
+    if (workdir)
+        next.workdir = resolveUserWorkdir({ workdir });
+    else
+        delete next.workdir;
+    return next;
+}
+export function loadUserConfig() {
+    return loadJsonFile(getUserConfigPath());
+}
+export function hasUserConfigFile() {
+    try {
+        return fs.existsSync(getUserConfigPath());
+    }
+    catch {
+        return false;
+    }
+}
+export function getActiveUserConfig() {
+    return activeUserConfig;
+}
+export function saveUserConfig(config) {
+    const filePath = getUserConfigPath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify({ version: 1, ...normalizeUserConfig(config) }, null, 2)}\n`, { mode: 0o600 });
+    return filePath;
+}
+export function updateUserConfig(patch) {
+    return saveUserConfig({ ...loadUserConfig(), ...patch });
+}
+export function resolveUserWorkdir(opts = {}) {
+    const raw = String(opts.workdir
+        || opts.config?.workdir
+        || process.env.PIKICLAW_WORKDIR
+        || opts.cwd
+        || process.cwd()).trim();
+    return path.resolve(expandHomeDir(raw));
+}
+function buildManagedEnv(config) {
+    const configuredWorkdir = config.workdir || '';
+    return {
+        PIKICLAW_CHANNEL: String(config.channel || '').trim(),
+        PIKICLAW_WORKDIR: configuredWorkdir ? resolveUserWorkdir({ workdir: configuredWorkdir }) : '',
+        DEFAULT_AGENT: String(config.defaultAgent || '').trim(),
+        TELEGRAM_BOT_TOKEN: String(config.telegramBotToken || '').trim(),
+        TELEGRAM_ALLOWED_CHAT_IDS: String(config.telegramAllowedChatIds || '').trim(),
+        FEISHU_APP_ID: String(config.feishuAppId || '').trim(),
+        FEISHU_APP_SECRET: String(config.feishuAppSecret || '').trim(),
+    };
+}
+function notifyUserConfigListeners(config, changedKeys) {
+    for (const listener of userConfigListeners) {
+        try {
+            listener(config, changedKeys);
+        }
+        catch { }
+    }
+}
+function readUserConfigRaw() {
+    try {
+        return fs.readFileSync(getUserConfigPath(), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+export function onUserConfigChange(listener) {
+    userConfigListeners.add(listener);
+    return () => userConfigListeners.delete(listener);
+}
+function configValuesEqual(a, b) {
+    if (Array.isArray(a) || Array.isArray(b))
+        return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+    return a === b;
+}
+function diffConfigKeys(prev, next) {
+    const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+    const changed = [];
+    for (const key of keys) {
+        if (!configValuesEqual(prev[key], next[key]))
+            changed.push(key);
+    }
+    return changed;
+}
+export function applyUserConfig(config, _channel, options = {}) {
+    const overwrite = options.overwrite ?? true;
+    const clearMissing = options.clearMissing ?? true;
+    const notify = options.notify ?? true;
+    const managed = buildManagedEnv(config);
+    const changedKeys = [];
+    const prevConfig = activeUserConfig;
+    for (const key of MANAGED_ENV_KEYS) {
+        const next = managed[key];
+        const prev = process.env[key] ?? '';
+        if (!next) {
+            if (clearMissing && key in process.env) {
+                delete process.env[key];
+                changedKeys.push(key);
+            }
+            continue;
+        }
+        if (!overwrite && prev)
+            continue;
+        if (prev !== next) {
+            process.env[key] = next;
+            changedKeys.push(key);
+        }
+    }
+    activeUserConfig = { ...config };
+    const configChangedKeys = diffConfigKeys(prevConfig, activeUserConfig);
+    const notifyKeys = [...new Set([...changedKeys, ...configChangedKeys])];
+    if (notify && notifyKeys.length)
+        notifyUserConfigListeners(activeUserConfig, notifyKeys);
+    return changedKeys;
+}
+export function setUserWorkdir(workdir, options = {}) {
+    const resolvedWorkdir = resolveUserWorkdir({ workdir });
+    const config = normalizeUserConfig({ ...loadUserConfig(), workdir: resolvedWorkdir });
+    const configPath = saveUserConfig(config);
+    applyUserConfig(config, undefined, { overwrite: true, clearMissing: true, notify: options.notify ?? true });
+    return { configPath, workdir: resolvedWorkdir, config };
+}
+export function startUserConfigSync(options = {}) {
+    const intervalMs = Math.max(250, Math.round(options.intervalMs ?? 1_000));
+    if (options.overrides)
+        userConfigSyncOverrides = { ...options.overrides };
+    const syncNow = () => {
+        const raw = readUserConfigRaw();
+        if (raw === userConfigSyncRaw && userConfigSyncTimer)
+            return;
+        userConfigSyncRaw = raw;
+        const merged = { ...loadUserConfig(), ...userConfigSyncOverrides };
+        const changedKeys = applyUserConfig(merged, undefined, { overwrite: true, clearMissing: true, notify: true });
+        if (changedKeys.length)
+            options.log?.(`config reloaded from setting.json (${changedKeys.join(', ')})`);
+    };
+    syncNow();
+    userConfigSyncRefCount++;
+    if (!userConfigSyncTimer) {
+        userConfigSyncTimer = setInterval(syncNow, intervalMs);
+        userConfigSyncTimer.unref?.();
+    }
+    return () => {
+        userConfigSyncRefCount = Math.max(0, userConfigSyncRefCount - 1);
+        if (userConfigSyncRefCount > 0 || !userConfigSyncTimer)
+            return;
+        clearInterval(userConfigSyncTimer);
+        userConfigSyncTimer = null;
+        userConfigSyncRaw = '';
+        userConfigSyncOverrides = {};
+    };
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "pikiclaw",
+  "version": "0.2.35",
+  "description": "The best IM-driven remote coding experience. Bridge AI coding agents to any IM.",
+  "type": "module",
+  "bin": {
+    "pikiclaw": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "telegram",
+    "ai",
+    "coding",
+    "claude",
+    "codex",
+    "bridge",
+    "cli"
+  ],
+  "author": "xiaotonng",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xiaotonng/pikiclaw.git"
+  },
+  "scripts": {
+    "dev": "npm run build:dashboard && tsx src/cli.ts",
+    "command": "set -ae && . ./.env && set +a && tsx src/run.ts",
+    "build:dashboard": "tsx scripts/build-dashboard.ts",
+    "build": "npm run build:dashboard && tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:e2e": "set -ae && . ./.env && set +a && vitest run --config vitest.e2e.config.ts test/e2e/",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.2.1",
+    "@types/node": "^25.3.5",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.4",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "tailwindcss": "^4.2.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite-plugin-singlefile": "^2.3.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "undici": "^7.22.0"
+  }
+}