shennian 0.2.5 → 0.2.6

package/dist/src/commands/pair.js

@@ -1,162 +0,0 @@
-import chalk from 'chalk';
-import os from 'node:os';
-import readline from 'node:readline';
-import { loadConfig, saveConfig } from '../config/index.js';
-import { detectAgents } from '../agents/detect.js';
-import { startDaemonProcess, installService, saveEnvSnapshot } from './daemon.js';
-import { detectAndChooseServer } from '../region.js';
-import { buildPairQrPayload, PAIR_QR_RENDER_OPTIONS } from './pair-qr.js';
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 10 * 60 * 1000;
-function renderTokenBox(token) {
-    const line = '─'.repeat(token.length + 4);
-    console.log(chalk.cyan(`┌${line}┐`));
-    console.log(chalk.cyan('│  ') + chalk.bold.yellow(token) + chalk.cyan('  │'));
-    console.log(chalk.cyan(`└${line}┘`));
-}
-async function renderQR(url) {
-    const qrcode = (await import('qrcode-terminal')).default;
-    return new Promise((resolve) => {
-        qrcode.generate(url, PAIR_QR_RENDER_OPTIONS, (qr) => {
-            console.log(qr);
-            resolve();
-        });
-    });
-}
-async function pollStatus(serverUrl, pairToken) {
-    const deadline = Date.now() + POLL_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-        let res;
-        try {
-            res = await fetch(`${serverUrl}/api/machines/pair/status?token=${encodeURIComponent(pairToken)}`);
-        }
-        catch {
-            continue;
-        }
-        if (res.status === 410) {
-            console.error(chalk.red('\n✗ Pairing code expired. Please re-run: shennian pair'));
-            process.exit(1);
-        }
-        if (!res.ok)
-            continue;
-        const data = (await res.json());
-        if (data.status === 'claimed' && data.machineToken && data.machineId) {
-            return {
-                machineToken: data.machineToken,
-                machineId: data.machineId,
-                machineName: data.machineName ?? '',
-            };
-        }
-    }
-    return null;
-}
-function askConfirm(question) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise((resolve) => {
-        rl.question(question, (ans) => {
-            rl.close();
-            resolve(ans.trim().toLowerCase() === 'y');
-        });
-    });
-}
-export async function runPairFlow(opts) {
-    const { serverUrl, machineName, force } = opts;
-    const config = loadConfig();
-    if (config.machineToken && config.machineId && !force) {
-        console.log(chalk.green(`✓ Already paired (machine ID: ${config.machineId})`));
-        console.log(chalk.gray('  Run "shennian pair" to re-pair to another account'));
-        return;
-    }
-    if (config.machineToken && !force)
-        return;
-    const detectedAgents = detectAgents();
-    const agentList = detectedAgents.map((a) => a.type);
-    const platform = os.platform();
-    const osName = platform === 'win32' ? 'windows' : platform === 'darwin' ? 'macos' : 'linux';
-    console.log(chalk.bold('\nShennian CLI — Pairing\n'));
-    console.log(chalk.gray(`  Machine: ${machineName}  |  OS: ${osName}  |  Agents: ${agentList.join(', ') || 'none'}`));
-    console.log();
-    let res;
-    try {
-        res = await fetch(`${serverUrl}/api/machines/pair/create`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ name: machineName, os: osName, agentList }),
-        });
-    }
-    catch {
-        console.error(chalk.red(`✗ Network error: cannot connect to ${serverUrl}`));
-        process.exit(1);
-    }
-    if (!res.ok) {
-        const body = await res.json().catch(() => ({}));
-        console.error(chalk.red(`✗ Failed to create machine: ${body.error ?? res.statusText}`));
-        process.exit(1);
-    }
-    const data = (await res.json());
-    config.machineId = data.machineId;
-    config.serverUrl = serverUrl;
-    saveConfig(config);
-    const pairUrl = buildPairQrPayload(data.pairToken);
-    console.log(chalk.white('Scan QR code or enter the pairing code in the Shennian app:'));
-    console.log();
-    await renderQR(pairUrl);
-    renderTokenBox(data.pairToken);
-    console.log();
-    console.log(chalk.gray('Waiting for pairing... (Ctrl+C to cancel)'));
-    const result = await pollStatus(serverUrl, data.pairToken);
-    if (!result) {
-        console.error(chalk.red('\n✗ Timed out. Pairing code expired, please try again.'));
-        process.exit(1);
-    }
-    config.machineToken = result.machineToken;
-    config.machineId = result.machineId;
-    saveConfig(config);
-    console.log(chalk.green(`\n✓ Paired successfully! Machine "${result.machineName}" is now linked.`));
-}
-export async function runSmartStart(serverUrl, machineName) {
-    const config = loadConfig();
-    if (!config.machineToken) {
-        const resolvedUrl = serverUrl ?? (await detectAndChooseServer());
-        await runPairFlow({ serverUrl: resolvedUrl, machineName, force: false });
-    }
-    else {
-        console.log(chalk.green(`✓ Already paired (machine ID: ${config.machineId})`));
-    }
-    saveEnvSnapshot();
-    console.log(chalk.gray('\nStarting background service...'));
-    const startedByService = installService();
-    if (!startedByService) {
-        startDaemonProcess();
-    }
-}
-export function registerPairCommand(program) {
-    program
-        .command('pair')
-        .description('Pair this machine to a Shennian account (re-pair if already paired)')
-        .option('--api <url>', 'Server URL override')
-        .option('--name <name>', 'Machine name', os.hostname())
-        .action(async (opts) => {
-        const config = loadConfig();
-        if (config.machineToken) {
-            console.log(chalk.yellow(`Currently paired (machine ID: ${config.machineId})`));
-            const yes = await askConfirm('Re-pairing will unlink the current account. Continue? (y/N) ');
-            if (!yes) {
-                console.log(chalk.gray('Cancelled'));
-                return;
-            }
-            delete config.machineToken;
-            delete config.machineId;
-            saveConfig(config);
-        }
-        const serverUrl = opts.api ?? (await detectAndChooseServer());
-        await runPairFlow({ serverUrl, machineName: opts.name, force: true });
-        saveEnvSnapshot();
-        console.log(chalk.gray('\nStarting background service...'));
-        const startedByService = installService();
-        if (!startedByService) {
-            startDaemonProcess();
-        }
-    });
-}

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

