shennian 0.2.72 → 0.2.74

package/dist/src/session/archive-zip.js

@@ -0,0 +1,220 @@
+// @arch docs/features/file-management-enhancements.md#文件夹打包下载
+// @test src/__tests__/archive-zip.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_MAX_FILES = 5000;
+const DEFAULT_MAX_TOTAL_SIZE = 1024 * 1024 * 1024;
+const ZIP_VERSION_NEEDED = 20;
+const ZIP_UTF8_FLAG = 0x0800;
+const ZIP_STORE_METHOD = 0;
+const CHUNK_SIZE = 1024 * 1024;
+const crcTable = new Uint32Array(256);
+for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    crcTable[index] = value >>> 0;
+}
+function updateCrc32(crc, buffer) {
+    let next = crc;
+    for (let index = 0; index < buffer.length; index += 1) {
+        next = crcTable[(next ^ buffer[index]) & 0xff] ^ (next >>> 8);
+    }
+    return next >>> 0;
+}
+function dosDateTime(mtimeMs) {
+    const date = new Date(mtimeMs || Date.now());
+    const year = Math.max(1980, Math.min(2107, date.getFullYear()));
+    return {
+        date: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+        time: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+    };
+}
+function writeUInt32(buffer, value, offset) {
+    buffer.writeUInt32LE(value >>> 0, offset);
+}
+function writeLocalHeader(fd, entry) {
+    const name = Buffer.from(entry.name, 'utf8');
+    const { date, time } = dosDateTime(entry.mtimeMs);
+    const header = Buffer.alloc(30);
+    writeUInt32(header, 0x04034b50, 0);
+    header.writeUInt16LE(ZIP_VERSION_NEEDED, 4);
+    header.writeUInt16LE(ZIP_UTF8_FLAG, 6);
+    header.writeUInt16LE(ZIP_STORE_METHOD, 8);
+    header.writeUInt16LE(time, 10);
+    header.writeUInt16LE(date, 12);
+    writeUInt32(header, entry.crc32, 14);
+    writeUInt32(header, entry.size, 18);
+    writeUInt32(header, entry.size, 22);
+    header.writeUInt16LE(name.length, 26);
+    header.writeUInt16LE(0, 28);
+    fs.writeSync(fd, header);
+    fs.writeSync(fd, name);
+}
+function writeCentralDirectoryHeader(fd, entry) {
+    const name = Buffer.from(entry.name, 'utf8');
+    const { date, time } = dosDateTime(entry.mtimeMs);
+    const header = Buffer.alloc(46);
+    writeUInt32(header, 0x02014b50, 0);
+    header.writeUInt16LE(0x031e, 4);
+    header.writeUInt16LE(ZIP_VERSION_NEEDED, 6);
+    header.writeUInt16LE(ZIP_UTF8_FLAG, 8);
+    header.writeUInt16LE(ZIP_STORE_METHOD, 10);
+    header.writeUInt16LE(time, 12);
+    header.writeUInt16LE(date, 14);
+    writeUInt32(header, entry.crc32, 16);
+    writeUInt32(header, entry.size, 20);
+    writeUInt32(header, entry.size, 24);
+    header.writeUInt16LE(name.length, 28);
+    header.writeUInt16LE(0, 30);
+    header.writeUInt16LE(0, 32);
+    header.writeUInt16LE(0, 34);
+    header.writeUInt16LE(0, 36);
+    writeUInt32(header, entry.isDir ? 0x10 : 0, 38);
+    writeUInt32(header, entry.offset, 42);
+    fs.writeSync(fd, header);
+    fs.writeSync(fd, name);
+}
+function writeEndOfCentralDirectory(fd, entryCount, centralSize, centralOffset) {
+    const header = Buffer.alloc(22);
+    writeUInt32(header, 0x06054b50, 0);
+    header.writeUInt16LE(0, 4);
+    header.writeUInt16LE(0, 6);
+    header.writeUInt16LE(entryCount, 8);
+    header.writeUInt16LE(entryCount, 10);
+    writeUInt32(header, centralSize, 12);
+    writeUInt32(header, centralOffset, 16);
+    header.writeUInt16LE(0, 20);
+    fs.writeSync(fd, header);
+}
+function normalizeZipName(relativePath, isDir) {
+    const normalized = relativePath.split(path.sep).join('/');
+    return isDir && !normalized.endsWith('/') ? `${normalized}/` : normalized;
+}
+function collectEntries(sourceDir, options) {
+    const sourceStat = fs.statSync(sourceDir);
+    const rootName = normalizeZipName(path.basename(sourceDir) || 'folder', true);
+    const entries = [{
+            name: rootName,
+            sourcePath: null,
+            crc32: 0,
+            size: 0,
+            isDir: true,
+            mtimeMs: sourceStat.mtimeMs,
+        }];
+    let fileCount = 0;
+    let totalSize = 0;
+    const visit = (dirPath) => {
+        const raw = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const dirent of raw) {
+            const fullPath = path.join(dirPath, dirent.name);
+            const relative = path.relative(sourceDir, fullPath);
+            if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+                continue;
+            const stat = fs.lstatSync(fullPath);
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                entries.push({
+                    name: path.posix.join(rootName, normalizeZipName(relative, true)),
+                    sourcePath: null,
+                    crc32: 0,
+                    size: 0,
+                    isDir: true,
+                    mtimeMs: stat.mtimeMs,
+                });
+                visit(fullPath);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            fileCount += 1;
+            if (fileCount > options.maxFiles)
+                throw new Error(`Too many files: ${fileCount}`);
+            totalSize += stat.size;
+            if (totalSize > options.maxTotalSize) {
+                throw new Error(`Folder too large: ${totalSize} bytes`);
+            }
+            entries.push({
+                name: path.posix.join(rootName, normalizeZipName(relative, false)),
+                sourcePath: fullPath,
+                crc32: computeFileCrc32(fullPath),
+                size: stat.size,
+                isDir: false,
+                mtimeMs: stat.mtimeMs,
+            });
+        }
+    };
+    visit(sourceDir);
+    return entries;
+}
+function computeFileCrc32(filePath) {
+    const fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(CHUNK_SIZE);
+    let crc = 0xffffffff;
+    try {
+        while (true) {
+            const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead <= 0)
+                break;
+            crc = updateCrc32(crc, buffer.subarray(0, bytesRead));
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function writeFileData(fd, filePath) {
+    const sourceFd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(CHUNK_SIZE);
+    try {
+        while (true) {
+            const bytesRead = fs.readSync(sourceFd, buffer, 0, buffer.length, null);
+            if (bytesRead <= 0)
+                break;
+            fs.writeSync(fd, buffer.subarray(0, bytesRead));
+        }
+    }
+    finally {
+        fs.closeSync(sourceFd);
+    }
+}
+export function createZipArchive(sourceDir, outputPath, options = {}) {
+    const sourceStat = fs.statSync(sourceDir);
+    if (!sourceStat.isDirectory())
+        throw new Error('Not a directory');
+    const limits = {
+        maxFiles: options.maxFiles ?? DEFAULT_MAX_FILES,
+        maxTotalSize: options.maxTotalSize ?? DEFAULT_MAX_TOTAL_SIZE,
+    };
+    const scanned = collectEntries(sourceDir, limits);
+    const zipEntries = [];
+    let fileCount = 0;
+    let totalSize = 0;
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    const fd = fs.openSync(outputPath, 'w');
+    try {
+        for (const entry of scanned) {
+            const offset = fs.fstatSync(fd).size;
+            const nextEntry = { ...entry, offset };
+            writeLocalHeader(fd, nextEntry);
+            if (nextEntry.sourcePath) {
+                writeFileData(fd, nextEntry.sourcePath);
+                fileCount += 1;
+                totalSize += nextEntry.size;
+            }
+            zipEntries.push(nextEntry);
+        }
+        const centralOffset = fs.fstatSync(fd).size;
+        for (const entry of zipEntries)
+            writeCentralDirectoryHeader(fd, entry);
+        const centralSize = fs.fstatSync(fd).size - centralOffset;
+        writeEndOfCentralDirectory(fd, zipEntries.length, centralSize, centralOffset);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return { outputPath, fileCount, totalSize };
+}

package/dist/src/session/handlers/agent-config.js

@@ -1,7 +1,14 @@
 // @arch docs/features/agent-provider-config.md
 // @test src/__tests__/agent-config-status.test.ts
+// @test src/__tests__/agent-config-handler.test.ts
+import { mkdir } from 'node:fs/promises';
+import { createAgent } from '../../agents/adapter.js';
 import { buildManagedAgentEnv, deleteManagedAgentProviderConfig, getAgentConfigSummary, upsertManagedAgentProviderConfig, } from '../../agents/config-status.js';
+import { resolveShennianPath } from '../../config/index.js';
 import { handleAgentsRefresh } from './agents.js';
+const AGENT_TEST_TIMEOUT_MS = 30_000;
+const AGENT_TEST_PROMPT = '这是一次神念连接测试。请只回复 OK，不要解释。';
+const AGENT_TEST_WORK_DIR = resolveShennianPath('tmp', 'agent-config-test');
 function normalizeAgent(value) {
     if (value === 'codex' || value === 'claude' || value === 'pi')
         return value;
@@ -45,13 +52,85 @@ export async function handleAgentConfigClear(runtime, req) {
 export async function handleAgentConfigTest(runtime, req) {
     const agent = normalizeAgent(req.params.agent);
     const summary = getAgentConfigSummary(agent);
-    runtime.client.sendRes({
-        type: 'res',
-        id: req.id,
-        ok: !!summary?.tokenPresent,
-        payload: { agent, config: summary },
-        ...(!summary?.tokenPresent ? { error: 'Token is missing on this machine' } : {}),
+    try {
+        const result = await runAgentConfigTest(agent);
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: { agent, config: getAgentConfigSummary(agent), test: result },
+        });
+    }
+    catch (err) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            payload: { agent, config: summary },
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+async function runAgentConfigTest(agent) {
+    const adapter = createAgent(agent);
+    if (!adapter)
+        throw new Error(`Unsupported agent: ${agent}`);
+    const sessionId = `agent-test-${agent}-${Date.now()}`;
+    await mkdir(AGENT_TEST_WORK_DIR, { recursive: true });
+    let settled = false;
+    let failWait = () => { };
+    const waitForReply = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error('Agent test timed out after 30 seconds'));
+        }, AGENT_TEST_TIMEOUT_MS);
+        function finish(result) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve(result);
+        }
+        function fail(error) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            reject(error);
+        }
+        failWait = fail;
+        adapter.on('agentEvent', (event) => {
+            if (event.state === 'delta' && event.text && !event.thinking) {
+                finish({ mode: 'agent-run', reply: event.text.slice(0, 120) });
+                return;
+            }
+            if (event.state === 'final') {
+                finish({ mode: 'agent-run' });
+                return;
+            }
+            if (event.state === 'error') {
+                fail(new Error(event.message || 'Agent test failed'));
+            }
+        });
+        adapter.on('error', fail);
     });
