@wrongstack/cli 1.0.33 → 1.0.36

package/dist/webui-server/http-bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HTTP + WebSocket listeners for the CLI-embedded WebUI host: the static
+ * frontend (when built), the authenticated WS bridge, the deferred SimpleUI
+ * bind, the IPv6 loopback proxy and the ready banner.
+ */
+import type { Server as HttpServer, IncomingMessage } from 'node:http';
+import { type SessionAgentRegistry } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export interface WebuiHttpBridgeInput {
+    opts: CliWebUIOptions;
+    surface: 'webui' | 'simpleui';
+    host: string;
+    httpPort: number;
+    strictPort: boolean;
+    globalRoot: string;
+    wsToken: string;
+    publicUrl: string | undefined;
+    publicWsUrl: string | undefined;
+    requireToken: boolean;
+    getSessionAgents: () => SessionAgentRegistry | undefined;
+    onFleetPing: () => void;
+    broadcast: WebuiTransport['broadcast'];
+    /** The bind advanced past the requested port; called before anything else reads the port. */
+    onPortRebound: (port: number) => void;
+}
+export declare function startWebuiHttpBridge(input: WebuiHttpBridgeInput): Promise<{
+    httpServer: import("@wrongstack/webui-server").StaticServeHandle | null;
+    wss: import("ws").Server<typeof import("ws").WebSocket, typeof IncomingMessage>;
+    ipv6LoopbackServer: HttpServer<typeof IncomingMessage, typeof import("node:http").ServerResponse> | null;
+}>;
+//# sourceMappingURL=http-bridge.d.ts.map

package/dist/webui-server/instance-registration.d.ts

@@ -0,0 +1,19 @@
+/** Registers the CLI-embedded WebUI host in the shared instance registry. */
+import type { CliWebUIOptions } from '../webui-server-options.js';
+export interface EmbeddedInstanceRegistrationInput {
+    opts: CliWebUIOptions;
+    surface: 'webui' | 'simpleui';
+    host: string;
+    httpPort: number;
+    publicUrl: string | undefined;
+    registryBaseDir: string;
+    wsToken: string;
+    currentSessionId: () => string;
+}
+/**
+ * Resolves true once the instance is registered. A session child awaits the
+ * registration (its parent reads the record to attach); every other host
+ * registers in the background and reports success optimistically.
+ */
+export declare function registerEmbeddedWebuiInstance(input: EmbeddedInstanceRegistrationInput): Promise<boolean>;
+//# sourceMappingURL=instance-registration.d.ts.map

package/dist/webui-server/kanban-services.d.ts

@@ -0,0 +1,9 @@
+/** Kanban run mirror + supervisor for the CLI-embedded WebUI host (only when a project root is known). */
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export declare function createWebuiKanbanServices(opts: CliWebUIOptions, broadcast: WebuiTransport['broadcast']): {
+    kanbanRunMirror: import("./kanban-run-mirror.js").KanbanRunMirror | null;
+    kanbanSupervisor: import("./kanban-supervisor.js").KanbanSupervisor | null;
+    stopKanbanSupervisorMemoryStats: (() => Promise<void>) | undefined;
+};
+//# sourceMappingURL=kanban-services.d.ts.map

package/dist/webui-server/message-router.d.ts

@@ -0,0 +1,14 @@
+/** Maps the CLI host's route contexts and domain handlers onto the shared embedded message router. */
+import { createEmbeddedMessageRouter } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { createWebuiDomainHandlers } from './domain-handlers.js';
+import type { createWebuiRouteContexts } from './route-contexts.js';
+type EmbeddedRouterOptions = Parameters<typeof createEmbeddedMessageRouter>[0];
+export type CliEmbeddedRouterInput = Pick<EmbeddedRouterOptions, 'trustBoundary' | 'send' | 'sendResult' | 'sessionPayload' | 'currentSessionId' | 'shutdown' | 'onDispose' | 'providerCtx' | 'kanbanHostRoutes'> & {
+    opts: CliWebUIOptions;
+    routeContexts: ReturnType<typeof createWebuiRouteContexts>;
+    domainHandlers: ReturnType<typeof createWebuiDomainHandlers>;
+};
+export declare function createCliEmbeddedMessageRouter(input: CliEmbeddedRouterInput): import("@wrongstack/webui-server").EmbeddedMessageRouter;
+export {};
+//# sourceMappingURL=message-router.d.ts.map

package/dist/webui-server/prefs-seeding.d.ts

@@ -1,6 +1,5 @@
 import type { ModelBlackoutRule } from '@wrongstack/core/models';
 import type { Config } from '@wrongstack/core/types';
