@myagentroam/node 0.9.8 → 0.9.9

package/dist/connector.d.ts

@@ -68,6 +68,7 @@ export declare class NodeConnector {
     private readonly workspaceChangeService;
     private readonly workspaceWorkbenchService;
     private database;
+    private readonly recentRunProjectionService;
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
     private readonly runtime;
     private readonly metrics;

package/dist/connector.js

@@ -30,6 +30,7 @@ import { WorkspaceChangeService } from './service/workspace-change-service.js';
 import { WorkspaceSessionService } from './service/workspace-session-service.js';
 import { WorkbenchEventService } from './service/workbench-event-service.js';
 import { RunDomainState } from './service/run-domain-state.js';
+import { RecentRunProjectionService } from './service/recent-run-projection-service.js';
 import { SessionDomainState } from './service/session-domain-state.js';
 import { RunEventService } from './service/run-event-service.js';
 import { RunAttachmentService } from './service/run-attachment-service.js';
@@ -166,8 +167,9 @@ export class NodeConnector {
     workspaceChangeService = new WorkspaceChangeService(this.workspaceState);
     workspaceWorkbenchService;
     database;
+    recentRunProjectionService = new RecentRunProjectionService((message) => this.send('recent-runs', message));
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
-    runtime = new NodeRuntimeState(() => this.config?.nodeId ?? 'runtime-node', (workspaceId) => this.database?.getWorkspace(workspaceId));
+    runtime = new NodeRuntimeState(() => this.config?.nodeId ?? 'runtime-node', (workspaceId) => this.database?.getWorkspace(workspaceId), Date.now, (run, session) => this.recentRunProjectionService.record(run, session));
     metrics = new NodeMetrics();
     runEventService = new RunEventService({
         runtime: this.runtime,
@@ -684,7 +686,8 @@ export class NodeConnector {
             terminal: this.terminalChannel,
             metrics: this.metrics,
             heartbeatMs: HEARTBEAT_MS,
-            refreshMs: CAPABILITY_REFRESH_MS
+            refreshMs: CAPABILITY_REFRESH_MS,
+            onConnected: () => this.recentRunProjectionService.publishSnapshot()
         });
         const requireDatabase = () => {
             if (this.database === undefined)
@@ -763,6 +766,7 @@ export class NodeConnector {
     }
     stop() {
         this.stopped = true;
+        this.recentRunProjectionService.dispose();
         this.upgradeCoordinator.stop();
         this.connectionLifecycle.stop();
         for (const approval of this.claudeClient.execution.approvals.values()) {

package/dist/runtime-state.d.ts

@@ -10,6 +10,8 @@ export declare class NodeRuntimeState {
     private readonly nodeId;
     private readonly getWorkspace;
     private readonly now;
+    private readonly onRunChanged?;
+    private static readonly MAX_RUN_EVENTS_PER_RUN;
     private static readonly MAX_COMPLETED_TURNS_PER_SESSION;
     private readonly sessions;
     private readonly runs;
@@ -26,7 +28,7 @@ export declare class NodeRuntimeState {
     /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
     private readonly terminalRunIds;
     private nextEventId;
-    constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number);
+    constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number, onRunChanged?: ((run: NodeAgentRun, session: NodeAgentSession) => void) | undefined);
     activeWorkspaceLeaseCount(): number;
     activeSessionRun(sessionId: string): NodeAgentRun | undefined;
     hasActiveSessionLease(sessionId: string): boolean;

package/dist/runtime-state.js

@@ -9,6 +9,8 @@ export class NodeRuntimeState {
     nodeId;
     getWorkspace;
     now;
+    onRunChanged;
+    static MAX_RUN_EVENTS_PER_RUN = 100;
     static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
@@ -25,10 +27,11 @@ export class NodeRuntimeState {
     /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
     terminalRunIds = new Set();
     nextEventId = 1;
-    constructor(nodeId, getWorkspace, now = Date.now) {
+    constructor(nodeId, getWorkspace, now = Date.now, onRunChanged) {
         this.nodeId = nodeId;
         this.getWorkspace = getWorkspace;
         this.now = now;
+        this.onRunChanged = onRunChanged;
     }
     activeWorkspaceLeaseCount() {
         return this.leases.size;
@@ -118,6 +121,7 @@ export class NodeRuntimeState {
         };
         this.runs.set(run.id, run);
         this.leases.set(run.sessionId, run.id);
+        this.onRunChanged?.(run, session);
         return run;
     }
     getAgentSession(id) {
@@ -322,6 +326,7 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(session.id);
         this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
         this.replaceSession(session.id, { lastActivityAt: now });
+        this.onRunChanged?.(run, this.requireSession(session.id));
         return { run, created: true };
     }
     sessionQueue(sessionId) {
@@ -434,6 +439,7 @@ export class NodeRuntimeState {
             throw new Error('RUN_STATE_INVALID');
         const value = { ...current, status: next, version: current.version + 1, updatedAt: this.now() };
         this.runs.set(id, value);
+        this.onRunChanged?.(value, this.requireSession(value.sessionId));
         if (terminal(next) && this.leases.get(value.sessionId) === value.id)
             this.leases.delete(value.sessionId);
         this.updateTurnForRun(id, (turn) => ({
@@ -464,7 +470,7 @@ export class NodeRuntimeState {
             ...(input.status === undefined ? {} : { status: input.status }),
             createdAt: this.now()
         };
-        this.events.set(input.runId, [...prior, value]);
+        this.events.set(input.runId, [...prior, value].slice(-NodeRuntimeState.MAX_RUN_EVENTS_PER_RUN));
         if (input.status !== undefined)
             this.transitionRun(input.runId, input.status);
         this.projectEvent(value);
@@ -714,6 +720,9 @@ export class NodeRuntimeState {
         const value = this.requireSession(id);
         const next = { ...value, ...patch };
         this.sessions.set(id, next);
+        if (value.customTitle !== next.customTitle || value.runnerTitle !== next.runnerTitle)
+            for (const run of this.listRunsForSession(id))
+                this.onRunChanged?.(run, next);
         return next;
     }
     bumpQueueVersion(sessionId) {

package/dist/service/node-connection-lifecycle-service.d.ts

@@ -17,6 +17,7 @@ interface NodeConnectionLifecycleServiceOptions {
     readonly metrics: NodeMetrics;
     readonly heartbeatMs: number;
     readonly refreshMs: number;
+    readonly onConnected?: () => void;
 }
 /** Owns registration completion, heartbeat and background capability refresh timers. */
 export declare class NodeConnectionLifecycleService {

package/dist/service/node-connection-lifecycle-service.js

@@ -47,6 +47,7 @@ export class NodeConnectionLifecycleService {
         this.options.control.send('capabilities', this.options.capabilities());
         this.options.terminal.connect();
         this.options.control.send('heartbeat', {});
+        this.options.onConnected?.();
         this.options.metrics.heartbeatSent();
         this.heartbeat = setInterval(() => {
             this.options.metrics.heartbeatSent();

package/dist/service/recent-run-projection-service.d.ts

@@ -0,0 +1,14 @@
+import type { NodeAgentRun, NodeAgentSession } from '../database.js';
+import type { RecentRunProjection, RecentRunProjectionMessage } from '@myagentroam/protocol';
+export declare class RecentRunProjectionService {
+    private readonly emit;
+    private readonly now;
+    private readonly runs;
+    private readonly cleanupTimer;
+    constructor(emit: (message: RecentRunProjectionMessage) => void, now?: () => number);
+    record(run: NodeAgentRun, session: NodeAgentSession): void;
+    snapshot(): readonly RecentRunProjection[];
+    publishSnapshot(): void;
+    dispose(): void;
+    private cleanup;
+}

package/dist/service/recent-run-projection-service.js

@@ -0,0 +1,78 @@
+const TERMINAL_TTL_MS = 12 * 60 * 60_000;
+const CLEANUP_INTERVAL_MS = 5 * 60_000;
+const TERMINAL_LIMIT = 100;
+export class RecentRunProjectionService {
+    emit;
+    now;
+    runs = new Map();
+    cleanupTimer;
+    constructor(emit, now = Date.now) {
+        this.emit = emit;
+        this.now = now;
+        this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+        this.cleanupTimer.unref();
+    }
+    record(run, session) {
+        if (!Number.isSafeInteger(run.initiatedByUserId) || run.initiatedByUserId === undefined)
+            return;
+        const existing = this.runs.get(run.id);
+        if (existing !== undefined && existing.version > run.version)
+            return;
+        const startedAt = existing?.startedAt ?? (run.status === 'QUEUED' ? null : run.updatedAt);
+        const completedAt = terminal(run.status) ? (existing?.completedAt ?? run.updatedAt) : null;
+        const projection = {
+            runId: run.id,
+            nodeId: run.nodeId,
+            workspaceId: run.workspaceId,
+            sessionId: run.sessionId,
+            sessionTitle: session.customTitle ?? session.runnerTitle ?? session.id,
+            runner: run.runner,
+            status: run.status,
+            createdAt: run.createdAt,
+            startedAt,
+            completedAt,
+            sortAt: startedAt ?? run.createdAt,
+            updatedAt: run.updatedAt,
+            version: run.version,
+            userId: run.initiatedByUserId
+        };
+        this.runs.set(run.id, projection);
+        this.cleanup();
+        this.emit({ kind: 'UPDATE', run: projection });
+    }
+    snapshot() {
+        this.cleanup();
+        return [...this.runs.values()].sort(compareRecentRuns);
+    }
+    publishSnapshot() {
+        this.emit({ kind: 'SNAPSHOT', runs: [...this.snapshot()] });
+    }
+    dispose() {
+        clearInterval(this.cleanupTimer);
+    }
+    cleanup() {
+        const cutoff = this.now() - TERMINAL_TTL_MS;
+        for (const [runId, run] of this.runs)
+            if (run.completedAt !== null && run.completedAt <= cutoff)
+                this.runs.delete(runId);
+        const byUser = new Map();
+        for (const run of this.runs.values()) {
+            if (run.completedAt === null)
+                continue;
+            const values = byUser.get(run.userId) ?? [];
+            values.push(run);
+            byUser.set(run.userId, values);
+        }
+        for (const values of byUser.values())
+            for (const run of values.sort(compareRecentRuns).slice(TERMINAL_LIMIT))
+                this.runs.delete(run.runId);
+    }
+}
+function compareRecentRuns(left, right) {
+    return (right.sortAt - left.sortAt ||
+        right.createdAt - left.createdAt ||
+        right.runId.localeCompare(left.runId));
+}
+function terminal(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.8"
+    "@myagentroam/protocol": "^0.9.9"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"