shennian 0.2.43 → 0.2.47

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

@@ -4,11 +4,65 @@ import os from 'node:os';
 import { createAgent } from '../../agents/adapter.js';
 import { reportLog } from '../../log-reporter.js';
 import { lookupClaudeTranscriptCwd } from '../../native-fusion/parsers.js';
+import { appendMessage, recordSession } from '../store.js';
+import { mergeProjectedSessions } from '../projection.js';
 function extractSummary(text) {
     const newline = text.indexOf('\n');
     const end = newline > 0 ? Math.min(newline, 80) : Math.min(text.length, 80);
     return text.slice(0, end);
 }
+function getNativeSourceAgentType(agentType, modelId) {
+    if (agentType !== 'manager')
+        return agentType;
+    return modelId === 'claude' ? 'claude' : 'codex';
+}
+function sendSessionMessageEvent(runtime, envelope, session) {
+    runtime.client.sendEvent({
+        type: 'event',
+        event: 'session.message',
+        payload: {
+            sessionId: envelope.sessionId,
+            message: envelope,
+            session: {
+                id: envelope.sessionId,
+                agentType: session.agentType,
+                agentSessionId: session.agentSessionId ?? null,
+                modelId: session.modelId ?? null,
+                workDir: session.workDir,
+                status: 'active',
+                ...(session.agentType === 'manager'
+                    ? { externalChannel: runtime.managerRuntime?.getExternalChannelStatus(envelope.sessionId) ?? null }
+                    : {}),
+            },
+        },
+    });
+}
+function sendSessionUpdateEvent(runtime, input) {
+    recordSession({
+        sessionId: input.sessionId,
+        agentType: input.agentType,
+        workDir: input.workDir,
+        agentSessionId: input.agentSessionId ?? null,
+        modelId: input.modelId ?? null,
+    });
+    runtime.client.sendEvent({
+        type: 'event',
+        event: 'session.update',
+        payload: {
+            session: {
+                id: input.sessionId,
+                agentType: input.agentType,
+                agentSessionId: input.agentSessionId ?? null,
+                modelId: input.modelId ?? null,
+                workDir: input.workDir,
+                status: 'active',
+                ...(input.agentType === 'manager'
+                    ? { externalChannel: runtime.managerRuntime?.getExternalChannelStatus(input.sessionId) ?? null }
+                    : {}),
+            },
+        },
+    });
+}
 function maybeResolveClaudeImportedWorkDir(agentType, workDir, agentSessionId) {
     if (agentType !== 'claude')
         return workDir;
@@ -52,6 +106,7 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
             if (event.agentSessionId)
                 activeSession.agentSessionId = event.agentSessionId;
         }
