shennian 0.2.12 → 0.2.14

package/README.md

@@ -1,6 +1,6 @@
 # @shennian/cli
 
-> Shennian AI Agent 移动控制台的本机 daemon / CLI
+> Shennian AI Agent 移动控制台的本机后台服务 / CLI
 >
 > **架构设计** → [docs/architecture/cli/](../../docs/architecture/cli/)
 > - [Daemon 架构](../../docs/architecture/cli/daemon.md) — 模块拓扑、数据流、守护进程
@@ -13,10 +13,17 @@
 
 | 命令 | 说明 |
 |------|------|
-| `shennian` | 智能启动：必要时 pair 再启动 daemon |
+| `shennian` | 智能启动：必要时 pair 再启动后台服务 |
 | `shennian pair` | 重新与账号 / server 配对 |
-| `shennian daemon status` | 查看 daemon 运行状态 |
+| `shennian start` | 启动后台服务 |
+| `shennian stop` | 停止后台服务 |
+| `shennian status` | 查看后台服务状态 |
+| `shennian logs -n 100` | 查看最近日志 |
 | `shennian config` | 查看本地配置 |
+| `shennian agent add/list/remove` | 管理自定义 Agent |
+| `shennian upgrade` | 升级 CLI |
+
+`start`、`stop`、`status` 可选加 `--json`。`logs` 输出日志文本，不支持 `--json`。
 
 ## 开发
 

package/dist/src/commands/daemon.d.ts

@@ -1,5 +1,16 @@
 import type { Command } from 'commander';
+type Platform = 'darwin' | 'linux' | 'win32';
 type ServiceLaunchMode = 'direct' | 'global-shim' | 'npx';
