@borgee/agents-host 0.2.2 → 0.2.26

package/dist/cli.js

@@ -1,36 +1,85 @@
 #!/usr/bin/env node
 import { realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CliUsageError, parseDescribeArgs, parseGenerateConfigArgs, parsePrintLayoutArgs, parseStartArgs, parseValidateArgs, USAGE, } from './cli-args.js';
-import { describeLocalConfig, generateLocalConfig, printLocalConfigLayout, runMain, validateLocalConfig } from './run.js';
+import { CliUsageError, parseApplyManagedArgs, parseDaemonArgs, parseDescribeArgs, parseDescribeManagedArgs, parseCleanupManagedArgs, parseGenerateConfigArgs, parseLogArgs, parseManagedStartArgs, parsePrintLayoutArgs, parseStartArgs, parseValidateArgs, USAGE, } from './cli-args.js';
+import { resolveAgentsHostDebugMode } from './debug.js';
+import { applyManagedSpec, bootstrapManagedDaemonStart, cleanupManagedRuntime, describeManagedSpec, ManagedAgentsHostDaemon, } from './managed-daemon.js';
+import { runManagedDaemonLogCommand } from './managed-daemon-log.js';
+import { describeLocalConfig, generateLocalConfig, printLocalConfigLayout, runMain, validateLocalConfig, } from './run.js';
 function formatErrorMessage(error) {
     if (error instanceof Error) {
         return error.message;
     }
     return String(error);
 }
