@borgee/agents-host 0.1.6 → 0.1.8

package/dist/providers/copilot/cli-client.d.ts

@@ -7,6 +7,7 @@ interface CopilotAcpRuntime {
     methods: typeof methods;
     protocolVersion: typeof PROTOCOL_VERSION;
     cwd: string;
+    idleSessionTtlMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
 }
@@ -50,6 +51,9 @@ export declare class CopilotCliClient {
     private invalidateSession;
     private closeSession;
     private rejectQueuedTurnsAfterSessionTaint;
+    private clearIdleTimer;
+    private reconcileIdleChannelState;
+    private evictIdleChannel;
     private shutdownBackend;
     private waitForPendingSessionStarts;
     private waitForPendingSessionCloses;

package/dist/providers/copilot/cli-client.js

@@ -2,6 +2,7 @@ import { Readable, Writable } from 'node:stream';
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 const SESSION_TAINTED_ERRORS = new WeakSet();
+const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
 const DEFAULT_SHUTDOWN_GRACE_PERIOD_MS = 250;
 const DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS = 250;
 const QUEUED_TURN_DROPPED_MESSAGE = 'Copilot ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
@@ -12,6 +13,7 @@ const DEFAULT_RUNTIME = {
     methods,
     protocolVersion: PROTOCOL_VERSION,
     cwd: process.cwd(),
+    idleSessionTtlMs: DEFAULT_IDLE_SESSION_TTL_MS,
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
 };
@@ -98,6 +100,7 @@ export class CopilotCliClient {
             throw this.fatalError;
         }
         const state = this.getOrCreateChannelState(channelId);
+        this.clearIdleTimer(state);
         const turn = createDeferredTurn(prompt);
         state.queue.push(turn);
         this.processChannelQueue(channelId, state);
@@ -182,6 +185,7 @@ export class CopilotCliClient {
         let state = this.channels.get(channelId);
         if (!state) {
             state = {
+                idleTimerGeneration: 0,
                 processing: false,
                 queue: [],
             };
@@ -228,6 +232,7 @@ export class CopilotCliClient {
             }
             finally {
                 state.processing = false;
+                this.reconcileIdleChannelState(channelId, state);
             }
         })();
     }