-import { PREF_KEYS } from '@wrongstack/webui-server';
 interface CliWebUIOptions {
     agent: {
         ctx: {
@@ -35,7 +34,6 @@ interface CliWebUIOptions {
     } | undefined;
 }
 type PrefSnapshot = Record<string, unknown>;
-export { PREF_KEYS };
 export declare function seedConfigToMeta(opts: CliWebUIOptions): Promise<void>;
 export interface PrefsSeeding {
     /**
@@ -51,4 +49,5 @@ export interface PrefsSeeding {
     persistPrefs: (payload: PrefSnapshot) => Promise<void>;
 }
 export declare function createPrefsSeeding(opts: CliWebUIOptions): PrefsSeeding;
+export {};
 //# sourceMappingURL=prefs-seeding.d.ts.map

package/dist/webui-server/provider-config.d.ts

@@ -1,6 +1,5 @@
 import { DefaultSecretVault } from '@wrongstack/core/security';
 import type { ProviderConfig } from '@wrongstack/core/types';
-export { expectDefined, maskedKey, normalizeKeys, nowIso, writeKeysBack, } from '../provider-config-utils.js';
 /**
  * PR 4 of Issue #30 (webui-server 8-PR refactor):
  * provider-config IO.

package/dist/webui-server/provider-plane.d.ts

@@ -0,0 +1,14 @@
+/** Provider routes context + credential hot-reload for the CLI-embedded WebUI host. */
+import { type EmbeddedProviderContext } from '@wrongstack/webui-server';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { WebuiTransport } from './transport.js';
+export declare function createEmbeddedProviderPlane(input: {
+    opts: CliWebUIOptions;
+    profileConfigPath: string;
+    send: WebuiTransport['send'];
+    broadcast: WebuiTransport['broadcast'];
+}): {
+    wsHandlerCtx: EmbeddedProviderContext;
+    credentialWatcherClose: (() => void) | undefined;
+};
+//# sourceMappingURL=provider-plane.d.ts.map

package/dist/webui-server/session-agents.d.ts

@@ -0,0 +1,18 @@
+/** Per-tab agents for the CLI-embedded WebUI host. */
+import type { WebSocket } from 'ws';
+import type { CliWebUIOptions } from '../webui-server-options.js';
+import type { ConnectedClient } from './connection-handler.js';
+/**
+ * One Agent per open tab.
+ *
+ * The embedded host used to hand every tab the same leader Agent, so the
+ * second tab to start a run hit `Agent.run()`'s concurrency guard —
+ * "already in progress on this instance". Four tabs need four Agents; the
+ * registry clones the leader's wiring and gives each session its own
+ * `Context`, which is the state a run actually mutates.
+ */
+export declare function createEmbeddedSessionAgents(opts: CliWebUIOptions, clients: Map<WebSocket, ConnectedClient>, abortControllers: Map<string, AbortController>): {
+    sessionAgents: import("@wrongstack/webui-server").SessionAgentRegistry;
+    isSessionDisplayed: (sessionId: string) => boolean;
+};
+//# sourceMappingURL=session-agents.d.ts.map

package/dist/webui-server/session-start-live.d.ts

@@ -0,0 +1,11 @@
+/** The CLI host's `session.start` payload builder, bound to the live options and per-tab agents. */
+import type { SessionAgentRegistry } from '@wrongstack/webui-server';
+import { type BuildSessionStartPayload, type SessionStartPayloadDeps } from './session-start-payload.js';
+/**
+ * The host's builder, reading the live `opts` and the per-tab agent registry.
+ * `getSessionAgents` is a forward reference: the registry is built after the
+ * builder, so a payload for a background tab still reports that tab's model,
+ * mode and context window rather than the leader's.
+ */
+export declare function createLiveSessionStartPayloadBuilder<T extends SessionStartPayloadDeps>(opts: T, getSessionAgents: () => SessionAgentRegistry | undefined): BuildSessionStartPayload;
+//# sourceMappingURL=session-start-live.d.ts.map

package/dist/webui-server/stream-coalescer.d.ts

@@ -1,2 +1,2 @@
-export { createStreamCoalescer, type StreamCoalescer, type StreamCoalescerDeps, type ToolProgressPayload, } from '@wrongstack/webui-server';
+export { createStreamCoalescer, type StreamCoalescer, } from '@wrongstack/webui-server';
 //# sourceMappingURL=stream-coalescer.d.ts.map

package/dist/webui-server/transport.d.ts

@@ -0,0 +1,12 @@
+/** Outbound frame delivery for the CLI-embedded WebUI host: unicast, session-aware broadcast, fan-out. */
+import type { WebSocket } from 'ws';
+import type { ConnectedClient } from './connection-handler.js';
+import type { WSServerMessage } from './contracts.js';
+export interface WebuiTransport {
+    send(ws: WebSocket, msg: WSServerMessage): void;
+    broadcast(msg: WSServerMessage, targetSessionId?: string): void;
+    broadcastEveryone(msg: WSServerMessage): void;
+    sendResult(ws: WebSocket, success: boolean, message: string): void;
+}
+export declare function createWebuiTransport(clients: Map<WebSocket, ConnectedClient>): WebuiTransport;
+//# sourceMappingURL=transport.d.ts.map