+const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
 export async function dispatchCli(argv, deps = {}) {
     const [command, ...rest] = argv;
     const env = deps.env ?? process.env;
     const runMainImpl = deps.runMain ?? runMain;
+    const bootstrapManagedDaemonStartImpl = deps.bootstrapManagedDaemonStart ?? bootstrapManagedDaemonStart;
     const validateLocalConfigImpl = deps.validateLocalConfig ?? validateLocalConfig;
     const describeLocalConfigImpl = deps.describeLocalConfig ?? describeLocalConfig;
     const printLocalConfigLayoutImpl = deps.printLocalConfigLayout ?? printLocalConfigLayout;
     const generateLocalConfigImpl = deps.generateLocalConfig ?? generateLocalConfig;
+    const runManagedDaemonLogCommandImpl = deps.runManagedDaemonLogCommand ?? runManagedDaemonLogCommand;
+    const describeManagedSpecImpl = deps.describeManagedSpec ?? describeManagedSpec;
+    const cleanupManagedRuntimeImpl = deps.cleanupManagedRuntime ?? cleanupManagedRuntime;
+    const applyManagedSpecImpl = deps.applyManagedSpec ?? applyManagedSpec;
+    const startManagedDaemonImpl = deps.startManagedDaemon ??
+        (async (rootPath, debug) => {
+            env[TASK_WORKSPACE_ROOT_DIR_ENV] = rootPath;
+            const daemon = new ManagedAgentsHostDaemon(rootPath, debug, {
+                logPath: env.AGENTS_HOST_MANAGED_DAEMON_LOG_PATH,
+            });
+            const shutdown = async (signal) => {
+                console.log(`[agents-host] managed daemon received ${signal}, shutting down`);
+                await daemon.stop().catch((error) => {
+                    console.error('[agents-host] managed daemon shutdown failed', error);
+                });
+                process.exit(0);
+            };
+            process.on('SIGINT', () => void shutdown('SIGINT'));
+            process.on('SIGTERM', () => void shutdown('SIGTERM'));
+            await daemon.start();
+        });
     const readStdin = deps.readStdin ?? readAllStdin;
+    const stdout = deps.stdout ?? console;
     if (command === 'start') {
         const parsed = parseStartArgs(rest);
+        const debug = resolveAgentsHostDebugMode(parsed.debug, env);
         if (parsed.mode === 'single-agent') {
             env.BORGEE_BASE_URL = parsed.serverUrl;
             env.BORGEE_AGENT_API_KEY = parsed.apiKey;
             for (const [key, value] of Object.entries(parsed.env)) {
                 env[key] = value;
             }
-            await runMainImpl();
+            await runMainImpl({ debug });
             return;
         }
-        await runMainImpl({ configPath: parsed.configPath });
+        env[TASK_WORKSPACE_ROOT_DIR_ENV] = dirname(resolve(parsed.configPath));
+        await runMainImpl({ configPath: parsed.configPath, debug });
+        return;
+    }
+    if (command === 'start-managed') {
+        const parsed = parseManagedStartArgs(rest);
+        if (resolveAgentsHostDebugMode(false, env)) {
+            throw new CliUsageError('start-managed does not support debug mode; use foreground start or start --config --debug instead');
+        }
+        if (parsed.apiKey === undefined) {
+            await bootstrapManagedDaemonStartImpl({
+                serverUrl: parsed.serverUrl,
+                processEnv: env,
+            });
+            return;
+        }
+        await bootstrapManagedDaemonStartImpl({
+            serverUrl: parsed.serverUrl,
+            apiKey: parsed.apiKey,
+            env: parsed.env,
+            processEnv: env,
+        });
         return;
     }
     if (command === 'validate') {
@@ -58,6 +107,64 @@ export async function dispatchCli(argv, deps = {}) {
         }
         return;
     }
+    if (command === 'describe-managed') {
+        const parsed = parseDescribeManagedArgs(rest);
+        stdout.log(JSON.stringify(await describeManagedSpecImpl({
+            serverUrl: parsed.serverUrl,
+            processEnv: env,
+        })));
+        return;
+    }
+    if (command === 'cleanup-managed') {
+        const parsed = parseCleanupManagedArgs(rest);
+        await cleanupManagedRuntimeImpl({
+            serverUrl: parsed.serverUrl,
+            purge: parsed.purge,
+            processEnv: env,
+        });
+        return;
+    }
+    if (command === 'apply-managed') {
+        const parsed = parseApplyManagedArgs(rest);
+        const specJson = parsed.input === 'stdin' ? await readStdin() : parsed.specJson;
+        let parsedSpec;
+        try {
+            parsedSpec = JSON.parse(specJson);
+        }
+        catch (error) {
+            stdout.log(JSON.stringify({
+                ok: false,
+                error: {
+                    code: 'MANAGED_SPEC_INVALID',
+                    message: `Invalid managed spec JSON: ${formatErrorMessage(error)}`,
+                },
+            }));
+            return;
+        }
+        stdout.log(JSON.stringify(await applyManagedSpecImpl({
+            serverUrl: parsed.serverUrl,
+            spec: parsedSpec,
+            processEnv: env,
+        })));
+        return;
+    }
+    if (command === 'log') {
+        const parsed = parseLogArgs(rest);
+        await runManagedDaemonLogCommandImpl({
+            serverUrl: parsed.serverUrl,
+            lines: parsed.lines,
+            follow: parsed.follow,
+            pathOnly: parsed.pathOnly,
+            env,
+        });
+        return;
+    }
+    if (command === 'daemon') {
+        const parsed = parseDaemonArgs(rest);
+        env[TASK_WORKSPACE_ROOT_DIR_ENV] = parsed.rootPath;
+        await startManagedDaemonImpl(parsed.rootPath, parsed.debug);
+        return;
+    }
     throw new CliUsageError(`Unknown command: ${command}`);
 }
 async function readAllStdin() {

package/dist/compatibility-gates.d.ts

@@ -0,0 +1,35 @@
+export declare const CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE = "claude-provider-v2";
+export declare const COPILOT_PROVIDER_V2_COMPATIBILITY_GATE = "copilot-provider-v2";
+export declare const CODEX_PROVIDER_COMPATIBILITY_GATE = "codex-provider";
+export declare const CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE = "connections-state-layer";
+export declare const CONTEXT_INJECTION_COMPATIBILITY_GATE = "context-injection";
+export declare const SKILL_RUNTIME_COMPATIBILITY_GATE = "skill-runtime";
+export declare const LOCALHOST_GATEWAY_COMPATIBILITY_GATE = "localhost-gateway";
+export declare const COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE = "collaboration-skill-first";
+export declare const TOKEN_BINDING_COMPATIBILITY_GATE = "token-binding";
+export declare const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = "policy-audit-enforcement";
+export declare const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = "managed-runtime-convergence";
+export declare const COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES";
+export declare const INTERNAL_POLICY_MODE_ENV = "AGENTS_HOST_INTERNAL_POLICY_MODE";
+export declare const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = "AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS";
+export declare const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
+export type InternalPolicyMode = 'audit-only' | 'enforce';
+export type InternalProviderImplementationPath = 'v1' | 'v2';
+export type InternalProviderImplementationKey = 'claude' | 'copilot';
+export type InternalProviderImplementationOverrides = Partial<Record<InternalProviderImplementationKey, InternalProviderImplementationPath>>;
+export interface ManagedRuntimeSettingsSnapshot {
+    schemaVersion: number;
+    compatibilityGates: string[];
+    providerImplementationOverrides: string[];
+    internalPolicyMode: InternalPolicyMode;
+}
+export declare function parseCompatibilityGates(rawValue: string | undefined): ReadonlySet<string>;
+export declare function resolveInternalCompatibilityGates(): ReadonlySet<string>;
+export declare function normalizeInternalProviderImplementationOverrides(rawValue: string | undefined): string[];
+export declare function parseInternalProviderImplementationOverrides(rawValue: string | undefined): InternalProviderImplementationOverrides;
+export declare function resolveManagedRuntimeProviderImplementationOverrides(env?: NodeJS.ProcessEnv, compatibilityGates?: string[]): string[];
+export declare function resolveManagedRuntimeCompatibilityGates(env?: NodeJS.ProcessEnv): string[];
+export declare function resolveInternalPolicyMode(gateEnabled: boolean, env?: NodeJS.ProcessEnv): InternalPolicyMode;
+export declare function resolveManagedRuntimeSettingsSnapshot(env?: NodeJS.ProcessEnv): ManagedRuntimeSettingsSnapshot;
+export declare function serializeManagedRuntimeSettingsSnapshot(snapshot: ManagedRuntimeSettingsSnapshot): string;
+export declare function createManagedRuntimeSettingsFingerprint(snapshot: ManagedRuntimeSettingsSnapshot): string;

package/dist/compatibility-gates.js

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+export const CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE = 'claude-provider-v2';
+export const COPILOT_PROVIDER_V2_COMPATIBILITY_GATE = 'copilot-provider-v2';
+export const CODEX_PROVIDER_COMPATIBILITY_GATE = 'codex-provider';
+export const CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE = 'connections-state-layer';
+export const CONTEXT_INJECTION_COMPATIBILITY_GATE = 'context-injection';
+export const SKILL_RUNTIME_COMPATIBILITY_GATE = 'skill-runtime';
+export const LOCALHOST_GATEWAY_COMPATIBILITY_GATE = 'localhost-gateway';
+export const COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE = 'collaboration-skill-first';
+export const TOKEN_BINDING_COMPATIBILITY_GATE = 'token-binding';
+export const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = 'policy-audit-enforcement';
+export const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = 'managed-runtime-convergence';
+export const COMPATIBILITY_GATES_ENV = 'AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES';
+export const INTERNAL_POLICY_MODE_ENV = 'AGENTS_HOST_INTERNAL_POLICY_MODE';
+export const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = 'AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS';
+export const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
+const VALID_PROVIDER_IMPLEMENTATION_ENTRIES = '"claude:v1", "claude:v2", "copilot:v1", or "copilot:v2"';
+const PROVIDER_IMPLEMENTATION_COMPATIBILITY_GATES = {
+    claude: CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE,
+    copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
+};
+function sortUniqueStrings(values) {
+    return [...new Set([...values].map((value) => value.trim()).filter((value) => value.length > 0))]
+        .sort((left, right) => left.localeCompare(right));
+}
+function isInternalProviderImplementationPath(value) {
+    return value === 'v1' || value === 'v2';
+}
+function isInternalProviderImplementationKey(value) {
+    return value === 'claude' || value === 'copilot';
+}
+function createInvalidProviderImplementationEntryError(assignment) {
+    return new Error(`Invalid ${INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV} entry "${assignment}". Expected ${VALID_PROVIDER_IMPLEMENTATION_ENTRIES}.`);
+}
+export function parseCompatibilityGates(rawValue) {
+    if (!rawValue || rawValue.trim().length === 0) {
+        return new Set();
+    }
+    const gates = new Set();
+    for (const gateRaw of rawValue.split(',')) {
+        const gate = gateRaw.trim();
+        if (gate.length === 0) {
+            continue;
+        }
+        gates.add(gate);
+    }
+    return gates;
+}
+export function resolveInternalCompatibilityGates() {
+    return parseCompatibilityGates(process.env[COMPATIBILITY_GATES_ENV]);
+}
+export function normalizeInternalProviderImplementationOverrides(rawValue) {
+    if (!rawValue || rawValue.trim().length === 0) {
+        return [];
+    }
+    const implementationsByProvider = new Map();
+    for (const assignmentRaw of rawValue.split(',')) {
+        const assignment = assignmentRaw.trim();
+        if (assignment.length === 0) {
+            continue;
+        }
+        const [providerRaw, implementationRaw, ...extraParts] = assignment.split(':');
+        const provider = providerRaw?.trim();
+        const implementation = implementationRaw?.trim();
+        if (extraParts.length > 0 || !provider || !implementation) {
+            throw createInvalidProviderImplementationEntryError(assignment);
+        }
+        if (!isInternalProviderImplementationKey(provider)) {
+            throw createInvalidProviderImplementationEntryError(assignment);
+        }
+        if (!isInternalProviderImplementationPath(implementation)) {
+            throw createInvalidProviderImplementationEntryError(assignment);
+        }
+        implementationsByProvider.set(provider, implementation);
+    }
+    return sortUniqueStrings([...implementationsByProvider.entries()].map(([provider, implementation]) => `${provider}:${implementation}`));
+}
+export function parseInternalProviderImplementationOverrides(rawValue) {
+    const implementationOverrides = {};
+    for (const assignment of normalizeInternalProviderImplementationOverrides(rawValue)) {
+        const [provider, implementation] = assignment.split(':');
+        implementationOverrides[provider] = implementation;
+    }
+    return implementationOverrides;
+}
+export function resolveManagedRuntimeProviderImplementationOverrides(env = process.env, compatibilityGates = resolveManagedRuntimeCompatibilityGates(env)) {
+    const enabledGates = new Set(compatibilityGates);
+    return normalizeInternalProviderImplementationOverrides(env[INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]).filter((assignment) => {
+        const [provider] = assignment.split(':');
+        return enabledGates.has(PROVIDER_IMPLEMENTATION_COMPATIBILITY_GATES[provider]);
+    });
+}
+export function resolveManagedRuntimeCompatibilityGates(env = process.env) {
+    const compatibilityGates = new Set(parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]));
+    if (compatibilityGates.has(MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE)) {
+        compatibilityGates.add(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
+        compatibilityGates.add(TOKEN_BINDING_COMPATIBILITY_GATE);
+    }
+    return sortUniqueStrings(compatibilityGates);
+}
+export function resolveInternalPolicyMode(gateEnabled, env = process.env) {
+    if (!gateEnabled) {
+        return 'audit-only';
+    }
+    const rawValue = env[INTERNAL_POLICY_MODE_ENV]?.trim();
+    if (rawValue === 'enforce') {
+        return 'enforce';
+    }
+    return 'audit-only';
+}
+export function resolveManagedRuntimeSettingsSnapshot(env = process.env) {
+    const compatibilityGates = resolveManagedRuntimeCompatibilityGates(env);
+    return {
+        schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
+        compatibilityGates,
+        providerImplementationOverrides: resolveManagedRuntimeProviderImplementationOverrides(env, compatibilityGates),
+        internalPolicyMode: resolveInternalPolicyMode(compatibilityGates.includes(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE), env),
+    };
+}
+export function serializeManagedRuntimeSettingsSnapshot(snapshot) {
+    return JSON.stringify(snapshot);
+}
+export function createManagedRuntimeSettingsFingerprint(snapshot) {
+    return createHash('sha256')
+        .update(serializeManagedRuntimeSettingsSnapshot(snapshot))
+        .digest('hex');
+}

