shennian 0.2.88 → 0.2.89

package/dist/src/session/handlers/tool-detail.js

@@ -0,0 +1,218 @@
+// @arch docs/architecture/data-retention-and-sync-policy.md#tool-结果
+// @test src/__tests__/session-manager.test.ts
+import { readMessages } from '../store.js';
+const DEFAULT_MAX_CHARS = 2_000;
+const MAX_MAX_CHARS = 8_000;
+const SENSITIVE_KEY_RE = /(?:token|api[-_]?key|password|passwd|pwd|secret|authorization|cookie|credential|private[-_]?key)/i;
+const SENSITIVE_ASSIGNMENT_RE = /\b([A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|PASSWD|PWD|AUTH)[A-Z0-9_]*)=("[^"]*"|'[^']*'|[^\s]+)/gi;
+const BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi;
+const OPENAI_KEY_RE = /\bsk-[A-Za-z0-9_-]{12,}\b/g;
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function normalizeDetailRef(value) {
+    if (!value)
+        return null;
+    if (typeof value === 'string') {
+        try {
+            return normalizeDetailRef(JSON.parse(value));
+        }
+        catch {
+            return null;
+        }
+    }
+    const record = asRecord(value);
+    if (!record)
+        return null;
+    const runId = typeof record.runId === 'string' ? record.runId : undefined;
+    const sourceSeq = typeof record.sourceSeq === 'number'
+        ? record.sourceSeq
+        : typeof record.seq === 'number'
+            ? record.seq
+            : undefined;
+    const toolIndex = typeof record.toolIndex === 'number' ? record.toolIndex : undefined;
+    return { ...(runId ? { runId } : {}), ...(sourceSeq != null ? { sourceSeq } : {}), ...(toolIndex != null ? { toolIndex } : {}) };
+}
+function parseRunIdFromMessageId(messageId) {
+    const match = /^agent-(.+)-\d+$/.exec(messageId);
+    return match?.[1] ?? null;
+}
+function parseSeqFromMessageId(messageId) {
+    const match = /^agent-.+-(\d+)$/.exec(messageId);
+    return match ? Number(match[1]) : null;
+}
+function clampMaxChars(value) {
+    const parsed = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_MAX_CHARS;
+    return Math.min(Math.max(200, Math.floor(parsed)), MAX_MAX_CHARS);
+}
+function redactString(value, maxChars) {
+    const redacted = value
+        .replace(SENSITIVE_ASSIGNMENT_RE, '$1=[REDACTED]')
+        .replace(BEARER_RE, 'Bearer [REDACTED]')
+        .replace(OPENAI_KEY_RE, 'sk-[REDACTED]');
+    return redacted.length > maxChars ? `${redacted.slice(0, maxChars)}…` : redacted;
+}
+function sanitizeValue(value, maxChars, depth = 0) {
+    if (value == null)
+        return value;
+    if (typeof value === 'string')
+        return redactString(value, maxChars);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (depth >= 4)
+        return '[Truncated]';
+    if (Array.isArray(value)) {
+        return value.slice(0, 20).map((item) => sanitizeValue(item, maxChars, depth + 1));
+    }
+    if (typeof value === 'object') {
+        const output = {};
+        for (const [key, raw] of Object.entries(value).slice(0, 50)) {
+            if (SENSITIVE_KEY_RE.test(key)) {
+                output[key] = '[REDACTED]';
+                continue;
+            }
+            output[key] = sanitizeValue(raw, maxChars, depth + 1);
+        }
+        return output;
+    }
+    return String(value);
+}
+function extractCommand(args, maxChars) {
+    const record = asRecord(args);
+    const raw = record?.command;
+    if (typeof raw === 'string')
+        return redactString(raw, maxChars);
+    if (Array.isArray(raw)) {
+        const rendered = raw.map((item) => String(item)).join(' ');
+        return redactString(rendered, maxChars);
+    }
+    return undefined;
+}
+function parseLocalToolCandidates(sessionId) {
+    const messages = readMessages(sessionId);
+    const candidates = [];
+    for (const message of messages) {
+        if (message.role !== 'agent' || !message.payload.trim().startsWith('{'))
+            continue;
+        try {
+            const parsed = JSON.parse(message.payload);
+            const type = parsed.type;
+            if (type !== 'tool' && type !== 'tool_use' && type !== 'tool_result')
+                continue;
+            const name = typeof parsed.name === 'string' && parsed.name.trim()
+                ? parsed.name.trim()
+                : 'tool';
+            candidates.push({
+                id: message.id,
+                ts: message.ts,
+                name,
+                args: parsed.args,
+                result: parsed.result,
+                status: type === 'tool_result' || Object.prototype.hasOwnProperty.call(parsed, 'result')
+                    ? 'completed'
+                    : parsed.status === 'completed' || parsed.status === 'failed' || parsed.status === 'running'
+                        ? parsed.status
+                        : 'running',
+                detailRef: normalizeDetailRef(parsed.detailRef),
+            });
+        }
+        catch {
+            // Ignore malformed local transcript lines.
+        }
+    }
+    return candidates;
+}
+function scoreCandidate(candidate, req, detailRef) {
+    let score = 0;
+    if (candidate.id === req.messageId)
+        score += 100;
+    if (req.name && candidate.name === req.name)
+        score += 20;
+    const requestRunId = detailRef?.runId ?? req.runId ?? parseRunIdFromMessageId(req.messageId);
+    const requestSeq = detailRef?.sourceSeq ?? req.sourceSeq ?? parseSeqFromMessageId(req.messageId) ?? undefined;
+    if (requestRunId) {
+        const candidateRunId = candidate.detailRef?.runId ?? parseRunIdFromMessageId(candidate.id);
+        if (candidateRunId === requestRunId)
+            score += 20;
+    }
+    if (requestSeq != null) {
+        const candidateSeq = candidate.detailRef?.sourceSeq ?? parseSeqFromMessageId(candidate.id);
+        if (candidateSeq === requestSeq)
+            score += 80;
+    }
+    if (candidate.args != null)
+        score += 5;
+    return score;
+}
+function findLocalToolDetail(params) {
+    const detailRef = normalizeDetailRef(params.detailRef) ?? normalizeDetailRef({
+        runId: params.runId,
+        sourceSeq: params.sourceSeq,
+        toolIndex: params.toolIndex,
+    });
+    const candidates = parseLocalToolCandidates(params.sessionId);
+    if (candidates.length === 0)
+        return null;
+    const ranked = candidates
+        .map((candidate) => ({ candidate, score: scoreCandidate(candidate, params, detailRef) }))
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score || right.candidate.ts - left.candidate.ts);
+    return ranked[0]?.candidate ?? null;
+}
+export async function handleSessionToolDetail(runtime, req) {
+    const params = req.params;
+    const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
+    const messageId = typeof params.messageId === 'string' ? params.messageId : '';
+    if (!sessionId || !messageId) {
+        runtime.client.sendRes({
+            type: 'res',
+            id: req.id,
+            ok: false,
+            error: 'sessionId and messageId are required',
+        });
+        return;
+    }
+    const request = {
+        sessionId,
+        messageId,
+        ...(typeof params.name === 'string' ? { name: params.name } : {}),
+        ...(typeof params.toolIndex === 'number' ? { toolIndex: params.toolIndex } : {}),
+        ...(typeof params.runId === 'string' ? { runId: params.runId } : {}),
+        ...(typeof params.sourceSeq === 'number' ? { sourceSeq: params.sourceSeq } : {}),
+        ...(params.detailRef !== undefined ? { detailRef: params.detailRef } : {}),
+        maxChars: clampMaxChars(params.maxChars),
+    };
+    const maxChars = clampMaxChars(request.maxChars);
+    const match = findLocalToolDetail(request);
+    if (!match || match.args == null) {
+        const payload = {
+            detailStatus: 'not_found',
+            messageId,
+            toolIndex: request.toolIndex ?? 0,
+            name: request.name,
+            resultOmitted: true,
+            source: 'unavailable',
+            reason: 'tool detail is not available on this machine',
+        };
+        runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload });
+        return;
+    }
+    const argsSummary = match.args == null ? undefined : sanitizeValue(match.args, maxChars);
+    const command = extractCommand(match.args, maxChars);
+    const payload = {
+        detailStatus: 'available',
+        messageId,
+        toolIndex: request.toolIndex ?? 0,
+        name: match.name,
+        status: match.status,
+        ...(argsSummary !== undefined ? { argsSummary } : {}),
+        ...(command ? { command } : {}),
+        resultOmitted: true,
+        source: 'local-session-store',
+    };
+    runtime.client.sendRes({ type: 'res', id: req.id, ok: true, payload });
+}

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

