shennian 0.2.6 → 0.2.7

package/dist/src/session/handlers/control.d.ts

@@ -0,0 +1,5 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { SessionManagerRuntime } from '../types.js';
+export declare function handleRegionProbe(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleRegionSwitch(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleUpgradeSetPolicy(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;

package/dist/src/session/handlers/control.js

@@ -0,0 +1,57 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/model-switching.test.ts
+import { SERVERS } from '../../region.js';
+import { loadConfig, saveConfig } from '../../config/index.js';
+export async function handleRegionProbe(runtime, req) {
+    const config = loadConfig();
+    const currentUrl = config.serverUrl ?? SERVERS.global.url;
+    const currentRegion = currentUrl.includes('shennian.net') ? 'cn' : 'global';
+    const results = await Promise.all(Object.keys(SERVERS).map(async (region) => {
+        const { url, label } = SERVERS[region];
+        const start = performance.now();
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 5000);
+            await fetch(`${url}/health`, { signal: controller.signal });
+            clearTimeout(timer);
+            return { region, url, label, latencyMs: Math.round(performance.now() - start) };
+        }
+        catch {
+            return { region, url, label, latencyMs: null };
+        }
+    }));
+    runtime.client.sendRes({
+        type: 'res',
+        id: req.id,
+        ok: true,
+        payload: { current: currentRegion, servers: results },
+    });
+}
+export async function handleRegionSwitch(runtime, req) {
+    const targetRegion = req.params.region;
+    if (targetRegion !== 'cn' && targetRegion !== 'global') {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'region must be "cn" or "global"' });
+        return;
+    }
+    const config = loadConfig();
+    config.serverUrl = SERVERS[targetRegion].url;
+    saveConfig(config);
+    runtime.client.sendRes({
+        type: 'res',
+        id: req.id,
+        ok: true,
+        payload: { region: targetRegion, url: SERVERS[targetRegion].url },
+    });
+    setTimeout(() => process.exit(0), 500);
+}
+export async function handleUpgradeSetPolicy(runtime, req) {
+    const policy = req.params.policy;
+    if (policy !== 'none' && policy !== 'patch' && policy !== 'minor') {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'policy must be "none", "patch", or "minor"' });
+        return;
+    }
+    const config = loadConfig();
+    config.autoUpgrade = policy;
+    saveConfig(config);
+    runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { autoUpgrade: policy } });
+}

package/dist/src/session/handlers/fs.d.ts

