nextclaw 0.16.14 → 0.16.15

package/dist/cli/index.js

@@ -6586,6 +6586,7 @@ function createUiNcpAgentHandle(params) {
     basePath: "/api/ncp/agent",
     agentClientEndpoint: createAgentClientFromServer(params.backend),
     streamProvider: params.backend,
+    sessionApi: params.backend,
     listSessionTypes: (describeParams) => {
       params.refreshPluginRuntimeRegistrations();
       return params.runtimeRegistry.listSessionTypes(describeParams);
@@ -6645,95 +6646,6 @@ async function createUiNcpAgent(params) {
   });
 }
 
-// src/cli/commands/ncp/ui-session-service.ts
-function applyLimit(items, limit) {
-  if (!Number.isFinite(limit) || typeof limit !== "number" || limit <= 0) {
-    return items;
-  }
-  return items.slice(0, Math.trunc(limit));
-}
-function now() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function toSessionSummary(params) {
-  return {
-    sessionId: params.sessionId,
-    messageCount: params.messages.length,
-    updatedAt: params.updatedAt,
-    status: "idle",
-    ...params.metadata ? { metadata: structuredClone(params.metadata) } : {}
-  };
-}
-function buildUpdatedMetadata(params) {
-  if (params.patch.metadata === null) {
-    return {};
-  }
-  if (params.patch.metadata) {
-    return structuredClone(params.patch.metadata);
-  }
-  return structuredClone(params.existingMetadata ?? {});
-}
-var UiSessionService = class {
-  sessionStore;
-  constructor(sessionManager, options = {}) {
-    this.sessionStore = new NextclawAgentSessionStore(sessionManager, {
-      onSessionUpdated: options.onSessionUpdated
-    });
-  }
-  async listSessions(options) {
-    const sessions = await this.sessionStore.listSessions();
-    return applyLimit(
-      sessions.map(
-        (session) => toSessionSummary({
-          sessionId: session.sessionId,
-          messages: session.messages,
-          updatedAt: session.updatedAt,
-          metadata: session.metadata
-        })
-      ),
-      options?.limit
-    );
-  }
-  async listSessionMessages(sessionId, options) {
-    const session = await this.sessionStore.getSession(sessionId);
-    if (!session) {
-      return [];
-    }
-    return applyLimit(session.messages.map((message) => structuredClone(message)), options?.limit);
-  }
-  async getSession(sessionId) {
-    const session = await this.sessionStore.getSession(sessionId);
-    if (!session) {
-      return null;
-    }
-    return toSessionSummary({
-      sessionId,
-      messages: session.messages,
-      updatedAt: session.updatedAt,
-      metadata: session.metadata
-    });
-  }
-  async updateSession(sessionId, patch) {
-    const session = await this.sessionStore.getSession(sessionId);
-    if (!session) {
-      return null;
-    }
-    await this.sessionStore.saveSession({
-      sessionId,
-      messages: session.messages.map((message) => structuredClone(message)),
-      updatedAt: now(),
-      metadata: buildUpdatedMetadata({
-        existingMetadata: session.metadata,
-        patch
-      })
-    });
-    return await this.getSession(sessionId);
-  }
-  async deleteSession(sessionId) {
-    await this.sessionStore.deleteSession(sessionId);
-  }
-};
-
 // src/cli/commands/service-gateway-context.ts
 import * as NextclawCore from "@nextclaw/core";
 import { getPluginChannelBindings as getPluginChannelBindings3, resolvePluginChannelMessageToolHints } from "@nextclaw/openclaw-compat";
@@ -8070,10 +7982,11 @@ async function startDeferredGatewayStartup(params) {
           gatewayController: params.gatewayController,
           getConfig: params.getConfig,
           getExtensionRegistry: params.getExtensionRegistry,
-          onSessionUpdated: (sessionKey) => params.uiStartup?.publish({ type: "session.updated", payload: { sessionKey } }),
+          onSessionUpdated: params.publishSessionChange,
           resolveMessageToolHints: ({ channel, accountId }) => params.resolveMessageToolHints({ channel, accountId })
         })
       );