@@ -274,9 +279,6 @@ export class CopilotCliClient {
             if (state.sessionPromise === sessionPromise) {
                 state.sessionPromise = undefined;
             }
-            if (!state.session && state.queue.length === 0 && !state.activeTurn) {
-                this.channels.delete(channelId);
-            }
         }
     }
     async runTurn(session, prompt) {
@@ -332,6 +334,7 @@ export class CopilotCliClient {
         this.fatalError = error;
         this.rejectFatalPromise(error);
         for (const [channelId, state] of this.channels.entries()) {
+            this.clearIdleTimer(state);
             state.activeTurn?.reject(error);
             for (const turn of state.queue) {
                 turn.reject(error);
@@ -351,6 +354,7 @@ export class CopilotCliClient {
         this.shutdownPromise = this.shutdownBackend(error);
     }
     invalidateSession(state, session) {
+        this.clearIdleTimer(state);
         if (state.session === session) {
             state.session = undefined;
         }
@@ -393,6 +397,55 @@ export class CopilotCliClient {
         }
         state.queue.length = 0;
     }
+    clearIdleTimer(state) {
+        state.idleTimerGeneration += 1;
+        if (!state.idleTimer) {
+            return;
+        }
+        clearTimeout(state.idleTimer);
+        state.idleTimer = undefined;
+    }
+    reconcileIdleChannelState(channelId, state) {
+        if (this.channels.get(channelId) !== state) {
+            return;
+        }
+        if (this.disposing || this.fatalError || this.backendClosed) {
+            this.clearIdleTimer(state);
+            return;
+        }
+        if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+            this.clearIdleTimer(state);
+            return;
+        }
+        if (!state.session) {
+            this.clearIdleTimer(state);
+            this.channels.delete(channelId);
+            return;
+        }
+        this.clearIdleTimer(state);
+        const generation = state.idleTimerGeneration;
+        state.idleTimer = setTimeout(() => {
+            this.evictIdleChannel(channelId, state, generation);
+        }, this.runtime.idleSessionTtlMs);
+    }
+    evictIdleChannel(channelId, state, generation) {
+        if (this.disposing || this.fatalError || this.backendClosed) {
+            return;
+        }
+        if (this.channels.get(channelId) !== state || state.idleTimerGeneration !== generation) {
+            return;
+        }
+        state.idleTimer = undefined;
+        if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+            return;
+        }
+        const session = state.session;
+        state.session = undefined;
+        if (session) {
+            this.closeSession(session);
+        }
+        this.channels.delete(channelId);
+    }
     async shutdownBackend(error) {
         if (this.backendClosed) {
             return;

package/dist/providers/create-provider.js

@@ -9,7 +9,9 @@ export function createProvider(config) {
             return new ClaudeProviderAdapter(cli);
         }
         case 'copilot': {
-            const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs);
+            const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
+                idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
+            });
             return new CopilotProviderAdapter(cli);
         }
         default:

package/dist/run.d.ts

@@ -1,7 +1,27 @@
-/**
- * Loads config from the environment, starts an `AgentsHost`, and wires up
- * graceful shutdown on SIGINT/SIGTERM. Shared by the plain env-var entry
- * point (`index.ts`) and the CLI entry point (`cli.ts`), which sets the
- * relevant env vars from argv before delegating here.
- */
-export declare function runMain(): Promise<void>;
+import { parseGenerateConfigSpec, resolveLocalConfigLayout } from './local-config.js';
+import type { LocalConfigGenerateResult, LocalConfigGenerateSpec, LocalConfigSnapshot } from './types.js';
+export interface RunMainOptions {
+    configPath?: string;
+}
+export interface ValidateLocalConfigDeps {
+    loadSnapshot?: (configPath: string) => Promise<LocalConfigSnapshot>;
+    logger?: Pick<Console, 'log'>;
+}
+export interface PrintLocalConfigLayoutDeps {
+    resolveLayout?: (rootPath: string) => ReturnType<typeof resolveLocalConfigLayout>;
+    writer?: Pick<Console, 'log'>;
+}
+export interface DescribeLocalConfigDeps {
+    loadSpec?: (configPath: string) => Promise<LocalConfigGenerateSpec>;
+    writer?: Pick<Console, 'log'>;
+}
+export interface GenerateLocalConfigDeps {
+    parseSpec?: (value: unknown, sourceLabel: string) => ReturnType<typeof parseGenerateConfigSpec>;
+    materialize?: (rootPath: string, spec: ReturnType<typeof parseGenerateConfigSpec>) => Promise<LocalConfigGenerateResult>;
+    writer?: Pick<Console, 'log'>;
+}
+export declare function validateLocalConfig(configPath: string, deps?: ValidateLocalConfigDeps): Promise<void>;
+export declare function printLocalConfigLayout(rootPath: string, deps?: PrintLocalConfigLayoutDeps): Promise<void>;
+export declare function describeLocalConfig(configPath: string, deps?: DescribeLocalConfigDeps): Promise<void>;
+export declare function generateLocalConfig(rootPath: string, specJson: string, sourceLabelOrDeps?: string | GenerateLocalConfigDeps, deps?: GenerateLocalConfigDeps): Promise<void>;
+export declare function runMain(options?: RunMainOptions): Promise<void>;

package/dist/run.js

@@ -1,14 +1,51 @@
-import { loadConfigFromEnv } from './config.js';
 import { AgentsHost } from './agents-host.js';
-/**
- * Loads config from the environment, starts an `AgentsHost`, and wires up
- * graceful shutdown on SIGINT/SIGTERM. Shared by the plain env-var entry
- * point (`index.ts`) and the CLI entry point (`cli.ts`), which sets the
- * relevant env vars from argv before delegating here.
- */
-export async function runMain() {
-    const config = loadConfigFromEnv();
-    const host = new AgentsHost(config);
+import { AgentsHostSupervisor } from './agents-host-supervisor.js';
+import { loadConfigFromEnv } from './config.js';
+import { loadLocalConfigGenerateSpec, loadLocalConfigSnapshot, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
+export async function validateLocalConfig(configPath, deps = {}) {
+    const loadSnapshot = deps.loadSnapshot ?? loadLocalConfigSnapshot;
+    const logger = deps.logger ?? console;
+    const snapshot = await loadSnapshot(configPath);
+    logger.log('[agents-host] local-config validation OK');
+    logger.log(`[agents-host] host config: ${snapshot.hostConfigPath}`);
+    logger.log(`[agents-host] agents dir: ${snapshot.agentsDir}`);
+    logger.log(`[agents-host] managed agents: ${snapshot.agents.length}`);
+    for (const agent of snapshot.agents) {
+        logger.log(`[agents-host] managed agent key=${agent.key} provider=${agent.config.agent.provider} sourcePath=${agent.sourcePath}`);
+    }
+}
+export async function printLocalConfigLayout(rootPath, deps = {}) {
+    const resolveLayout = deps.resolveLayout ?? resolveLocalConfigLayout;
+    const writer = deps.writer ?? console;
+    writer.log(JSON.stringify(resolveLayout(rootPath), null, 2));
+}
+export async function describeLocalConfig(configPath, deps = {}) {
+    const loadSpec = deps.loadSpec ?? loadLocalConfigGenerateSpec;
+    const writer = deps.writer ?? console;
+    writer.log(JSON.stringify(await loadSpec(configPath), null, 2));
+}
+export async function generateLocalConfig(rootPath, specJson, sourceLabelOrDeps = '--spec-json', deps = {}) {
+    const sourceLabel = typeof sourceLabelOrDeps === 'string' ? sourceLabelOrDeps : '--spec-json';
+    const resolvedDeps = typeof sourceLabelOrDeps === 'string' ? deps : sourceLabelOrDeps;
+    const parseSpec = resolvedDeps.parseSpec ?? parseGenerateConfigSpec;
+    const materialize = resolvedDeps.materialize ?? materializeLocalConfig;
+    const writer = resolvedDeps.writer ?? console;
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(specJson);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${sourceLabel}: ${message}`);
+    }
+    const spec = parseSpec(parsedJson, sourceLabel);
+    const result = await materialize(rootPath, spec);
+    writer.log(JSON.stringify(result, null, 2));
+}
+export async function runMain(options = {}) {
+    const host = options.configPath
+        ? new AgentsHostSupervisor(options.configPath)
+        : new AgentsHost(loadConfigFromEnv());
     const shutdown = (signal) => {
         console.log(`[agents-host] received ${signal}, shutting down`);
         host
@@ -19,4 +56,5 @@ export async function runMain() {
     process.on('SIGINT', () => shutdown('SIGINT'));
     process.on('SIGTERM', () => shutdown('SIGTERM'));
     await host.start();
+    console.log('[agents-host] ready');
 }

package/dist/types.d.ts

@@ -4,15 +4,11 @@ export interface ProviderCommandConfig {
     claudeArgs: string[];
     copilotCommand: string;
     copilotArgs: string[];
+    copilotSessionTtlMinutes: number;
 }
 export interface ProviderRuntimeConfig extends ProviderCommandConfig {
     provider: ProviderKind;
 }
-/**
- * Single hosted-agent configuration. The minimal agents host supports exactly
- * one Borgee agent per process — running multiple agents means running
- * multiple processes with different env vars (see README).
- */
 export interface HostedAgentConfig {
     agentApiKey: string;
     agentName: string;
@@ -22,6 +18,66 @@ export interface AgentsHostConfig extends ProviderCommandConfig {
     borgeeBaseUrl: string;
     agent: HostedAgentConfig;
 }
+export interface LocalHostConfigFile {
+    borgeeBaseUrl: string;
+    agentsDir?: string;
+    defaults?: Partial<ProviderCommandConfig>;
+}
+export interface LocalHostGenerateConfigFile {
+    borgeeBaseUrl: string;
+    defaults?: Partial<ProviderCommandConfig>;
+}
+export interface LocalAgentConfigFile extends Partial<ProviderCommandConfig> {
+    key: string;
+    name: string;
+    apiKey: string;
+    provider: ProviderKind;
+    enabled?: boolean;
+}
+export interface ManagedAgentConfigSnapshot {
+    key: string;
+    sourcePath: string;
+    config: AgentsHostConfig;
+}
+export interface LocalConfigSnapshot {
+    /** Stable caller-facing paths, suitable for validation output and publication watches. */
+    hostConfigPath: string;
+    hostConfigDir: string;
+    agentsDir: string;
+    /** Managed stable root when the snapshot comes from generate-config publication. */
+    managedRootPath?: string;
+    /** Resolved paths pinned before config files are read. */
+    resolvedHostConfigPath: string;
+    resolvedHostConfigDir: string;
+    resolvedAgentsDir: string;
+    agents: ManagedAgentConfigSnapshot[];
+}
+export interface LocalConfigGenerateSpec {
+    host: LocalHostGenerateConfigFile;
+    agents: LocalAgentConfigFile[];
+}
+export interface LocalConfigGenerateWarning {
+    code: 'PRUNE_SUPERSEDED_GENERATIONS_FAILED';
+    message: string;
+}
+export interface LocalConfigGenerateResult {
+    root: string;
+    hostConfigPath: string;
+    agentsDir: string;
+    generatedAgents: Array<{
+        key: string;
+        path: string;
+        provider: ProviderKind;
+        enabled: boolean;
+    }>;
+    /**
+     * Agent config paths removed from the active authoritative set. Publication
+     * switches the whole set atomically rather than deleting these paths first.
+     */
+    prunedAgentConfigPaths: string[];
+    /** Non-fatal maintenance problems encountered after publication. */
+    warnings: LocalConfigGenerateWarning[];
+}
 export interface ChannelMessageEvent {
     type?: string;
     channel_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,6 +23,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.2.1",
     "cross-spawn": "^7.0.6",
+    "yaml": "^2.8.1",
     "@borgee/plugin-sdk": "0.1.1"
   },
   "devDependencies": {
@@ -43,6 +44,7 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "pretest": "pnpm --filter @borgee/plugin-sdk build",
-    "test": "vitest run"
+    "test": "vitest run --testTimeout=10000",
+    "pretypecheck": "pnpm --filter @borgee/plugin-sdk build"
   }
 }