shennian 0.2.26 → 0.2.28

package/README.md

@@ -1,6 +1,6 @@
 # @shennian/cli
 
-> Shennian AI Agent 移动控制台的本机后台服务 / CLI
+> Shennian AI Agent 控制面的本机后台服务 / CLI
 >
 > **架构设计** → [docs/architecture/cli/](../../docs/architecture/cli/)
 > - [Daemon 架构](../../docs/architecture/cli/daemon.md) — 模块拓扑、数据流、守护进程
@@ -20,10 +20,12 @@
 | `shennian status` | 查看后台服务状态 |
 | `shennian logs -n 100` | 查看最近日志 |
 | `shennian config` | 查看本地配置 |
+| `shennian config set server cn\|global` | 切换国内 / 海外中继节点 |
 | `shennian agent add/list/remove` | 管理自定义 Agent |
 | `shennian upgrade` | 升级 CLI |
 
 `start`、`stop`、`status` 可选加 `--json`。`logs` 输出日志文本，不支持 `--json`。
+切换节点后运行 `shennian stop && shennian start` 让后台服务重新连接。
 
 ## 开发
 

package/dist/src/agents/command-spec.js

@@ -19,6 +19,9 @@ const BUILTIN_COMMANDS = {
     openclaw: [
         { command: 'openclaw', args: [], display: 'openclaw' },
     ],
+    opencode: [
+        { command: 'opencode', args: [], display: 'opencode' },
+    ],
     pi: [
         { command: 'shennian', args: [], display: 'shennian' },
     ],

package/dist/src/agents/model-registry/discovery.js

@@ -2,7 +2,7 @@
 // @test src/__tests__/model-switching.test.ts
 import { createInterface } from 'node:readline';
 import { resolveBuiltinCommand, spawnResolvedCommand } from '../command-spec.js';
-import { fallbackClaudeAliasModels, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenClawModels, } from './parsers.js';
+import { fallbackClaudeAliasModels, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenCodeModels, parseOpenClawModels, } from './parsers.js';
 import { runResolvedCommand } from './runner.js';
 import { DISCOVERY_WORKDIR } from './types.js';
 function sendAppServerRpc(proc, pending, id, method, params, timeoutMs) {
@@ -97,6 +97,13 @@ async function discoverOpenClawModels() {
     const result = await runResolvedCommand(spec, ['models', 'list', '--json']);
     return parseOpenClawModels(result.stdout);
 }
+async function discoverOpenCodeModels() {
+    const spec = resolveBuiltinCommand('opencode');
+    if (!spec)
+        return [];
+    const result = await runResolvedCommand(spec, ['models']);
+    return parseOpenCodeModels(result.stdout);
+}
 async function discoverClaudeModels() {
     if (!resolveBuiltinCommand('claude'))
         return [];
@@ -154,6 +161,8 @@ async function discoverBuiltinModels(type, context) {
             return discoverCursorModels();
         case 'openclaw':
             return discoverOpenClawModels();
+        case 'opencode':
+            return discoverOpenCodeModels();
         case 'pi':
             return discoverPiModels(context);
     }

package/dist/src/agents/model-registry/parsers.d.ts

@@ -2,6 +2,7 @@ import type { ModelInfo } from '@shennian/wire';
 export declare function stripAnsi(text: string): string;
 export declare function parseCursorModels(raw: string): ModelInfo[];
 export declare function parseOpenClawModels(raw: string): ModelInfo[];
+export declare function parseOpenCodeModels(raw: string): ModelInfo[];
 export declare function parseClaudeModels(raw: string): ModelInfo[];
 type EnvLike = Record<string, string | undefined>;
 export declare function applyClaudeModelEnvOverrides(models: ModelInfo[], env?: EnvLike): ModelInfo[];

package/dist/src/agents/model-registry/parsers.js

@@ -94,6 +94,19 @@ export function parseOpenClawModels(raw) {
         return [];
     }
 }
+export function parseOpenCodeModels(raw) {
+    const models = stripAnsi(raw)
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => !line.includes(' '))
+        .map((id) => ({
+        id,
+        name: id,
+        provider: id.includes('/') ? id.split('/')[0] : undefined,
+    }));
+    return uniqueModels(models);
+}
 export function parseClaudeModels(raw) {
     const rawClean = stripAnsi(raw).replace(/\s+/g, ' ');
     const patterns = [

package/dist/src/agents/opencode.d.ts

@@ -0,0 +1,21 @@
+import { AgentAdapter } from './adapter.js';
+export declare class OpenCodeAdapter extends AgentAdapter {
+    readonly type: "opencode";
+    private process;
+    private agentSessionId;
+    private workDir;
+    private seq;
+    private runId;
+    private terminalState;
+    start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
+    send(text: string, modelId?: string): Promise<void>;
+    resume(agentSessionId: string): Promise<void>;
+    stop(): Promise<void>;
+    private resetRunState;
+    private spawnAndParse;
+    private handleStreamEvent;
+    private emitEvent;
+    private emitFinalIfOpen;
+    private emitErrorIfOpen;
+    private killProcess;
+}

package/dist/src/agents/opencode.js

@@ -0,0 +1,230 @@
+// @arch docs/architecture/cli/agent-adapters.md
+// @test src/__tests__/opencode-adapter.test.ts
+import { createInterface } from 'node:readline';
+import { randomUUID } from 'node:crypto';
+import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
+function usageFromTokens(tokens) {
+    if (!tokens)
+        return undefined;
+    const input = tokens.input;
+    const output = tokens.output;
+    if (typeof input !== 'number' && typeof output !== 'number')
+        return undefined;
+    return {
+        inputTokens: typeof input === 'number' ? input : 0,
+        outputTokens: typeof output === 'number' ? output : 0,
+    };
+}
+function stringifyResult(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractErrorMessage(value) {
+    if (!value)
+        return 'opencode request failed';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object')
+        return String(value);
+    const record = value;
+    if (typeof record.message === 'string')
+        return record.message;
+    if (typeof record.name === 'string')
+        return record.name;
+    if ('data' in record)
+        return extractErrorMessage(record.data);
+    return stringifyResult(value) || 'opencode request failed';
+}
+export class OpenCodeAdapter extends AgentAdapter {
+    type = 'opencode';
+    process = null;
+    agentSessionId = null;
+    workDir = null;
+    seq = 0;
+    runId = '';
+    terminalState = 'closed';
+    async start(_sessionId, workDir, agentSessionId) {
+        this.workDir = workDir;
+        if (agentSessionId)
+            this.agentSessionId = agentSessionId;
+        this.resetRunState();
+    }
+    async send(text, modelId) {
+        await this.killProcess();
+        this.runId = randomUUID();
+        this.resetRunState();
+        const args = [
+            'run',
+            '--format',
+            'json',
+            '--dangerously-skip-permissions',
+            '--dir',
+            this.workDir ?? process.cwd(),
+        ];
+        if (this.agentSessionId) {
+            args.push('--session', this.agentSessionId);
+        }
+        if (modelId) {
+            args.push('--model', modelId);
+        }
+        args.push(text);
+        this.spawnAndParse(args);
+    }
+    async resume(agentSessionId) {
+        await this.killProcess();
+        this.agentSessionId = agentSessionId;
+        this.runId = randomUUID();
+        this.resetRunState();
+        this.emitEvent({ state: 'start', agentSessionId });
+        this.emitFinalIfOpen({ state: 'final', agentSessionId });
+    }
+    async stop() {
+        await this.killProcess();
+    }
+    resetRunState() {
+        this.seq = 0;
+        this.terminalState = 'open';
+    }
+    spawnAndParse(args) {
+        const spec = resolveBuiltinCommand('opencode');
+        if (!spec) {
+            this.emit('error', new Error('Command "opencode" not found. Install it with "npm i -g opencode-ai@latest".'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, args, {
+            cwd: this.workDir ?? undefined,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, NO_COLOR: '1' },
+        });
+        this.process = proc;
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const obj = JSON.parse(line);
+                this.handleStreamEvent(obj);
+            }
+            catch {
+                this.emitEvent({ state: 'delta', text: line });
+            }
+        });
+        let stderrBuf = '';
+        proc.stderr?.on('data', (chunk) => {
+            stderrBuf += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (this.terminalState !== 'open')
+                return;
+            const stderr = stderrBuf.trim();
+            if (code !== 0 && code !== null) {
+                this.emitErrorIfOpen({ state: 'error', message: stderr || `opencode exited with code ${code}` });
+                return;
+            }
+            this.emitFinalIfOpen({ state: 'final', agentSessionId: this.agentSessionId ?? undefined });
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "opencode" not found. Install it with "npm i -g opencode-ai@latest".'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    handleStreamEvent(obj) {
+        if (obj.sessionID && obj.sessionID !== this.agentSessionId) {
+            this.agentSessionId = obj.sessionID;
+            this.emitEvent({ state: 'start', agentSessionId: obj.sessionID });
+        }
+        const part = obj.part;
+        if (obj.type === 'text' && part?.text) {
+            this.emitEvent({ state: 'delta', text: part.text });
+            return;
+        }
+        if (obj.type === 'reasoning' && part?.text) {
+            this.emitEvent({ state: 'delta', text: part.text, thinking: true });
+            return;
+        }
+        if (obj.type === 'tool_use' && part?.type === 'tool') {
+            if (part.state?.status === 'completed' || part.state?.status === 'error') {
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: part.tool ?? 'tool',
+                    result: part.state.status === 'error'
+                        ? part.state.error ?? 'tool failed'
+                        : stringifyResult(part.state?.output),
+                });
+            }
+            else {
+                this.emitEvent({
+                    state: 'tool-call',
+                    name: part.tool ?? 'tool',
+                    args: part.state?.input ?? {},
+                });
+            }
+            return;
+        }
+        if (obj.type === 'error') {
+            this.emitErrorIfOpen({ state: 'error', message: extractErrorMessage(obj.error) });
+            return;
+        }
+        if (obj.type === 'step_finish') {
+            this.emitFinalIfOpen({
+                state: 'final',
+                agentSessionId: this.agentSessionId ?? obj.sessionID,
+                usage: usageFromTokens(part?.tokens),
+            });
+        }
+    }
+    emitEvent(partial) {
+        const event = {
+            ...partial,
+            runId: this.runId,
+            seq: this.seq++,
+        };
+        this.emit('agentEvent', event);
+    }
+    emitFinalIfOpen(partial) {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'closed';
+        this.emitEvent(partial);
+    }
+    emitErrorIfOpen(partial) {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'closed';
+        this.emitEvent(partial);
+    }
+    async killProcess() {
+        const proc = this.process;
+        if (!proc)
+            return;
+        this.process = null;
+        proc.kill('SIGTERM');
+        await new Promise((resolve) => {
+            proc.on('close', resolve);
+            setTimeout(() => {
+                proc.kill('SIGKILL');
+                resolve();
+            }, 3000);
+        });
+    }
+}
+registerAgent('opencode', () => new OpenCodeAdapter());

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

@@ -1,11 +1,13 @@
 import type { Command } from 'commander';
 type Platform = 'darwin' | 'linux' | 'win32';
 type ServiceLaunchMode = 'direct' | 'global-shim' | 'npx';
+type DaemonLauncher = 'desktop-managed' | 'global-cli' | 'unknown';
 export type DaemonStatus = {
     running: boolean;
     pid: number | null;
     stale: boolean;
     remoteAccessDisabled: boolean;
+    launcher: DaemonLauncher;
     platform: Platform;
     shennianDir: string;
     pidFile: string;
@@ -25,6 +27,10 @@ export declare function resolveServiceLaunchSpec(input: {
     desktopBridgePath?: string | null;
 }): ServiceLaunchSpec;
 export declare function isRemoteAccessDisabled(): boolean;
+export declare function getCurrentProcessDaemonLauncher(): DaemonLauncher;
+export declare function writeDaemonLauncher(pid: number, launcher?: DaemonLauncher): void;
+export declare function clearDaemonLauncher(): void;
+export declare function recordStartedDaemon(childPid: number | undefined): void;
 export declare function getDaemonStatus(opts?: {
     cleanupStale?: boolean;
 }): DaemonStatus;

package/dist/src/commands/daemon.js

@@ -6,12 +6,13 @@ import path from 'node:path';
 import os from 'node:os';
 import { execSync, spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { getShennianDir, resolveShennianPath } from '../config/index.js';
+import { getShennianDir, loadConfig, resolveShennianPath, saveConfig } from '../config/index.js';
 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 LAUNCHER_FILE = resolveShennianPath('daemon-launcher.json');
 const SHENNIAN_SCRIPT = path.resolve(__dirname, '../../bin/shennian.js');
 const NODE_EXEC = process.execPath;
 function getPlatform() {
@@ -29,16 +30,17 @@ export function isEphemeralCliPath(candidate) {
         normalized.startsWith(tmp.endsWith('/') ? tmp : `${tmp}/`));
 }
 export function resolveServiceLaunchSpec(input) {
+    if (process.env.ELECTRON_RUN_AS_NODE === '1' &&
+        input.desktopBridgePath &&
+        fs.existsSync(input.scriptPath) &&
+        fs.existsSync(input.desktopBridgePath)) {
+        return {
+            command: input.nodeExec,
+            args: [input.desktopBridgePath, input.scriptPath, 'run-service'],
+            mode: 'direct',
+        };
+    }
     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, 'run-service'],
@@ -88,6 +90,68 @@ function isRunning(pid) {
 export function isRemoteAccessDisabled() {
     return fs.existsSync(REMOTE_ACCESS_DISABLED_FILE);
 }
+export function getCurrentProcessDaemonLauncher() {
+    return process.env.SHENNIAN_DESKTOP_CLI_SCRIPT ? 'desktop-managed' : 'global-cli';
+}
+export function writeDaemonLauncher(pid, launcher = getCurrentProcessDaemonLauncher()) {
+    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.writeFileSync(LAUNCHER_FILE, JSON.stringify({
+        pid,
+        launcher,
+        updatedAt: new Date().toISOString(),
+    }, null, 2));
+}
+export function clearDaemonLauncher() {
+    try {
+        fs.unlinkSync(LAUNCHER_FILE);
+    }
+    catch {
+        // Launcher metadata may already be absent.
+    }
+}
+export function recordStartedDaemon(childPid) {
+    if (childPid)
+        writeDaemonLauncher(childPid);
+}
+function readDaemonLauncher(pid, running) {
+    if (!pid || !running)
+        return 'unknown';
+    try {
+        const raw = JSON.parse(fs.readFileSync(LAUNCHER_FILE, 'utf-8'));
+        if (raw.pid !== pid)
+            return 'unknown';
+        if (raw.launcher === 'desktop-managed' || raw.launcher === 'global-cli')
+            return raw.launcher;
+    }
+    catch {
+        // Older daemons do not have launcher metadata.
+    }
+    return inferDaemonLauncherFromProcess(pid);
+}
+function inferDaemonLauncherFromProcess(pid) {
+    if (getPlatform() === 'win32')
+        return 'unknown';
+    try {
+        const command = execSync(`ps -p ${pid} -o command=`, {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 1000,
+        }).replace(/\\/g, '/');
+        if (command.includes('/cli-bridge.js') || command.includes('/Resources/daemon/')) {
+            return 'desktop-managed';
+        }
+        if (command.includes('/node_modules/shennian/') ||
+            command.includes('/bin/shennian') ||
+            command.includes(' shennian run-service') ||
+            command.includes(' shennian.js run-service')) {
+            return 'global-cli';
+        }
+    }
+    catch {
+        // Process command inspection is best effort.
+    }
+    return 'unknown';
+}
 export function getDaemonStatus(opts = {}) {
     const pid = readPid();
     const running = pid !== null && isRunning(pid);
@@ -105,6 +169,7 @@ export function getDaemonStatus(opts = {}) {
         pid,
         stale,
         remoteAccessDisabled: isRemoteAccessDisabled(),
+        launcher: readDaemonLauncher(pid, running),
         platform: getPlatform(),
         shennianDir: SHENNIAN_DIR,
         pidFile: PID_FILE,
@@ -114,6 +179,14 @@ export function getDaemonStatus(opts = {}) {
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function persistServerUrlOverride(serverUrl) {
+    const normalized = serverUrl?.trim();
+    if (!normalized)
+        return;
+    const config = loadConfig();
+    config.serverUrl = normalized;
+    saveConfig(config);
+}
 // ─── Service definitions ─────────────────────────────────────────────────────
 const LAUNCHD_LABEL = 'com.shennian.agent';
 const LAUNCHD_PLIST = path.join(os.homedir(), 'Library/LaunchAgents', `${LAUNCHD_LABEL}.plist`);
@@ -454,7 +527,7 @@ export function startDaemonProcess(opts = {}) {
     });
     child.unref();
     fs.closeSync(logFd);
-    fs.writeFileSync(PID_FILE, String(child.pid));
+    recordStartedDaemon(child.pid);
     if (!opts.quiet) {
         console.log(chalk.green(`✓ Background service started (PID ${child.pid})`));
         console.log(chalk.gray(`  Logs: ${LOG_FILE}`));
@@ -570,9 +643,11 @@ async function stopDaemonProcessAndWait(timeoutMs = 5000) {
     catch {
         // Best-effort cleanup after the process exits.
     }
+    clearDaemonLauncher();
     return result;
 }
 function enableRemoteAccess(opts = {}) {
+    persistServerUrlOverride(opts.api);
     try {
         fs.unlinkSync(REMOTE_ACCESS_DISABLED_FILE);
     }
@@ -660,6 +735,7 @@ async function waitForPidExit(pid, timeoutMs = 5000) {
     return !isRunning(pid);
 }
 async function daemonRestart(opts = {}) {
+    persistServerUrlOverride(opts.api);
     const pid = readPid();
     if (pid !== null && isRunning(pid)) {
         try {
@@ -675,6 +751,7 @@ async function daemonRestart(opts = {}) {
             catch {
                 // Best-effort cleanup after restart stop.
             }
+            clearDaemonLauncher();
             if (!opts.json) {
                 console.log(chalk.green(`✓ Background service stopped (PID ${pid})`));
             }
@@ -697,6 +774,7 @@ async function daemonRestart(opts = {}) {
         catch {
             // Stale pid file is already gone.
         }
+        clearDaemonLauncher();
         if (!opts.json) {
             console.log(chalk.yellow(`⚠ Service process no longer exists, cleaned up stale PID ${pid}`));
         }
@@ -820,6 +898,7 @@ export function registerDaemonCommand(program) {
         .command('start')
         .description('Start the background service')
         .option('--json', 'Print machine-readable status JSON')
+        .option('--api <url>', 'Server URL override')
         .action((opts) => daemonStart(opts));
     program
         .command('stop')
@@ -845,6 +924,7 @@ export function registerDaemonCommand(program) {
         .command('start')
         .description('Start the background service')
         .option('--json', 'Print machine-readable status JSON')
+        .option('--api <url>', 'Server URL override')
         .action((opts) => {
         warnDeprecated('start', opts.json);
         daemonStart(opts);
@@ -861,6 +941,7 @@ export function registerDaemonCommand(program) {
         .command('restart')
         .description('Restart the background service')
         .option('--json', 'Print machine-readable status JSON')
+        .option('--api <url>', 'Server URL override')
         .action((opts) => {
         warnDeprecated('stop && shennian start', opts.json);
         daemonRestart(opts);

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

@@ -4,5 +4,13 @@ export declare function runPairFlow(opts: {
     machineName: string;
     force?: boolean;
 }): Promise<void>;
+export declare function registerDesktopMachine(opts: {
+    serverUrl: string;
+    authToken: string;
+    machineName: string;
+}): Promise<{
+    machineId: string;
+    machineName: string;
+}>;
 export declare function runSmartStart(serverUrl: string | undefined, machineName: string): Promise<void>;
 export declare function registerPairCommand(program: Command): void;

package/dist/src/commands/pair.js

@@ -115,6 +115,40 @@ export async function runPairFlow(opts) {
     saveConfig(config);
     console.log(chalk.green(`\n✓ Paired successfully! Machine "${result.machineName}" is now linked.`));
 }
+export async function registerDesktopMachine(opts) {
+    const config = loadConfig();
+    const detectedAgents = detectAgents();
+    const agentList = detectedAgents.map((a) => a.type);
+    const platform = os.platform();
+    const osName = platform === 'win32' ? 'windows' : platform === 'darwin' ? 'macos' : 'linux';
+    const res = await fetch(`${opts.serverUrl}/api/machines/desktop/register`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${opts.authToken}`,
+        },
+        body: JSON.stringify({
+            machineId: config.machineId,
+            name: opts.machineName,
+            os: osName,
+            agentList,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        const message = body.error ?? res.statusText;
+        throw new Error(`Failed to register desktop machine: ${message}`);
+    }
+    const data = (await res.json());
+    if (!data.machine?.id || !data.machineToken) {
+        throw new Error('Failed to register desktop machine: missing machine token');
+    }
+    config.machineId = data.machine.id;
+    config.machineToken = data.machineToken;
+    config.serverUrl = opts.serverUrl;
+    saveConfig(config);
+    return { machineId: data.machine.id, machineName: data.machine.name };
+}
 export async function runSmartStart(serverUrl, machineName) {
     const config = loadConfig();
     if (!config.machineToken) {
@@ -132,6 +166,28 @@ export async function runSmartStart(serverUrl, machineName) {
     }
 }
 export function registerPairCommand(program) {
+    program
+        .command('desktop-register', { hidden: true })
+        .description('Register this desktop-managed machine to the authenticated account')
+        .requiredOption('--api <url>', 'Server URL')
+        .option('--name <name>', 'Machine name', os.hostname())
+        .action(async (opts) => {
+        try {
+            const token = process.env.SHENNIAN_DESKTOP_AUTH_TOKEN;
+            if (!token)
+                throw new Error('Missing desktop auth token');
+            const result = await registerDesktopMachine({
+                serverUrl: opts.api,
+                authToken: token,
+                machineName: opts.name,
+            });
+            console.log(JSON.stringify({ ok: true, ...result }));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
     program
         .command('pair')
         .description('Pair this machine to a Shennian account (re-pair if already paired)')

package/dist/src/index.js

@@ -8,7 +8,7 @@ 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 { isRemoteAccessDisabled, registerDaemonCommand } from './commands/daemon.js';
+import { clearDaemonLauncher, isRemoteAccessDisabled, registerDaemonCommand, writeDaemonLauncher, } from './commands/daemon.js';
 import { registerAgentCommand } from './commands/agent.js';
 import { registerUpgradeCommand } from './commands/upgrade.js';
 import { SessionManager } from './session/manager.js';
@@ -59,7 +59,7 @@ async function waitForPidExit(pid, timeoutMs = 5000) {
     }
 }
 const program = new Command();
-program.name('shennian').description('Shennian — AI Agent Mobile Console').version(cliVersion);
+program.name('shennian').description('Shennian — AI Agent Control Plane').version(cliVersion);
 program
     .option('--api <url>', 'Server URL override')
     .option('--name <name>', 'Machine name', os.hostname())
@@ -120,6 +120,7 @@ program
         /* noop */
     }
     fs.writeFileSync(pidFile, String(process.pid));
+    writeDaemonLauncher(process.pid);
     process.on('exit', () => {
         try {
             fs.unlinkSync(pidFile);
@@ -127,6 +128,7 @@ program
         catch {
             /* noop */
         }
+        clearDaemonLauncher();
     });
     // Crash detection: if we're recovering from a failed upgrade, rollback and exit
     const didRollback = await handleStartupCrashCheck();
@@ -247,6 +249,7 @@ program
     const sessionManager = new SessionManager(client, nativeFusion);
     fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
     fs.writeFileSync(PID_FILE, String(process.pid));
+    writeDaemonLauncher(process.pid);
     client.connect();
     process.stdin.resume();
     const shutdown = () => {
@@ -261,6 +264,7 @@ program
         catch {
             /* noop */
         }
+        clearDaemonLauncher();
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

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

@@ -1,4 +1,32 @@
 import type { ParsedNativeEvent } from './types.js';
+type OpenCodeSnapshot = {
+    sessions: Array<{
+        id: string;
+        title: string;
+        directory: string;
+        time_created?: number;
+        time_updated?: number;
+    }>;
+    messages: Array<{
+        id: string;
+        session_id: string;
+        time_created: number;
+        data: string;
+    }>;
+    parts: Array<{
+        id: string;
+        message_id: string;
+        session_id: string;
+        time_created: number;
+        data: string;
+    }>;
+};
+export declare function parseOpenCodeSessionSnapshot(snapshotPath: string, snapshot: OpenCodeSnapshot): ParsedNativeEvent[];
+export declare function listOpenCodeSessionFiles(): string[];
+export declare function parseOpenCodeSessionFile(filePath: string, startOffset: number): {
+    nextOffset: number;
+    events: ParsedNativeEvent[];
+};
 export declare function listCodexRolloutFiles(): string[];
 export declare function listClaudeTranscriptFiles(): string[];
 export declare function lookupClaudeTranscriptCwd(sourceSessionKey: string): string | null;
@@ -10,3 +38,4 @@ export declare function parseClaudeTranscriptChunk(filePath: string, startOffset
     nextOffset: number;
     events: ParsedNativeEvent[];
 };
+export {};

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

@@ -5,6 +5,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { buildUserMessagePayload, isToolPayload } from '@shennian/wire';
+import { resolveBuiltinCommand, spawnResolvedCommandSync } from '../agents/command-spec.js';
 function normalizeText(text) {
     return stripGitDirectiveArtifacts(text.replace(/\r\n/g, '\n').trim());
 }
@@ -277,6 +278,121 @@ function pushCodexEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts
 function pushCodexToolEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts, toolName, title, modelId, workDir, args, result) {
     pushCodexEvent(events, filePath, lineOffset, kind, sourceSessionKey, ts, buildToolPayload(toolName, args, result), title, modelId, workDir);
 }
+function parseJsonObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function textFromOpenCodeParts(parts) {
+    return parts
+        .filter((part) => part.type === 'text' || part.type === 'reasoning')
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n\n')
+        .trim();
+}
+function pushOpenCodeEvent(events, snapshotPath, session, message, role, payload, modelId, terminal) {
+    if (!payload)
+        return;
+    events.push({
+        agentType: 'opencode',
+        sourceMode: 'opencode_session_import',
+        sourceSessionKey: session.id,
+        sourceEventKey: `opencode:${session.id}:${message.id}:${role}`,
+        cursor: `${snapshotPath}:${message.time_created}:${message.id}`,
+        role,
+        ts: message.time_created,
+        payload,
+        title: session.title,
+        modelId,
+        workDir: session.directory,
+        terminal,
+    });
+}
+export function parseOpenCodeSessionSnapshot(snapshotPath, snapshot) {
+    const events = [];
+    const sessionsById = new Map(snapshot.sessions.map((session) => [session.id, session]));
+    const partsByMessage = new Map();
+    for (const partRow of snapshot.parts) {
+        const data = parseJsonObject(partRow.data);
+        if (!data)
+            continue;
+        const list = partsByMessage.get(partRow.message_id) ?? [];
+        list.push(data);
+        partsByMessage.set(partRow.message_id, list);
+    }
+    for (const message of [...snapshot.messages].sort((left, right) => left.time_created - right.time_created)) {
+        const session = sessionsById.get(message.session_id);
+        if (!session)
+            continue;
+        const data = parseJsonObject(message.data);
+        if (!data)
+            continue;
+        const role = data.role === 'user' ? 'user' : data.role === 'assistant' ? 'agent' : null;
+        if (!role)
+            continue;
+        const parts = partsByMessage.get(message.id) ?? [];
+        const payload = textFromOpenCodeParts(parts);
+        const modelId = typeof data.modelID === 'string'
+            ? `${typeof data.providerID === 'string' ? `${data.providerID}/` : ''}${data.modelID}`
+            : null;
+        pushOpenCodeEvent(events, snapshotPath, session, message, role, payload, modelId, role === 'agent');
+    }
+    return events;
+}
+export function listOpenCodeSessionFiles() {
+    const dataDir = path.join(os.homedir(), '.local', 'share', 'opencode');
+    const snapshot = path.join(dataDir, 'shennian-opencode-session-snapshot.opencode-session.json');
+    refreshOpenCodeSessionSnapshot(snapshot);
+    return fs.existsSync(snapshot) ? [snapshot] : [];
+}
+function queryOpenCodeDb(query) {
+    const spec = resolveBuiltinCommand('opencode');
+    if (!spec)
+        return [];
+    const result = spawnResolvedCommandSync(spec, ['db', query, '--format', 'json'], {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 10_000,
+    });
+    if (result.status !== 0)
+        return [];
+    try {
+        const parsed = JSON.parse(String(result.stdout ?? ''));
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function refreshOpenCodeSessionSnapshot(snapshotPath) {
+    try {
+        const sessions = queryOpenCodeDb('select id, title, directory, time_created, time_updated from session where time_archived is null order by time_updated asc');
+        if (sessions.length === 0)
+            return;
+        const messages = queryOpenCodeDb('select id, session_id, time_created, data from message order by time_created asc, id asc');
+        const parts = queryOpenCodeDb('select id, message_id, session_id, time_created, data from part order by message_id asc, id asc');
+        fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+        fs.writeFileSync(snapshotPath, JSON.stringify({ sessions, messages, parts }));
+    }
+    catch {
+        /* best-effort native import */
+    }
+}
+export function parseOpenCodeSessionFile(filePath, startOffset) {
+    const stat = fs.statSync(filePath);
+    if (startOffset >= stat.size)
+        return { nextOffset: stat.size, events: [] };
+    const snapshot = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return {
+        nextOffset: stat.size,
+        events: parseOpenCodeSessionSnapshot(filePath, snapshot),
+    };
+}
 function parseCodexResponseItem(events, filePath, lineOffset, payload, sourceSessionKey, ts, title, modelId, workDir) {
     const itemType = typeof payload.type === 'string' ? payload.type : '';
     if (!itemType)

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

@@ -2,7 +2,7 @@
 // @test src/__tests__/native-fusion-parsers.test.ts
 import { randomUUID } from 'node:crypto';
 import fs from 'node:fs';
-import { listClaudeTranscriptFiles, listCodexRolloutFiles, parseClaudeTranscriptChunk, parseCodexRolloutChunk, } from './parsers.js';
+import { listClaudeTranscriptFiles, listCodexRolloutFiles, listOpenCodeSessionFiles, parseClaudeTranscriptChunk, parseCodexRolloutChunk, parseOpenCodeSessionFile, } from './parsers.js';
 import { loadNativeScannerState, saveNativeScannerState } from './state.js';
 const SCAN_INTERVAL_MS = 60_000;
 const CLAIM_TTL_MS = SCAN_INTERVAL_MS * 2;
@@ -46,7 +46,7 @@ export class NativeSessionFusionService {
     registerManagedSend(params) {
         if (!params.canonicalMessageId)
             return;
-        if (params.agentType !== 'codex' && params.agentType !== 'claude')
+        if (params.agentType !== 'codex' && params.agentType !== 'claude' && params.agentType !== 'opencode')
             return;
         this.pendingClaims.set(params.sessionId, {
             sessionId: params.sessionId,
@@ -93,15 +93,22 @@ export class NativeSessionFusionService {
         const nextFilesState = { ...state.files };
         const backfillWindowsCodex = shouldBackfillWindowsCodex(state);
         const batches = [];
-        const files = [...listCodexRolloutFiles(), ...listClaudeTranscriptFiles()];
+        const files = [...listCodexRolloutFiles(), ...listClaudeTranscriptFiles(), ...listOpenCodeSessionFiles()];
         for (const filePath of files) {
             const stat = fs.statSync(filePath);
             const current = state.files[filePath];
             const isCodex = isCodexRolloutPath(filePath);
-            const startOffset = backfillWindowsCodex && isCodex ? 0 : current?.offset ?? 0;
-            const parsed = isCodex
-                ? parseCodexRolloutChunk(filePath, startOffset)
-                : parseClaudeTranscriptChunk(filePath, startOffset);
+            const isOpenCode = filePath.endsWith('.opencode-session.json');
+            const startOffset = isOpenCode && current?.mtimeMs !== stat.mtimeMs
+                ? 0
+                : backfillWindowsCodex && isCodex
+                    ? 0
+                    : current?.offset ?? 0;
+            const parsed = isOpenCode
+                ? parseOpenCodeSessionFile(filePath, startOffset)
+                : isCodex
+                    ? parseCodexRolloutChunk(filePath, startOffset)
+                    : parseClaudeTranscriptChunk(filePath, startOffset);
             nextFilesState[filePath] = {
                 offset: parsed.nextOffset,
                 mtimeMs: stat.mtimeMs,

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

@@ -9,7 +9,7 @@ export type NativeScannerState = {
 export type ParsedNativeEvent = NativeSessionEventPayload;
 export type PendingManagedClaim = {
     sessionId: string;
-    agentType: 'codex' | 'claude';
+    agentType: 'codex' | 'claude' | 'opencode';
     canonicalMessageId: string;
     text: string;
     createdAt: number;
@@ -18,7 +18,7 @@ export type PendingManagedClaim = {
 };
 export type ManagedSuppressionWindow = {
     sessionId: string;
-    agentType: 'codex' | 'claude';
+    agentType: 'codex' | 'claude' | 'opencode';
     sourceSessionKey: string;
     startedAt: number;
     endsAt: number;

package/dist/src/session/manager.d.ts

@@ -6,6 +6,7 @@ import '../agents/codex.js';
 import '../agents/gemini.js';
 import '../agents/cursor.js';
 import '../agents/openclaw.js';
+import '../agents/opencode.js';
 import '../agents/pi.js';
 export declare function resolveSessionWorkDir(input: string): string;
 export declare class SessionManager {

package/dist/src/session/manager.js

@@ -16,6 +16,7 @@ import '../agents/codex.js';
 import '../agents/gemini.js';
 import '../agents/cursor.js';
 import '../agents/openclaw.js';
+import '../agents/opencode.js';
 import '../agents/pi.js';
 import { registerCustomAgent } from '../agents/custom.js';
 const MAX_SESSIONS = 50;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shennian",
-  "version": "0.2.26",
-  "description": "Shennian — AI Agent Mobile Console CLI",
+  "version": "0.2.28",
+  "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {
     "shennian": "dist/bin/shennian.js"
@@ -32,20 +32,14 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "build": "tsc",
-    "build:publish": "node -e \"const fs=require('node:fs'); fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('.tsbuildinfo.publish', { force: true })\" && tsc -p tsconfig.publish.json",
-    "dev": "tsc --watch",
-    "prepublishOnly": "pnpm build:publish"
-  },
   "dependencies": {
     "@mariozechner/pi-agent-core": "^0.64.0",
     "@sinclair/typebox": "^0.34.49",
-    "@shennian/wire": "^0.1.2",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "qrcode-terminal": "^0.12.0",
-    "ws": "^8.18.1"
+    "ws": "^8.18.1",
+    "@shennian/wire": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^20",
@@ -53,5 +47,10 @@
     "@types/ws": "^8.18.1",
     "tsx": "^4.19.4",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:publish": "node -e \"const fs=require('node:fs'); fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('.tsbuildinfo.publish', { force: true })\" && tsc -p tsconfig.publish.json",
+    "dev": "tsc --watch"
   }
-}
+}