@moorline/core 0.0.1

package/dist/core/runtime/moorlineRuntimeBuilder.d.ts

@@ -0,0 +1,180 @@
+import { defaultAdminConfig, type MoorlineConfig } from '../../types/config.js';
+import { ensureRuntimePaths } from '../system/config/configStore.js';
+import { PluginHost } from '../extension/plugins/pluginHost.js';
+import type { RuntimePluginContext } from '../../types/plugin.js';
+import type { RuntimeActionGuard } from '../system/policy/runtimeActionGuard.js';
+import { SessionLifecycleService } from '../domain/sessions/sessionLifecycleService.js';
+import { MissionRegistry } from '../domain/missions/missionRegistry.js';
+import { MissionHookService } from '../domain/missions/missionHookService.js';
+import { SkillRegistry } from '../extension/skills/skillRegistry.js';
+import { SqliteSessionStore, type RuntimeSessionRow } from '../system/state/sqliteSessionStore.js';
+import { JsonAuditLogger } from '../system/audit/auditLogger.js';
+import { SessionRegistry } from '../domain/sessions/sessionState.js';
+import { MemoryStore } from '../domain/memory/store.js';
+import { RuntimeIngestion } from './execution/runtimeIngestion.js';
+import { CommandReactor } from './execution/commandReactor.js';
+import { RuntimeReceiptBus } from './execution/runtimeReceiptBus.js';
+import { OrchestrationEngine } from './execution/orchestrationEngine.js';
+import type { KeyedDrainableWorker } from './execution/drainableWorker.js';
+import { RuntimeActivityStore, type RuntimeActivityRecord } from '../system/projection/runtimeActivityStore.js';
+import { ProjectionStateStore } from '../system/projection/projectionStateStore.js';
+import { PendingRequestProjectionStore } from '../system/projection/pendingRequestProjectionStore.js';
+import { RuntimeSnapshotQuery } from '../system/projection/runtimeSnapshotQuery.js';
+import { RuntimeReconciler } from '../system/projection/runtimeReconciler.js';
+import { ProviderSessionDirectory } from './execution/providerSessionDirectory.js';
+import { CanonicalEventLogStore } from '../system/state/canonicalEventLogStore.js';
+import { SidecarManager } from './supervision/sidecarManager.js';
+import type { RuntimeMessagePayload, RuntimeTransport, RuntimeActorIdentity } from '../../types/transport.js';
+import type { RuntimeControlRequest, RuntimeControlResult, RuntimeControlStatus } from './supervision/runtimeControl.js';
+import type { SidecarScopeKind } from './supervision/managedSidecar.js';
+import { ManagementReadModelService } from '../system/projection/managementReadModelService.js';
+import { RuntimeControlService } from './supervision/runtimeControlService.js';
+import { type RuntimeManagementSurfaceFactory, type RuntimeManagementSurfaceHandle } from './hosting/runtimeManagementPort.js';
+import { RuntimeWorkManagementService } from '../domain/sessions/runtimeWorkManagementService.js';
+import { ManagedChannelLifecycleService } from './lifecycle/managedChannelLifecycleService.js';
+import { RuntimeInteractionService } from './execution/runtimeInteractionService.js';
+import { RuntimeTransportSurfaceService } from './hosting/runtimeTransportSurfaceService.js';
+import { ProviderOrchestrator } from './execution/providerOrchestration/providerOrchestrator.js';
+import { RuntimeProjectionService } from '../system/projection/runtimeProjectionService.js';
+import { RuntimeOrchestrationRequestService } from './execution/runtimeOrchestrationRequestService.js';
+import { RuntimeLifecycleService } from './lifecycle/runtimeLifecycleService.js';
+import { RuntimePluginContextService } from './execution/runtimePluginContextService.js';
+import { RuntimePendingRequestService } from './execution/runtimePendingRequestService.js';
+import { RuntimeHostingService } from './hosting/runtimeHostingService.js';
+import type { RuntimeEnvironmentVerifier, RuntimeProvider, RuntimeProviderFactory } from '../../types/provider.js';
+import type { RuntimeCommandRunner } from '../../types/runtime.js';
+export interface MoorlineRuntimeDeps {
+    config: MoorlineConfig;
+    configPath?: string;
+    commandRunner?: RuntimeCommandRunner;
+    transport?: RuntimeTransport;
+    now?: () => string;
+    provider?: RuntimeProvider;
+    providerFactory?: RuntimeProviderFactory;
+    verifyEnvironment?: RuntimeEnvironmentVerifier;
+    supervised?: boolean;
+    providerTurnWaitTimeoutMs?: number;
+    queueLimits?: {
+        provider?: {
+            maxPendingPerKey?: number;
+            maxPendingTotal?: number;
+        };
+        command?: {
+            maxPendingPerKey?: number;
+            maxPendingTotal?: number;
+        };
+        projection?: {
+            maxPendingPerKey?: number;
+            maxPendingTotal?: number;
+        };
+        transport?: {
+            maxPendingPerKey?: number;
+            maxPendingTotal?: number;
+        };
+    };
+    requestControl?: (input: RuntimeControlRequest) => Promise<RuntimeControlResult>;
+    managementSurfaceFactory?: RuntimeManagementSurfaceFactory;
+    managementPresentation?: import('../../types/app.js').ManagementReadModelPresentation;
+}
+interface MoorlineRuntimeBuilderCallbacks {
+    now(): string;
+    requireGuard(): RuntimeActionGuard;
+    getEffectiveAdminConfig(): ReturnType<typeof defaultAdminConfig>;
+    createPluginContext(actorId: string): RuntimePluginContext;
+    cleanupScopedSidecars(scopeKind: SidecarScopeKind, scopeKey: string, reason: string): Promise<void>;
+    runOrchestrationTurn(session: RuntimeSessionRow, actorId: string, content: string): Promise<RuntimeMessagePayload>;
+    ensureChatSession(spaceId: string, cwd: string): Promise<RuntimeSessionRow>;
+    isAdminActor(input: RuntimeActorIdentity): boolean;
+    postTransportMessage(actor: string, spaceId: string, payload: RuntimeMessagePayload): Promise<{
+        id: string;
+    }>;
+    sendStatusUpdate(payload: RuntimeMessagePayload): Promise<void>;
+    runGuardedAction<T>(input: {
+        action: Parameters<RuntimeActionGuard['run']>[0]['action'];
+        actor: string;
+        target?: string;
+        payload?: unknown;
+        threadId?: string;
+        title: string;
+        execute: () => Promise<T>;
+    }): Promise<T>;
+    requireNamespaceState(): import('../../types/config.js').RuntimeSurfaceState;
+    getNamespaceState(): import('../../types/config.js').RuntimeSurfaceState | null;
+    getRuntimeStatus(): {
+        uptimeSeconds: number;
+        openSessions: number;
+        coolSessions: number;
+        archivedSessions: number;
+        waitingSessions: number;
+        runningSessions: number;
+    };
+    getRuntimeControlStatus(): RuntimeControlStatus;
+    appendAuditEvent(event: string, payload: Record<string, unknown>): void;
+    recordRuntimeActivity(input: Omit<RuntimeActivityRecord, 'activityId'>): void;
+    setAcceptingNewWork(accepting: boolean): void;
+    setProviderAutoStartDefault(enabled: boolean): void;
+    getProviderAutoStartDefault(): boolean;
+    rejectTurnWaitersForThread(threadId: string, reason: string): void;
+}
+export interface RuntimeStateGraph {
+    store: SqliteSessionStore;
+    sessionRegistry: SessionRegistry;
+    missionRegistry: MissionRegistry;
+    missionHooks: MissionHookService;
+    sessionLifecycle: SessionLifecycleService;
+    memoryStore: MemoryStore;
+    audit: JsonAuditLogger;
+    ingestion: RuntimeIngestion;
+    reactor: CommandReactor;
+    receiptBus: RuntimeReceiptBus;
+    activities: RuntimeActivityStore;
+    pendingRequests: PendingRequestProjectionStore;
+    projectionState: ProjectionStateStore;
+    orchestration: OrchestrationEngine;
+    snapshots: RuntimeSnapshotQuery;
+    reconciler: RuntimeReconciler;
+    canonicalEvents: CanonicalEventLogStore;
+    projectionService: RuntimeProjectionService;
+}
+export interface RuntimeExtensionGraph {
+    pluginHostRef: {
+        current: PluginHost;
+    };
+    pluginHost: PluginHost;
+    skillRegistry: SkillRegistry;
+    sidecars: SidecarManager;
+    pluginContexts: RuntimePluginContextService;
+}
+export interface RuntimeTransportGraph {
+    managedChannelLifecycle: ManagedChannelLifecycleService;
+    interactions: RuntimeInteractionService;
+    transportSurface: RuntimeTransportSurfaceService;
+    hostingService: RuntimeHostingService;
+}
+export interface RuntimeProviderGraph {
+    providerService: RuntimeProvider;
+    providerDirectory: ProviderSessionDirectory;
+    providerOrchestrator: ProviderOrchestrator;
+}
+export interface RuntimeManagementGraph {
+    managementReadModel: ManagementReadModelService;
+    runtimeControl: RuntimeControlService;
+    workManagement: RuntimeWorkManagementService;
+    managementSurface: RuntimeManagementSurfaceHandle;
+    orchestrationRequests: RuntimeOrchestrationRequestService;
+    lifecycleService: RuntimeLifecycleService;
+    pendingRequestService: RuntimePendingRequestService;
+}
+export interface MoorlineRuntimeServiceGraph extends RuntimeStateGraph, RuntimeExtensionGraph, RuntimeTransportGraph, RuntimeProviderGraph, RuntimeManagementGraph {
+    deps: MoorlineRuntimeDeps;
+    paths: ReturnType<typeof ensureRuntimePaths>;
+    chatWorkspacePath: string;
+    runtimePolicyPath: string;
+    providerQueue: KeyedDrainableWorker;
+    commandQueue: KeyedDrainableWorker;
+    projectionQueue: KeyedDrainableWorker;
+    transportQueue: KeyedDrainableWorker;
+}
+export declare function buildMoorlineRuntimeServiceGraph(deps: MoorlineRuntimeDeps, callbacks: MoorlineRuntimeBuilderCallbacks): MoorlineRuntimeServiceGraph;
+export declare function prepareRuntimeLayout(runtimeRoot: string): Promise<void>;
+export {};