shennian 0.2.0 → 0.2.5

package/dist/src/commands/daemon.js

@@ -28,7 +28,7 @@ export function isEphemeralCliPath(candidate) {
         normalized.startsWith(tmp.endsWith('/') ? tmp : `${tmp}/`));
 }
 export function resolveServiceLaunchSpec(input) {
-    if (!isEphemeralCliPath(input.scriptPath)) {
+    if (fs.existsSync(input.scriptPath) && !isEphemeralCliPath(input.scriptPath)) {
         return {
             command: input.nodeExec,
             args: [input.scriptPath, 'start'],
@@ -79,8 +79,10 @@ function isRunning(pid) {
 const LAUNCHD_LABEL = 'com.shennian.agent';
 const LAUNCHD_PLIST = path.join(os.homedir(), 'Library/LaunchAgents', `${LAUNCHD_LABEL}.plist`);
 const WINDOWS_STARTUP_DIR = path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
-const WINDOWS_STARTUP_VBS = path.join(WINDOWS_STARTUP_DIR, 'ShennianAgent.vbs');
 const WINDOWS_STARTUP_CMD = resolveShennianPath('autostart.cmd');
+const WINDOWS_LAUNCHER_VBS = resolveShennianPath('autostart.vbs');
+const WINDOWS_TASK_XML = resolveShennianPath('autostart.xml');
+const WINDOWS_STARTUP_VBS = path.join(WINDOWS_STARTUP_DIR, 'ShennianAgent.vbs');
 function findCommandPath(binary) {
     const command = getPlatform() === 'win32' ? `where ${binary}` : `command -v ${binary}`;
     try {
@@ -130,12 +132,20 @@ function quoteCmdArg(text) {
 function escapeVbsString(text) {
     return text.replace(/"/g, '""');
 }
+function escapeXmlValue(text) {
+    return escapeXml(text);
+}
+function isWindowsCmdScript(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.cmd' || ext === '.bat';
+}
 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',
-        `${commandLine} >> ${quoteCmdArg(logFile)} 2>&1`,
+        `${invocation} >> ${quoteCmdArg(logFile)} 2>&1`,
         '',
     ].join('\r\n');
 }
@@ -146,6 +156,66 @@ export function buildWindowsStartupVbs(cmdPath) {
         '',
     ].join('\r\n');
 }
+export function buildWindowsScheduledTaskXml(input) {
+    const joinedArgs = input.arguments.join(' ');
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Shennian Agent Daemon</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${escapeXmlValue(input.userId)}</UserId>
+    </LogonTrigger>
+    <EventTrigger>
+      <Enabled>true</Enabled>
+      <Subscription><![CDATA[
+<QueryList>
+  <Query Id="0" Path="System">
+    <Select Path="System">*[System[Provider[@Name='Microsoft-Windows-Power-Troubleshooter'] and EventID=1]]</Select>
+  </Query>
+</QueryList>]]></Subscription>
+    </EventTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${escapeXmlValue(input.userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>true</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>3</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${escapeXmlValue(input.command)}</Command>
+      <Arguments>${escapeXmlValue(joinedArgs)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>`;
+}
 function removeLegacyWindowsTask() {
     try {
         execSync(`schtasks /delete /tn "${WINDOWS_TASK_NAME}" /f`, { stdio: 'pipe' });
@@ -154,10 +224,64 @@ function removeLegacyWindowsTask() {
         // Ignore missing legacy Task Scheduler entries during migration.
     }
 }
-function captureEnvForService() {
+function removeLegacyWindowsStartupFiles() {
+    try {
+        fs.unlinkSync(WINDOWS_STARTUP_VBS);
+    }
+    catch {
+        // Legacy Startup entry may already be absent.
+    }
+}
+function getWindowsTaskUserId() {
+    const domain = process.env.USERDOMAIN?.trim();
+    const computer = process.env.COMPUTERNAME?.trim();
+    const username = process.env.USERNAME?.trim() || os.userInfo().username;
+    if (domain && domain.toUpperCase() !== 'WORKGROUP')
+        return `${domain}\\${username}`;
+    if (computer)
+        return `${computer}\\${username}`;
+    return username;
+}
+function buildDetachedLaunchSpec(spec) {
+    if (getPlatform() === 'win32' && isWindowsCmdScript(spec.command)) {
+        const commandLine = [spec.command, ...spec.args].map(quoteCmdArg).join(' ');
+        return {
+            command: process.env.ComSpec || 'cmd.exe',
+            args: ['/d', '/s', '/c', `"${commandLine}"`],
+            windowsVerbatimArguments: true,
+        };
+    }
+    return {
+        command: spec.command,
+        args: spec.args,
+    };
+}
+function installWindowsScheduledTask() {
+    const launch = resolveCurrentServiceLaunchSpec();
+    fs.writeFileSync(WINDOWS_STARTUP_CMD, buildWindowsLauncherCommand(launch, LOG_FILE));
+    fs.writeFileSync(WINDOWS_LAUNCHER_VBS, buildWindowsStartupVbs(WINDOWS_STARTUP_CMD));
+    removeLegacyWindowsStartupFiles();
+    removeLegacyWindowsTask();
+    const taskXml = buildWindowsScheduledTaskXml({
+        userId: getWindowsTaskUserId(),
+        command: path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'wscript.exe'),
+        arguments: [quoteCmdArg(WINDOWS_LAUNCHER_VBS)],
+    });
+    fs.writeFileSync(WINDOWS_TASK_XML, taskXml, 'utf8');
+    try {
+        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;
+    }
+    catch {
+        return false;
+    }
+}
+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',
@@ -170,7 +294,15 @@ function captureEnvForService() {
     env.HOME ??= os.homedir();
     env.PATH ??= '/usr/local/bin:/usr/bin:/bin';
     env.USER ??= os.userInfo().username;
-    env.TMPDIR ??= '/tmp';
+    if (getPlatform() === 'win32') {
+        const tempDir = process.env.TEMP || process.env.TMP || os.tmpdir();
+        env.TMPDIR ??= tempDir;
+        env.TEMP ??= tempDir;
+        env.TMP ??= tempDir;
+    }
+    else {
+        env.TMPDIR ??= '/tmp';
+    }
     return env;
 }
 function buildPlist() {
@@ -255,10 +387,12 @@ export function startDaemonProcess() {
         return;
     }
     const logFd = fs.openSync(LOG_FILE, 'a');
-    const child = spawn(NODE_EXEC, [SHENNIAN_SCRIPT, 'start'], {
+    const launch = buildDetachedLaunchSpec(resolveCurrentServiceLaunchSpec());
+    const child = spawn(launch.command, launch.args, {
         detached: true,
         stdio: ['ignore', logFd, logFd],
         env: process.env,
+        ...(launch.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
     });
     child.unref();
     fs.closeSync(logFd);
@@ -320,12 +454,7 @@ export function installService() {
             return false; // systemd enable doesn't start immediately; caller should startDaemonProcess
         }
         case 'win32': {
-            const launch = resolveCurrentServiceLaunchSpec();
-            fs.mkdirSync(WINDOWS_STARTUP_DIR, { recursive: true });
-            fs.writeFileSync(WINDOWS_STARTUP_CMD, buildWindowsLauncherCommand(launch, LOG_FILE));
-            fs.writeFileSync(WINDOWS_STARTUP_VBS, buildWindowsStartupVbs(WINDOWS_STARTUP_CMD));
-            removeLegacyWindowsTask();
-            return false; // Startup folder launches on logon; caller should startDaemonProcess now
+            return installWindowsScheduledTask();
         }
     }
 }
@@ -435,18 +564,25 @@ function daemonUninstall() {
         case 'win32': {
             removeLegacyWindowsTask();
             try {
-                fs.unlinkSync(WINDOWS_STARTUP_VBS);
+                fs.unlinkSync(WINDOWS_STARTUP_CMD);
             }
             catch {
-                // Startup entry may already be removed.
+                // Launcher script may already be removed.
             }
             try {
-                fs.unlinkSync(WINDOWS_STARTUP_CMD);
+                fs.unlinkSync(WINDOWS_LAUNCHER_VBS);
             }
             catch {
-                // Launcher script may already be removed.
+                // Launcher vbs may already be removed.
+            }
+            try {
+                fs.unlinkSync(WINDOWS_TASK_XML);
+            }
+            catch {
+                // Task xml may already be removed.
             }
-            console.log(chalk.green('✓ Auto-start uninstalled (Startup folder)'));
+            removeLegacyWindowsStartupFiles();
+            console.log(chalk.green('✓ Auto-start uninstalled (Task Scheduler)'));
             break;
         }
     }
@@ -474,4 +610,3 @@ export function registerDaemonCommand(program) {
         .description('Uninstall auto-start service')
         .action(daemonUninstall);
 }
-//# sourceMappingURL=daemon.js.map

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

@@ -2,4 +2,3 @@ export declare const PAIR_QR_RENDER_OPTIONS: {
     readonly small: false;
 };
 export declare function buildPairQrPayload(pairToken: string): string;
-//# sourceMappingURL=pair-qr.d.ts.map

package/dist/src/commands/pair-qr.js

@@ -4,4 +4,3 @@ export const PAIR_QR_RENDER_OPTIONS = { small: false };
 export function buildPairQrPayload(pairToken) {
     return `pair:${pairToken}`;
 }
-//# sourceMappingURL=pair-qr.js.map

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

@@ -6,4 +6,3 @@ export declare function runPairFlow(opts: {
 }): Promise<void>;
 export declare function runSmartStart(serverUrl: string | undefined, machineName: string): Promise<void>;
 export declare function registerPairCommand(program: Command): void;
-//# sourceMappingURL=pair.d.ts.map

package/dist/src/commands/pair.js

@@ -160,4 +160,3 @@ export function registerPairCommand(program) {
         }
     });
 }
-//# sourceMappingURL=pair.js.map

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

@@ -3,4 +3,3 @@ import type { CliRelayClient } from '../relay/client.js';
 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>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/src/commands/upgrade.js

@@ -143,4 +143,3 @@ export async function handleUpgradeStatus(client, reqId) {
             : { hasUpdate: false, current: getCurrentVersion() },
     });
 }
-//# sourceMappingURL=upgrade.js.map

package/dist/src/config/index.d.ts

@@ -30,4 +30,3 @@ export type ShennianConfig = {
 export declare function loadConfig(): ShennianConfig;
 export declare function saveConfig(config: ShennianConfig): void;
 export declare function ensureDir(): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/config/index.js

@@ -29,4 +29,3 @@ export function ensureDir() {
     fs.mkdirSync(getShennianDir(), { recursive: true });
     fs.mkdirSync(resolveShennianPath('sessions'), { recursive: true });
 }
-//# sourceMappingURL=index.js.map

package/dist/src/fs/handler.d.ts

@@ -24,4 +24,3 @@ export declare function handleFsUploadInit(req: FsTransferRequest): {
     error: string;
 };
 export declare function handleFsUploadChunk(targetPath: string, chunk: FsChunk): void;
-//# sourceMappingURL=handler.d.ts.map

package/dist/src/fs/handler.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { normalizePath, isPathSafe } from './security.js';
+const FILE_SYSTEM_ROOTS_PATH = '__roots__';
 const MAX_READ_SIZE = 100 * 1024;
 const MAX_TRANSFER_SIZE = 20 * 1024 * 1024;
 const CHUNK_SIZE = 64 * 1024;
@@ -8,7 +10,23 @@ const RATE_LIMIT_BYTES_PER_SEC = 5 * 1024 * 1024;
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+function listFileSystemRoots() {
+    if (os.platform() === 'win32') {
+        const entries = [];
+        for (let code = 65; code <= 90; code += 1) {
+            const drive = `${String.fromCharCode(code)}:\\`;
+            if (!fs.existsSync(drive))
+                continue;
+            entries.push({ name: drive, path: drive, isDir: true });
+        }
+        return { entries };
+    }
+    return { entries: [{ name: '/', path: '/', isDir: true }] };
+}
 export function handleFsLs(reqPath) {
+    if (reqPath === FILE_SYSTEM_ROOTS_PATH) {
+        return listFileSystemRoots();
+    }
     const normalized = normalizePath(reqPath);
     if (!isPathSafe(normalized)) {
         return { error: `Access denied: ${reqPath}` };
@@ -110,4 +128,3 @@ export function handleFsUploadChunk(targetPath, chunk) {
     const flag = chunk.seq === 0 ? 'w' : 'a';
     fs.writeFileSync(targetPath, buf, { flag });
 }
-//# sourceMappingURL=handler.js.map

package/dist/src/fs/security.d.ts

@@ -1,3 +1,2 @@
 export declare function normalizePath(inputPath: string): string;
 export declare function isPathSafe(normalizedPath: string): boolean;
-//# sourceMappingURL=security.d.ts.map

package/dist/src/fs/security.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import os from 'node:os';
+const FILE_SYSTEM_ROOTS_PATH = '__roots__';
 const ALLOWED_ROOTS = [os.homedir()];
 const BLOCKED_PATTERNS = [
     /\.\./, // directory traversal
@@ -10,12 +11,16 @@ const BLOCKED_PATTERNS = [
     /\/\.env\./,
 ];
 export function normalizePath(inputPath) {
+    if (inputPath === FILE_SYSTEM_ROOTS_PATH)
+        return inputPath;
     const expanded = inputPath.startsWith('~')
         ? path.join(os.homedir(), inputPath.slice(1))
         : inputPath;
     return path.resolve(expanded);
 }
 export function isPathSafe(normalizedPath) {
+    if (normalizedPath === FILE_SYSTEM_ROOTS_PATH)
+        return true;
     const withinAllowed = ALLOWED_ROOTS.some((root) => normalizedPath === root || normalizedPath.startsWith(root + path.sep));
     if (!withinAllowed)
         return false;
@@ -25,4 +30,3 @@ export function isPathSafe(normalizedPath) {
     }
     return true;
 }
-//# sourceMappingURL=security.js.map

package/dist/src/index.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -23,6 +23,19 @@ const PID_FILE = resolveShennianPath('daemon.pid');
 function httpToWs(url) {
     return url.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://');
 }
+function formatDisconnectInfo(info) {
+    const parts = [
+        `trigger=${info.trigger ?? 'unknown'}`,
+        `phase=${info.phase}`,
+        `code=${info.code ?? 'unknown'}`,
+        `attempt=${info.reconnectAttempt}`,
+    ];
+    if (info.reason)
+        parts.push(`reason=${info.reason}`);
+    if (info.error)
+        parts.push(`error=${info.error}`);
+    return parts.join(' ');
+}
 const program = new Command();
 program
     .name('shennian')
@@ -59,10 +72,13 @@ program
         const oldPid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
         if (oldPid && oldPid !== process.pid) {
             try {
-                process.kill(oldPid, 'SIGTERM');
+                process.kill(oldPid, 0);
+                console.log(`[${new Date().toISOString()}] daemon already running (PID ${oldPid}), skipping duplicate start`);
+                process.exit(0);
+            }
+            catch {
+                // Stale pid; continue booting and overwrite it below.
             }
-            catch { /* noop */ }
-            await new Promise((r) => setTimeout(r, 500));
         }
     }
     catch { /* noop */ }
@@ -143,9 +159,20 @@ program
             void scheduleAutoUpgrade(client, config.autoUpgrade ?? 'patch');
             nativeFusion?.handleConnected();
         },
-        onDisconnected: () => {
-            console.log(`[${new Date().toISOString()}] ⚠ Disconnected, reconnecting...`);
-            reportLog({ level: 'warn', wsEvent: 'daemon.disconnected' });
+        onDisconnected: (info) => {
+            console.log(`[${new Date().toISOString()}] ⚠ Disconnected, reconnecting... ${formatDisconnectInfo(info)}`);
+            reportLog({
+                level: 'warn',
+                wsEvent: 'daemon.disconnected',
+                metadata: {
+                    code: info.code,
+                    reason: info.reason,
+                    error: info.error,
+                    phase: info.phase,
+                    trigger: info.trigger,
+                    reconnectAttempt: info.reconnectAttempt,
+                },
+            });
         },
         onReq: (req) => {
             console.log(`[${new Date().toISOString()}] [req] ${req.method}`);
@@ -153,7 +180,9 @@ program
             void sessionManager.handleReq(req);
         },
     });
-    nativeFusion = 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));
@@ -246,4 +275,3 @@ async function scheduleAutoUpgrade(client, policy) {
     // Use a dummy reqId since this is self-triggered
     await handleUpgradeStart(client, 'auto-upgrade', latest);
 }
-//# sourceMappingURL=index.js.map

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

@@ -16,4 +16,3 @@ export declare function initCliLogReporter(serverUrl: string, machineId: string)
 export declare function generateTraceId(): string;
 export declare function reportLog(entry: LogEntry): void;
 export {};
-//# sourceMappingURL=log-reporter.d.ts.map

package/dist/src/log-reporter.js

@@ -11,24 +11,6 @@ export function generateTraceId() {
 export function reportLog(entry) {
     if (!_serverUrl || !_machineId)
         return;
-    const body = {
-        traceId: entry.traceId || generateTraceId(),
-        machineId: _machineId,
-        source: 'cli',
-        type: entry.type ?? 'internal',
-        level: entry.level,
-        wsEvent: entry.wsEvent,
-        wsDirection: entry.wsDirection,
-        sessionId: entry.sessionId,
-        errorMessage: entry.errorMessage,
-        errorStack: entry.errorStack,
-        durationMs: entry.durationMs,
-        metadata: entry.metadata,
-    };
-    fetch(`${_serverUrl}/log`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    }).catch(() => { });
+    // Remote DB log reporting is intentionally disabled; keep the API for callers.
+    void entry;
 }
-//# sourceMappingURL=log-reporter.js.map

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

@@ -10,4 +10,3 @@ export declare function parseClaudeTranscriptChunk(filePath: string, startOffset
     nextOffset: number;
     events: ParsedNativeEvent[];
 };
-//# sourceMappingURL=parsers.d.ts.map