+export type DaemonStatus = {
+    running: boolean;
+    pid: number | null;
+    stale: boolean;
+    remoteAccessDisabled: boolean;
+    platform: Platform;
+    shennianDir: string;
+    pidFile: string;
+    logFile: string;
+};
 export type ServiceLaunchSpec = {
     command: string;
     args: string[];
@@ -11,7 +22,12 @@ export declare function resolveServiceLaunchSpec(input: {
     scriptPath: string;
     shennianCommandPath?: string | null;
     npxPath?: string | null;
+    desktopBridgePath?: string | null;
 }): ServiceLaunchSpec;
+export declare function isRemoteAccessDisabled(): boolean;
+export declare function getDaemonStatus(opts?: {
+    cleanupStale?: boolean;
+}): DaemonStatus;
 export declare function buildWindowsLauncherCommand(spec: ServiceLaunchSpec, logFile: string): string;
 export declare function buildWindowsStartupVbs(cmdPath: string): string;
 export declare function buildWindowsScheduledTaskXml(input: {
@@ -25,7 +41,9 @@ export declare function captureEnvForService(): Record<string, string>;
  * This is critical for launchd/systemd which start with minimal env.
  */
 export declare function saveEnvSnapshot(): void;
-export declare function startDaemonProcess(): void;
+export declare function startDaemonProcess(opts?: {
+    quiet?: boolean;
+}): void;
 /**
  * Install the platform-native auto-start service.
  * Returns true if the service was immediately started (so caller can skip startDaemonProcess).

package/dist/src/commands/daemon.js

@@ -11,6 +11,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SHENNIAN_DIR = getShennianDir();
 const PID_FILE = resolveShennianPath('daemon.pid');
 const LOG_FILE = resolveShennianPath('daemon.log');
+const REMOTE_ACCESS_DISABLED_FILE = resolveShennianPath('remote-access.disabled');
 const SHENNIAN_SCRIPT = path.resolve(__dirname, '../../bin/shennian.js');
 const NODE_EXEC = process.execPath;
 function getPlatform() {
@@ -29,29 +30,38 @@ export function isEphemeralCliPath(candidate) {
 }
 export function resolveServiceLaunchSpec(input) {
     if (fs.existsSync(input.scriptPath) && !isEphemeralCliPath(input.scriptPath)) {
+        if (process.env.ELECTRON_RUN_AS_NODE === '1' &&
+            input.desktopBridgePath &&
+            fs.existsSync(input.desktopBridgePath)) {
+            return {
+                command: input.nodeExec,
+                args: [input.desktopBridgePath, input.scriptPath, 'run-service'],
+                mode: 'direct',
+            };
+        }
         return {
             command: input.nodeExec,
-            args: [input.scriptPath, 'start'],
+            args: [input.scriptPath, 'run-service'],
             mode: 'direct',
         };
     }
     if (input.shennianCommandPath && !isEphemeralCliPath(input.shennianCommandPath)) {
         return {
             command: input.shennianCommandPath,
-            args: ['start'],
+            args: ['run-service'],
             mode: 'global-shim',
         };
     }
     if (input.npxPath) {
         return {
             command: input.npxPath,
-            args: ['--yes', 'shennian', 'start'],
+            args: ['--yes', 'shennian', 'run-service'],
             mode: 'npx',
         };
     }
     return {
         command: input.nodeExec,
-        args: [input.scriptPath, 'start'],
+        args: [input.scriptPath, 'run-service'],
         mode: 'direct',
     };
 }
@@ -75,6 +85,35 @@ function isRunning(pid) {
         return false;
     }
 }
+export function isRemoteAccessDisabled() {
+    return fs.existsSync(REMOTE_ACCESS_DISABLED_FILE);
+}
+export function getDaemonStatus(opts = {}) {
+    const pid = readPid();
+    const running = pid !== null && isRunning(pid);
+    const stale = pid !== null && !running;
+    if (stale && opts.cleanupStale) {
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch {
+            // Another process may have cleaned up the stale pid file first.
+        }
+    }
+    return {
+        running,
+        pid,
+        stale,
+        remoteAccessDisabled: isRemoteAccessDisabled(),
+        platform: getPlatform(),
+        shennianDir: SHENNIAN_DIR,
+        pidFile: PID_FILE,
+        logFile: LOG_FILE,
+    };
+}
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
 // ─── Service definitions ─────────────────────────────────────────────────────
 const LAUNCHD_LABEL = 'com.shennian.agent';
 const LAUNCHD_PLIST = path.join(os.homedir(), 'Library/LaunchAgents', `${LAUNCHD_LABEL}.plist`);
@@ -113,6 +152,7 @@ function resolveCurrentServiceLaunchSpec() {
         scriptPath: SHENNIAN_SCRIPT,
         shennianCommandPath: findCommandPath('shennian'),
         npxPath: resolveNpxPath(),
+        desktopBridgePath: process.env.SHENNIAN_DESKTOP_CLI_BRIDGE,
     });
 }
 function escapeXml(text) {
@@ -142,12 +182,7 @@ function isWindowsCmdScript(filePath) {
 export function buildWindowsLauncherCommand(spec, logFile) {
     const commandLine = [spec.command, ...spec.args].map(quoteCmdArg).join(' ');
     const invocation = isWindowsCmdScript(spec.command) ? `call ${commandLine}` : commandLine;
-    return [
-        '@echo off',
-        'setlocal',
-        `${invocation} >> ${quoteCmdArg(logFile)} 2>&1`,
-        '',
-    ].join('\r\n');
+    return ['@echo off', 'setlocal', `${invocation} >> ${quoteCmdArg(logFile)} 2>&1`, ''].join('\r\n');
 }
 export function buildWindowsStartupVbs(cmdPath) {
     return [
@@ -269,7 +304,9 @@ function installWindowsScheduledTask() {
     });
     fs.writeFileSync(WINDOWS_TASK_XML, taskXml, 'utf8');
     try {
-        execSync(`schtasks /create /tn "${WINDOWS_TASK_NAME}" /xml "${WINDOWS_TASK_XML}" /f`, { stdio: 'pipe' });
+        execSync(`schtasks /create /tn "${WINDOWS_TASK_NAME}" /xml "${WINDOWS_TASK_XML}" /f`, {
+            stdio: 'pipe',
+        });
         execSync(`schtasks /run /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe' });
         return true;
     }
@@ -279,12 +316,31 @@ function installWindowsScheduledTask() {
 }
 export function captureEnvForService() {
     const keep = [
-        'PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'TMPDIR', 'LANG',
-        'LC_ALL', 'LC_CTYPE', 'SSH_AUTH_SOCK', 'XDG_CONFIG_HOME', 'XDG_DATA_HOME',
-        'TEMP', 'TMP',
-        'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL',
-        'OPENAI_API_KEY', 'OPENAI_BASE_URL',
-        'GEMINI_API_KEY', 'GOOGLE_API_KEY',
+        'PATH',
+        'HOME',
+        'USER',
+        'LOGNAME',
+        'SHELL',
+        'TMPDIR',
+        'LANG',
+        'LC_ALL',
+        'LC_CTYPE',
+        'SSH_AUTH_SOCK',
+        'XDG_CONFIG_HOME',
+        'XDG_DATA_HOME',
+        'TEMP',
+        'TMP',
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_BASE_URL',
+        'OPENAI_API_KEY',
+        'OPENAI_BASE_URL',
+        'GEMINI_API_KEY',
+        'GOOGLE_API_KEY',
+        'ELECTRON_RUN_AS_NODE',
+        'SHENNIAN_DESKTOP_CLI_SCRIPT',
+        'SHENNIAN_DESKTOP_CLI_BRIDGE',
+        'SHENNIAN_HOME',
     ];
     const env = {};
     for (const k of keep) {
@@ -379,11 +435,13 @@ export function saveEnvSnapshot() {
     fs.writeFileSync(resolveShennianPath('env.json'), JSON.stringify(snapshot, null, 2));
 }
 // ─── Exported helpers (used by pair.ts) ─────────────────────────────────────
-export function startDaemonProcess() {
+export function startDaemonProcess(opts = {}) {
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
     const pid = readPid();
     if (pid !== null && isRunning(pid)) {
-        console.log(chalk.green(`✓ Background service already running (PID ${pid})`));
+        if (!opts.quiet) {
+            console.log(chalk.green(`✓ Background service already running (PID ${pid})`));
+        }
         return;
     }
     const logFd = fs.openSync(LOG_FILE, 'a');
@@ -397,8 +455,10 @@ export function startDaemonProcess() {
     child.unref();
     fs.closeSync(logFd);
     fs.writeFileSync(PID_FILE, String(child.pid));
-    console.log(chalk.green(`✓ Background service started (PID ${child.pid})`));
-    console.log(chalk.gray(`  Logs: ${LOG_FILE}`));
+    if (!opts.quiet) {
+        console.log(chalk.green(`✓ Background service started (PID ${child.pid})`));
+        console.log(chalk.gray(`  Logs: ${LOG_FILE}`));
+    }
 }
 /**
  * Install the platform-native auto-start service.
@@ -409,8 +469,8 @@ export function installService() {
     const platform = getPlatform();
     const spec = resolveCurrentServiceLaunchSpec();
     if (spec.mode === 'direct' && isEphemeralCliPath(SHENNIAN_SCRIPT)) {
-        console.warn(chalk.yellow('⚠ Warning: Current CLI path is temporary (npx). Auto-start may not work after reboot.\n'
-            + '  Run `npm install -g shennian` for reliable auto-start.'));
+        console.warn(chalk.yellow('⚠ Warning: Current CLI path is temporary (npx). Auto-start may not work after reboot.\n' +
+            '  Run `npm install -g shennian` for reliable auto-start.'));
     }
     switch (platform) {
         case 'darwin': {
@@ -438,7 +498,9 @@ export function installService() {
             fs.mkdirSync(dir, { recursive: true });
             fs.writeFileSync(SYSTEMD_UNIT, buildSystemdUnit());
             try {
-                execSync('systemctl --user daemon-reload && systemctl --user enable shennian', { stdio: 'pipe' });
+                execSync('systemctl --user daemon-reload && systemctl --user enable shennian', {
+                    stdio: 'pipe',
+                });
             }
             catch {
                 // Some Linux environments lack systemd user services; keep best-effort behavior.
@@ -459,11 +521,10 @@ export function installService() {
     }
 }
 // ─── Subcommand implementations ──────────────────────────────────────────────
-function daemonStop() {
+function stopDaemonProcess() {
     const pid = readPid();
     if (pid === null) {
-        console.log(chalk.yellow('⚠ No running background service found'));
-        return;
+        return {};
     }
     if (!isRunning(pid)) {
         try {
@@ -472,42 +533,193 @@ function daemonStop() {
         catch {
             // Stale pid file is already gone.
         }
-        console.log(chalk.yellow('⚠ Service process no longer exists, cleaned up'));
-        return;
+        return { stalePid: pid };
     }
     try {
         process.kill(pid, 'SIGTERM');
+        return { stoppedPid: pid };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function stopDaemonProcessAndWait(timeoutMs = 5000) {
+    const result = stopDaemonProcess();
+    if (!result.stoppedPid)
+        return result;
+    const stopped = await waitForPidExit(result.stoppedPid, timeoutMs);
+    if (!stopped) {
         try {
-            fs.unlinkSync(PID_FILE);
+            process.kill(result.stoppedPid, 'SIGKILL');
+            await waitForPidExit(result.stoppedPid, 2000);
         }
-        catch {
-            // Best-effort cleanup after SIGTERM.
+        catch (err) {
+            return { ...result, error: err instanceof Error ? err.message : String(err) };
         }
-        console.log(chalk.green(`✓ Background service stopped (PID ${pid})`));
     }
-    catch (err) {
-        console.error(chalk.red(`✗ Failed to stop: ${err instanceof Error ? err.message : String(err)}`));
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch {
+        // Best-effort cleanup after the process exits.
     }
+    return result;
 }
-function daemonStatus() {
-    const pid = readPid();
-    if (pid === null) {
-        console.log(chalk.gray('● Background service not running'));
+function enableRemoteAccess(opts = {}) {
+    try {
+        fs.unlinkSync(REMOTE_ACCESS_DISABLED_FILE);
+    }
+    catch {
+        // Remote access may already be enabled.
+    }
+    const startedByService = installService();
+    if (!startedByService) {
+        startDaemonProcess({ quiet: opts.json });
+    }
+    if (opts.json) {
+        printJson(getDaemonStatus());
+    }
+    else {
+        console.log(chalk.green('✓ Background service started'));
+    }
+}
+async function disableRemoteAccess(opts = {}) {
+    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.writeFileSync(REMOTE_ACCESS_DISABLED_FILE, new Date().toISOString());
+    const platform = getPlatform();
+    switch (platform) {
+        case 'darwin': {
+            if (fs.existsSync(LAUNCHD_PLIST)) {
+                try {
+                    execSync(`launchctl unload -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe' });
+                }
+                catch {
+                    // The job may already be unloaded; keep the plist for future re-enable.
+                }
+            }
+            break;
+        }
+        case 'linux': {
+            try {
+                execSync('systemctl --user disable --now shennian', { stdio: 'pipe' });
+            }
+            catch {
+                // systemd user services may be unavailable; still stop the manual daemon.
+            }
+            break;
+        }
+        case 'win32': {
+            try {
+                execSync(`schtasks /change /tn "${WINDOWS_TASK_NAME}" /disable`, { stdio: 'pipe' });
+            }
+            catch {
+                // Task may not exist yet; still stop the manual daemon.
+            }
+            try {
+                execSync(`schtasks /end /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe' });
+            }
+            catch {
+                // Task may not be running.
+            }
+            break;
+        }
+    }
+    const result = await stopDaemonProcessAndWait();
+    const status = getDaemonStatus({ cleanupStale: true });
+    if (opts.json) {
+        printJson(result.error ? { ...status, error: result.error } : status);
         return;
     }
-    if (isRunning(pid)) {
-        console.log(chalk.green(`● Background service running (PID ${pid})`));
-        console.log(chalk.gray(`  Logs: ${LOG_FILE}`));
+    if (result.error) {
+        console.error(chalk.red(`✗ Failed to stop: ${result.error}`));
     }
     else {
-        console.log(chalk.yellow(`● Background service stopped (PID ${pid} is stale)`));
+        console.log(chalk.green('✓ Background service stopped'));
+    }
+}
+function daemonStart(opts) {
+    enableRemoteAccess(opts);
+}
+async function daemonStop(opts = {}) {
+    await disableRemoteAccess(opts);
+}
+async function waitForPidExit(pid, timeoutMs = 5000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (!isRunning(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return !isRunning(pid);
+}
+async function daemonRestart(opts = {}) {
+    const pid = readPid();
+    if (pid !== null && isRunning(pid)) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            const stopped = await waitForPidExit(pid);
+            if (!stopped) {
+                process.kill(pid, 'SIGKILL');
+                await waitForPidExit(pid, 2000);
+            }
+            try {
+                fs.unlinkSync(PID_FILE);
+            }
+            catch {
+                // Best-effort cleanup after restart stop.
+            }
+            if (!opts.json) {
+                console.log(chalk.green(`✓ Background service stopped (PID ${pid})`));
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (opts.json) {
+                printJson({ ...getDaemonStatus(), error: message });
+            }
+            else {
+                console.error(chalk.red(`✗ Failed to stop: ${message}`));
+            }
+            return;
+        }
+    }
+    else if (pid !== null) {
         try {
             fs.unlinkSync(PID_FILE);
         }
         catch {
-            // Another process may have cleaned up the stale pid file first.
+            // Stale pid file is already gone.
+        }
+        if (!opts.json) {
+            console.log(chalk.yellow(`⚠ Service process no longer exists, cleaned up stale PID ${pid}`));
+        }
+    }
+    else {
+        if (!opts.json) {
+            console.log(chalk.gray('● Background service not running, starting it now'));
         }
     }
+    startDaemonProcess({ quiet: opts.json });
+    if (opts.json)
+        printJson(getDaemonStatus());
+}
+function daemonStatus(opts = {}) {
+    const status = getDaemonStatus({ cleanupStale: true });
+    if (opts.json) {
+        printJson(status);
+        return;
+    }
+    if (status.pid === null) {
+        console.log(chalk.gray('● Background service not running'));
+        return;
+    }
+    if (status.running) {
+        console.log(chalk.green(`● Background service running (PID ${status.pid})`));
+        console.log(chalk.gray(`  Logs: ${LOG_FILE}`));
+    }
+    else {
+        console.log(chalk.yellow(`● Background service stopped (PID ${status.pid} is stale)`));
+    }
 }
 function daemonLogs(opts) {
     if (!fs.existsSync(LOG_FILE)) {
@@ -525,8 +737,8 @@ function daemonLogs(opts) {
         console.log(lines.join('\n'));
     }
 }
-function daemonUninstall() {
-    daemonStop();
+async function daemonUninstall() {
+    await daemonStop();
     const platform = getPlatform();
     switch (platform) {
         case 'darwin': {
@@ -589,24 +801,70 @@ function daemonUninstall() {
 }
 // ─── Register command ─────────────────────────────────────────────────────────
 export function registerDaemonCommand(program) {
-    const daemon = program
-        .command('daemon')
-        .description('Manage the background service');
+    program
+        .command('start')
+        .description('Start the background service')
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => daemonStart(opts));
+    program
+        .command('stop')
+        .description('Stop the background service')
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => daemonStop(opts));
+    program
+        .command('status')
+        .description('Show background service status')
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => daemonStatus(opts));
+    program
+        .command('logs')
+        .description('Show recent logs')
+        .option('-n, --lines <n>', 'Number of lines', '50')
+        .action((opts) => daemonLogs({ lines: parseInt(opts.lines, 10) }));
+    const daemon = program.command('daemon', { hidden: true }).description('Deprecated: use top-level start/stop/status/logs');
+    const warnDeprecated = (replacement, json) => {
+        if (!json)
+            console.error(chalk.yellow(`⚠ Deprecated command. Use \`shennian ${replacement}\` instead.`));
+    };
+    daemon
+        .command('start')
+        .description('Start the background service')
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => {
+        warnDeprecated('start', opts.json);
+        daemonStart(opts);
+    });
     daemon
         .command('stop')
         .description('Stop the background service')
-        .action(daemonStop);
+        .option('--json', 'Print machine-readable status JSON')
+        .action(async (opts) => {
+        warnDeprecated('stop', opts.json);
+        await daemonStop(opts);
+    });
+    daemon
+        .command('restart')
+        .description('Restart the background service')
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => {
+        warnDeprecated('stop && shennian start', opts.json);
+        daemonRestart(opts);
+    });
     daemon
         .command('status')
         .description('Show background service status')
-        .action(daemonStatus);
+        .option('--json', 'Print machine-readable status JSON')
+        .action((opts) => {
+        warnDeprecated('status', opts.json);
+        daemonStatus(opts);
+    });
     daemon
         .command('logs')
         .description('Show recent logs')
         .option('-n, --lines <n>', 'Number of lines', '50')
-        .action((opts) => daemonLogs({ lines: parseInt(opts.lines, 10) }));
-    daemon
-        .command('uninstall')
-        .description('Uninstall auto-start service')
-        .action(daemonUninstall);
+        .action((opts) => {
+        warnDeprecated('logs');
+        daemonLogs({ lines: parseInt(opts.lines, 10) });
+    });
+    daemon.command('uninstall').description('Uninstall auto-start service').action(daemonUninstall);
 }

package/dist/src/index.js

@@ -1,13 +1,14 @@
 // @arch docs/architecture/cli/daemon.md
 // @test src/__tests__/agents-e2e.ts
+// @test src/__tests__/daemon-autostart.test.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 { 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 { isRemoteAccessDisabled, registerDaemonCommand } from './commands/daemon.js';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerUpgradeCommand } from './commands/upgrade.js';
 import { SessionManager } from './session/manager.js';
@@ -37,10 +38,7 @@ function formatDisconnectInfo(info) {
     return parts.join(' ');
 }
 const program = new Command();
-program
-    .name('shennian')
-    .description('Shennian — AI Agent Mobile Console')
-    .version(cliVersion);
+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())
@@ -49,12 +47,16 @@ program
     const serverUrl = opts.api ?? config.serverUrl ?? undefined;
     await runSmartStart(serverUrl, opts.name);
 });
-// start: internal command used by the daemon process
+// run-service: internal command used by the background service process
 program
-    .command('start', { hidden: true })
-    .description('(internal) Connect to relay server, called by daemon')
+    .command('run-service', { hidden: true })
+    .description('(internal) Connect to relay server, called by the background service')
     .option('--api <url>', 'Server URL override')
     .action(async (opts) => {
+    if (isRemoteAccessDisabled()) {
+        console.log(`[${new Date().toISOString()}] remote access disabled, service start skipped`);
+        process.exit(0);
+    }
     const envFile = resolveShennianPath('env.json');
     try {
         const saved = JSON.parse(fs.readFileSync(envFile, 'utf-8'));
@@ -81,12 +83,18 @@ program
             }
         }
     }
-    catch { /* noop */ }
-    fs.writeFileSync(pidFile, String(process.pid));
-    process.on('exit', () => { try {
-        fs.unlinkSync(pidFile);
+    catch {
+        /* noop */
     }
-    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) {
@@ -109,7 +117,11 @@ program
         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 } });
+    reportLog({
+        level: 'info',
+        wsEvent: 'daemon.start',
+        metadata: { version: cliVersion, agents: agentList },
+    });
     let nativeFusion = null;
     const client = new CliRelayClient({
         serverUrl: wsUrl,
@@ -132,7 +144,8 @@ program
             void resolveAgentInfos(detectedAgents, {
                 serverUrl: config.serverUrl ?? serverUrl,
                 authToken: config.machineToken ?? config.accessToken,
-            }).then((agents) => {
+            })
+                .then((agents) => {
                 if (JSON.stringify(agents) === JSON.stringify(cachedAgentInfos))
                     return;
                 client.sendEvent({
@@ -143,8 +156,10 @@ program
                         agents,
                     },
                 });
-            }).catch(() => { });
-            import('./upgrade/engine.js').then(({ readUpgradeAttempt, clearUpgradeAttempt }) => {
+            })
+                .catch(() => { });
+            import('./upgrade/engine.js')
+                .then(({ readUpgradeAttempt, clearUpgradeAttempt }) => {
                 const attempt = readUpgradeAttempt();
                 clearUpgradeAttempt();
                 if (attempt) {
@@ -152,10 +167,16 @@ program
                     client.sendEvent({
                         type: 'event',
                         event: 'upgrade',
-                        payload: { state: 'success', machineId: 'self', from: attempt.from, to: attempt.to },
+                        payload: {
+                            state: 'success',
+                            machineId: 'self',
+                            from: attempt.from,
+                            to: attempt.to,
+                        },
                     });
                 }
-            }).catch(() => { });
+            })
+                .catch(() => { });
             void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch');
             nativeFusion?.handleConnected();
         },
