@nextclaw/kernel 0.1.2-beta.1 → 0.1.2-beta.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { a as getUnsignedUpdateManifest, c as UpdateBlockReason, d as UpdateSnapshot, f as UpdateStatus, i as UpdateManifestReader, l as UpdatePreferences, n as UpdateHostKind, o as serializeUnsignedUpdateManifest, r as UpdateManifest, s as InstallationKind, t as UnsignedUpdateManifest, u as UpdateProgress } from "./update-manifest.types-BAJqcsP5.js";
-import { NcpMessage } from "@nextclaw/ncp";
+import { NcpMessage, NcpSessionSummary } from "@nextclaw/ncp";
 
 //#region src/types/entity-ids.types.d.ts
 type AgentId = string;
@@ -284,4 +284,149 @@ declare class NextclawKernel<TGatewayInput = unknown, TUiInput = unknown, TStart
   readonly run: (input: NextclawKernelRunInput) => NextclawKernelRun;
 }
 //#endregion
-export { AgentId, AgentManager, AgentRecord, AutomationId, AutomationManager, AutomationRecord, AutomationTrigger, ChannelDirection, ChannelId, ChannelManager, ChannelRecord, ContextBuilder, ContextRecord, InstallationKind, LlmProviderId, LlmProviderManager, LlmProviderRecord, NextclawKernel, NextclawKernelRun, NextclawKernelRunInput, NextclawKernelRunMetadata, SessionId, SessionManager, SessionMessage, SessionRecord, SkillId, SkillManager, SkillRecord, TaskId, TaskManager, TaskRecord, TaskStatus, ToolId, ToolManager, ToolRecord, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, getUnsignedUpdateManifest, serializeUnsignedUpdateManifest };
+//#region src/events/event-bus.types.d.ts
+type AppEventKey<T> = {
+  readonly id: string;
+  readonly _type?: T;
+};
+type AppEventSource = "backend" | "realtime" | "local";
+type AppEventEnvelope<T = unknown> = {
+  type: string;
+  payload: T;
+  emittedAt?: string;
+  source?: AppEventSource;
+};
+type AppEventEmitOptions = {
+  emittedAt?: string;
+  source?: AppEventSource;
+};
+type AppEventHandler<T> = (payload: T, envelope: AppEventEnvelope<T>) => void;
+type EventBusOptions = {
+  onListenerError?: (params: {
+    type: string;
+    payload: unknown;
+    error: unknown;
+  }) => void;
+};
+type ConfigUpdatedEvent = AppEventEnvelope<{
+  path: string;
+}> & {
+  type: "config.updated";
+};
+type ChannelConfigApplyStatusEvent = AppEventEnvelope<{
+  channel: string;
+  status: "started" | "succeeded" | "failed";
+  message?: string;
+}> & {
+  type: "channel.config.apply-status";
+};
+type SessionUpdatedEvent = AppEventEnvelope<{
+  sessionKey: string;
+}> & {
+  type: "session.updated";
+};
+type SessionRunStatusEvent = AppEventEnvelope<{
+  sessionKey: string;
+  status: "running" | "idle";
+}> & {
+  type: "session.run-status";
+};
+type SessionSummaryUpsertEvent = AppEventEnvelope<{
+  summary: NcpSessionSummary;
+}> & {
+  type: "session.summary.upsert";
+};
+type SessionSummaryDeleteEvent = AppEventEnvelope<{
+  sessionKey: string;
+}> & {
+  type: "session.summary.delete";
+};
+type ConfigReloadStartedEvent = AppEventEnvelope<Record<string, unknown> | undefined> & {
+  type: "config.reload.started";
+};
+type ConfigReloadFinishedEvent = AppEventEnvelope<Record<string, unknown> | undefined> & {
+  type: "config.reload.finished";
+};
+type ErrorEvent = AppEventEnvelope<{
+  message: string;
+  code?: string;
+}> & {
+  type: "error";
+};
+type ConnectionOpenEvent = AppEventEnvelope<Record<string, never> | undefined> & {
+  type: "connection.open";
+};
+type ConnectionCloseEvent = AppEventEnvelope<Record<string, never> | undefined> & {
+  type: "connection.close";
+};
+type ConnectionErrorEvent = AppEventEnvelope<{
+  message?: string;
+} | undefined> & {
+  type: "connection.error";
+};
+type RuntimeUpdateSnapshotEvent = AppEventEnvelope<UpdateSnapshot> & {
+  type: "runtime.update.snapshot";
+};
+type AppEvent = ConfigUpdatedEvent | ChannelConfigApplyStatusEvent | SessionUpdatedEvent | SessionRunStatusEvent | SessionSummaryUpsertEvent | SessionSummaryDeleteEvent | ConfigReloadStartedEvent | ConfigReloadFinishedEvent | ErrorEvent | ConnectionOpenEvent | ConnectionCloseEvent | ConnectionErrorEvent | RuntimeUpdateSnapshotEvent;
+//#endregion
+//#region src/events/event-bus.service.d.ts
+declare class EventBus {
+  private readonly listeners;
+  private readonly globalListeners;
+  private readonly onListenerError?;
+  constructor(options?: EventBusOptions);
+  emit: <T>(key: AppEventKey<T>, payload: T, options?: AppEventEmitOptions) => void;
+  emitEnvelope: <T>(event: AppEventEnvelope<T>) => void;
+  on: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => (() => void);
+  off: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => void;
+  once: <T>(key: AppEventKey<T>, handler: AppEventHandler<T>) => (() => void);
+  subscribeAll: (handler: (event: AppEventEnvelope) => void) => (() => void);
+  private safeInvokeListener;
+  private safeInvokeGlobalListener;
+}
+//#endregion
+//#region src/app/nextclaw-app.service.d.ts
+type NextClawApp = {
+  readonly eventBus: EventBus;
+};
+declare const nextclaw: NextClawApp;
+//#endregion
+//#region src/events/event.keys.d.ts
+declare function createAppEventKey<T>(id: string): AppEventKey<T>;
+declare const eventKeys: {
+  readonly configUpdated: AppEventKey<{
+    path: string;
+  }>;
+  readonly channelConfigApplyStatus: AppEventKey<{
+    channel: string;
+    status: "started" | "succeeded" | "failed";
+    message?: string;
+  }>;
+  readonly sessionUpdated: AppEventKey<{
+    sessionKey: string;
+  }>;
+  readonly sessionRunStatus: AppEventKey<{
+    sessionKey: string;
+    status: "running" | "idle";
+  }>;
+  readonly sessionSummaryUpsert: AppEventKey<{
+    summary: NcpSessionSummary;
+  }>;
+  readonly sessionSummaryDelete: AppEventKey<{
+    sessionKey: string;
+  }>;
+  readonly configReloadStarted: AppEventKey<Record<string, unknown> | undefined>;
+  readonly configReloadFinished: AppEventKey<Record<string, unknown> | undefined>;
+  readonly error: AppEventKey<{
+    message: string;
+    code?: string;
+  }>;
+  readonly connectionOpen: AppEventKey<Record<string, never> | undefined>;
+  readonly connectionClose: AppEventKey<Record<string, never> | undefined>;
+  readonly connectionError: AppEventKey<{
+    message?: string;
+  } | undefined>;
+  readonly runtimeUpdateSnapshot: AppEventKey<UpdateSnapshot>;
+};
+//#endregion
+export { AgentId, AgentManager, AgentRecord, type AppEvent, type AppEventEmitOptions, type AppEventEnvelope, type AppEventHandler, type AppEventKey, type AppEventSource, AutomationId, AutomationManager, AutomationRecord, AutomationTrigger, type ChannelConfigApplyStatusEvent, ChannelDirection, ChannelId, ChannelManager, ChannelRecord, type ConfigReloadFinishedEvent, type ConfigReloadStartedEvent, type ConfigUpdatedEvent, type ConnectionCloseEvent, type ConnectionErrorEvent, type ConnectionOpenEvent, ContextBuilder, ContextRecord, type ErrorEvent, EventBus, type EventBusOptions, InstallationKind, LlmProviderId, LlmProviderManager, LlmProviderRecord, NextClawApp, NextclawKernel, NextclawKernelRun, NextclawKernelRunInput, NextclawKernelRunMetadata, type RuntimeUpdateSnapshotEvent, SessionId, SessionManager, SessionMessage, SessionRecord, type SessionRunStatusEvent, type SessionSummaryDeleteEvent, type SessionSummaryUpsertEvent, type SessionUpdatedEvent, SkillId, SkillManager, SkillRecord, TaskId, TaskManager, TaskRecord, TaskStatus, ToolId, ToolManager, ToolRecord, UnsignedUpdateManifest, UpdateBlockReason, UpdateHostKind, UpdateManifest, UpdateManifestReader, UpdatePreferences, UpdateProgress, UpdateSnapshot, UpdateStatus, createAppEventKey, eventKeys, getUnsignedUpdateManifest, nextclaw, serializeUnsignedUpdateManifest };

