pikiloop 0.4.0

package/dist/dashboard/routes/config.js

@@ -0,0 +1,523 @@
+/**
+ * Dashboard API routes: configuration, channels, extensions, permissions.
+ */
+import { Hono } from 'hono';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn, spawnSync } from 'node:child_process';
+import { loadUserConfig, saveUserConfig, applyUserConfig, hasUserConfigFile } from '../../core/config/user-config.js';
+import { expandTilde } from '../../core/platform.js';
+import { readGitStatus } from '../../core/git.js';
+import { isSetupReady } from '../../cli/onboarding.js';
+import { validateDingtalkConfig, validateDiscordConfig, validateFeishuConfig, validateSlackConfig, validateTelegramConfig, validateWecomConfig, validateWeixinConfig, } from '../../core/config/validation.js';
+import { resolveGuiIntegrationConfig } from '../../agent/mcp/bridge.js';
+import { normalizeWeixinBaseUrl, startWeixinQrLogin, waitForWeixinQrLogin, } from '../../channels/weixin/api.js';
+import { getConfiguredRemoteCdpUrl, getManagedBrowserStatus, launchManagedBrowserSetup, } from '../../browser-profile.js';
+import { requestProcessRestart, getActiveTaskCount, } from '../../core/process-control.js';
+import { getPermissionsStatus, getHostTerminalApp, isValidPermissionKey, requestPermission, } from '../platform.js';
+import { VERSION } from '../../core/version.js';
+import { runtime } from '../runtime.js';
+import { writeScopedLog } from '../../core/logging.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export async function buildBrowserStatusResponse(config = loadUserConfig(), browserState = getManagedBrowserStatus()) {
+    const gui = resolveGuiIntegrationConfig(config);
+    // In remote mode the local Chrome state is irrelevant — pikiloop attaches to
+    // the external CDP endpoint and never launches/manages a local browser. Report
+    // the endpoint so the dashboard shows the truth instead of "Chrome missing".
+    const remoteCdpUrl = gui.browserEnabled ? getConfiguredRemoteCdpUrl() : null;
+    return {
+        browser: {
+            status: gui.browserEnabled ? browserState.status : 'disabled',
+            enabled: gui.browserEnabled,
+            remoteCdpUrl,
+            headlessMode: gui.browserHeadless ? 'headless' : 'headed',
+            chromeInstalled: browserState.chromeInstalled,
+            profileCreated: browserState.profileCreated,
+            running: browserState.running,
+            pid: browserState.pid,
+            profileDir: browserState.profileDir || gui.browserProfileDir,
+            detail: !gui.browserEnabled
+                ? 'Browser automation is disabled. No browser MCP server will be injected into agent sessions. On macOS, operate your main browser directly with open, osascript, and screencapture when needed.'
+                : remoteCdpUrl
+                    ? `Attached to an external Chrome over CDP at ${remoteCdpUrl} (PIKILOOP_BROWSER_CDP_URL). pikiloop does not launch or manage a local browser in this mode — sign in to sites from the Chrome that owns this endpoint (e.g. your sidecar's web VNC).`
+                    : browserState.detail,
+        },
+    };
+}
+function isOpenTarget(value) {
+    return value === 'vscode'
+        || value === 'cursor'
+        || value === 'windsurf'
+        || value === 'finder'
+        || value === 'default';
+}
+function runOpenCommand(command, args) {
+    const result = spawnSync(command, args, {
+        encoding: 'utf8',
+        timeout: 5_000,
+    });
+    if (result.error)
+        throw result.error;
+    if ((result.status ?? 0) !== 0) {
+        const detail = String(result.stderr || result.stdout || '').trim();
+        throw new Error(detail || `Failed to run ${command} ${args.join(' ')}`);
+    }
+}
+function openPathWithTarget(filePath, target, isDirectory) {
+    if (process.platform === 'darwin') {
+        switch (target) {
+            case 'finder':
+                runOpenCommand('open', isDirectory ? [filePath] : ['-R', filePath]);
+                return;
+            case 'default':
+                runOpenCommand('open', [filePath]);
+                return;
+            case 'cursor':
+                runOpenCommand('open', ['-a', 'Cursor', filePath]);
+                return;
+            case 'windsurf':
+                runOpenCommand('open', ['-a', 'Windsurf', filePath]);
+                return;
+            case 'vscode':
+            default:
+                runOpenCommand('open', ['-a', 'Visual Studio Code', filePath]);
+                return;
+        }
+    }
+    if (process.platform === 'win32') {
+        switch (target) {
+            case 'cursor':
+                runOpenCommand('cursor', [filePath]);
+                return;
+            case 'windsurf':
+                runOpenCommand('windsurf', [filePath]);
+                return;
+            case 'finder':
+            case 'default':
+                runOpenCommand('cmd', ['/c', 'start', '', filePath]);
+                return;
+            case 'vscode':
+            default:
+                runOpenCommand('code', [filePath]);
+                return;
+        }
+    }
+    switch (target) {
+        case 'cursor':
+            runOpenCommand('cursor', [filePath]);
+            return;
+        case 'windsurf':
+            runOpenCommand('windsurf', [filePath]);
+            return;
+        case 'finder':
+        case 'default':
+            runOpenCommand('xdg-open', [filePath]);
+            return;
+        case 'vscode':
+        default:
+            runOpenCommand('code', [filePath]);
+            return;
+    }
+}
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+const app = new Hono();
+// Full state (config from file only)
+app.get('/api/state', async (c) => {
+    const config = loadUserConfig();
+    const setupState = await runtime.buildValidatedSetupState(config);
+    const permissions = getPermissionsStatus();
+    const botRef = runtime.getBotRef();
+    return c.json({
+        version: VERSION,
+        ready: isSetupReady(setupState),
+        configExists: hasUserConfigFile(),
+        config,
+        runtimeWorkdir: runtime.getRuntimeWorkdir(config),
+        setupState,
+        permissions,
+        hostApp: getHostTerminalApp(),
+        platform: process.platform,
+        pid: process.pid,
+        nodeVersion: process.versions.node,
+        bot: botRef ? {
+            workdir: botRef.workdir,
+            defaultAgent: botRef.defaultAgent,
+            uptime: Date.now() - botRef.startedAt,
+            connected: botRef.connected,
+            stats: botRef.stats,
+            activeTasks: botRef.activeTasks.size,
+            sessions: botRef.sessionStates.size,
+        } : null,
+    });
+});
+// Host info
+app.get('/api/host', (c) => {
+    const botRef = runtime.getBotRef();
+    if (botRef)
+        return c.json(botRef.getHostData());
+    const cpus = os.cpus();
+    const [one, five, fifteen] = os.loadavg();
+    return c.json({
+        hostName: os.hostname(), cpuModel: cpus[0]?.model || 'unknown',
+        cpuCount: cpus.length, totalMem: os.totalmem(), freeMem: os.freemem(),
+        loadAverage: { one, five, fifteen },
+        platform: process.platform, arch: os.arch(),
+    });
+});
+// Permissions
+app.get('/api/permissions', (c) => {
+    const data = { ...getPermissionsStatus(), hostApp: getHostTerminalApp() };
+    return c.json(data);
+});
+// Save config (to ~/.pikiloop/setting.json). Channel reconciliation is
+// handled by ChannelSupervisor via the onUserConfigChange listener — adding,
+// removing, or swapping credentials of an IM channel takes effect in-process
+// without restarting pikiloop.
+app.post('/api/config', async (c) => {
+    const body = await c.req.json();
+    const merged = { ...loadUserConfig(), ...body };
+    const configPath = saveUserConfig(merged);
+    applyUserConfig(loadUserConfig());
+    return c.json({ ok: true, configPath });
+});
+// Validate Telegram token
+app.post('/api/validate-telegram-token', async (c) => {
+    const body = await c.req.json();
+    const result = await validateTelegramConfig(body.token || '', body.allowedChatIds || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        bot: result.bot,
+        normalizedAllowedChatIds: result.normalizedAllowedChatIds,
+    });
+});
+// Validate Feishu credentials
+app.post('/api/validate-feishu-config', async (c) => {
+    const body = await c.req.json();
+    const startedAt = Date.now();
+    const rawAppId = String(body.appId || '').trim();
+    const maskedAppId = !rawAppId
+        ? '(missing)'
+        : rawAppId.length <= 10
+            ? rawAppId
+            : `${rawAppId.slice(0, 6)}...${rawAppId.slice(-4)}`;
+    writeScopedLog('dashboard', `[feishu-config] request app=${maskedAppId}`, { level: 'debug' });
+    const result = await validateFeishuConfig(body.appId || '', body.appSecret || '');
+    writeScopedLog('dashboard', `[feishu-config] result app=${maskedAppId} ok=${result.state.ready} status=${result.state.status} elapsedMs=${Date.now() - startedAt}`, { level: 'debug' });
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        app: result.app,
+    });
+});
+// Validate Weixin credentials
+app.post('/api/validate-weixin-config', async (c) => {
+    const body = await c.req.json();
+    const result = await validateWeixinConfig(body.baseUrl || '', body.botToken || '', body.accountId || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        account: result.account,
+        normalizedBaseUrl: result.normalizedBaseUrl,
+    });
+});
+// Validate Slack credentials
+app.post('/api/validate-slack-config', async (c) => {
+    const body = await c.req.json();
+    const result = await validateSlackConfig(body.botToken || '', body.appToken || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        bot: result.bot,
+    });
+});
+// Validate Discord credentials
+app.post('/api/validate-discord-config', async (c) => {
+    const body = await c.req.json();
+    const result = await validateDiscordConfig(body.botToken || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        bot: result.bot,
+    });
+});
+// Validate DingTalk credentials
+app.post('/api/validate-dingtalk-config', async (c) => {
+    const body = await c.req.json();
+    const result = await validateDingtalkConfig(body.clientId || '', body.clientSecret || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        app: result.app,
+    });
+});
+// Validate WeChat Work (企业微信) credentials
+app.post('/api/validate-wecom-config', async (c) => {
+    const body = await c.req.json();
+    const result = await validateWecomConfig(body.botId || '', body.botSecret || '');
+    return c.json({
+        ok: result.state.ready,
+        error: result.state.ready ? null : result.state.detail,
+        bot: result.bot,
+    });
+});
+// Start Weixin QR login
+app.post('/api/weixin-login/start', async (c) => {
+    const body = await c.req.json();
+    const result = await startWeixinQrLogin({
+        baseUrl: normalizeWeixinBaseUrl(body.baseUrl || ''),
+        sessionKey: body.sessionKey || undefined,
+    });
+    return c.json(result, result.ok ? 200 : 500);
+});
+// Wait for Weixin QR login
+app.post('/api/weixin-login/wait', async (c) => {
+    const body = await c.req.json();
+    const result = await waitForWeixinQrLogin({
+        baseUrl: normalizeWeixinBaseUrl(body.baseUrl || ''),
+        sessionKey: String(body.sessionKey || '').trim(),
+    });
+    return c.json(result, result.ok ? 200 : 500);
+});
+// Open macOS preferences
+app.post('/api/open-preferences', async (c) => {
+    const body = await c.req.json();
+    const permission = String(body.permission || '');
+    if (!isValidPermissionKey(permission)) {
+        return c.json({
+            ok: false,
+            action: 'unsupported',
+            granted: false,
+            requiresManualGrant: false,
+            error: 'Invalid permission.',
+        }, 400);
+    }
+    const result = requestPermission(permission);
+    runtime.log(`[permissions] permission=${permission} action=${result.action} granted=${result.granted} manual=${result.requiresManualGrant} ok=${result.ok}`);
+    return c.json(result, result.ok ? 200 : 500);
+});
+// Restart process
+app.post('/api/restart', (c) => {
+    // A successful restart exits this process, so its result can never reach the
+    // client — the route fires it async and returns ok:true. But the restart is
+    // REFUSED while any turn is still running (requestProcessRestart guards on
+    // active tasks so it won't kill in-flight work). Surface that refusal
+    // synchronously: otherwise the dashboard sends ok:true into a "reconnecting"
+    // wait for a restart that never happens and shows a generic failure, with no
+    // hint that a running task is the reason.
+    const activeTasks = getActiveTaskCount();
+    if (activeTasks > 0) {
+        return c.json({
+            ok: false,
+            activeTasks,
+            error: `${activeTasks} task(s) still running — can't restart. Wait for them to finish or stop them, then retry.`,
+        }, 409);
+    }
+    setTimeout(() => {
+        void requestProcessRestart({ log: message => runtime.log(message) });
+    }, 50);
+    return c.json({ ok: true });
+});
+// Switch workdir
+app.post('/api/switch-workdir', async (c) => {
+    const body = await c.req.json();
+    const newPath = body.path;
+    if (!newPath)
+        return c.json({ ok: false, error: 'Missing path' }, 400);
+    const resolvedPath = path.resolve(expandTilde(String(newPath)));
+    const botRef = runtime.getBotRef();
+    if (botRef) {
+        botRef.switchWorkdir(resolvedPath);
+        return c.json({ ok: true, workdir: botRef.workdir });
+    }
+    const { setUserWorkdir } = await import('../../core/config/user-config.js');
+    const saved = setUserWorkdir(resolvedPath);
+    return c.json({ ok: true, workdir: saved.workdir });
+});
+// Browser profile status
+app.get('/api/browser', async (c) => {
+    const config = loadUserConfig();
+    const data = await buildBrowserStatusResponse(config);
+    return c.json(data);
+});
+// Launch managed browser profile for login/setup
+app.post('/api/browser/setup', async (c) => {
+    runtime.log('[browser] setup requested');
+    try {
+        const config = loadUserConfig();
+        const gui = resolveGuiIntegrationConfig(config);
+        if (!gui.browserEnabled) {
+            return c.json({
+                ok: false,
+                error: 'Browser automation is disabled. Enable it first if you want pikiloop to launch the managed browser profile.',
+            }, 400);
+        }
+        // Remote mode: pikiloop attaches to an external CDP endpoint and owns no
+        // local Chrome. There is nothing to launch — return the (enabled) status as
+        // a clean no-op instead of failing with "Chrome is not available".
+        if (getConfiguredRemoteCdpUrl()) {
+            runtime.log('[browser] setup skipped: PIKILOOP_BROWSER_CDP_URL configured (external CDP, no local browser to launch)');
+            return c.json({ ok: true, ...(await buildBrowserStatusResponse(config)) });
+        }
+        const launch = launchManagedBrowserSetup();
+        runtime.log(`[browser] launched managed profile at ${launch.profileDir} pid=${launch.pid ?? 'unknown'}`);
+        const payload = await buildBrowserStatusResponse(config, launch);
+        return c.json({
+            ok: true,
+            browser: {
+                ...payload.browser,
+                detail: launch.running
+                    ? 'Managed browser is open. Sign in to the sites you want pikiloop to reuse. If it is still open later, pikiloop will close it automatically before browser automation starts.'
+                    : payload.browser.detail,
+            },
+        });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        runtime.log(`[browser] setup failed: ${detail}`);
+        return c.json({ ok: false, error: detail }, 500);
+    }
+});
+// List directory entries for tree browser
+app.get('/api/ls-dir', (c) => {
+    const dir = c.req.query('path') || os.homedir();
+    const includeFiles = c.req.query('files') === '1';
+    const includeHidden = c.req.query('hidden') === '1';
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const dirs = entries
+            .filter(e => (includeHidden || !e.name.startsWith('.')) && (includeFiles || e.isDirectory()))
+            .map(e => ({ name: e.name, path: path.join(dir, e.name), isDir: e.isDirectory() }))
+            .sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        const isGit = fs.existsSync(path.join(dir, '.git'));
+        return c.json({ ok: true, path: dir, parent: path.dirname(dir), dirs, isGit });
+    }
+    catch (err) {
+        return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 400);
+    }
+});
+// Git changes for a directory (uncommitted + staged)
+app.get('/api/git-changes', (c) => {
+    const dir = c.req.query('path');
+    if (!dir)
+        return c.json({ ok: false, error: 'path is required' }, 400);
+    try {
+        if (!fs.existsSync(path.join(dir, '.git'))) {
+            return c.json({ ok: true, changes: [], isGit: false });
+        }
+        // --no-optional-locks avoids contention with other git processes
+        const result = spawnSync('git', ['diff', '--name-status', 'HEAD', '--no-renames'], {
+            cwd: dir,
+            timeout: 5_000,
+            encoding: 'utf-8',
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+        });
+        const lines = (result.stdout || '').trim().split('\n').filter(Boolean);
+        const changes = lines.map(line => {
+            const [status, ...rest] = line.split('\t');
+            const file = rest.join('\t');
+            return {
+                status: status === 'A' ? 'added'
+                    : status === 'D' ? 'deleted'
+                        : 'modified',
+                file,
+                path: path.join(dir, file),
+            };
+        });
+        return c.json({ ok: true, changes, isGit: true });
+    }
+    catch (err) {
+        return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
+// Git status summary for a workspace: branch, ahead/behind, dirty count.
+// Backed by the same readGitStatus helper that feeds the IM /status command.
+app.get('/api/workspace-git', (c) => {
+    const dir = c.req.query('path');
+    if (!dir)
+        return c.json({ ok: false, error: 'path is required' }, 400);
+    const git = readGitStatus(dir);
+    return c.json({ ok: true, isGit: git !== null, git });
+});
+// Open file/directory in a selected editor or file browser
+app.post('/api/open-in-editor', async (c) => {
+    try {
+        const body = await c.req.json();
+        const filePath = typeof body?.filePath === 'string' ? body.filePath.trim() : '';
+        const target = isOpenTarget(body?.target) ? body.target : 'vscode';
+        if (!filePath)
+            return c.json({ ok: false, error: 'filePath is required' }, 400);
+        if (!fs.existsSync(filePath))
+            return c.json({ ok: false, error: 'Path not found' }, 404);
+        const stat = fs.statSync(filePath);
+        openPathWithTarget(filePath, target, stat.isDirectory());
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        runtime.log(`[open-in-editor] failed: ${detail}`);
+        return c.json({ ok: false, error: detail }, 500);
+    }
+});
+// Open git diff for a file in the selected editor
+app.post('/api/open-diff', async (c) => {
+    try {
+        const body = await c.req.json();
+        const filePath = typeof body?.filePath === 'string' ? body.filePath.trim() : '';
+        const target = isOpenTarget(body?.target) ? body.target : 'vscode';
+        if (!filePath)
+            return c.json({ ok: false, error: 'filePath is required' }, 400);
+        const dir = path.dirname(filePath);
+        const relFile = path.basename(filePath);
+        // Write the original (HEAD) version to a temp file
+        const origResult = spawnSync('git', ['show', `HEAD:${path.relative(findGitRoot(dir), filePath)}`], {
+            cwd: dir,
+            timeout: 5_000,
+            encoding: 'buffer',
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+        });
+        if (origResult.status !== 0) {
+            // New file — no HEAD version, just open the file
+            openPathWithTarget(filePath, target, false);
+            return c.json({ ok: true });
+        }
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikiloop-diff-'));
+        const origPath = path.join(tmpDir, `${relFile}.orig`);
+        fs.writeFileSync(origPath, origResult.stdout);
+        // Use editor CLI diff command (fire-and-forget)
+        const cli = target === 'cursor' ? 'cursor' : target === 'windsurf' ? 'windsurf' : 'code';
+        const child = spawn(cli, ['--diff', origPath, filePath], {
+            cwd: dir,
+            stdio: 'ignore',
+            detached: true,
+        });
+        child.unref();
+        // Clean up temp after a delay
+        setTimeout(() => fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => { }), 30_000);
+        return c.json({ ok: true });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        runtime.log(`[open-diff] failed: ${detail}`);
+        return c.json({ ok: false, error: detail }, 500);
+    }
+});
+function findGitRoot(dir) {
+    let current = dir;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, '.git')))
+            return current;
+        current = path.dirname(current);
+    }
+    return dir;
+}
+export default app;