@@ -176,13 +197,20 @@ program
         },
         onReq: (req) => {
             console.log(`[${new Date().toISOString()}] [req] ${req.method}`);
-            reportLog({ level: 'info', type: 'ws', wsEvent: req.method, wsDirection: 'in', traceId: req.traceId });
+            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);
+    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));
@@ -197,16 +225,16 @@ program
         try {
             fs.unlinkSync(PID_FILE);
         }
-        catch { /* noop */ }
+        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');
+const configCmd = program.command('config').description('View or modify configuration');
 configCmd
     .command('show', { isDefault: true })
     .description('Show current configuration')
@@ -238,7 +266,7 @@ configCmd
         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'));
+        console.log(chalk.yellow('  Restart the background service for this to take effect: shennian stop && shennian start'));
         return;
     }
     console.error(chalk.red(`✗ Unknown config key: ${key}. Supported: server`));

package/dist/src/native-fusion/parsers.js

@@ -4,7 +4,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { buildUserMessagePayload } from '@shennian/wire';
+import { buildUserMessagePayload, isToolPayload } from '@shennian/wire';
 function normalizeText(text) {
     return stripGitDirectiveArtifacts(text.replace(/\r\n/g, '\n').trim());
 }
@@ -256,7 +256,7 @@ function parseCodexUserMessage(payload) {
     }
     return { payload: text, titleText: text };
 }