package/dist/config.d.ts

@@ -8,5 +8,6 @@ export declare function parseArgs(value: string): string[];
 export declare function optionalStringArray(value: unknown, fieldName: string, sourceLabel: string): string[] | undefined;
 export declare function parseCopilotSessionTtlMinutesValue(value: unknown, sourceLabel: string): number;
 export declare function resolveProvider(rawValue: string, sourceLabel: string): ProviderKind;
+export declare function assertProviderCompatibility(provider: ProviderKind, sourceLabel: string, env?: NodeJS.ProcessEnv): void;
 export declare function resolveProviderCommandConfig(overrides?: Partial<ProviderCommandConfig>): ProviderCommandConfig;
 export declare function loadConfigFromEnv(env?: NodeJS.ProcessEnv): AgentsHostConfig;

package/dist/config.js

@@ -1,10 +1,13 @@
 import { resolveSingleAgentStateRoot } from './state-paths.js';
+import { CODEX_PROVIDER_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, parseCompatibilityGates, } from './compatibility-gates.js';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 export const MAX_COPILOT_SESSION_TTL_MINUTES = MAX_TIMER_DELAY_MS / 60_000;
 export const DEFAULT_COPILOT_SESSION_TTL_MINUTES = 2 * 24 * 60;
 export const DEFAULT_PROVIDER_COMMAND_CONFIG = {
     claudeCommand: 'claude',
-    claudeArgs: ['--print'],
+    claudeArgs: ['--print', '--permission-mode', 'bypassPermissions'],
+    codexCommand: 'codex-acp',
+    codexArgs: [],
     copilotCommand: 'copilot',
     copilotArgs: ['-s', '--no-color', '--allow-all-tools', '--output-format', 'text'],
     copilotSessionTtlMinutes: DEFAULT_COPILOT_SESSION_TTL_MINUTES,
@@ -57,15 +60,26 @@ export function parseCopilotSessionTtlMinutesValue(value, sourceLabel) {
 }
 export function resolveProvider(rawValue, sourceLabel) {
     const raw = rawValue.trim().toLowerCase();
-    if (raw === 'claude' || raw === 'copilot') {
+    if (raw === 'claude' || raw === 'codex' || raw === 'copilot') {
         return raw;
     }
-    throw new Error(`${sourceLabel}: expected "claude" or "copilot", got "${rawValue}"`);
+    throw new Error(`${sourceLabel}: expected "claude", "codex", or "copilot", got "${rawValue}"`);
+}
+export function assertProviderCompatibility(provider, sourceLabel, env = process.env) {
+    if (provider !== 'codex') {
+        return;
+    }
+    const compatibilityGates = parseCompatibilityGates(env[COMPATIBILITY_GATES_ENV]);
+    if (!compatibilityGates.has(CODEX_PROVIDER_COMPATIBILITY_GATE)) {
+        throw new Error(`${sourceLabel}: provider "codex" requires ${COMPATIBILITY_GATES_ENV} to include ${CODEX_PROVIDER_COMPATIBILITY_GATE}`);
+    }
 }
 export function resolveProviderCommandConfig(overrides = {}) {
     return {
         claudeCommand: overrides.claudeCommand ?? DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand,
         claudeArgs: [...(overrides.claudeArgs ?? DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs)],
+        codexCommand: overrides.codexCommand ?? DEFAULT_PROVIDER_COMMAND_CONFIG.codexCommand,
+        codexArgs: [...(overrides.codexArgs ?? DEFAULT_PROVIDER_COMMAND_CONFIG.codexArgs)],
         copilotCommand: overrides.copilotCommand ?? DEFAULT_PROVIDER_COMMAND_CONFIG.copilotCommand,
         copilotArgs: [...(overrides.copilotArgs ?? DEFAULT_PROVIDER_COMMAND_CONFIG.copilotArgs)],
         copilotSessionTtlMinutes: overrides.copilotSessionTtlMinutes ?? DEFAULT_PROVIDER_COMMAND_CONFIG.copilotSessionTtlMinutes,
@@ -73,12 +87,16 @@ export function resolveProviderCommandConfig(overrides = {}) {
 }
 export function loadConfigFromEnv(env = process.env) {
     const provider = resolveProvider(envOr('RUNTIME_PROVIDER', 'claude', env), 'Unsupported RUNTIME_PROVIDER');
+    assertProviderCompatibility(provider, 'Unsupported RUNTIME_PROVIDER', env);
+    const agentApiKey = requireEnv('BORGEE_AGENT_API_KEY', env);
     return {
         borgeeBaseUrl: requireEnv('BORGEE_BASE_URL', env),
-        stateRootDir: resolveSingleAgentStateRoot(env),
+        stateRootDir: resolveSingleAgentStateRoot(env, undefined, agentApiKey),
         ...resolveProviderCommandConfig({
             claudeCommand: envOr('CLAUDE_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand, env),
             claudeArgs: parseArgs(envOr('CLAUDE_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs.join(' '), env)),
+            codexCommand: envOr('CODEX_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.codexCommand, env),
+            codexArgs: parseArgs(envOr('CODEX_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.codexArgs.join(' '), env)),
             copilotCommand: envOr('COPILOT_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotCommand, env),
             copilotArgs: parseArgs(envOr('COPILOT_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.copilotArgs.join(' '), env)),
             copilotSessionTtlMinutes: env.COPILOT_SESSION_TTL_MINUTES && env.COPILOT_SESSION_TTL_MINUTES.trim().length > 0
@@ -86,7 +104,7 @@ export function loadConfigFromEnv(env = process.env) {
                 : DEFAULT_PROVIDER_COMMAND_CONFIG.copilotSessionTtlMinutes,
         }),
         agent: {
-            agentApiKey: requireEnv('BORGEE_AGENT_API_KEY', env),
+            agentApiKey,
             agentName: envOr('BORGEE_AGENT_NAME', 'Assistant', env),
             provider,
         },

package/dist/connections-state-store.d.ts

@@ -0,0 +1,81 @@
+import { type DebugLogger } from './debug.js';
+import type { ProviderKind } from './types.js';
+export interface ChannelSessionStoreLike {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+    close?(): Promise<void> | void;
+}
+export interface ChannelTokenBinding {
+    token: string;
+    agentId: string;
+    channelId: string;
+}
+export interface ConnectionsStateStore {
+    loadProviderSessions(provider: ProviderKind, agentId: string): Record<string, string>;
+    saveProviderSessions(provider: ProviderKind, agentId: string, sessions: Record<string, string>): void;
+    hasTokenBinding(token: string): boolean;
+    loadTokenBinding(token: string): ChannelTokenBinding | null;
+    loadTokenBindingForChannel(agentId: string, channelId: string): ChannelTokenBinding | null;
+    replaceTokenBinding(binding: ChannelTokenBinding): void;
+    deleteTokenBinding(token: string): void;
+    revokeTokenBinding(token: string): void;
+    revokeAllTokenBindings(): void;
+    close(): void;
+}
+export interface SqliteConnectionsStateStoreOptions {
+    stateRootDir: string;
+    busyTimeoutMs?: number;
+    resolveDatabasePath?: (stateRootDir: string) => string;
+    openDatabase?: (path: string) => SqliteDatabaseLike;
+}
+export interface ConnectionsStateBackedChannelSessionStoreOptions {
+    provider: ProviderKind;
+    legacyStore: ChannelSessionStoreLike;
+    sqliteStateStore?: ConnectionsStateStore;
+    logger?: DebugLogger;
+}
+export interface ProviderConnectionsSessionStoreOptions {
+    provider: ProviderKind;
+    legacyStore: ChannelSessionStoreLike;
+    stateRootDir: string;
+    gateEnabled: boolean;
+    logger?: DebugLogger;
+}
+interface SqliteStatementLike {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+}
+interface SqliteDatabaseLike {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatementLike;
+    close(): void;
+}
+export declare class SqliteConnectionsStateStore implements ConnectionsStateStore {
+    private readonly options;
+    private database;
+    private closed;
+    constructor(options: SqliteConnectionsStateStoreOptions);
+    loadProviderSessions(provider: ProviderKind, agentId: string): Record<string, string>;
+    saveProviderSessions(provider: ProviderKind, agentId: string, sessions: Record<string, string>): void;
+    hasTokenBinding(token: string): boolean;
+    loadTokenBinding(token: string): ChannelTokenBinding | null;
+    loadTokenBindingForChannel(agentId: string, channelId: string): ChannelTokenBinding | null;
+    replaceTokenBinding(binding: ChannelTokenBinding): void;
+    deleteTokenBinding(token: string): void;
+    revokeTokenBinding(token: string): void;
+    revokeAllTokenBindings(): void;
+    close(): void;
+    private ensureDatabase;
+    private loadStoredTokenBinding;
+}
+export declare class ConnectionsStateBackedChannelSessionStore implements ChannelSessionStoreLike {
+    private readonly options;
+    private readonly logger;
+    constructor(options: ConnectionsStateBackedChannelSessionStoreOptions);
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+    close(): void;
+}
+export declare function createProviderConnectionsSessionStore(options: ProviderConnectionsSessionStoreOptions): ChannelSessionStoreLike;
+export {};