package/dist/index.js

@@ -249,4 +249,102 @@ var NextclawKernel = class {
 	};
 };
 //#endregion
-export { AgentManager, AutomationManager, ChannelManager, ContextBuilder, LlmProviderManager, NextclawKernel, SessionManager, SkillManager, TaskManager, ToolManager, UpdateManifestReader, getUnsignedUpdateManifest, serializeUnsignedUpdateManifest };
+//#region src/events/event-bus.service.ts
+var EventBus = class {
+	listeners = /* @__PURE__ */ new Map();
+	globalListeners = /* @__PURE__ */ new Set();
+	onListenerError;
+	constructor(options = {}) {
+		this.onListenerError = options.onListenerError;
+	}
+	emit = (key, payload, options = {}) => {
+		const envelope = {
+			type: key.id,
+			payload,
+			...options.emittedAt ? { emittedAt: options.emittedAt } : {},
+			...options.source ? { source: options.source } : {}
+		};
+		this.emitEnvelope(envelope);
+	};
+	emitEnvelope = (event) => {
+		const listeners = this.listeners.get(event.type);
+		if (listeners) for (const listener of listeners) this.safeInvokeListener(event, listener);
+		if (this.globalListeners.size === 0) return;
+		for (const listener of this.globalListeners) this.safeInvokeGlobalListener(event, listener);
+	};
+	on = (key, handler) => {
+		const listeners = this.listeners.get(key.id) ?? /* @__PURE__ */ new Set();
+		listeners.add(handler);
+		this.listeners.set(key.id, listeners);
+		return () => {
+			this.off(key, handler);
+		};
+	};
+	off = (key, handler) => {
+		const listeners = this.listeners.get(key.id);
+		if (!listeners) return;
+		listeners.delete(handler);
+		if (listeners.size === 0) this.listeners.delete(key.id);
+	};
+	once = (key, handler) => {
+		const wrappedHandler = (payload, envelope) => {
+			unsubscribe();
+			handler(payload, envelope);
+		};
+		const unsubscribe = this.on(key, wrappedHandler);
+		return unsubscribe;
+	};
+	subscribeAll = (handler) => {
+		this.globalListeners.add(handler);
+		return () => {
+			this.globalListeners.delete(handler);
+		};
+	};
+	safeInvokeListener = (event, listener) => {
+		try {
+			listener(event.payload, event);
+		} catch (error) {
+			this.onListenerError?.({
+				type: event.type,
+				payload: event.payload,
+				error
+			});
+		}
+	};
+	safeInvokeGlobalListener = (event, listener) => {
+		try {
+			listener(event);
+		} catch (error) {
+			this.onListenerError?.({
+				type: event.type,
+				payload: event.payload,
+				error
+			});
+		}
+	};
+};
+//#endregion
+//#region src/app/nextclaw-app.service.ts
+const nextclaw = { eventBus: new EventBus() };
+//#endregion
+//#region src/events/event.keys.ts
+function createAppEventKey(id) {
+	return { id };
+}
+const eventKeys = {
+	configUpdated: createAppEventKey("config.updated"),
+	channelConfigApplyStatus: createAppEventKey("channel.config.apply-status"),
+	sessionUpdated: createAppEventKey("session.updated"),
+	sessionRunStatus: createAppEventKey("session.run-status"),
+	sessionSummaryUpsert: createAppEventKey("session.summary.upsert"),
+	sessionSummaryDelete: createAppEventKey("session.summary.delete"),
+	configReloadStarted: createAppEventKey("config.reload.started"),
+	configReloadFinished: createAppEventKey("config.reload.finished"),
+	error: createAppEventKey("error"),
+	connectionOpen: createAppEventKey("connection.open"),
+	connectionClose: createAppEventKey("connection.close"),
+	connectionError: createAppEventKey("connection.error"),
+	runtimeUpdateSnapshot: createAppEventKey("runtime.update.snapshot")
+};
+//#endregion
+export { AgentManager, AutomationManager, ChannelManager, ContextBuilder, EventBus, LlmProviderManager, NextclawKernel, SessionManager, SkillManager, TaskManager, ToolManager, UpdateManifestReader, createAppEventKey, eventKeys, getUnsignedUpdateManifest, nextclaw, serializeUnsignedUpdateManifest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/kernel",
-  "version": "0.1.2-beta.1",
+  "version": "0.1.2-beta.3",
   "private": false,
   "description": "NextClaw product kernel skeleton for agents, tasks, sessions, context, tools, skills, providers, automation, and channels.",
   "type": "module",
@@ -20,7 +20,7 @@
     "dist"
   ],
   "dependencies": {
-    "@nextclaw/ncp": "0.5.6-beta.0"
+    "@nextclaw/ncp": "0.5.6-beta.1"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",