@@ -22,8 +22,11 @@ export declare class SessionManager {
     private pendingTransfers;
     private managerRuntime;
     private chatQueue;
+    private activityProbeTimer;
     constructor(client: CliRelayClient, nativeFusion?: NativeSessionFusionService | null, cliVersion?: string | undefined);
     private getRuntime;
+    private publishSessionActivity;
+    private publishManagedActivitySnapshots;
     private reloadCustomAgents;
     handleReq(req: ReqFrame): Promise<void>;
     private evictIdleSessions;

package/dist/src/session/manager.js

@@ -8,6 +8,7 @@ import { handleAgentsRefresh, handleModelsRefresh } from './handlers/agents.js';
 import { handleAgentConfigClear, handleAgentConfigGet, handleAgentConfigTest, handleAgentConfigUpsert, } from './handlers/agent-config.js';
 import { handleChatAbort, handleChatSend } from './handlers/chat.js';
 import { handleSessionRefresh } from './handlers/session-refresh.js';
+import { handleSessionToolDetail } from './handlers/tool-detail.js';
 import { handleSessionTitleSet } from './handlers/title.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';
@@ -41,6 +42,7 @@ export class SessionManager {
     pendingTransfers = new Map();
     managerRuntime;
     chatQueue;
+    activityProbeTimer = null;
     constructor(client, nativeFusion = null, cliVersion) {
         this.client = client;
         this.nativeFusion = nativeFusion;
@@ -56,6 +58,12 @@ export class SessionManager {
         setManagerRuntimeService(this.managerRuntime);
         void this.managerRuntime.start();
         this.reloadCustomAgents();
+        this.activityProbeTimer = setInterval(() => {
+            void this.publishManagedActivitySnapshots().catch((error) => {
+                console.error('[session.activity] managed probe failed', error);
+            });
+        }, 15_000);
+        this.activityProbeTimer.unref?.();
     }
     getRuntime() {
         return {
@@ -71,8 +79,51 @@ export class SessionManager {
             nativeFusion: this.nativeFusion,
             managerRuntime: this.managerRuntime,
             chatQueue: this.chatQueue,
+            activityPublisher: {
+                publish: (sessionId, activity) => this.publishSessionActivity(sessionId, activity),
+            },
         };
     }
+    publishSessionActivity(sessionId, activity) {
+        this.client.sendEvent({
+            type: 'event',
+            event: 'session.activity',
+            payload: { sessionId, activity },
+        });
+    }
+    async publishManagedActivitySnapshots() {
+        for (const [sessionId, session] of this.sessions.entries()) {
+            if (!session.currentRunId || !session.adapter.getStatus)
+                continue;
+            const status = await session.adapter.getStatus().catch(() => null);
+            if (!status?.active || !status.runPhase)
+                continue;
+            const nowIso = new Date().toISOString();
+            this.publishSessionActivity(sessionId, {
+                sessionId,
+                runId: status.runId || session.currentRunId,
+                runPhase: status.runPhase,
+                startedAt: new Date(session.lastActiveAt).toISOString(),
+                updatedAt: nowIso,
+                canStop: status.canStop ?? true,
+            });
+            const seq = session.heartbeatSeq++;
+            this.client.sendAgentEvent({
+                type: 'event',
+                event: 'agent',
+                payload: {
+                    state: 'heartbeat',
+                    sessionId,
+                    runId: status.runId || session.currentRunId,
+                    seq,
+                    runPhase: status.runPhase,
+                    canStop: status.canStop ?? true,
+                },
+                seq,
+                id: `agent-status-${status.runId || session.currentRunId}-${Date.now()}`,
+            });
+        }
+    }
     reloadCustomAgents() {
         for (const agentType of getRegisteredAgents()) {
             if (agentType.startsWith('custom:')) {
@@ -109,6 +160,9 @@ export class SessionManager {
                 case 'session.refresh':
                     await handleSessionRefresh(runtime, req);
                     break;
+                case 'session.tool.detail':
+                    await handleSessionToolDetail(runtime, req);
+                    break;
                 case 'session.title.set':
                     await handleSessionTitleSet(runtime, req);
                     break;
@@ -245,6 +299,10 @@ export class SessionManager {
         return resolveAuthorizedPath(p, createAuthorizedFsRoot(rootPath));
     }
     cleanup() {
+        if (this.activityProbeTimer) {
+            clearInterval(this.activityProbeTimer);
+            this.activityProbeTimer = null;
+        }
         for (const [, session] of this.sessions) {
             if (session.heartbeatTimer) {
                 clearInterval(session.heartbeatTimer);

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

@@ -48,6 +48,9 @@ export type ChatQueueService = {
     noteTerminal(sessionId: string): void;
     getSnapshot(sessionId: string): import('@shennian/wire').ChatQueueSnapshot;
 };
+export type SessionActivityPublisher = {
+    publish(sessionId: string, activity: import('@shennian/wire').SessionActivitySnapshot | null): void;
+};
 export type SessionManagerRuntime = {
     client: CliRelayClient;
     pendingTransfers: Map<string, PendingTransfer>;
@@ -61,4 +64,5 @@ export type SessionManagerRuntime = {
     nativeFusion: NativeSessionFusionService | null;
     managerRuntime: ManagerRuntimeService | null;
     chatQueue: ChatQueueService | null;
+    activityPublisher?: SessionActivityPublisher | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.88",
+  "version": "0.2.89",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {
@@ -51,7 +51,7 @@
   },
   "scripts": {
     "build": "tsc && node scripts/copy-wechat-rpa-assets.mjs && 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 scripts/copy-wechat-rpa-assets.mjs && 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 scripts/copy-wechat-rpa-assets.mjs && node -e \"require('node:fs').chmodSync('dist/bin/shennian.js', 0o755)\" && node scripts/check-publish-artifact.mjs",
     "dev": "tsc --watch"
   }
 }

package/dist/scripts/wechat-rpa-download-candidates.mjs

@@ -1,105 +0,0 @@
-// @arch docs/features/wechat-rpa-channel.md
-// @test packages/cli/src/__tests__/wechat-rpa-download-candidates.test.ts
-
-import path from 'node:path'
-import { normalizeReplyText } from './wechat-rpa-confirmation.mjs'
-
-export function selectDownloadedAttachment(before, after, startedAt, attachment) {
-  const changed = Array.from(after.values())
-    .filter((file) => file.mtimeMs >= startedAt - 1_000)
-    .filter((file) => isPlausibleDownloadedAttachment(file, attachment))
-    .filter((file) => {
-      const prev = before.get(file.path)
-      return !prev || prev.size !== file.size || prev.mtimeMs !== file.mtimeMs
-    })
-  if (!changed.length) return null
-  const expectedName = normalizeReplyText(attachment?.name || '')
-  return changed
-    .map((file) => {
-      const base = normalizeReplyText(path.basename(file.path))
-      const expectedHead = expectedName.slice(0, Math.min(expectedName.length, 16))
-      const nameScore = expectedHead && base.includes(expectedHead) ? 10 : 0
-      return { ...file, score: nameScore + file.mtimeMs / 1_000_000_000_000 }
-    })
-    .sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs)[0] || null
-}
-
-export function selectCachedAttachment(candidates, attachment) {
-  const expectedName = normalizeReplyText(attachment?.name || '')
-  if (expectedName.length < 4) return null
-  const expectedExt = path.extname(String(attachment?.name || '')).toLowerCase()
-  const expectedHead = expectedName.slice(0, Math.min(expectedName.length, 24))
-  const matched = Array.from(candidates.values())
-    .filter((file) => isPlausibleDownloadedAttachment(file, attachment))
-    .filter((file) => {
-      const base = normalizeReplyText(path.basename(file.path))
-      if (base === expectedName) return true
-      return expectedHead.length >= 8 && base.includes(expectedHead)
-    })
-  if (!matched.length) return null
-  return matched
-    .map((file) => ({
-      ...file,
-      score: (path.extname(file.path).toLowerCase() === expectedExt ? 10 : 0) + file.mtimeMs / 1_000_000_000_000,
-    }))
-    .sort((a, b) => b.score - a.score || b.mtimeMs - a.mtimeMs)[0] || null
-}
-
-const INTERNAL_EXTENSIONS = new Set([
-  '.db',
-  '.ini',
-  '.log',
-  '.plist',
-  '.shm',
-  '.sqlite',
-  '.statistic',
-  '.tmp',
-  '.wal',
-  '.xlog',
-])
-
-const ATTACHMENT_EXTENSIONS = new Set([
-  '.7z',
-  '.aac',
-  '.avi',
-  '.csv',
-  '.doc',
-  '.docx',
-  '.gif',
-  '.heic',
-  '.jpeg',
-  '.jpg',
-  '.key',
-  '.m4a',
-  '.m4v',
-  '.md',
-  '.mov',
-  '.mp3',
-  '.mp4',
-  '.numbers',
-  '.pages',
-  '.pdf',
-  '.png',
-  '.ppt',
-  '.pptx',
-  '.rar',
-  '.rtf',
-  '.txt',
-  '.wav',
-  '.webp',
-  '.xls',
-  '.xlsx',
-  '.zip',
-])
-
-export function isPlausibleDownloadedAttachment(file, attachment) {
-  const base = path.basename(file?.path || '')
-  if (!base || base.startsWith('.')) return false
-  if (!Number.isFinite(file?.size) || file.size <= 0) return false
-  const ext = path.extname(base).toLowerCase()
-  if (!ext || INTERNAL_EXTENSIONS.has(ext)) return false
-  const expectedExt = path.extname(String(attachment?.name || '')).toLowerCase()
-  if (expectedExt && ext !== expectedExt) return false
-  if (ATTACHMENT_EXTENSIONS.has(ext)) return true
-  return Boolean(expectedExt)
-}