+        runtime.managerRuntime?.noteAgentEvent(sessionId, event);
         if (event.state !== 'delta') {
             reportLog({
                 level: 'info',
@@ -61,13 +116,54 @@ function bindAdapterEvents(runtime, sessionId, agentType, adapter) {
                 metadata: { runId: event.runId, seq: event.seq, agentType },
             });
         }
+        if (event.state === 'delta' && event.text && !event.thinking) {
+            appendMessage(sessionId, {
+                id: `agent-${event.runId}-${event.seq}`,
+                sessionId,
+                role: 'agent',
+                ts: Date.now(),
+                payload: event.text,
+            });
+        }
+        else if (event.state === 'tool-call' || event.state === 'tool-result') {
+            appendMessage(sessionId, {
+                id: `agent-${event.runId}-${event.seq}`,
+                sessionId,
+                role: 'agent',
+                ts: Date.now(),
+                payload: JSON.stringify({
+                    v: 1,
+                    type: event.state === 'tool-call' ? 'tool_use' : 'tool_result',
+                    name: event.name,
+                    args: event.args,
+                    result: event.result,
+                }),
+            });
+        }
+        else if ((event.state === 'error' || event.state === 'aborted') && event.message) {
+            appendMessage(sessionId, {
+                id: `agent-${event.runId || 'run'}-${event.seq}`,
+                sessionId,
+                role: 'agent',
+                ts: Date.now(),
+                payload: event.message,
+            });
+        }
         const runKey = `${sessionId}:${event.runId}`;
         if (event.state === 'delta' && !event.thinking && event.text) {
             runtime.runTextAcc.set(runKey, (runtime.runTextAcc.get(runKey) ?? '') + event.text);
         }
         if (event.agentSessionId && event.agentSessionId !== emittedAgentSessionId) {
             emittedAgentSessionId = event.agentSessionId;
-            runtime.nativeFusion?.noteManagedSourceSession(sessionId, agentType, event.agentSessionId);
+            runtime.nativeFusion?.noteManagedSourceSession(sessionId, getNativeSourceAgentType(agentType, event.source), event.agentSessionId);
+            if (activeSession) {
+                recordSession({
+                    sessionId,
+                    agentType,
+                    workDir: activeSession.workDir,
+                    agentSessionId: event.agentSessionId,
+                });
+            }
             runtime.client.sendEvent({
                 type: 'event',
                 event: 'session.update',
@@ -186,7 +282,8 @@ export async function handleChatSend(runtime, req) {
         return;
     }
     rememberProcessedReqId(runtime, req.id);
-    const { sessionId, text, agentType, workDir, agentSessionId: incomingAgentSid, modelId, clientMessageId } = req.params;
+    const { sessionId, text, agentType, workDir, agentSessionId: incomingAgentSid, modelId, clientMessageId, sessionListProjection } = req.params;
+    mergeProjectedSessions(sessionListProjection);
     if (!sessionId || !text) {
         runtime.processedReqIds.delete(req.id);
         runtime.client.sendRes({ type: 'res', id: req.id, ok: false, error: 'sessionId and text are required' });
@@ -256,15 +353,37 @@ export async function handleChatSend(runtime, req) {
             return;
         }
     }
+    sendSessionUpdateEvent(runtime, {
+        sessionId,
+        agentType: requestedAgentType,
+        workDir: resolvedWorkDir,
+        agentSessionId: session.agentSessionId ?? incomingAgentSid ?? null,
+        modelId,
+    });
     session.currentRunId = null;
     session.nextEventSeq = 0;
     runtime.nativeFusion?.registerManagedSend({
         sessionId,
         agentType: requestedAgentType,
+        sourceAgentType: getNativeSourceAgentType(requestedAgentType, modelId),
         canonicalMessageId: clientMessageId ?? null,
         sourceSessionKey: session.agentSessionId ?? incomingAgentSid ?? null,
         text,
     });
+    const userEnvelope = {
+        id: clientMessageId ?? `user-${req.id}`,
+        sessionId,
+        role: 'user',
+        ts: Date.now(),
+        payload: text,
+    };
+    appendMessage(sessionId, userEnvelope);
+    sendSessionMessageEvent(runtime, userEnvelope, {
+        agentType: requestedAgentType,
+        workDir: resolvedWorkDir,
+        agentSessionId: session.agentSessionId ?? incomingAgentSid ?? null,
+        modelId,
+    });
     reportLog({
         level: 'info',
         sessionId,

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

@@ -4,7 +4,7 @@ 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 currentUrl = config.serverUrl ?? SERVERS.cn.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];

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

@@ -7,6 +7,7 @@ import '../agents/gemini.js';
 import '../agents/cursor.js';
 import '../agents/opencode.js';
 import '../agents/pi.js';
+import '../agents/manager.js';
 export declare function resolveSessionWorkDir(input: string): string;
 export declare class SessionManager {
     private client;
@@ -19,6 +20,7 @@ export declare class SessionManager {
     private runTextAcc;
     /** In-flight chunked uploads: transferId → metadata */
     private pendingTransfers;
+    private managerRuntime;
     constructor(client: CliRelayClient, nativeFusion?: NativeSessionFusionService | null, cliVersion?: string | undefined);
     private getRuntime;
     private reloadCustomAgents;

package/dist/src/session/manager.js

@@ -10,6 +10,7 @@ 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';
+import { ManagerRuntimeService, setManagerRuntimeService } from '../manager/runtime.js';
 // Side-effect imports to register built-in agent adapters.
 import '../agents/claude.js';
 import '../agents/codex.js';
@@ -19,6 +20,7 @@ import '../agents/cursor.js';
 // import '../agents/openclaw.js'
 import '../agents/opencode.js';
 import '../agents/pi.js';
+import '../agents/manager.js';
 import { registerCustomAgent } from '../agents/custom.js';
 const MAX_SESSIONS = 50;
 function isWindowsAbsolutePath(input) {
@@ -58,10 +60,17 @@ export class SessionManager {
     runTextAcc = new Map();
     /** In-flight chunked uploads: transferId → metadata */
     pendingTransfers = new Map();
+    managerRuntime;
     constructor(client, nativeFusion = null, cliVersion) {
         this.client = client;
         this.nativeFusion = nativeFusion;
         this.cliVersion = cliVersion;
+        this.managerRuntime = new ManagerRuntimeService({
+            getRuntime: () => this.getRuntime(),
+            dispatchReq: (req) => this.handleReq(req),
+        });
+        setManagerRuntimeService(this.managerRuntime);
+        void this.managerRuntime.start();
         this.reloadCustomAgents();
     }
     getRuntime() {
@@ -75,6 +84,7 @@ export class SessionManager {
             sessions: this.sessions,
             evictIdleSessions: () => this.evictIdleSessions(),
             nativeFusion: this.nativeFusion,
+            managerRuntime: this.managerRuntime,
         };
     }
     reloadCustomAgents() {
@@ -142,6 +152,10 @@ export class SessionManager {
                 case 'models.refresh':
                     await handleModelsRefresh(runtime, req);
                     break;
+                case 'manager.channel.get':
+                case 'manager.channel.upsert':
+                    await runtime.managerRuntime?.handleAppReq(req);
+                    break;
                 default:
                     this.client.sendRes({ type: 'res', id: req.id, ok: false, error: `Unknown method: ${req.method}` });
             }
@@ -180,5 +194,7 @@ export class SessionManager {
         this.sessions.clear();
         this.runTextAcc.clear();
         cleanupPendingTransfers(this.getRuntime());
+        void this.managerRuntime.stop();
+        setManagerRuntimeService(null);
     }
 }

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

@@ -0,0 +1,3 @@
+import type { SessionListProjection } from '@shennian/wire';
+export declare function listProjectedSessions(): SessionListProjection[];
+export declare function mergeProjectedSessions(sessions: SessionListProjection[] | undefined): void;

package/dist/src/session/projection.js

@@ -0,0 +1,54 @@
+// @arch docs/features/manager-agent.md
+// @test src/__tests__/manager-runtime.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveShennianPath } from '../config/index.js';
+const PROJECTION_FILE = resolveShennianPath('session-list-projection.json');
+function emptyProjection() {
+    return { updatedAt: new Date(0).toISOString(), sessions: {} };
+}
+function readProjectionFile() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(PROJECTION_FILE, 'utf-8'));
+        return {
+            updatedAt: parsed.updatedAt ?? new Date(0).toISOString(),
+            sessions: parsed.sessions ?? {},
+        };
+    }
+    catch {
+        return emptyProjection();
+    }
+}
+function writeProjectionFile(file) {
+    fs.mkdirSync(path.dirname(PROJECTION_FILE), { recursive: true });
+    fs.writeFileSync(PROJECTION_FILE, JSON.stringify(file, null, 2));
+}
+export function listProjectedSessions() {
+    return Object.values(readProjectionFile().sessions);
+}
+export function mergeProjectedSessions(sessions) {
+    if (!sessions?.length)
+        return;
+    try {
+        const file = readProjectionFile();
+        for (const session of sessions) {
+            if (!session?.id)
+                continue;
+            if (session.deletedAt) {
+                delete file.sessions[session.id];
+                continue;
+            }
+            const existing = file.sessions[session.id];
+            const existingMs = Date.parse(existing?.updatedAt ?? existing?.lastActivityAt ?? '');
+            const incomingMs = Date.parse(session.updatedAt ?? session.lastActivityAt ?? '');
+            if (!existing || !Number.isFinite(existingMs) || !Number.isFinite(incomingMs) || incomingMs >= existingMs) {
+                file.sessions[session.id] = session;
+            }
+        }
+        file.updatedAt = new Date().toISOString();
+        writeProjectionFile(file);
+    }
+    catch {
+        // Projection is a local cache. Losing it should not break chat delivery.
+    }
+}

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

@@ -1,4 +1,27 @@
-import type { Envelope } from '@shennian/wire';
+import type { AgentType, Envelope } from '@shennian/wire';
+export type LocalSessionRecord = {
+    sessionId: string;
+    agentType: AgentType;
+    workDir: string;
+    agentSessionId?: string | null;
+    modelId?: string | null;
+    status?: 'active' | 'completed' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+    lastActivityAt: string;
+    lastMessagePreview?: string | null;
+};
+export declare function recordSession(input: {
+    sessionId: string;
+    agentType: AgentType;
+    workDir: string;
+    agentSessionId?: string | null;
+    modelId?: string | null;
+    status?: 'active' | 'completed' | 'failed';
+    lastActivityAt?: string;
+    lastMessagePreview?: string | null;
+}): void;
+export declare function listSessionRecords(): LocalSessionRecord[];
 export declare function appendMessage(sessionId: string, envelope: Envelope): void;
 export declare function readMessages(sessionId: string, opts?: {
     limit?: number;

package/dist/src/session/store.js

@@ -2,16 +2,79 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolveShennianPath } from '../config/index.js';
 const SESSIONS_DIR = resolveShennianPath('sessions');
+const SESSIONS_INDEX_FILE = resolveShennianPath('sessions-index.json');
 function ensureSessionsDir() {
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
 }
 function sessionFile(sessionId) {
     return path.join(SESSIONS_DIR, `${sessionId}.jsonl`);
 }
+function readSessionIndex() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(SESSIONS_INDEX_FILE, 'utf-8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeSessionIndex(index) {
+    fs.mkdirSync(path.dirname(SESSIONS_INDEX_FILE), { recursive: true });
+    fs.writeFileSync(SESSIONS_INDEX_FILE, JSON.stringify(index, null, 2));
+}
+function previewFromEnvelope(envelope) {
+    const text = envelope.payload.replace(/\s+/g, ' ').trim();
+    if (!text || text.startsWith('{"v":1,"type":"tool'))
+        return null;
+    return text.length > 120 ? `${text.slice(0, 120)}...` : text;
+}
+export function recordSession(input) {
+    try {
+        const index = readSessionIndex();
+        const existing = index[input.sessionId];
+        const now = new Date().toISOString();
+        index[input.sessionId] = {
+            sessionId: input.sessionId,
+            agentType: input.agentType,
+            workDir: input.workDir,
+            agentSessionId: input.agentSessionId ?? existing?.agentSessionId ?? null,
+            modelId: input.modelId ?? existing?.modelId ?? null,
+            status: input.status ?? existing?.status ?? 'active',
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+            lastActivityAt: input.lastActivityAt ?? existing?.lastActivityAt ?? now,
+            lastMessagePreview: input.lastMessagePreview ?? existing?.lastMessagePreview ?? null,
+        };
+        writeSessionIndex(index);
+    }
+    catch {
+        // Local session indexing is best-effort; relay delivery remains authoritative.
+    }
+}
+export function listSessionRecords() {
+    return Object.values(readSessionIndex());
+}
 export function appendMessage(sessionId, envelope) {
-    ensureSessionsDir();
-    const line = JSON.stringify(envelope) + '\n';
-    fs.appendFileSync(sessionFile(sessionId), line, 'utf-8');
+    try {
+        ensureSessionsDir();
+        const line = JSON.stringify(envelope) + '\n';
+        fs.appendFileSync(sessionFile(sessionId), line, 'utf-8');
+        const index = readSessionIndex();
+        const existing = index[sessionId];
+        if (existing) {
+            const preview = previewFromEnvelope(envelope);
+            index[sessionId] = {
+                ...existing,
+                updatedAt: new Date().toISOString(),
+                lastActivityAt: new Date(envelope.ts).toISOString(),
+                lastMessagePreview: preview ?? existing.lastMessagePreview ?? null,
+            };
+            writeSessionIndex(index);
+        }
+    }
+    catch {
+        // Local transcript persistence is best-effort; relay delivery remains authoritative.
+    }
 }
 export function readMessages(sessionId, opts) {
     const file = sessionFile(sessionId);

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

@@ -2,6 +2,7 @@ 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';
+import type { ManagerRuntimeService } from '../manager/runtime.js';
 export type ActiveSession = {
     adapter: AgentAdapter;
     workDir: string;
@@ -32,4 +33,5 @@ export type SessionManagerRuntime = {
     sessions: Map<string, ActiveSession>;
     evictIdleSessions: () => void;
     nativeFusion: NativeSessionFusionService | null;
+    managerRuntime: ManagerRuntimeService | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.43",
+  "version": "0.2.47",
   "description": "Shennian — AI Agent Control Plane CLI",
   "type": "module",
   "bin": {
@@ -36,11 +36,11 @@
   "dependencies": {
     "@mariozechner/pi-agent-core": "^0.64.0",
     "@sinclair/typebox": "^0.34.49",
-    "@shennian/wire": "^0.1.3",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "qrcode-terminal": "^0.12.0",
-    "ws": "^8.18.1"
+    "ws": "^8.18.1",
+    "@shennian/wire": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^20",
@@ -50,8 +50,8 @@
     "typescript": "^5.9.3"
   },
   "scripts": {
-    "build": "tsc",
-    "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",
+    "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"
   }
 }