+    try {
+        adapter.configure?.({
+            sessionId,
+            env: getManagedEnvForAgent(agent),
+        });
+        await adapter.start(sessionId, AGENT_TEST_WORK_DIR, null);
+        const sendPromise = adapter.send(AGENT_TEST_PROMPT).catch((err) => {
+            failWait(err instanceof Error ? err : new Error(String(err)));
+        });
+        return await Promise.race([waitForReply, sendPromise.then(() => waitForReply)]);
+    }
+    finally {
+        adapter.removeAllListeners();
+        await adapter.stop().catch(() => { });
+    }
 }
 async function broadcastAgents(runtime) {
     const req = {

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

@@ -34,6 +34,31 @@ function extractSummary(text) {
     const end = newline > 0 ? Math.min(newline, 80) : Math.min(text.length, 80);
     return text.slice(0, end);
 }
+function buildRelayAgentPayload(event, sessionId, extra = {}) {
+    if (event.state === 'tool-call' || event.state === 'tool-result') {
+        return {
+            state: event.state,
+            runId: event.runId,
+            seq: event.seq,
+            sessionId,
+            ...(event.name ? { name: event.name } : {}),
+            ...(event.source ? { source: event.source } : {}),
+            ...(event.agentSessionId ? { agentSessionId: event.agentSessionId } : {}),
+            ...extra,
+        };
+    }
+    return { ...event, sessionId, ...extra };
+}
+function formatAgentSendFailure(agentType, err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    if (agentType === 'pi' &&
+        (raw.includes('429') || raw.includes('daily_quota_exceeded') || raw.includes('nian_quota_exceeded'))) {
+        return raw.includes('too quickly') || raw.includes('per minute')
+            ? 'Nian 请求过于频繁，请稍后再试。'
+            : 'Nian 今日额度已用完，次日自动恢复。';
+    }
+    return `Agent send failed: ${raw}`;
+}
 function getNativeSourceAgentType(agentType, modelId) {
     if (agentType !== 'manager')
         return agentType;
@@ -94,6 +119,21 @@ function normalizeExternalChannel(value) {
         name: typeof raw.name === 'string' ? raw.name : null,
         canReply: raw.canReply === undefined || raw.canReply === null ? null : Boolean(raw.canReply),
         systemPrompt: typeof raw.systemPrompt === 'string' ? raw.systemPrompt : null,
+        wechatRpaSource: typeof raw.wechatRpaSource === 'string' ? raw.wechatRpaSource : null,
+        wechatRpaGroups: Array.isArray(raw.wechatRpaGroups)
+            ? raw.wechatRpaGroups
+                .map((item) => ({ name: String(item?.name || '').trim() }))
+                .filter((item) => item.name)
+            : null,
+        pollIntervalMs: Number.isFinite(raw.pollIntervalMs) ? Number(raw.pollIntervalMs) : null,
+        recentLimit: Number.isFinite(raw.recentLimit) ? Number(raw.recentLimit) : null,
+        idleSeconds: Number.isFinite(raw.idleSeconds) ? Number(raw.idleSeconds) : null,
+        forceForeground: raw.forceForeground === undefined || raw.forceForeground === null ? null : Boolean(raw.forceForeground),
+        noRestore: raw.noRestore === undefined || raw.noRestore === null ? null : Boolean(raw.noRestore),
+        downloadAttachments: raw.downloadAttachments === undefined || raw.downloadAttachments === null ? null : Boolean(raw.downloadAttachments),
+        downloadAttachmentsDir: typeof raw.downloadAttachmentsDir === 'string' ? raw.downloadAttachmentsDir : null,
+        cloudOcrUrl: typeof raw.cloudOcrUrl === 'string' ? raw.cloudOcrUrl : null,
+        cloudOcrMode: typeof raw.cloudOcrMode === 'string' ? raw.cloudOcrMode : null,
     };
 }
 function externalChannelEnabled(channel) {
@@ -148,7 +188,7 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
         runtime.client.sendAgentEvent({
             type: 'event',
             event: 'agent',
-            payload: { ...event, sessionId, ...extra },
+            payload: buildRelayAgentPayload(event, sessionId, extra),
             seq: event.seq,
             id: `agent-evt-${event.runId}-${event.seq}`,
         });
@@ -500,7 +540,7 @@ export async function handleChatSend(runtime, req) {
         });
     };
     const handleSendFailure = async (err, respondToReq) => {
-        const message = `Agent send failed: ${err instanceof Error ? err.message : String(err)}`;
+        const message = formatAgentSendFailure(requestedAgentType, err);
         console.error(`[chat.send] send failed reqId=${req.id} sessionId=${sessionId} agentType=${agentType} workDir=${resolvedWorkDir} agentSessionId=${session.agentSessionId ?? incomingAgentSid ?? ''}: ${message}`);
         runtime.sessions.delete(sessionId);
         try {
@@ -518,6 +558,22 @@ export async function handleChatSend(runtime, req) {
                 seq: 0,
             },
         });
+        if (!respondToReq) {
+            const errorEnvelope = {
+                id: `agent-error-${req.id}-${Date.now()}`,
+                sessionId,
+                role: 'agent',
+                ts: Date.now(),
+                payload: message,
+            };
+            appendMessage(sessionId, errorEnvelope);
+            sendSessionMessageEvent(runtime, errorEnvelope, {
+                agentType: requestedAgentType,
+                workDir: displayWorkDir,
+                agentSessionId: session.agentSessionId ?? incomingAgentSid ?? null,
+                modelId,
+            });
+        }
         if (respondToReq) {
             runtime.processedReqIds.delete(req.id);
             runtime.client.sendRes({

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

@@ -5,6 +5,7 @@ export declare function handleFsRead(runtime: SessionManagerRuntime, req: ReqFra
 export declare function handleFsWrite(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
 export declare function handleFsRename(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
 export declare function handleFsExportMarkdownPdf(runtime: SessionManagerRuntime, req: ReqFrame): Promise<void>;
+export declare function handleFsArchiveZip(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>;

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

@@ -4,9 +4,12 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { convertMarkdownToPdf, defaultPdfOutputPath, MarkdownPdfBrowserMissingError, } from '../../tools/markdown-to-pdf.js';
+import { createZipArchive } from '../archive-zip.js';
 const FILE_SYSTEM_ROOTS_PATH = '__roots__';
 const MAX_FOLDER_UPLOAD_FILES = 2000;
 const MAX_FOLDER_UPLOAD_TOTAL_SIZE = 1024 * 1024 * 1024;
+const MAX_ARCHIVE_FILES = 5000;
+const MAX_ARCHIVE_TOTAL_SIZE = 1024 * 1024 * 1024;
 function isWindowsAbsolutePath(pathValue) {
     return /^[A-Za-z]:([\\/]|$)/.test(pathValue) || /^\\\\[^\\]+\\[^\\]+/.test(pathValue);
 }
@@ -263,7 +266,6 @@ export async function handleFsWrite(runtime, req) {
 export async function handleFsRename(runtime, req) {
     const requestedPath = req.params.path;
     const newName = req.params.newName;
-    const rootPath = req.params.rootPath || requestedPath;
     if (!requestedPath || !newName) {
         runtime.client.sendRes({
             type: 'res',
@@ -277,6 +279,8 @@ export async function handleFsRename(runtime, req) {
         runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'Invalid newName' });
         return;
     }
+    const api = pathApiForPath(requestedPath);
+    const rootPath = req.params.rootPath || api.dirname(requestedPath);
     const resolved = runtime.resolveAuthorizedPath(requestedPath, rootPath);
     if (!resolved.ok) {
         runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: resolved.error });
@@ -373,6 +377,58 @@ export async function handleFsExportMarkdownPdf(runtime, req) {
         });
     }
 }
+function safeArchiveBaseName(name) {
+    const trimmed = name.trim().replace(/[<>:"/\\|?*\u0000-\u001f]+/g, '-').replace(/[. ]+$/g, '');
+    return trimmed || 'folder';
+}
+export async function handleFsArchiveZip(runtime, req) {
+    const requestedPath = req.params.path;
+    const rootPath = req.params.rootPath || requestedPath;
+    if (!requestedPath) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'path is required' });
+        return;
+    }
+    const resolved = runtime.resolveAuthorizedPath(requestedPath, rootPath);
+    if (!resolved.ok) {
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: resolved.error });
+        return;
+    }
+    try {
+        const stat = fs.statSync(resolved.path);
+        if (!stat.isDirectory()) {
+            runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'Not a directory' });
+            return;
+        }
+        const api = pathApiForPath(resolved.path);
+        const baseName = safeArchiveBaseName(api.basename(resolved.path));
+        const archiveDir = path.join(os.tmpdir(), 'shennian-archives');
+        const outputPath = path.join(archiveDir, `${baseName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.zip`);
+        const result = createZipArchive(resolved.path, outputPath, {
+            maxFiles: MAX_ARCHIVE_FILES,
+            maxTotalSize: MAX_ARCHIVE_TOTAL_SIZE,
+        });
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: true,
+            payload: {
+                sourcePath: resolved.path,
+                outputPath: result.outputPath,
+                entry: makeFsEntry(result.outputPath),
+                fileCount: result.fileCount,
+                totalSize: result.totalSize,
+            },
+        });
+    }
+    catch (err) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 export async function handleFsTransfer(runtime, req) {
     const { name, targetPath, data, direct } = req.params;
     if (!name || !data) {

package/dist/src/session/manager.js

@@ -9,7 +9,7 @@ import { handleAgentConfigClear, handleAgentConfigGet, handleAgentConfigTest, ha
 import { handleChatAbort, handleChatSend } from './handlers/chat.js';
 import { handleSessionRefresh } from './handlers/session-refresh.js';
 import { handleSessionTitleSet } from './handlers/title.js';
-import { cleanupPendingTransfers, handleFsLs, handleFsRead, handleFsRename, handleFsWrite, handleFsTransfer, handleFsTransferAbort, handleFsTransferChunk, handleFsTransferFinish, handleFsTransferStart, handleFsExportMarkdownPdf, } from './handlers/fs.js';
+import { cleanupPendingTransfers, handleFsLs, handleFsRead, handleFsRename, handleFsWrite, handleFsTransfer, handleFsTransferAbort, handleFsTransferChunk, handleFsTransferFinish, handleFsTransferStart, handleFsExportMarkdownPdf, handleFsArchiveZip, } from './handlers/fs.js';
 import { handleSkillDoctor, handleSkillInstall, handleSkillList, handleSkillSetup, handleSkillUse, } from './handlers/skills.js';
 import { handleRegionProbe, handleRegionSwitch, handleUpgradeSetPolicy, } from './handlers/control.js';
 import { ManagerRuntimeService, setManagerRuntimeService } from '../manager/runtime.js';
@@ -124,6 +124,9 @@ export class SessionManager {
                 case 'fs.export.markdown-pdf':
                     await handleFsExportMarkdownPdf(runtime, req);
                     break;
+                case 'fs.archive.zip':
+                    await handleFsArchiveZip(runtime, req);
+                    break;
                 case 'fs.rename':
                     await handleFsRename(runtime, req);
                     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.72",
+  "version": "0.2.74",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {
@@ -33,14 +33,20 @@
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "build": "tsc && node -e \"require('node:fs').chmodSync('dist/bin/shennian.js', 0o755)\"",
+    "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 && node -e \"require('node:fs').chmodSync('dist/bin/shennian.js', 0o755)\"",
+    "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.5"
+    "ws": "^8.18.1"
   },
   "devDependencies": {
     "@types/node": "^20",
@@ -48,10 +54,5 @@
     "@types/ws": "^8.18.1",
     "tsx": "^4.19.4",
     "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "build": "tsc && node -e \"require('node:fs').chmodSync('dist/bin/shennian.js', 0o755)\"",
-    "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 && node -e \"require('node:fs').chmodSync('dist/bin/shennian.js', 0o755)\"",
-    "dev": "tsc --watch"
   }
-}
+}