+      params.deferredNcpSessionService.activate(ncpAgent.sessionApi);
       params.onNcpAgentReady(ncpAgent);
       params.uiStartup.deferredNcpAgent.activate(ncpAgent);
       console.log("\u2713 UI NCP agent: ready");
@@ -8105,6 +8018,194 @@ async function runGatewayRuntimeLoop(params) {
   }
 }
 
+// src/cli/commands/ncp/ncp-session-realtime-change.ts
+function toNcpSessionRealtimeEvent(change) {
+  if (change.kind === "upsert") {
+    return {
+      type: "session.summary.upsert",
+      payload: {
+        summary: change.summary
+      }
+    };
+  }
+  return {
+    type: "session.summary.delete",
+    payload: {
+      sessionKey: change.sessionKey
+    }
+  };
+}
+function createNcpSessionRealtimeChangePublisher(params) {
+  return {
+    publishSessionChange: async (sessionKey) => {
+      const normalizedSessionKey = sessionKey.trim();
+      if (!normalizedSessionKey) {
+        return;
+      }
+      const summary = await params.sessionApi.getSession(normalizedSessionKey);
+      params.publishUiEvent?.(
+        toNcpSessionRealtimeEvent(
+          summary ? {
+            kind: "upsert",
+            summary
+          } : {
+            kind: "delete",
+            sessionKey: normalizedSessionKey
+          }
+        )
+      );
+    }
+  };
+}
+
+// src/cli/commands/ncp/ncp-session-summary.ts
+function createNcpSessionSummary(params) {
+  return {
+    sessionId: params.sessionId,
+    messageCount: params.messages.length,
+    updatedAt: params.updatedAt,
+    status: params.status,
+    ...params.metadata ? { metadata: structuredClone(params.metadata) } : {}
+  };
+}
+
+// src/cli/commands/ncp/ui-session-service.ts
+function applyLimit(items, limit) {
+  if (!Number.isFinite(limit) || typeof limit !== "number" || limit <= 0) {
+    return items;
+  }
+  return items.slice(0, Math.trunc(limit));
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function buildUpdatedMetadata(params) {
+  if (params.patch.metadata === null) {
+    return {};
+  }
+  if (params.patch.metadata) {
+    return structuredClone(params.patch.metadata);
+  }
+  return structuredClone(params.existingMetadata ?? {});
+}
+var UiSessionService = class {
+  sessionStore;
+  constructor(sessionManager, options = {}) {
+    this.sessionStore = new NextclawAgentSessionStore(sessionManager, {
+      onSessionUpdated: options.onSessionUpdated
+    });
+  }
+  async listSessions(options) {
+    const sessions = await this.sessionStore.listSessions();
+    return applyLimit(
+      sessions.map(
+        (session) => createNcpSessionSummary({
+          sessionId: session.sessionId,
+          messages: session.messages,
+          updatedAt: session.updatedAt,
+          status: "idle",
+          metadata: session.metadata
+        })
+      ),
+      options?.limit
+    );
+  }
+  async listSessionMessages(sessionId, options) {
+    const session = await this.sessionStore.getSession(sessionId);
+    if (!session) {
+      return [];
+    }
+    return applyLimit(session.messages.map((message) => structuredClone(message)), options?.limit);
+  }
+  async getSession(sessionId) {
+    const session = await this.sessionStore.getSession(sessionId);
+    if (!session) {
+      return null;
+    }
+    return createNcpSessionSummary({
+      sessionId,
+      messages: session.messages,
+      updatedAt: session.updatedAt,
+      status: "idle",
+      metadata: session.metadata
+    });
+  }
+  async updateSession(sessionId, patch) {
+    const session = await this.sessionStore.getSession(sessionId);
+    if (!session) {
+      return null;
+    }
+    await this.sessionStore.saveSession({
+      sessionId,
+      messages: session.messages.map((message) => structuredClone(message)),
+      updatedAt: now(),
+      metadata: buildUpdatedMetadata({
+        existingMetadata: session.metadata,
+        patch
+      })
+    });
+    return await this.getSession(sessionId);
+  }
+  async deleteSession(sessionId) {
+    await this.sessionStore.deleteSession(sessionId);
+  }
+};
+
+// src/cli/commands/service-deferred-ncp-session-service.ts
+function createDeferredUiNcpSessionService(fallbackService) {
+  let activeService = null;
+  const resolveService = () => activeService ?? fallbackService;
+  const service = {
+    listSessions: (options) => resolveService().listSessions(options),
+    listSessionMessages: (sessionId, options) => resolveService().listSessionMessages(sessionId, options),
+    getSession: (sessionId) => resolveService().getSession(sessionId),
+    updateSession: (sessionId, patch) => resolveService().updateSession(sessionId, patch),
+    deleteSession: (sessionId) => resolveService().deleteSession(sessionId)
+  };
+  return {
+    service,
+    activate(nextService) {
+      activeService = nextService;
+    },
+    clear() {
+      activeService = null;
+    },
+    isReady() {
+      return activeService !== null;
+    }
+  };
+}
+
+// src/cli/commands/service-ncp-session-realtime-bridge.ts
+function createServiceNcpSessionRealtimeBridge(params) {
+  let publishUiEvent = params.publishUiEvent;
+  let publishSessionChange = async (_sessionKey) => {
+  };
+  const persistedSessionService = new UiSessionService(params.sessionManager, {
+    onSessionUpdated: (sessionKey) => {
+      void publishSessionChange(sessionKey);
+    }
+  });
+  const deferredSessionService = createDeferredUiNcpSessionService(persistedSessionService);
+  publishSessionChange = async (sessionKey) => {
+    await createNcpSessionRealtimeChangePublisher({
+      sessionApi: deferredSessionService.service,
+      publishUiEvent
+    }).publishSessionChange(sessionKey);
+  };
+  return {
+    sessionService: deferredSessionService.service,
+    deferredSessionService,
+    publishSessionChange,
+    setUiEventPublisher(nextPublishUiEvent) {
+      publishUiEvent = nextPublishUiEvent;
+    },
+    clear() {
+      deferredSessionService.clear();
+    }
+  };
+}
+
 // src/cli/commands/plugin-registry-loader.ts
 import {
   discoverPluginStatusReport,
@@ -8727,7 +8828,7 @@ var ServiceCommands = class {
     };
     let runtimeState = null;
     const bootstrapStatus = createBootstrapStatus(shellContext.config.remote.enabled);
-    const ncpSessionService = new UiSessionService(shellContext.sessionManager, { onSessionUpdated: (sessionKey) => uiStartup?.publish({ type: "session.updated", payload: { sessionKey } }) });
+    const ncpSessionRealtimeBridge = createServiceNcpSessionRealtimeBridge({ sessionManager: shellContext.sessionManager });
     const marketplaceInstaller = new ServiceMarketplaceInstaller({ applyLiveConfigReload, runCliSubcommand: (args) => this.runCliSubcommand(args), installBuiltinSkill: (slug, force) => this.installBuiltinMarketplaceSkill(slug, force) }).createInstaller();
     const remoteAccess = createRemoteAccessHost({ serviceCommands: this, requestRestart: this.deps.requestRestart, uiConfig: shellContext.uiConfig, remoteModule: shellContext.remoteModule });
     const uiStartup = await measureStartupAsync(
@@ -8746,9 +8847,10 @@ var ServiceCommands = class {
         getBootstrapStatus: () => bootstrapStatus.getStatus(),
         openBrowserWindow: shellContext.uiConfig.open,
         applyLiveConfigReload,
-        ncpSessionService
+        ncpSessionService: ncpSessionRealtimeBridge.sessionService
       })
     );
+    ncpSessionRealtimeBridge.setUiEventPublisher(uiStartup?.publish);
     bootstrapStatus.markShellReady();
     await waitForNextTick();
     const gateway = measureStartupSync(
@@ -8770,10 +8872,7 @@ var ServiceCommands = class {
     uiStartup?.publish({ type: "config.updated", payload: { path: "channels" } });
     uiStartup?.publish({ type: "config.updated", payload: { path: "plugins" } });
     configureGatewayPluginRuntime({ gateway, state: gatewayRuntimeState, getLiveUiNcpAgent: () => this.liveUiNcpAgent });
-    wireSystemSessionUpdatedPublisher({
-      runtimePool: gateway.runtimePool,
-      publishUiEvent: uiStartup?.publish
-    });
+    wireSystemSessionUpdatedPublisher({ runtimePool: gateway.runtimePool, publishUiEvent: uiStartup?.publish });
     console.log("\u2713 Capability hydration: scheduled in background");
     await measureStartupAsync(
       "service.start_gateway_support_services",
@@ -8794,15 +8893,14 @@ var ServiceCommands = class {
       setLiveUiNcpAgent: (ncpAgent) => {
         this.liveUiNcpAgent = ncpAgent;
       },
-      wakeFromRestartSentinel: async () => {
-        await this.wakeFromRestartSentinel({ bus: gateway.bus, sessionManager: gateway.sessionManager });
-      }
+      wakeFromRestartSentinel: async () => await this.wakeFromRestartSentinel({ bus: gateway.bus, sessionManager: gateway.sessionManager })
     });
     logStartupTrace("service.start_gateway.runtime_loop_begin");
     await runGatewayRuntimeLoop({
       runtimePool: gateway.runtimePool,
       startDeferredStartup: () => startDeferredGatewayStartup({
         uiStartup,
+        deferredNcpSessionService: ncpSessionRealtimeBridge.deferredSessionService,
         bus: gateway.bus,
         sessionManager: gateway.sessionManager,
         providerManager: gateway.providerManager,
@@ -8820,7 +8918,8 @@ var ServiceCommands = class {
         startPluginGateways: deferredGatewayStartupHooks.startPluginGateways,
         startChannels: deferredGatewayStartupHooks.startChannels,
         wakeFromRestartSentinel: deferredGatewayStartupHooks.wakeFromRestartSentinel,
-        onNcpAgentReady: deferredGatewayStartupHooks.onNcpAgentReady
+        onNcpAgentReady: deferredGatewayStartupHooks.onNcpAgentReady,
+        publishSessionChange: ncpSessionRealtimeBridge.publishSessionChange
       }),
       onDeferredStartupError: (error) => {
         const message = error instanceof Error ? error.message : String(error);
@@ -8833,6 +8932,7 @@ var ServiceCommands = class {
       cleanup: async () => {
         this.applyLiveConfigReload = null;
         this.liveUiNcpAgent = null;
+        ncpSessionRealtimeBridge.clear();
         await uiStartup?.deferredNcpAgent.close();
         await gateway.remoteModule?.stop();
         await stopPluginChannelGateways2(runtimeState?.pluginGatewayHandles ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextclaw",
-  "version": "0.16.14",
+  "version": "0.16.15",
   "description": "Lightweight personal AI assistant with CLI, multi-provider routing, and channel integrations.",
   "private": false,
   "type": "module",
@@ -39,16 +39,16 @@
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "yaml": "^2.8.1",
+    "@nextclaw/core": "0.11.6",
+    "@nextclaw/ncp-toolkit": "0.4.6",
+    "@nextclaw/mcp": "0.1.53",
+    "@nextclaw/remote": "0.1.61",
     "@nextclaw/ncp-agent-runtime": "0.3.0",
+    "@nextclaw/ncp-mcp": "0.1.53",
+    "@nextclaw/server": "0.11.9",
+    "@nextclaw/openclaw-compat": "0.3.43",
     "@nextclaw/ncp": "0.4.0",
-    "@nextclaw/core": "0.11.5",
-    "@nextclaw/ncp-mcp": "0.1.52",
-    "@nextclaw/remote": "0.1.60",
-    "@nextclaw/ncp-toolkit": "0.4.5",
-    "@nextclaw/mcp": "0.1.52",
-    "@nextclaw/runtime": "0.2.19",
-    "@nextclaw/server": "0.11.8",
-    "@nextclaw/openclaw-compat": "0.3.42"
+    "@nextclaw/runtime": "0.2.20"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
@@ -57,7 +57,7 @@
     "tsx": "^4.19.2",
     "typescript": "^5.6.3",
     "vitest": "^2.1.2",
-    "@nextclaw/ui": "0.11.9"
+    "@nextclaw/ui": "0.11.10"
   },
   "scripts": {
     "dev": "tsx watch --tsconfig tsconfig.json src/cli/index.ts",