nexus-agentd 0.1.1 → 0.1.7

package/dist/events.js

@@ -20,8 +20,19 @@ export class SessionEventLog {
         if (this.events.length > this.maxEvents) {
             this.events.splice(0, this.events.length - this.maxEvents);
         }
-        for (const listener of this.listeners)
-            listener(structuredClone(event));
+        for (const listener of this.listeners) {
+            try {
+                listener(structuredClone(event));
+            }
+            catch (error) {
+                console.error(JSON.stringify({
+                    level: 'error',
+                    event: 'session_event_listener_failed',
+                    sessionId: this.sessionId,
+                    message: error instanceof Error ? error.message : String(error)
+                }));
+            }
+        }
         return event;
     }
     after(id) {

package/dist/index.d.ts

@@ -1,13 +1,19 @@
 import type { Server } from 'node:http';
+import { AgentdControlPlane } from './control-plane.js';
+import { RunStore } from './run-store.js';
 import { SessionManager } from './session.js';
 export declare function startAgentd(configPath: string): Promise<{
     config: import("./types.js").AgentdConfig;
     server: Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
     sessions: SessionManager;
+    runStore: RunStore;
+    controlPlane: AgentdControlPlane;
     close(): Promise<void>;
 }>;
 export * from './config.js';
+export * from './control-plane.js';
 export * from './server.js';
+export * from './run-store.js';
 export * from './session.js';
 export * from './types.js';
 export * from './workspace.js';

package/dist/index.js

@@ -1,22 +1,32 @@
+import path from 'node:path';
 import { loadAgentdConfig } from './config.js';
+import { AgentdControlPlane } from './control-plane.js';
 import { createDriverRegistry } from './drivers/index.js';
 import { createAgentdServer } from './server.js';
+import { RunStore, runStorePathForConfig } from './run-store.js';
 import { SessionManager } from './session.js';
 import { WorkspacePolicy } from './workspace.js';
 export async function startAgentd(configPath) {
-    const config = await loadAgentdConfig(configPath);
+    const absoluteConfigPath = path.resolve(configPath);
+    const config = await loadAgentdConfig(absoluteConfigPath);
+    const runStore = new RunStore(runStorePathForConfig(absoluteConfigPath), 1000, config.maxRequestBytes);
+    await runStore.init();
     const workspacePolicy = await WorkspacePolicy.create(config.workspaceRoots);
-    const sessions = new SessionManager(config, workspacePolicy, createDriverRegistry(config));
+    const sessions = new SessionManager(config, workspacePolicy, createDriverRegistry(config), runStore);
     sessions.startCleanup();
-    const server = createAgentdServer(config, sessions);
+    const controlPlane = new AgentdControlPlane(absoluteConfigPath, config, sessions);
+    const server = createAgentdServer(config, sessions, controlPlane);
     await listen(server, config.listen.port, config.listen.host);
     return {
         config,
         server,
         sessions,
+        runStore,
+        controlPlane,
         async close() {
             await closeServer(server);
             await sessions.shutdown();
+            await runStore.flush();
         }
     };
 }
@@ -42,7 +52,9 @@ function closeServer(server) {
     });
 }
 export * from './config.js';
+export * from './control-plane.js';
 export * from './server.js';
+export * from './run-store.js';
 export * from './session.js';
 export * from './types.js';
 export * from './workspace.js';

package/dist/run-store.d.ts

@@ -0,0 +1,49 @@
+import type { AgentdProtocol, AgentdRunDetail, AgentdRunView, AgentdSessionState } from './types.js';
+interface StoredRun extends AgentdRunDetail {
+    ownerKeyId: string;
+}
+export interface CreateRunInput {
+    sessionId: string;
+    agentId: string;
+    agentName: string;
+    protocol: AgentdProtocol;
+    workspace?: string;
+    protocolSessionId?: string;
+    ownerKeyId: string;
+    task: string;
+    inputAttachmentCount?: number;
+}
+export interface RunListQuery {
+    agentId?: string;
+    sessionId?: string;
+    state?: AgentdSessionState;
+    query?: string;
+    limit?: number;
+}
+export declare class RunStore {
+    readonly filePath: string;
+    private readonly maxRuns;
+    private readonly maxTaskChars;
+    private readonly runs;
+    private initialized;
+    private dirty;
+    private persistTimer?;
+    private writeQueue;
+    constructor(filePath: string, maxRuns?: number, maxTaskChars?: number);
+    init(): Promise<void>;
+    create(input: CreateRunInput): AgentdRunDetail;
+    update(id: string, patch: Partial<Pick<StoredRun, 'protocolSessionId' | 'state' | 'progress' | 'output' | 'error' | 'artifacts' | 'artifactCount' | 'updatedAt' | 'endedAt' | 'durationMs' | 'inputAttachmentCount'>>): AgentdRunDetail | undefined;
+    get(id: string): AgentdRunDetail | undefined;
+    list(query?: RunListQuery): {
+        runs: AgentdRunView[];
+        total: number;
+    };
+    flush(): Promise<void>;
+    private load;
+    private changed;
+    private prune;
+    private persist;
+    private assertInitialized;
+}
+export declare function runStorePathForConfig(configPath: string): string;
+export {};