@@ -1,5 +0,0 @@
-import type { Command } from 'commander';
-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>;

package/dist/src/commands/upgrade.js

@@ -1,145 +0,0 @@
-// @arch docs/architecture/cli/upgrade.md
-import chalk from 'chalk';
-import { getCurrentVersion, fetchLatestVersion, compareVersions, performUpgrade, checkForUpdate, } from '../upgrade/engine.js';
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-// ─── Interactive CLI upgrade command ─────────────────────────────────────────
-export function registerUpgradeCommand(program) {
-    program
-        .command('upgrade')
-        .description('Upgrade shennian CLI to the latest version')
-        .option('--check', 'Only check for updates, do not install')
-        .option('--to <version>', 'Upgrade to a specific version')
-        .action(async (opts) => {
-        const current = getCurrentVersion();
-        console.log(chalk.gray(`Current version: ${current}`));
-        console.log();
-        let spinIdx = 0;
-        const spinTimer = setInterval(() => {
-            process.stdout.write(`\r  ${SPINNER[spinIdx % SPINNER.length]} Checking for updates...`);
-            spinIdx++;
-        }, 80);
-        let latest;
-        try {
-            latest = opts.to ?? await fetchLatestVersion();
-            clearInterval(spinTimer);
-            process.stdout.write('\r' + ' '.repeat(40) + '\r');
-        }
-        catch (err) {
-            clearInterval(spinTimer);
-            process.stdout.write('\r' + ' '.repeat(40) + '\r');
-            console.error(chalk.red(`✗ Failed to check for updates: ${err instanceof Error ? err.message : String(err)}`));
-            process.exit(1);
-        }
-        const changeType = compareVersions(current, latest);
-        if (changeType === 'none' && !opts.to) {
-            console.log(chalk.green(`✓ Already up to date (${current})`));
-            return;
-        }
-        console.log(`  Available: ${chalk.green(latest)} ${changeType === 'major' ? chalk.red('(major)') : changeType === 'minor' ? chalk.yellow('(minor)') : chalk.green('(patch)')}`);
-        console.log();
-        if (opts.check)
-            return;
-        if (changeType === 'major') {
-            console.log(chalk.yellow('  ⚠ This is a major version update and may contain breaking changes.'));
-            console.log(chalk.gray('    Please review the changelog before upgrading.'));
-            console.log();
-        }
-        const result = await performUpgrade(latest, (progress) => {
-            switch (progress.step) {
-                case 'checking':
-                    console.log(chalk.gray('  → Checking npm...'));
-                    break;
-                case 'backing-up':
-                    console.log(chalk.gray('  → Backing up current version...'));
-                    break;
-                case 'installing':
-                    console.log(chalk.gray(`  → Installing ${progress.version}...`));
-                    break;
-                case 'verifying':
-                    console.log(chalk.gray(`  → Verifying ${progress.version}...`));
-                    break;
-                case 'restarting':
-                    console.log(chalk.gray(`  → Restarting daemon...`));
-                    break;
-            }
-        });
-        if (result.ok) {
-            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');
-        }
-        else {
-            console.log();
-            if (result.rolledBack) {
-                console.error(chalk.red(`✗ Upgrade failed (rolled back to ${current})`));
-            }
-            else {
-                console.error(chalk.red(`✗ Upgrade failed: ${result.error}`));
-            }
-            process.exit(1);
-        }
-    });
-}
-// ─── Relay-triggered upgrade (called from session manager) ───────────────────
-export async function handleUpgradeStart(client, reqId, targetVersion) {
-    const sendEvent = (payload) => {
-        client.sendEvent({ type: 'event', event: 'upgrade', payload });
-    };
-    const current = getCurrentVersion();
-    // Resolve target version
-    let latest;
-    try {
-        sendEvent({ state: 'checking', machineId: 'self' });
-        latest = targetVersion ?? await fetchLatestVersion();
-    }
-    catch (err) {
-        client.sendRes({ type: 'res', id: reqId, ok: false, error: `Version check failed: ${err instanceof Error ? err.message : String(err)}` });
-        return;
-    }
-    const changeType = compareVersions(current, latest);
-    if (changeType === 'none') {
-        client.sendRes({ type: 'res', id: reqId, ok: true, payload: { alreadyLatest: true, version: current } });
-        return;
-    }
-    // ACK immediately — upgrade is async
-    client.sendRes({ type: 'res', id: reqId, ok: true, payload: { from: current, to: latest } });
-    const result = await performUpgrade(latest, (progress) => {
-        switch (progress.step) {
-            case 'backing-up':
-                sendEvent({ state: 'downloading', machineId: 'self', version: latest });
-                break;
-            case 'installing':
-                sendEvent({ state: 'installing', machineId: 'self', version: latest });
-                break;
-            case 'restarting':
-                sendEvent({ state: 'restarting', machineId: 'self', from: current, to: latest });
-                break;
-        }
-    });
-    if (result.ok) {
-        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');
-    }
-    else {
-        sendEvent({
-            state: result.rolledBack ? 'rolledback' : 'failed',
-            machineId: 'self',
-            ...(result.rolledBack ? { to: current, reason: result.error } : { error: result.error }),
-        });
-    }
-}
-export async function handleUpgradeStatus(client, reqId) {
-    const result = await checkForUpdate();
-    client.sendRes({
-        type: 'res',
-        id: reqId,
-        ok: true,
-        payload: result.hasUpdate
-            ? { hasUpdate: true, current: result.current, latest: result.latest, changeType: result.changeType }
-            : { hasUpdate: false, current: getCurrentVersion() },
-    });
-}

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