@@ -0,0 +1,10 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { SessionManagerRuntime } from '../types.js';
+export declare function handleFsLs(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsRead(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsTransfer(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsTransferStart(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsTransferChunk(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsTransferFinish(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsTransferAbort(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function cleanupPendingTransfers(runtime: SessionManagerRuntime): void;

package/dist/src/session/handlers/fs.js

@@ -0,0 +1,256 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/session-manager.test.ts
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const FILE_SYSTEM_ROOTS_PATH = '__roots__';
+function isWindowsAbsolutePath(pathValue) {
+    return /^[A-Za-z]:([\\/]|$)/.test(pathValue) || /^\\\\[^\\]+\\[^\\]+/.test(pathValue);
+}
+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 { path: FILE_SYSTEM_ROOTS_PATH, entries };
+    }
+    return {
+        path: FILE_SYSTEM_ROOTS_PATH,
+        entries: [{ name: '/', path: '/', isDir: true }],
+    };
+}
+export async function handleFsLs(runtime, req) {
+    const requestedPath = req.params.path || os.homedir();
+    if (requestedPath === FILE_SYSTEM_ROOTS_PATH) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: listFileSystemRoots(),
+        });
+        return;
+    }
+    const dirPath = runtime.resolvePath(requestedPath);
+    try {
+        const raw = fs.readdirSync(dirPath, { withFileTypes: true });
+        const joinPath = isWindowsAbsolutePath(dirPath) ? path.win32.join : path.join;
+        const entries = raw
+            .map((entry) => ({
+            name: entry.name,
+            path: joinPath(dirPath, entry.name),
+            isDir: entry.isDirectory(),
+        }))
+            .sort((left, right) => {
+            if (left.isDir !== right.isDir)
+                return left.isDir ? -1 : 1;
+            return left.name.localeCompare(right.name);
+        });
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: { path: dirPath, entries },
+        });
+    }
+    catch (err) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+    }
+}
+export async function handleFsRead(runtime, req) {
+    const filePath = runtime.resolvePath(req.params.path);
+    const encoding = req.params.encoding || 'utf8';
+    const offset = req.params.offset;
+    const length = req.params.length;
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'Not a file' });
+            return;
+        }
+        if (offset != null && length != null) {
+            const readLen = Math.min(length, Math.max(0, stat.size - offset));
+            if (readLen <= 0) {
+                runtime.client.sendRes({
+                    type: 'res',
+                    id: req.id,
+                    ok: true,
+                    payload: { data: '', offset, length: 0, totalSize: stat.size, path: filePath },
+                });
+                return;
+            }
+            const fd = fs.openSync(filePath, 'r');
+            try {
+                const buffer = Buffer.alloc(readLen);
+                const bytesRead = fs.readSync(fd, buffer, 0, readLen, offset);
+                runtime.client.sendRes({
+                    type: 'res',
+                    id: req.id,
+                    ok: true,
+                    payload: {
+                        data: buffer.subarray(0, bytesRead).toString('base64'),
+                        offset,
+                        length: bytesRead,
+                        totalSize: stat.size,
+                        path: filePath,
+                    },
+                });
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            return;
+        }
+        const maxSize = req.params.maxSize || (encoding === 'base64' ? 5 * 1024 * 1024 : 512 * 1024);
+        if (stat.size > maxSize) {
+            runtime.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: false,
+                error: `File too large: ${stat.size} bytes (max ${maxSize})`,
+                payload: { size: stat.size, path: filePath },
+            });
+            return;
+        }
+        if (encoding === 'base64') {
+            const buffer = fs.readFileSync(filePath);
+            runtime.client.sendRes({
+                type: 'res',
+                id: req.id,
+                ok: true,
+                payload: { data: buffer.toString('base64'), path: filePath, size: stat.size },
+            });
+            return;
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: { content, path: filePath, size: stat.size },
+        });
+    }
+    catch (err) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+    }
+}
+export async function handleFsTransfer(runtime, req) {
+    const { name, targetPath, data, direct } = req.params;
+    if (!name || !data) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'name and data are required' });
+        return;
+    }
+    try {
+        const baseDir = runtime.resolvePath(targetPath || os.homedir());
+        const uploadDir = direct ? baseDir : path.join(baseDir, '.uploads');
+        if (!direct)
+            fs.mkdirSync(uploadDir, { recursive: true });
+        const filePath = path.join(uploadDir, path.basename(name));
+        const buffer = Buffer.from(data, 'base64');
+        fs.writeFileSync(filePath, buffer);
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { path: filePath } });
+    }
+    catch (err) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+    }
+}
+export async function handleFsTransferStart(runtime, req) {
+    const { name, targetPath, totalSize, direct } = req.params;
+    if (!name || !totalSize) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'name and totalSize are required' });
+        return;
+    }
+    try {
+        const baseDir = runtime.resolvePath(targetPath || os.homedir());
+        const destinationDir = direct ? baseDir : path.join(baseDir, '.uploads');
+        if (!direct)
+            fs.mkdirSync(destinationDir, { recursive: true });
+        const transferId = `tf-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const tempPath = path.join(os.tmpdir(), `.shennian-upload-${transferId}`);
+        const finalPath = path.join(destinationDir, path.basename(name));
+        fs.writeFileSync(tempPath, Buffer.alloc(0));
+        runtime.pendingTransfers.set(transferId, { tempPath, targetPath: finalPath, totalSize });
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { transferId } });
+    }
+    catch (err) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+    }
+}
+export async function handleFsTransferChunk(runtime, req) {
+    const { transferId, offset, data } = req.params;
+    const transfer = runtime.pendingTransfers.get(transferId);
+    if (!transfer) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'Invalid transferId' });
+        return;
+    }
+    try {
+        const buffer = Buffer.from(data, 'base64');
+        const fd = fs.openSync(transfer.tempPath, 'r+');
+        try {
+            fs.writeSync(fd, buffer, 0, buffer.length, offset);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { written: buffer.length } });
+    }
+    catch (err) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+    }
+}
+export async function handleFsTransferFinish(runtime, req) {
+    const { transferId } = req.params;
+    const transfer = runtime.pendingTransfers.get(transferId);
+    if (!transfer) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'Invalid transferId' });
+        return;
+    }
+    try {
+        fs.renameSync(transfer.tempPath, transfer.targetPath);
+        runtime.pendingTransfers.delete(transferId);
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { path: transfer.targetPath } });
+    }
+    catch {
+        try {
+            fs.copyFileSync(transfer.tempPath, transfer.targetPath);
+            fs.unlinkSync(transfer.tempPath);
+            runtime.pendingTransfers.delete(transferId);
+            runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload: { path: transfer.targetPath } });
+        }
+        catch (err) {
+            runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: String(err) });
+        }
+    }
+}
+export async function handleFsTransferAbort(runtime, req) {
+    const { transferId } = req.params;
+    const transfer = runtime.pendingTransfers.get(transferId);
+    if (transfer) {
+        try {
+            fs.unlinkSync(transfer.tempPath);
+        }
+        catch {
+            // ignore cleanup failures
+        }
+        runtime.pendingTransfers.delete(transferId);
+    }
+    runtime.client.sendRes({ type: 'res', id: req.id, ok: true });
+}
+export function cleanupPendingTransfers(runtime) {
+    for (const [, transfer] of runtime.pendingTransfers) {
+        try {
+            fs.unlinkSync(transfer.tempPath);
+        }
+        catch {
+            // ignore cleanup failures
+        }
+    }
+    runtime.pendingTransfers.clear();
+}

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

@@ -0,0 +1,28 @@
+import type { ReqFrame } from '@shennian/wire';
+import type { CliRelayClient } from '../relay/client.js';
+import type { NativeSessionFusionService } from '../native-fusion/service.js';
+import '../agents/claude.js';
+import '../agents/codex.js';
+import '../agents/gemini.js';
+import '../agents/cursor.js';
+import '../agents/openclaw.js';
+import '../agents/pi.js';
+export declare function resolveSessionWorkDir(input: string): string;
+export declare class SessionManager {
+    private client;
+    private nativeFusion;
+    private sessions;
+    /** Track processed request IDs to deduplicate replayed offline messages */
+    private processedReqIds;
+    /** Accumulate agent text per run for messageSummary on final event */
+    private runTextAcc;
+    /** In-flight chunked uploads: transferId → metadata */
+    private pendingTransfers;
+    constructor(client: CliRelayClient, nativeFusion?: NativeSessionFusionService | null);
+    private getRuntime;
+    private reloadCustomAgents;
+    handleReq(req: ReqFrame): Promise<void>;
+    private evictIdleSessions;
+    private resolvePath;
+    cleanup(): void;
+}

package/dist/src/session/manager.js

@@ -0,0 +1,174 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/session-store.test.ts
+// @test src/__tests__/model-switching.test.ts
+import path from 'node:path';
+import os from 'node:os';
+import { getRegisteredAgents, unregisterAgent } from '../agents/adapter.js';
+import { loadConfig } from '../config/index.js';
+import { handleUpgradeStart, handleUpgradeStatus } from '../commands/upgrade.js';
+import { handleAgentsRefresh, handleModelsRefresh } from './handlers/agents.js';
+import { handleChatAbort, handleChatSend } from './handlers/chat.js';
+import { cleanupPendingTransfers, handleFsLs, handleFsRead, handleFsTransfer, handleFsTransferAbort, handleFsTransferChunk, handleFsTransferFinish, handleFsTransferStart, } from './handlers/fs.js';
+import { handleRegionProbe, handleRegionSwitch, handleUpgradeSetPolicy } from './handlers/control.js';
+// Side-effect imports to register built-in agent adapters.
+import '../agents/claude.js';
+import '../agents/codex.js';
+import '../agents/gemini.js';
+import '../agents/cursor.js';
+import '../agents/openclaw.js';
+import '../agents/pi.js';
+import { registerCustomAgent } from '../agents/custom.js';
+const MAX_SESSIONS = 50;
+function isWindowsAbsolutePath(input) {
+    return /^[A-Za-z]:([\\/]|$)/.test(input) || /^\\\\[^\\]+\\[^\\]+/.test(input);
+}
+export function resolveSessionWorkDir(input) {
+    if (!input)
+        return os.homedir();
+    const joinPath = process.platform === 'win32' ? path.win32.join : path.join;
+    if (input.startsWith('~')) {
+        return joinPath(os.homedir(), input.slice(1).replace(/^[/\\]+/, ''));
+    }
+    if (process.platform === 'win32') {
+        const normalized = input.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);
+    }
+    return path.resolve(input);
+}
+export class SessionManager {
+    client;
+    nativeFusion;
+    sessions = new Map();
+    /** Track processed request IDs to deduplicate replayed offline messages */
+    processedReqIds = new Set();
+    /** Accumulate agent text per run for messageSummary on final event */
+    runTextAcc = new Map();
+    /** In-flight chunked uploads: transferId → metadata */
+    pendingTransfers = new Map();
+    constructor(client, nativeFusion = null) {
+        this.client = client;
+        this.nativeFusion = nativeFusion;
+        this.reloadCustomAgents();
+    }
+    getRuntime() {
+        return {
+            client: this.client,
+            pendingTransfers: this.pendingTransfers,
+            processedReqIds: this.processedReqIds,
+            reloadCustomAgents: () => this.reloadCustomAgents(),
+            resolvePath: (pathValue) => this.resolvePath(pathValue),
+            runTextAcc: this.runTextAcc,
+            sessions: this.sessions,
+            evictIdleSessions: () => this.evictIdleSessions(),
+            nativeFusion: this.nativeFusion,
+        };
+    }
+    reloadCustomAgents() {
+        for (const agentType of getRegisteredAgents()) {
+            if (agentType.startsWith('custom:')) {
+                unregisterAgent(agentType);
+            }
+        }
+        const config = loadConfig();
+        for (const [name, entry] of Object.entries(config.customAgents ?? {})) {
+            registerCustomAgent(name, entry);
+        }
+    }
+    async handleReq(req) {
+        const runtime = this.getRuntime();
+        try {
+            switch (req.method) {
+                case 'chat.send':
+                    await handleChatSend(runtime, req);
+                    break;
+                case 'chat.abort':
+                    await handleChatAbort(runtime, req);
+                    break;
+                case 'fs.ls':
+                    await handleFsLs(runtime, req);
+                    break;
+                case 'fs.read':
+                    await handleFsRead(runtime, req);
+                    break;
+                case 'fs.transfer':
+                    await handleFsTransfer(runtime, req);
+                    break;
+                case 'fs.transfer.start':
+                    await handleFsTransferStart(runtime, req);
+                    break;
+                case 'fs.transfer.chunk':
+                    await handleFsTransferChunk(runtime, req);
+                    break;
+                case 'fs.transfer.finish':
+                    await handleFsTransferFinish(runtime, req);
+                    break;
+                case 'fs.transfer.abort':
+                    await handleFsTransferAbort(runtime, req);
+                    break;
+                case 'region.probe':
+                    await handleRegionProbe(runtime, req);
+                    break;
+                case 'region.switch':
+                    await handleRegionSwitch(runtime, req);
+                    break;
+                case 'upgrade.start':
+                    await handleUpgradeStart(this.client, req.id, req.params.version);
+                    break;
+                case 'upgrade.status':
+                    await handleUpgradeStatus(this.client, req.id);
+                    break;
+                case 'upgrade.set-policy':
+                    await handleUpgradeSetPolicy(runtime, req);
+                    break;
+                case 'agents.refresh':
+                    await handleAgentsRefresh(runtime, req);
+                    break;
+                case 'models.refresh':
+                    await handleModelsRefresh(runtime, req);
+                    break;
+                default:
+                    this.client.sendRes({ type: 'res', id: req.id, ok: false, error: `Unknown method: ${req.method}` });
+            }
+        }
+        catch (err) {
+            this.client.sendRes({
+                type: 'res', id: req.id, ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // ─── Session eviction ──────────────────────────────────────────────────────
+    evictIdleSessions() {
+        if (this.sessions.size < MAX_SESSIONS)
+            return;
+        let oldest = null;
+        for (const [key, session] of this.sessions) {
+            if (!oldest || session.lastActiveAt < oldest.session.lastActiveAt) {
+                oldest = { key, session };
+            }
+        }
+        if (oldest) {
+            oldest.session.adapter.removeAllListeners();
+            oldest.session.adapter.stop().catch(() => { });
+            this.sessions.delete(oldest.key);
+        }
+    }
+    // ─── Helpers ──────────────────────────────────────────────────────────────
+    resolvePath(p) {
+        return resolveSessionWorkDir(p);
+    }
+    cleanup() {
+        for (const [, session] of this.sessions) {
+            session.adapter.stop().catch(() => { });
+        }
+        this.sessions.clear();
+        this.runTextAcc.clear();
+        cleanupPendingTransfers(this.getRuntime());
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { Envelope } from '@shennian/wire';
+export declare function appendMessage(sessionId: string, envelope: Envelope): void;
+export declare function readMessages(sessionId: string, opts?: {
+    limit?: number;
+    before?: number;
+}): Envelope[];
+export declare function listSessions(): string[];

package/dist/src/session/store.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveShennianPath } from '../config/index.js';
+const SESSIONS_DIR = resolveShennianPath('sessions');
+function ensureSessionsDir() {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function sessionFile(sessionId) {
+    return path.join(SESSIONS_DIR, `${sessionId}.jsonl`);
+}
+export function appendMessage(sessionId, envelope) {
+    ensureSessionsDir();
+    const line = JSON.stringify(envelope) + '\n';
+    fs.appendFileSync(sessionFile(sessionId), line, 'utf-8');
+}
+export function readMessages(sessionId, opts) {
+    const file = sessionFile(sessionId);
+    if (!fs.existsSync(file))
+        return [];
+    const content = fs.readFileSync(file, 'utf-8');
+    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+    let messages = [];
+    for (const line of lines) {
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed lines
+        }
+    }
+    messages.sort((a, b) => b.ts - a.ts);
+    if (opts?.before !== undefined) {
+        messages = messages.filter((m) => m.ts < opts.before);
+    }
+    if (opts?.limit !== undefined && opts.limit > 0) {
+        messages = messages.slice(0, opts.limit);
+    }
+    return messages;
+}
+export function listSessions() {
+    ensureSessionsDir();
+    return fs
+        .readdirSync(SESSIONS_DIR)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => f.replace(/\.jsonl$/, ''));
+}

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

@@ -0,0 +1,35 @@
+import type { AgentType } from '@shennian/wire';
+import type { AgentAdapter } from '../agents/adapter.js';
+import type { CliRelayClient } from '../relay/client.js';
+import type { NativeSessionFusionService } from '../native-fusion/service.js';
+export type ActiveSession = {
+    adapter: AgentAdapter;
+    workDir: string;
+    agentType: AgentType;
+    agentSessionId: string | null;
+    lastActiveAt: number;
+    currentRunId: string | null;
+    nextEventSeq: number;
+    pendingTextEvent: {
+        runId: string;
+        seq: number;
+        text: string;
+        thinking: boolean;
+    } | null;
+};
+export type PendingTransfer = {
+    tempPath: string;
+    targetPath: string;
+    totalSize: number;
+};
+export type SessionManagerRuntime = {
+    client: CliRelayClient;
+    pendingTransfers: Map<string, PendingTransfer>;
+    processedReqIds: Set<string>;
+    reloadCustomAgents: () => void;
+    resolvePath: (pathValue: string) => string;
+    runTextAcc: Map<string, string>;
+    sessions: Map<string, ActiveSession>;
+    evictIdleSessions: () => void;
+    nativeFusion: NativeSessionFusionService | null;
+};

package/dist/src/session/types.js

@@ -0,0 +1,4 @@
+// @arch docs/architecture/cli/daemon.md#会话管理
+// @test src/__tests__/session-manager.test.ts
+// @test src/__tests__/model-switching.test.ts
+export {};