package/dist/run-store.js

@@ -0,0 +1,291 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const STATES = new Set([
+    'created',
+    'running',
+    'input_required',
+    'permission_required',
+    'completed',
+    'failed',
+    'canceled'
+]);
+const MAX_OUTPUT_CHARS = 256 * 1024;
+const MAX_SUMMARY_CHARS = 600;
+export class RunStore {
+    filePath;
+    maxRuns;
+    maxTaskChars;
+    runs = new Map();
+    initialized = false;
+    dirty = false;
+    persistTimer;
+    writeQueue = Promise.resolve();
+    constructor(filePath, maxRuns = 1000, maxTaskChars = 1024 * 1024) {
+        this.filePath = filePath;
+        this.maxRuns = maxRuns;
+        this.maxTaskChars = maxTaskChars;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        await mkdir(path.dirname(this.filePath), { recursive: true });
+        try {
+            const raw = await readFile(this.filePath, 'utf8');
+            this.load(raw);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                if (error instanceof SyntaxError || error instanceof InvalidRunFileError) {
+                    const backup = `${this.filePath}.corrupt-${Date.now()}`;
+                    await rename(this.filePath, backup);
+                    console.error(JSON.stringify({
+                        level: 'error',
+                        event: 'run_history_recovered',
+                        file: this.filePath,
+                        backup,
+                        message: error.message
+                    }));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        this.initialized = true;
+        const now = Date.now();
+        for (const [id, run] of this.runs) {
+            if (!isActive(run.state))
+                continue;
+            this.runs.set(id, {
+                ...run,
+                state: 'failed',
+                error: 'Gateway restarted before the task finished.',
+                progress: { phase: '已中断', message: '网关重启前任务尚未结束' },
+                updatedAt: now,
+                endedAt: now,
+                durationMs: Math.max(0, now - run.startedAt)
+            });
+            this.dirty = true;
+        }
+        this.prune();
+        if (!(await fileExists(this.filePath)))
+            this.dirty = true;
+        if (this.dirty)
+            await this.flush();
+    }
+    create(input) {
+        this.assertInitialized();
+        const now = Date.now();
+        const taskTruncated = input.task.length > this.maxTaskChars;
+        const run = {
+            id: randomUUID(),
+            sessionId: input.sessionId,
+            agentId: input.agentId,
+            agentName: input.agentName,
+            protocol: input.protocol,
+            workspace: input.workspace,
+            protocolSessionId: input.protocolSessionId,
+            ownerKeyId: input.ownerKeyId,
+            task: taskTruncated ? input.task.slice(0, this.maxTaskChars) : input.task,
+            taskTruncated: taskTruncated || undefined,
+            inputAttachmentCount: input.inputAttachmentCount || undefined,
+            state: 'running',
+            progress: { phase: '已接收', message: '任务已交给智能体' },
+            artifacts: [],
+            artifactCount: 0,
+            startedAt: now,
+            updatedAt: now
+        };
+        this.runs.set(run.id, run);
+        this.changed();
+        return publicDetail(run);
+    }
+    update(id, patch) {
+        this.assertInitialized();
+        const current = this.runs.get(id);
+        if (!current)
+            return undefined;
+        const output = patch.output === undefined
+            ? current.output
+            : clipTail(patch.output, MAX_OUTPUT_CHARS);
+        const updatedAt = patch.updatedAt ?? Date.now();
+        const next = {
+            ...current,
+            ...structuredClone(patch),
+            output,
+            resultSummary: output ? summarize(output) : current.resultSummary,
+            updatedAt
+        };
+        if (patch.endedAt !== undefined) {
+            next.durationMs = Math.max(0, patch.endedAt - next.startedAt);
+        }
+        this.runs.delete(id);
+        this.runs.set(id, next);
+        this.changed();
+        return publicDetail(next);
+    }
+    get(id) {
+        this.assertInitialized();
+        const run = this.runs.get(id);
+        return run ? publicDetail(run) : undefined;
+    }
+    list(query = {}) {
+        this.assertInitialized();
+        const needle = String(query.query || '').trim().toLowerCase();
+        const limit = Math.min(200, Math.max(1, Number(query.limit) || 50));
+        const matched = Array.from(this.runs.values())
+            .reverse()
+            .filter((run) => !query.agentId || run.agentId === query.agentId)
+            .filter((run) => !query.sessionId || run.sessionId === query.sessionId)
+            .filter((run) => !query.state || run.state === query.state)
+            .filter((run) => !needle ||
+            run.task.toLowerCase().includes(needle) ||
+            run.agentName.toLowerCase().includes(needle) ||
+            run.id.toLowerCase().includes(needle));
+        const total = matched.length;
+        const runs = matched.slice(0, limit).map(publicView);
+        return { runs, total };
+    }
+    async flush() {
+        this.assertInitialized();
+        if (this.persistTimer)
+            clearTimeout(this.persistTimer);
+        this.persistTimer = undefined;
+        if (this.dirty)
+            await this.persist();
+        await this.writeQueue;
+    }
+    load(raw) {
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            typeof parsed !== 'object' ||
+            Array.isArray(parsed) ||
+            parsed.schemaVersion !== 1 ||
+            !Array.isArray(parsed.runs)) {
+            throw new InvalidRunFileError('Invalid Agent Nexus run history file');
+        }
+        for (const value of parsed.runs) {
+            const run = normalizeRun(value);
+            if (run)
+                this.runs.set(run.id, run);
+        }
+    }
+    changed() {
+        this.dirty = true;
+        this.prune();
+        if (this.persistTimer)
+            return;
+        this.persistTimer = setTimeout(() => {
+            this.persistTimer = undefined;
+            void this.persist().catch((error) => {
+                console.error(JSON.stringify({
+                    level: 'error',
+                    event: 'run_history_write_failed',
+                    message: error instanceof Error ? error.message : String(error)
+                }));
+            });
+        }, 250);
+        this.persistTimer.unref?.();
+    }
+    prune() {
+        while (this.runs.size > this.maxRuns) {
+            const terminal = Array.from(this.runs.entries()).find(([, run]) => !isActive(run.state));
+            if (!terminal)
+                break;
+            this.runs.delete(terminal[0]);
+            this.dirty = true;
+        }
+    }
+    persist() {
+        if (!this.dirty)
+            return this.writeQueue;
+        this.dirty = false;
+        const payload = {
+            schemaVersion: 1,
+            runs: Array.from(this.runs.values()).map((run) => structuredClone(run))
+        };
+        const serialized = `${JSON.stringify(payload, null, 2)}\n`;
+        const write = async () => {
+            const temp = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+            await writeFile(temp, serialized, { encoding: 'utf8', mode: 0o600 });
+            await rename(temp, this.filePath);
+            await chmod(this.filePath, 0o600).catch(() => undefined);
+        };
+        const next = this.writeQueue.then(write, write).catch((error) => {
+            this.dirty = true;
+            throw error;
+        });
+        this.writeQueue = next.catch(() => undefined);
+        return next;
+    }
+    assertInitialized() {
+        if (!this.initialized)
+            throw new Error('RunStore is not initialized');
+    }
+}
+export function runStorePathForConfig(configPath) {
+    const absolute = path.resolve(configPath);
+    const extension = path.extname(absolute);
+    const basename = path.basename(absolute, extension);
+    return path.join(path.dirname(absolute), `${basename}-runs.json`);
+}
+function normalizeRun(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const run = value;
+    if (typeof run.id !== 'string' ||
+        typeof run.sessionId !== 'string' ||
+        typeof run.agentId !== 'string' ||
+        typeof run.agentName !== 'string' ||
+        (run.protocol !== 'acp' && run.protocol !== 'a2a') ||
+        typeof run.ownerKeyId !== 'string' ||
+        typeof run.task !== 'string' ||
+        !STATES.has(run.state) ||
+        !run.progress ||
+        typeof run.progress.phase !== 'string' ||
+        !Number.isFinite(run.startedAt) ||
+        !Number.isFinite(run.updatedAt)) {
+        return undefined;
+    }
+    return {
+        ...structuredClone(run),
+        artifacts: Array.isArray(run.artifacts) ? structuredClone(run.artifacts) : [],
+        artifactCount: Number.isFinite(run.artifactCount) ? run.artifactCount : 0
+    };
+}
+function publicView(run) {
+    const { ownerKeyId: _ownerKeyId, output: _output, artifacts: _artifacts, ...view } = run;
+    return structuredClone(view);
+}
+function publicDetail(run) {
+    const { ownerKeyId: _ownerKeyId, ...detail } = run;
+    return structuredClone(detail);
+}
+function summarize(value) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    return compact.length > MAX_SUMMARY_CHARS
+        ? `${compact.slice(0, MAX_SUMMARY_CHARS)}…`
+        : compact;
+}
+function clipTail(value, max) {
+    return value.length <= max
+        ? value
+        : `…[truncated by Agent Nexus]\n${value.slice(-max)}`;
+}
+function isActive(state) {
+    return state === 'running' || state === 'input_required' || state === 'permission_required';
+}
+async function fileExists(filePath) {
+    try {
+        await readFile(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+class InvalidRunFileError extends Error {
+}

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import http from 'node:http';
-import type { AgentdConfig } from './types.js';
+import { type AgentdControlPlane } from './control-plane.js';
 import { SessionManager } from './session.js';
-export declare function createAgentdServer(config: AgentdConfig, sessions: SessionManager): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+import type { AgentdConfig } from './types.js';
+export declare function createAgentdServer(config: AgentdConfig, sessions: SessionManager, controlPlane?: AgentdControlPlane): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;