-function pushCodexEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts, payload, title, modelId, workDir, role = 'agent') {
+function pushCodexEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts, payload, title, modelId, workDir, role = 'agent', terminal = false) {
     if (!payload)
         return;
     events.push({
@@ -271,6 +271,7 @@ function pushCodexEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts
         title,
         modelId,
         workDir,
+        terminal,
     });
 }
 function pushCodexToolEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts, toolName, title, modelId, workDir, args, result) {
@@ -327,6 +328,17 @@ function parseCodexEventMessage(events, filePath, lineOffset, payload, sourceSes
         pushCodexEvent(events, filePath, lineOffset, eventType, sourceSessionKey, ts, text, title, modelId, workDir);
         return;
     }
+    if (eventType === 'turn_aborted' || eventType === 'error') {
+        const text = typeof payload.message === 'string'
+            ? normalizeText(payload.message)
+            : typeof payload.error === 'string'
+                ? normalizeText(payload.error)
+                : '';
+        if (!text)
+            return;
+        pushCodexEvent(events, filePath, lineOffset, eventType, sourceSessionKey, ts, text, title, modelId, workDir, 'agent', true);
+        return;
+    }
     if (eventType === 'exec_command_end') {
         const command = Array.isArray(payload.command) ? payload.command : payload.parsed_cmd ?? payload.command;
         const exitCode = payload.exit_code ?? payload.exitCode;
@@ -565,6 +577,7 @@ export function parseCodexRolloutChunk(filePath, startOffset) {
     const lines = chunk.split('\n').filter(Boolean);
     const events = [];
     let { sourceSessionKey, workDir, modelId, title } = readCodexSessionMeta(filePath);
+    let pendingTerminal = false;
     for (let index = 0, offset = startOffset; index < lines.length; index++) {
         const line = lines[index];
         const parsed = safeParse(line);
@@ -595,12 +608,32 @@ export function parseCodexRolloutChunk(filePath, startOffset) {
         }
         if (type === 'event_msg') {
             const eventType = typeof payload.type === 'string' ? payload.type : '';
+            if (eventType === 'turn_completed') {
+                for (let i = events.length - 1; i >= 0; i -= 1) {
+                    const event = events[i];
+                    if (event?.agentType !== 'codex')
+                        continue;
+                    if (event.role !== 'agent')
+                        continue;
+                    if (isToolPayload(event.payload))
+                        continue;
+                    event.terminal = true;
+                    pendingTerminal = false;
+                    break;
+                }
+                continue;
+            }
             if (eventType === 'user_message') {
                 const parsedUser = parseCodexUserMessage(payload);
                 if (parsedUser?.titleText && !title)
                     title = parsedUser.titleText.slice(0, 80);
             }
+            const beforeCount = events.length;
             parseCodexEventMessage(events, filePath, lineOffset, payload, sourceSessionKey, ts, title, modelId, workDir);
+            if (pendingTerminal && events.length > beforeCount) {
+                events[events.length - 1].terminal = true;
+                pendingTerminal = false;
+            }
         }
     }
     return { nextOffset, events };

package/dist/src/native-fusion/service.js

@@ -11,6 +11,12 @@ const MAX_BATCH_SIZE = 20;
 function normalizeText(text) {
     return text.replace(/\r\n/g, '\n').trim();
 }
+function isCodexRolloutPath(filePath) {
+    return filePath.split(/[\\/]+/).includes('.codex');
+}
+function shouldBackfillWindowsCodex(state) {
+    return process.platform === 'win32' && state.codexWindowsPathParserFixed !== true;
+}
 export class NativeSessionFusionService {
     client;
     timer = null;
@@ -85,13 +91,15 @@ export class NativeSessionFusionService {
         this.pruneState();
         const state = loadNativeScannerState();
         const nextFilesState = { ...state.files };
+        const backfillWindowsCodex = shouldBackfillWindowsCodex(state);
         const batches = [];
         const files = [...listCodexRolloutFiles(), ...listClaudeTranscriptFiles()];
         for (const filePath of files) {
             const stat = fs.statSync(filePath);
             const current = state.files[filePath];
-            const startOffset = current?.offset ?? 0;
-            const parsed = filePath.includes('/.codex/sessions/')
+            const isCodex = isCodexRolloutPath(filePath);
+            const startOffset = backfillWindowsCodex && isCodex ? 0 : current?.offset ?? 0;
+            const parsed = isCodex
                 ? parseCodexRolloutChunk(filePath, startOffset)
                 : parseClaudeTranscriptChunk(filePath, startOffset);
             nextFilesState[filePath] = {
@@ -121,6 +129,9 @@ export class NativeSessionFusionService {
             }, 60_000);
         }
         state.files = nextFilesState;
+        if (backfillWindowsCodex) {
+            state.codexWindowsPathParserFixed = true;
+        }
         saveNativeScannerState(state);
     }
     tryClaimManagedEcho(event) {

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

@@ -4,6 +4,7 @@ export type NativeScannerState = {
         offset: number;
         mtimeMs: number;
     }>;
+    codexWindowsPathParserFixed?: boolean;
 };
 export type ParsedNativeEvent = NativeSessionEventPayload;
 export type PendingManagedClaim = {

package/dist/src/session/manager.js

@@ -22,24 +22,28 @@ const MAX_SESSIONS = 50;
 function isWindowsAbsolutePath(input) {
     return /^[A-Za-z]:([\\/]|$)/.test(input) || /^\\\\[^\\]+\\[^\\]+/.test(input);
 }
+function normalizeWindowsAbsolutePath(input) {
+    return input.replace(/^[/\\]([A-Za-z]:[\\/].*)$/, '$1');
+}
 export function resolveSessionWorkDir(input) {
     if (!input)
         return os.homedir();
+    const normalizedInput = normalizeWindowsAbsolutePath(input);
     const joinPath = process.platform === 'win32' ? path.win32.join : path.join;
-    if (input.startsWith('~')) {
-        return joinPath(os.homedir(), input.slice(1).replace(/^[/\\]+/, ''));
+    if (normalizedInput.startsWith('~')) {
+        return joinPath(os.homedir(), normalizedInput.slice(1).replace(/^[/\\]+/, ''));
     }
     if (process.platform === 'win32') {
-        const normalized = input.replace(/\\/g, '/');
+        const normalized = normalizedInput.replace(/\\/g, '/');
         if (normalized === '/tmp' || normalized.startsWith('/tmp/')) {
             const suffix = normalized.slice('/tmp'.length).replace(/^\/+/, '');
             return suffix ? path.win32.join(os.tmpdir(), ...suffix.split('/')) : os.tmpdir();
         }
     }
-    if (isWindowsAbsolutePath(input)) {
-        return path.win32.resolve(input);
+    if (isWindowsAbsolutePath(normalizedInput)) {
+        return path.win32.resolve(normalizedInput);
     }
-    return path.resolve(input);
+    return path.resolve(normalizedInput);
 }
 export class SessionManager {
     client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.12",
+  "version": "0.2.14",
   "description": "Shennian — AI Agent Mobile Console CLI",
   "type": "module",
   "bin": {