@@ -1,32 +0,0 @@
-export declare function getShennianDir(): string;
-export declare function resolveShennianPath(...parts: string[]): string;
-export declare const configPath: string;
-export type CustomAgentEntry = {
-    command: string;
-    caps: {
-        name: string;
-        model?: string;
-        models?: string[];
-        defaultModel?: string;
-        mode: 'spawn' | 'stdio';
-        proactive?: boolean;
-        resume?: boolean;
-        version?: string;
-    };
-};
-export type ShennianConfig = {
-    defaultProvider?: string;
-    defaultModel?: string;
-    apiKeys?: Record<string, string>;
-    machineId?: string;
-    machineToken?: string;
-    accessToken?: string;
-    refreshToken?: string;
-    serverUrl?: string;
-    customAgents?: Record<string, CustomAgentEntry>;
-    /** Auto-upgrade policy: 'none' | 'patch' | 'minor' (default: 'patch') */
-    autoUpgrade?: 'none' | 'patch' | 'minor';
-};
-export declare function loadConfig(): ShennianConfig;
-export declare function saveConfig(config: ShennianConfig): void;
-export declare function ensureDir(): void;

package/dist/src/config/index.js

@@ -1,31 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-export function getShennianDir() {
-    const customHome = process.env.SHENNIAN_HOME?.trim();
-    if (customHome)
-        return path.resolve(customHome);
-    return path.join(os.homedir(), '.shennian');
-}
-export function resolveShennianPath(...parts) {
-    return path.join(getShennianDir(), ...parts);
-}
-export const configPath = resolveShennianPath('config.json');
-export function loadConfig() {
-    try {
-        if (!fs.existsSync(configPath))
-            return {};
-        return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-export function saveConfig(config) {
-    fs.mkdirSync(getShennianDir(), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-export function ensureDir() {
-    fs.mkdirSync(getShennianDir(), { recursive: true });
-    fs.mkdirSync(resolveShennianPath('sessions'), { recursive: true });
-}

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

@@ -1,26 +0,0 @@
-import type { FsEntry, FsTransferRequest, FsChunk } from '@shennian/wire';
-export type TransferProgress = {
-    transferId: string;
-    seq: number;
-    total: number;
-    bytesSent: number;
-    bytesTotal: number;
-};
-export declare function handleFsLs(reqPath: string): {
-    entries: FsEntry[];
-} | {
-    error: string;
-};
-export declare function handleFsRead(reqPath: string): {
-    path: string;
-    content: string;
-} | {
-    error: string;
-};
-export declare function handleFsDownload(req: FsTransferRequest, onProgress?: (progress: TransferProgress) => void): AsyncGenerator<FsChunk>;
-export declare function handleFsUploadInit(req: FsTransferRequest): {
-    targetPath: string;
-} | {
-    error: string;
-};
-export declare function handleFsUploadChunk(targetPath: string, chunk: FsChunk): void;

package/dist/src/fs/handler.js

@@ -1,130 +0,0 @@
-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;
-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}` };
-    }
-    try {
-        const dirents = fs.readdirSync(normalized, { withFileTypes: true });
-        const entries = dirents.map((d) => {
-            const fullPath = path.join(normalized, d.name);
-            const isDir = d.isDirectory();
-            const entry = { name: d.name, path: fullPath, isDir };
-            try {
-                const stat = fs.statSync(fullPath);
-                entry.size = isDir ? undefined : stat.size;
-                entry.modifiedAt = stat.mtimeMs;
-            }
-            catch {
-                // stat failure is non-fatal
-            }
-            return entry;
-        });
-        return { entries };
-    }
-    catch (err) {
-        return { error: `Failed to list ${reqPath}: ${err.message}` };
-    }
-}
-export function handleFsRead(reqPath) {
-    const normalized = normalizePath(reqPath);
-    if (!isPathSafe(normalized)) {
-        return { error: `Access denied: ${reqPath}` };
-    }
-    try {
-        const stat = fs.statSync(normalized);
-        if (stat.isDirectory()) {
-            return { error: `Not a file: ${reqPath}` };
-        }
-        if (stat.size > MAX_READ_SIZE) {
-            return { error: `File too large (${stat.size} bytes, max ${MAX_READ_SIZE})` };
-        }
-        const content = fs.readFileSync(normalized, 'utf-8');
-        return { path: normalized, content };
-    }
-    catch (err) {
-        return { error: `Failed to read ${reqPath}: ${err.message}` };
-    }
-}
-export async function* handleFsDownload(req, onProgress) {
-    const filePath = req.path;
-    if (!filePath) {
-        throw new Error('Missing path for download');
-    }
-    const normalized = normalizePath(filePath);
-    if (!isPathSafe(normalized)) {
-        throw new Error(`Access denied: ${filePath}`);
-    }
-    const stat = fs.statSync(normalized);
-    if (stat.size > MAX_TRANSFER_SIZE) {
-        throw new Error(`File too large (${stat.size} bytes, max ${MAX_TRANSFER_SIZE})`);
-    }
-    const buf = fs.readFileSync(normalized);
-    const total = Math.ceil(buf.length / CHUNK_SIZE);
-    const chunksPerSec = Math.floor(RATE_LIMIT_BYTES_PER_SEC / CHUNK_SIZE);
-    const delayMs = chunksPerSec > 0 ? Math.ceil(1000 / chunksPerSec) : 0;
-    for (let seq = 0; seq < total; seq++) {
-        const start = seq * CHUNK_SIZE;
-        const end = Math.min(start + CHUNK_SIZE, buf.length);
-        const data = buf.subarray(start, end).toString('base64');
-        yield { transferId: req.transferId, seq, total, data };
-        onProgress?.({
-            transferId: req.transferId,
-            seq,
-            total,
-            bytesSent: end,
-            bytesTotal: buf.length,
-        });
-        if (delayMs > 0 && seq < total - 1) {
-            await sleep(delayMs);
-        }
-    }
-}
-export function handleFsUploadInit(req) {
-    const targetPath = req.targetPath ?? req.path;
-    if (!targetPath) {
-        return { error: 'Missing targetPath for upload' };
-    }
-    const normalized = normalizePath(targetPath);
-    if (!isPathSafe(normalized)) {
-        return { error: `Access denied: ${targetPath}` };
-    }
-    if (req.size != null && req.size > MAX_TRANSFER_SIZE) {
-        return { error: `File too large (${req.size} bytes, max ${MAX_TRANSFER_SIZE})` };
-    }
-    const dir = path.dirname(normalized);
-    fs.mkdirSync(dir, { recursive: true });
-    return { targetPath: normalized };
-}
-export function handleFsUploadChunk(targetPath, chunk) {
-    const buf = Buffer.from(chunk.data, 'base64');
-    const flag = chunk.seq === 0 ? 'w' : 'a';
-    fs.writeFileSync(targetPath, buf, { flag });
-}

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

@@ -1,2 +0,0 @@
-export declare function normalizePath(inputPath: string): string;
-export declare function isPathSafe(normalizedPath: string): boolean;

package/dist/src/fs/security.js

@@ -1,32 +0,0 @@
-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
-    /\/\.ssh\//,
-    /\/\.gnupg\//,
-    /\/\.aws\/credentials/,
-    /\/\.env$/,
-    /\/\.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;
-    for (const pattern of BLOCKED_PATTERNS) {
-        if (pattern.test(normalizedPath))
-            return false;
-    }
-    return true;
-}

package/dist/src/index.d.ts

@@ -1 +0,0 @@
-export {};