shennian 0.2.13 → 0.2.15

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,17 +13,18 @@
 
 | 命令 | 说明 |
 |------|------|
-| `shennian` | 智能启动：必要时 pair 再启动 daemon |
+| `shennian` | 智能启动：必要时 pair 再启动后台服务 |
 | `shennian pair` | 重新与账号 / server 配对 |
-| `shennian restart` | 重启 daemon；未运行则启动 |
-| `shennian daemon status` | 查看 daemon 运行状态 |
-| `shennian daemon stop` | 停止 daemon |
-| `shennian daemon restart` | 重启 daemon |
-| `shennian daemon logs -n 100` | 查看最近日志 |
+| `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`。
+
 ## 开发
 
 ```bash

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

@@ -5,6 +5,7 @@ export type DaemonStatus = {
     running: boolean;
     pid: number | null;
     stale: boolean;
+    remoteAccessDisabled: boolean;
     platform: Platform;
     shennianDir: string;
     pidFile: string;
@@ -21,7 +22,9 @@ 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;

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,9 @@ 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);
@@ -91,6 +104,7 @@ export function getDaemonStatus(opts = {}) {
         running,
         pid,
         stale,
+        remoteAccessDisabled: isRemoteAccessDisabled(),
         platform: getPlatform(),
         shennianDir: SHENNIAN_DIR,
         pidFile: PID_FILE,
@@ -138,6 +152,7 @@ function resolveCurrentServiceLaunchSpec() {
         scriptPath: SHENNIAN_SCRIPT,
         shennianCommandPath: findCommandPath('shennian'),
         npxPath: resolveNpxPath(),
+        desktopBridgePath: process.env.SHENNIAN_DESKTOP_CLI_BRIDGE,
     });
 }
 function escapeXml(text) {
@@ -322,6 +337,10 @@ export function captureEnvForService() {
         '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) {
@@ -502,21 +521,10 @@ export function installService() {
     }
 }
 // ─── Subcommand implementations ──────────────────────────────────────────────
-function daemonStart(opts) {
-    startDaemonProcess({ quiet: opts.json });
-    if (opts.json)
-        printJson(getDaemonStatus());
-}
-function daemonStop(opts = {}) {
+function stopDaemonProcess() {
     const pid = readPid();
     if (pid === null) {
-        if (opts.json) {
-            printJson(getDaemonStatus());
-        }
-        else {
-            console.log(chalk.yellow('⚠ No running background service found'));
-        }
-        return;
+        return {};
     }
     if (!isRunning(pid)) {
         try {
@@ -525,38 +533,115 @@ function daemonStop(opts = {}) {
         catch {
             // Stale pid file is already gone.
         }
-        if (opts.json) {
-            printJson(getDaemonStatus());
-        }
-        else {
-            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);
-        }
-        catch {
-            // Best-effort cleanup after SIGTERM.
-        }
-        if (opts.json) {
-            printJson(getDaemonStatus());
+            process.kill(result.stoppedPid, 'SIGKILL');
+            await waitForPidExit(result.stoppedPid, 2000);
         }
-        else {
-            console.log(chalk.green(`✓ Background service stopped (PID ${pid})`));
+        catch (err) {
+            return { ...result, error: err instanceof Error ? err.message : String(err) };
         }
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (opts.json) {
-            printJson({ ...getDaemonStatus(), error: message });
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch {
+        // Best-effort cleanup after the process exits.
+    }
+    return result;
+}
+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;
         }
-        else {
-            console.error(chalk.red(`✗ Failed to stop: ${message}`));
+        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 (result.error) {
+        console.error(chalk.red(`✗ Failed to stop: ${result.error}`));
+    }
+    else {
+        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();
@@ -652,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': {
@@ -716,32 +801,70 @@ function daemonUninstall() {
 }
 // ─── Register command ─────────────────────────────────────────────────────────
 export function registerDaemonCommand(program) {
-    const daemon = program.command('daemon').description('Manage the background service');
-    program.command('restart').description('Restart the background service').action(() => daemonRestart());
-    daemon
+    program
         .command('start')
         .description('Start the background service')
         .option('--json', 'Print machine-readable status JSON')
         .action((opts) => daemonStart(opts));
-    daemon
+    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')
+        .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) => daemonRestart(opts));
+        .action((opts) => {
+        warnDeprecated('stop && shennian start', opts.json);
+        daemonRestart(opts);
+    });
     daemon
         .command('status')
         .description('Show background service status')
         .option('--json', 'Print machine-readable status JSON')
-        .action((opts) => daemonStatus(opts));
+        .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) }));
+        .action((opts) => {
+        warnDeprecated('logs');
+        daemonLogs({ lines: parseInt(opts.lines, 10) });
+    });
     daemon.command('uninstall').description('Uninstall auto-start service').action(daemonUninstall);
 }

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

@@ -1,5 +1,16 @@
+import { execSync, spawn } from 'node:child_process';
 import type { Command } from 'commander';
 import type { CliRelayClient } from '../relay/client.js';
+type RestartAfterUpgradeDeps = {
+    platform?: NodeJS.Platform;
+    kill?: typeof process.kill;
+    pid?: number;
+    spawn?: typeof spawn;
+    execSync?: typeof execSync;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function restartCurrentDaemonAfterUpgrade(deps?: RestartAfterUpgradeDeps): void;
 export declare function registerUpgradeCommand(program: Command): void;
 export declare function handleUpgradeStart(client: CliRelayClient, reqId: string, targetVersion?: string): Promise<void>;
 export declare function handleUpgradeStatus(client: CliRelayClient, reqId: string): Promise<void>;
+export {};

package/dist/src/commands/upgrade.js

@@ -1,7 +1,57 @@
 // @arch docs/architecture/cli/upgrade.md
+// @test packages/cli/src/__tests__/upgrade-command.test.ts
 import chalk from 'chalk';
+import { execSync, spawn } from 'node:child_process';
+import os from 'node:os';
 import { getCurrentVersion, fetchLatestVersion, compareVersions, performUpgrade, checkForUpdate, } from '../upgrade/engine.js';
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function restartCurrentDaemonAfterUpgrade(deps = {}) {
+    const platform = deps.platform ?? os.platform();
+    const kill = deps.kill ?? process.kill;
+    const currentPid = deps.pid ?? process.pid;
+    const env = deps.env ?? process.env;
+    const spawnFn = deps.spawn ?? spawn;
+    const execSyncFn = deps.execSync ?? execSync;
+    if (platform === 'win32') {
+        const command = env.ComSpec || 'cmd.exe';
+        const delayedStart = [
+            'timeout /t 2 /nobreak >nul',
+            'wscript "%USERPROFILE%\\.shennian\\autostart.vbs"',
+        ].join(' & ');
+        try {
+            const child = spawnFn(command, ['/d', '/s', '/c', `"${delayedStart}"`], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            child.unref();
+            kill(currentPid, 'SIGTERM');
+            return;
+        }
+        catch {
+            try {
+                execSyncFn('schtasks /run /tn "ShennianAgent"', { stdio: 'pipe' });
+            }
+            catch {
+                // Fall through to process exit; manual start/status still works.
+            }
+        }
+    }
+    else {
+        try {
+            const child = spawnFn('sh', ['-c', 'sleep 2; shennian start >/dev/null 2>&1'], {
+                detached: true,
+                stdio: 'ignore',
+                env,
+            });
+            child.unref();
+        }
+        catch {
+            // launchd/systemd may still restart this process; otherwise manual start/status still works.
+        }
+    }
+    kill(currentPid, 'SIGTERM');
+}
 // ─── Interactive CLI upgrade command ─────────────────────────────────────────
 export function registerUpgradeCommand(program) {
     program
@@ -67,8 +117,7 @@ export function registerUpgradeCommand(program) {
             console.log();
             console.log(chalk.green(`✓ Upgraded ${result.from} → ${result.to}`));
             console.log(chalk.gray('  Daemon is restarting...'));
-            // Kill self — systemd/launchd will restart with new version
-            process.kill(process.pid, 'SIGTERM');
+            restartCurrentDaemonAfterUpgrade();
         }
         else {
             console.log();
@@ -122,7 +171,7 @@ export async function handleUpgradeStart(client, reqId, targetVersion) {
         sendEvent({ state: 'restarting', machineId: 'self', from: result.from, to: result.to });
         // Brief delay so the event is flushed before we exit
         await new Promise((r) => setTimeout(r, 500));
-        process.kill(process.pid, 'SIGTERM');
+        restartCurrentDaemonAfterUpgrade();
     }
     else {
         sendEvent({

package/dist/src/index.js

@@ -1,5 +1,6 @@
 // @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';
@@ -7,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 { 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';
@@ -46,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'));
@@ -261,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 restart'));
+        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/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.13",
+  "version": "0.2.15",
   "description": "Shennian — AI Agent Mobile Console CLI",
   "type": "module",
   "bin": {
@@ -32,14 +32,20 @@
   "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": "workspace:*",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "qrcode-terminal": "^0.12.0",
-    "ws": "^8.18.1",
-    "@shennian/wire": "0.1.2"
+    "ws": "^8.18.1"
   },
   "devDependencies": {
     "@types/node": "^20",
@@ -47,10 +53,5 @@
     "@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"
   }
-}
+}