shennian 0.2.6 → 0.2.8

package/dist/src/index.js

@@ -0,0 +1,277 @@
+// @arch docs/architecture/cli/daemon.md
+// @test src/__tests__/agents-e2e.ts
+import { Command } from 'commander';
+import chalk from 'chalk';
+import os from 'node:os';
+import fs from 'node:fs';
+import { loadConfig, saveConfig, configPath, getShennianDir, resolveShennianPath } from './config/index.js';
+import { CliRelayClient } from './relay/client.js';
+import { registerPairCommand, runSmartStart } from './commands/pair.js';
+import { registerDaemonCommand } from './commands/daemon.js';
+import { registerAgentCommand } from './commands/agent.js';
+import { registerUpgradeCommand } from './commands/upgrade.js';
+import { SessionManager } from './session/manager.js';
+import { SERVERS, regionToUrl, urlToRegion } from './region.js';
+import { getCurrentVersion, handleStartupCrashCheck, checkForUpdate } from './upgrade/engine.js';
+import { detectAgents } from './agents/detect.js';
+const cliVersion = getCurrentVersion();
+import { getCachedAgentInfos, resolveAgentInfos } from './agents/model-registry.js';
+import { initCliLogReporter, reportLog } from './log-reporter.js';
+import { NativeSessionFusionService } from './native-fusion/service.js';
+const SHENNIAN_DIR = getShennianDir();
+const PID_FILE = resolveShennianPath('daemon.pid');
+function httpToWs(url) {
+    return url.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
+}
+function formatDisconnectInfo(info) {
+    const parts = [
+        `trigger=${info.trigger ?? 'unknown'}`,
+        `phase=${info.phase}`,
+        `code=${info.code ?? 'unknown'}`,
+        `attempt=${info.reconnectAttempt}`,
+    ];
+    if (info.reason)
+        parts.push(`reason=${info.reason}`);
+    if (info.error)
+        parts.push(`error=${info.error}`);
+    return parts.join(' ');
+}
+const program = new Command();
+program
+    .name('shennian')
+    .description('Shennian — AI Agent Mobile Console')
+    .version(cliVersion);
+program
+    .option('--api <url>', 'Server URL override')
+    .option('--name <name>', 'Machine name', os.hostname())
+    .action(async (opts) => {
+    const config = loadConfig();
+    const serverUrl = opts.api ?? config.serverUrl ?? undefined;
+    await runSmartStart(serverUrl, opts.name);
+});
+// start: internal command used by the daemon process
+program
+    .command('start', { hidden: true })
+    .description('(internal) Connect to relay server, called by daemon')
+    .option('--api <url>', 'Server URL override')
+    .action(async (opts) => {
+    const envFile = resolveShennianPath('env.json');
+    try {
+        const saved = JSON.parse(fs.readFileSync(envFile, 'utf-8'));
+        for (const [k, v] of Object.entries(saved)) {
+            if (!process.env[k])
+                process.env[k] = v;
+        }
+    }
+    catch {
+        // env.json may not exist yet
+    }
+    // Single-instance guard: kill any existing daemon before starting
+    const pidFile = resolveShennianPath('daemon.pid');
+    try {
+        const oldPid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        if (oldPid && oldPid !== process.pid) {
+            try {
+                process.kill(oldPid, 0);
+                console.log(`[${new Date().toISOString()}] daemon already running (PID ${oldPid}), skipping duplicate start`);
+                process.exit(0);
+            }
+            catch {
+                // Stale pid; continue booting and overwrite it below.
+            }
+        }
+    }
+    catch { /* noop */ }
+    fs.writeFileSync(pidFile, String(process.pid));
+    process.on('exit', () => { try {
+        fs.unlinkSync(pidFile);
+    }
+    catch { /* noop */ } });
+    // Crash detection: if we're recovering from a failed upgrade, rollback and exit
+    const didRollback = await handleStartupCrashCheck();
+    if (didRollback) {
+        console.log(`[${new Date().toISOString()}] Rolled back to previous version, restarting...`);
+        process.exit(0);
+    }
+    const config = loadConfig();
+    if (!config.machineToken) {
+        console.error(chalk.red('✗ Not paired yet. Run: shennian'));
+        process.exit(1);
+    }
+    const serverUrl = opts.api ?? config.serverUrl ?? SERVERS.global.url;
+    const wsBase = httpToWs(serverUrl);
+    const wsUrl = `${wsBase}/relay/machine`;
+    const cliVersion = getCurrentVersion();
+    const detectedAgents = detectAgents();
+    const agentList = detectedAgents.map((a) => a.type);
+    const cachedAgentInfos = getCachedAgentInfos(detectedAgents);
+    if (config.machineId) {
+        initCliLogReporter(serverUrl, config.machineId);
+    }
+    console.log(`[${new Date().toISOString()}] Connecting to ${wsUrl}... (v${cliVersion}) agents: ${agentList.join(',')}`);
+    reportLog({ level: 'info', wsEvent: 'daemon.start', metadata: { version: cliVersion, agents: agentList } });
+    let nativeFusion = null;
+    const client = new CliRelayClient({
+        serverUrl: wsUrl,
+        machineToken: config.machineToken,
+        cliVersion,
+        agentList,
+        onConnected: () => {
+            console.log(`[${new Date().toISOString()}] ✓ Connected`);
+            reportLog({ level: 'info', wsEvent: 'daemon.connected' });
+            if (cachedAgentInfos.some((agent) => agent.models.length > 0)) {
+                client.sendEvent({
+                    type: 'event',
+                    event: 'machine.agents',
+                    payload: {
+                        agentList,
+                        agents: cachedAgentInfos,
+                    },
+                });
+            }
+            void resolveAgentInfos(detectedAgents, {
+                serverUrl: config.serverUrl ?? serverUrl,
+                authToken: config.machineToken ?? config.accessToken,
+            }).then((agents) => {
+                if (JSON.stringify(agents) === JSON.stringify(cachedAgentInfos))
+                    return;
+                client.sendEvent({
+                    type: 'event',
+                    event: 'machine.agents',
+                    payload: {
+                        agentList,
+                        agents,
+                    },
+                });
+            }).catch(() => { });
+            import('./upgrade/engine.js').then(({ readUpgradeAttempt, clearUpgradeAttempt }) => {
+                const attempt = readUpgradeAttempt();
+                clearUpgradeAttempt();
+                if (attempt) {
+                    console.log(`[${new Date().toISOString()}] [upgrade] Reporting success: ${attempt.from} → ${attempt.to}`);
+                    client.sendEvent({
+                        type: 'event',
+                        event: 'upgrade',
+                        payload: { state: 'success', machineId: 'self', from: attempt.from, to: attempt.to },
+                    });
+                }
+            }).catch(() => { });
+            void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch');
+            nativeFusion?.handleConnected();
+        },
+        onDisconnected: (info) => {
+            console.log(`[${new Date().toISOString()}] ⚠ Disconnected, reconnecting... ${formatDisconnectInfo(info)}`);
+            reportLog({
+                level: 'warn',
+                wsEvent: 'daemon.disconnected',
+                metadata: {
+                    code: info.code,
+                    reason: info.reason,
+                    error: info.error,
+                    phase: info.phase,
+                    trigger: info.trigger,
+                    reconnectAttempt: info.reconnectAttempt,
+                },
+            });
+        },
+        onReq: (req) => {
+            console.log(`[${new Date().toISOString()}] [req] ${req.method}`);
+            reportLog({ level: 'info', type: 'ws', wsEvent: req.method, wsDirection: 'in', traceId: req.traceId });
+            void sessionManager.handleReq(req);
+        },
+    });
+    nativeFusion = process.env.SHENNIAN_NATIVE_FUSION_DISABLED === '1'
+        ? null
+        : new NativeSessionFusionService(client);
+    const sessionManager = new SessionManager(client, nativeFusion);
+    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.writeFileSync(PID_FILE, String(process.pid));
+    client.connect();
+    process.stdin.resume();
+    const shutdown = () => {
+        console.log(chalk.gray('\nDisconnecting...'));
+        reportLog({ level: 'info', wsEvent: 'daemon.stop' });
+        sessionManager.cleanup();
+        nativeFusion?.stop();
+        client.disconnect();
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { /* noop */ }
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+});
+// config: view and modify settings
+const configCmd = program
+    .command('config')
+    .description('View or modify configuration');
+configCmd
+    .command('show', { isDefault: true })
+    .description('Show current configuration')
+    .action(() => {
+    console.log(`Config file: ${configPath}`);
+    const config = loadConfig();
+    const display = { ...config };
+    if (display.machineToken)
+        display.machineToken = display.machineToken.slice(0, 12) + '...';
+    if (display.serverUrl) {
+        const region = urlToRegion(display.serverUrl);
+        console.log(`Region: ${region} (${SERVERS[region].label})`);
+    }
+    console.log(JSON.stringify(display, null, 2));
+});
+configCmd
+    .command('set')
+    .description('Update a config value')
+    .argument('<key>', 'Config key (e.g. "server")')
+    .argument('<value>', 'Config value (e.g. "cn" or "global")')
+    .action((key, value) => {
+    const config = loadConfig();
+    if (key === 'server') {
+        if (value !== 'cn' && value !== 'global') {
+            console.error(chalk.red('✗ Value must be "cn" or "global"'));
+            process.exit(1);
+        }
+        const region = value;
+        config.serverUrl = regionToUrl(region);
+        saveConfig(config);
+        console.log(chalk.green(`✓ Server set to ${SERVERS[region].label}`));
+        console.log(chalk.yellow('  Restart the daemon for this to take effect: shennian daemon stop && shennian'));
+        return;
+    }
+    console.error(chalk.red(`✗ Unknown config key: ${key}. Supported: server`));
+    process.exit(1);
+});
+registerPairCommand(program);
+registerDaemonCommand(program);
+registerAgentCommand(program);
+registerUpgradeCommand(program);
+program.parse();
+// ─── Auto-upgrade helper ──────────────────────────────────────────────────────
+async function scheduleAutoUpgrade(client, policy) {
+    if (policy === 'none')
+        return;
+    // Delay slightly so we don't hit npm on every cold start during development
+    await new Promise((r) => setTimeout(r, 30_000));
+    let result;
+    try {
+        result = await checkForUpdate();
+    }
+    catch {
+        return; // silently skip on network error
+    }
+    if (!result.hasUpdate)
+        return;
+    const { changeType, current, latest } = result;
+    // Respect the policy
+    if (policy === 'patch' && changeType !== 'patch')
+        return;
+    if (policy === 'minor' && changeType === 'major')
+        return;
+    console.log(`[${new Date().toISOString()}] [upgrade] ${current} → ${latest} (${changeType}), auto-upgrading...`);
+    const { handleUpgradeStart } = await import('./commands/upgrade.js');
+    // Use a dummy reqId since this is self-triggered
+    await handleUpgradeStart(client, 'auto-upgrade', latest);
+}

package/dist/src/log-reporter.d.ts

@@ -0,0 +1,18 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+type LogType = 'http' | 'ws' | 'internal';
+type LogEntry = {
+    traceId?: string;
+    sessionId?: string;
+    type?: LogType;
+    level: LogLevel;
+    wsEvent?: string;
+    wsDirection?: 'in' | 'out';
+    errorMessage?: string;
+    errorStack?: string;
+    durationMs?: number;
+    metadata?: unknown;
+};
+export declare function initCliLogReporter(serverUrl: string, machineId: string): void;
+export declare function generateTraceId(): string;
+export declare function reportLog(entry: LogEntry): void;
+export {};

package/dist/src/log-reporter.js

@@ -0,0 +1,16 @@
+import crypto from 'node:crypto';
+let _serverUrl;
+let _machineId;
+export function initCliLogReporter(serverUrl, machineId) {
+    _serverUrl = serverUrl.replace(/\/$/, '');
+    _machineId = machineId;
+}
+export function generateTraceId() {
+    return crypto.randomBytes(8).toString('hex');
+}
+export function reportLog(entry) {
+    if (!_serverUrl || !_machineId)
+        return;
+    // Remote DB log reporting is intentionally disabled; keep the API for callers.
+    void entry;
+}

package/dist/src/native-fusion/parsers.d.ts

@@ -0,0 +1,12 @@
+import type { ParsedNativeEvent } from './types.js';
+export declare function listCodexRolloutFiles(): string[];
+export declare function listClaudeTranscriptFiles(): string[];
+export declare function lookupClaudeTranscriptCwd(sourceSessionKey: string): string | null;
+export declare function parseCodexRolloutChunk(filePath: string, startOffset: number): {
+    nextOffset: number;
+    events: ParsedNativeEvent[];
+};
+export declare function parseClaudeTranscriptChunk(filePath: string, startOffset: number): {
+    nextOffset: number;
+    events: ParsedNativeEvent[];
+};