@borgee/agents-host 0.2.2 → 0.2.26

package/dist/index.js

@@ -1,9 +1,11 @@
+import { resolveAgentsHostDebugMode } from './debug.js';
 import { runMain } from './run.js';
-// Plain env-var entry point (`pnpm dev` / `pnpm start`). For the CLI entry
-// point that accepts `agents-host start <serverUrl> <apiKey> ...`, see
-// cli.ts, which sets the equivalent env vars from argv and delegates to the
-// same runMain().
-runMain().catch((error) => {
+// Plain env-var entry point (`pnpm dev` / `pnpm start`) for the standalone
+// single-agent process. For the CLI entry point that accepts foreground
+// `agents-host start <serverUrl> <apiKey> ...` and opt-in
+// `agents-host start-managed <serverUrl>` / `agents-host start-managed <serverUrl> <apiKey> ...`,
+// see cli.ts.
+runMain({ debug: resolveAgentsHostDebugMode(false, process.env) }).catch((error) => {
     console.error('[agents-host] fatal error:', error);
     process.exitCode = 1;
 });

package/dist/local-config.d.ts

@@ -36,16 +36,19 @@ export interface ManagedLocalConfigFileSystem extends LocalConfigFileSystem {
     chmod(path: string, mode: number): Promise<void>;
 }
 export declare function resolveLocalConfigLayout(rootPath: string): LocalConfigLayout;
-export declare function parseGenerateConfigSpec(value: unknown, sourceLabel: string): LocalConfigGenerateSpec;
+export declare function parseGenerateConfigSpec(value: unknown, sourceLabel: string, env?: NodeJS.ProcessEnv): LocalConfigGenerateSpec;
 export declare function loadLocalConfigSnapshot(hostConfigPath: string, deps?: {
     fileSystem?: LocalConfigFileSystem;
     acquireManagedGenerationLease?: boolean;
+    env?: NodeJS.ProcessEnv;
 }): Promise<LocalConfigSnapshot>;
 export declare function loadLocalConfigGenerateSpec(hostConfigPath: string, deps?: {
     fileSystem?: LocalConfigFileSystem;
     acquireManagedGenerationLease?: boolean;
+    env?: NodeJS.ProcessEnv;
 }): Promise<LocalConfigGenerateSpec>;
 export declare function materializeLocalConfig(rootPath: string, spec: LocalConfigGenerateSpec, deps?: {
     fileSystem?: ManagedLocalConfigFileSystem;
+    env?: NodeJS.ProcessEnv;
 }): Promise<LocalConfigGenerateResult>;
 export {};

package/dist/local-config.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
-import { optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
 import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
@@ -105,6 +105,14 @@ function parseProviderCommandOverrides(value, sourceLabel) {
     if (claudeArgs !== undefined) {
         overrides.claudeArgs = claudeArgs;
     }
+    const codexCommand = optionalNonEmptyString(value.codexCommand, 'codexCommand', sourceLabel);
+    if (codexCommand !== undefined) {
+        overrides.codexCommand = codexCommand;
+    }
+    const codexArgs = optionalStringArray(value.codexArgs, 'codexArgs', sourceLabel);
+    if (codexArgs !== undefined) {
+        overrides.codexArgs = codexArgs;
+    }
     const copilotCommand = optionalNonEmptyString(value.copilotCommand, 'copilotCommand', sourceLabel);
     if (copilotCommand !== undefined) {
         overrides.copilotCommand = copilotCommand;
@@ -144,21 +152,23 @@ function parseGenerateHostConfigFile(sourceLabel, value) {
         defaults: parseProviderCommandOverrides(value.defaults, `generate-config host spec ${sourceLabel}`),
     };
 }
-function parseAgentConfigFile(agentConfigPath, value) {
+function parseAgentConfigFile(agentConfigPath, value, env = process.env) {
     const enabled = value.enabled;
     if (enabled !== undefined && typeof enabled !== 'boolean') {
         throw new Error(`Invalid enabled in ${agentConfigPath}: expected a boolean`);
     }
+    const provider = resolveProvider(requireNonEmptyString(value.provider, `Invalid agent config ${agentConfigPath}: missing required provider`), `Invalid provider in ${agentConfigPath}`);
+    assertProviderCompatibility(provider, `Invalid provider in ${agentConfigPath}`, env);
     return {
         key: requireNonEmptyString(value.key, `Invalid agent config ${agentConfigPath}: missing required key`),
         name: requireNonEmptyString(value.name, `Invalid agent config ${agentConfigPath}: missing required name`),
         apiKey: requireNonEmptyString(value.apiKey, `Invalid agent config ${agentConfigPath}: missing required apiKey`),
-        provider: resolveProvider(requireNonEmptyString(value.provider, `Invalid agent config ${agentConfigPath}: missing required provider`), `Invalid provider in ${agentConfigPath}`),
+        provider,
         enabled: enabled ?? true,
         ...parseProviderCommandOverrides(value, `agent config ${agentConfigPath}`),
     };
 }
-export function parseGenerateConfigSpec(value, sourceLabel) {
+export function parseGenerateConfigSpec(value, sourceLabel, env = process.env) {
     if (!isRecord(value)) {
         throw new Error(`Invalid generate-config spec in ${sourceLabel}: expected a top-level object`);
     }
@@ -175,7 +185,7 @@ export function parseGenerateConfigSpec(value, sourceLabel) {
         if (!isRecord(entry)) {
             throw new Error(`Invalid generate-config agents[${index}] in ${sourceLabel}: expected an object`);
         }
-        const agent = parseAgentConfigFile(`generate-config agents[${index}] in ${sourceLabel}`, entry);
+        const agent = parseAgentConfigFile(`generate-config agents[${index}] in ${sourceLabel}`, entry, env);
         const existingIndex = seenKeys.get(agent.key);
         if (existingIndex !== undefined) {
             throw new Error(`Duplicate generate-config agent key "${agent.key}" in ${sourceLabel} at indexes ${existingIndex} and ${index}`);
@@ -566,6 +576,12 @@ function renderAgentConfigYaml(agent) {
     if (agent.claudeArgs !== undefined) {
         config.claudeArgs = agent.claudeArgs;
     }
+    if (agent.codexCommand !== undefined) {
+        config.codexCommand = agent.codexCommand;
+    }
+    if (agent.codexArgs !== undefined) {
+        config.codexArgs = agent.codexArgs;
+    }
     if (agent.copilotCommand !== undefined) {
         config.copilotCommand = agent.copilotCommand;
     }
@@ -631,7 +647,7 @@ export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
         const seenKeys = new Map();
         for (const agentFilePath of agentFiles) {
             const agentRecord = await loadParsedDocument(fileSystem, agentFilePath, 'agent config');
-            const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord);
+            const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord, deps.env);
             const existingPath = seenKeys.get(agentConfig.key);
             if (existingPath) {
                 throw new Error(`Duplicate agent key "${agentConfig.key}" in ${existingPath} and ${agentFilePath}`);
@@ -681,7 +697,7 @@ export async function loadLocalConfigGenerateSpec(hostConfigPath, deps = {}) {
                 continue;
             }
             const agentRecord = await loadParsedDocument(fileSystem, agentFilePath, 'agent config');
-            const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord);
+            const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord, deps.env);
             const existingPath = seenKeys.get(agentConfig.key);
             if (existingPath) {
                 throw new Error(`Duplicate agent key "${agentConfig.key}" in ${existingPath} and ${agentFilePath}`);
@@ -736,6 +752,7 @@ export async function materializeLocalConfig(rootPath, spec, deps = {}) {
             await loadLocalConfigSnapshot(generationHostConfigPath, {
                 fileSystem,
                 acquireManagedGenerationLease: false,
+                env: deps.env,
             });
             const nextCurrentPath = join(layout.root, `.${MANAGED_CURRENT_LINK_NAME}-${generationName}`);
             await fileSystem.symlink(join(MANAGED_GENERATIONS_DIRNAME, generationName), nextCurrentPath);

package/dist/managed-daemon-log.d.ts

@@ -0,0 +1,34 @@
+interface FileStatsLike {
+    size: number;
+    ino: number | bigint;
+    isFile(): boolean;
+}
+interface ManagedDaemonLogFileHandle {
+    stat(): Promise<FileStatsLike>;
+    read(buffer: Buffer, offset: number, length: number, position: number): Promise<{
+        bytesRead: number;
+    }>;
+    close(): Promise<void>;
+}
+interface ManagedDaemonLogFs {
+    stat(path: string): Promise<FileStatsLike>;
+    open(path: string, flags: string): Promise<ManagedDaemonLogFileHandle>;
+}
+export interface RunManagedDaemonLogCommandOptions {
+    serverUrl: string;
+    lines?: number;
+    follow?: boolean;
+    pathOnly?: boolean;
+    env?: NodeJS.ProcessEnv;
+    resolvedHomeDir?: string;
+    signal?: AbortSignal;
+}
+export interface RunManagedDaemonLogCommandDeps {
+    fs?: ManagedDaemonLogFs;
+    write?: (chunk: string) => void;
+    sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+    pollIntervalMs?: number;
+}
+export declare function resolveManagedDaemonLogCliPath(serverUrl: string, env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
+export declare function runManagedDaemonLogCommand(options: RunManagedDaemonLogCommandOptions, deps?: RunManagedDaemonLogCommandDeps): Promise<void>;
+export {};

package/dist/managed-daemon-log.js

@@ -0,0 +1,261 @@
+import { promises as fs } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, } from './state-paths.js';
+const DEFAULT_TAIL_LINES = 100;
+const DEFAULT_POLL_INTERVAL_MS = 500;
+const READ_CHUNK_BYTES = 64 * 1024;
+const CURSOR_ANCHOR_BYTES = 256;
+const defaultManagedDaemonLogFs = {
+    stat: (path) => fs.stat(path),
+    open: async (path, flags) => {
+        const handle = await fs.open(path, flags);
+        return wrapFileHandle(handle);
+    },
+};
+function wrapFileHandle(handle) {
+    return {
+        stat: () => handle.stat(),
+        async read(buffer, offset, length, position) {
+            const result = await handle.read(buffer, offset, length, position);
+            return { bytesRead: result.bytesRead };
+        },
+        close: () => handle.close(),
+    };
+}
+function resolveSleep(milliseconds, signal) {
+    return new Promise((resolveDelay) => {
+        if (signal?.aborted) {
+            resolveDelay();
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolveDelay();
+        }, milliseconds);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            resolveDelay();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function countTrailingNewlineOffset(text) {
+    let offset = text.length;
+    while (offset > 0 && text[offset - 1] === '\n') {
+        offset--;
+    }
+    return offset;
+}
+function sliceLastLines(text, lineCount) {
+    if (lineCount <= 0 || text.length === 0) {
+        return '';
+    }
+    const scanLimit = countTrailingNewlineOffset(text);
+    let linesSeen = 0;
+    for (let index = scanLimit - 1; index >= 0; index--) {
+        if (text[index] !== '\n') {
+            continue;
+        }
+        linesSeen++;
+        if (linesSeen === lineCount) {
+            return text.slice(index + 1);
+        }
+    }
+    return text;
+}
+function countNewlinesInBuffer(buffer) {
+    let count = 0;
+    for (const byte of buffer) {
+        if (byte === 0x0a) {
+            count++;
+        }
+    }
+    return count;
+}
+async function withOpenFile(filePath, managedFs, operation) {
+    const handle = await managedFs.open(filePath, 'r');
+    try {
+        return await operation(handle);
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readRange(handle, start, length) {
+    const buffer = Buffer.alloc(length);
+    let totalBytesRead = 0;
+    while (totalBytesRead < length) {
+        const { bytesRead } = await handle.read(buffer, totalBytesRead, length - totalBytesRead, start + totalBytesRead);
+        if (bytesRead === 0) {
+            break;
+        }
+        totalBytesRead += bytesRead;
+    }
+    return buffer.subarray(0, totalBytesRead);
+}
+async function readTailFromHandle(handle, lineCount) {
+    if (lineCount <= 0) {
+        return '';
+    }
+    const stats = await handle.stat();
+    let position = stats.size;
+    const chunks = [];
+    let newlinesFound = 0;
+    while (position > 0 && newlinesFound <= lineCount) {
+        const start = Math.max(0, position - READ_CHUNK_BYTES);
+        const length = position - start;
+        const chunk = await readRange(handle, start, length);
+        if (chunk.length === 0) {
+            break;
+        }
+        chunks.unshift(Buffer.from(chunk));
+        newlinesFound += countNewlinesInBuffer(chunk);
+        position = start;
+    }
+    const collected = Buffer.concat(chunks).toString('utf8');
+    return sliceLastLines(collected, lineCount);
+}
+async function readCursorAnchor(handle, endPosition) {
+    if (endPosition <= 0) {
+        return Buffer.alloc(0);
+    }
+    const length = Math.min(CURSOR_ANCHOR_BYTES, endPosition);
+    const start = endPosition - length;
+    return readRange(handle, start, length);
+}
+function createMissingLogFileError(logPath) {
+    return new Error(`Managed daemon log file does not exist yet: ${logPath}`);
+}
+function createNonFileLogPathError(logPath) {
+    return new Error(`Managed daemon log path is not a regular file: ${logPath}`);
+}
+async function readInitialTail(logPath, lineCount, managedFs) {
+    const openErrorMessage = (error) => {
+        if (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT') {
+            throw createMissingLogFileError(logPath);
+        }
+        throw error;
+    };
+    const { text, stats, anchor } = await withOpenFile(logPath, managedFs, async (handle) => {
+        const currentStats = await handle.stat();
+        if (!currentStats.isFile()) {
+            throw createNonFileLogPathError(logPath);
+        }
+        return {
+            text: await readTailFromHandle(handle, lineCount),
+            stats: currentStats,
+            anchor: await readCursorAnchor(handle, currentStats.size),
+        };
+    }).catch(openErrorMessage);
+    return {
+        text,
+        cursor: {
+            ino: stats.ino,
+            position: stats.size,
+            anchor,
+        },
+    };
+}
+async function readAppendedChunk(logPath, cursor, managedFs) {
+    const isNotFoundError = (error) => typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+    const stats = await managedFs.stat(logPath).catch((error) => {
+        if (isNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    });
+    if (stats === null || !stats.isFile()) {
+        return {
+            bytes: Buffer.alloc(0),
+            cursor: { ino: null, position: 0, anchor: Buffer.alloc(0) },
+            reset: true,
+        };
+    }
+    try {
+        return await withOpenFile(logPath, managedFs, async (handle) => {
+            const currentStats = await handle.stat();
+            if (!currentStats.isFile()) {
+                return {
+                    bytes: Buffer.alloc(0),
+                    cursor: { ino: null, position: 0, anchor: Buffer.alloc(0) },
+                    reset: true,
+                };
+            }
+            let resetCursor = cursor.ino !== currentStats.ino || currentStats.size < cursor.position;
+            if (!resetCursor && cursor.anchor.length > 0) {
+                const anchor = await readCursorAnchor(handle, cursor.position);
+                if (!anchor.equals(cursor.anchor)) {
+                    resetCursor = true;
+                }
+            }
+            const nextPosition = resetCursor ? 0 : cursor.position;
+            if (currentStats.size <= nextPosition) {
+                return {
+                    bytes: Buffer.alloc(0),
+                    cursor: { ino: currentStats.ino, position: currentStats.size, anchor: await readCursorAnchor(handle, currentStats.size) },
+                    reset: resetCursor,
+                };
+            }
+            const bytes = await readRange(handle, nextPosition, currentStats.size - nextPosition);
+            const endPosition = nextPosition + bytes.length;
+            return {
+                bytes,
+                cursor: {
+                    ino: currentStats.ino,
+                    position: endPosition,
+                    anchor: await readCursorAnchor(handle, endPosition),
+                },
+                reset: resetCursor,
+            };
+        });
+    }
+    catch (error) {
+        if (isNotFoundError(error)) {
+            return {
+                bytes: Buffer.alloc(0),
+                cursor: { ino: null, position: 0, anchor: Buffer.alloc(0) },
+                reset: true,
+            };
+        }
+        throw error;
+    }
+}
+export function resolveManagedDaemonLogCliPath(serverUrl, env = process.env, resolvedHomeDir) {
+    const rootPath = resolveManagedRuntimeRoot(serverUrl, env, resolvedHomeDir);
+    return resolveManagedDaemonLogPath(rootPath);
+}
+export async function runManagedDaemonLogCommand(options, deps = {}) {
+    const lineCount = options.lines ?? DEFAULT_TAIL_LINES;
+    const follow = options.follow === true;
+    const pathOnly = options.pathOnly === true;
+    const write = deps.write ?? ((chunk) => process.stdout.write(chunk));
+    const managedFs = deps.fs ?? defaultManagedDaemonLogFs;
+    const sleep = deps.sleep ?? resolveSleep;
+    const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const logPath = resolveManagedDaemonLogCliPath(options.serverUrl, options.env, options.resolvedHomeDir);
+    if (pathOnly) {
+        write(`${logPath}\n`);
+        return;
+    }
+    const initial = await readInitialTail(logPath, lineCount, managedFs);
+    if (initial.text.length > 0) {
+        write(initial.text);
+    }
+    if (!follow) {
+        return;
+    }
+    let cursor = initial.cursor;
+    let decoder = new StringDecoder('utf8');
+    while (!options.signal?.aborted) {
+        const next = await readAppendedChunk(logPath, cursor, managedFs);
+        cursor = next.cursor;
+        if (next.reset) {
+            decoder = new StringDecoder('utf8');
+        }
+        if (next.bytes.length > 0) {
+            write(decoder.write(next.bytes));
+        }
+        await sleep(pollIntervalMs, options.signal);
+    }
+}

package/dist/managed-daemon.d.ts

@@ -0,0 +1,220 @@
+import { spawn } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
+import type { LocalAgentConfigFile, LocalConfigGenerateSpec } from './types.js';
+export declare const MANAGED_DAEMON_ERROR_CODES: readonly ["MANAGED_BINDING_MISMATCH", "MANAGED_RUNTIME_NOT_PRESENT", "MANAGED_SPEC_INVALID", "MANAGED_BOOTSTRAP_LOCK_TIMEOUT", "MANAGED_DAEMON_START_FAILED", "MANAGED_DAEMON_NOT_READY", "MANAGED_RELOAD_FAILED", "MANAGED_CONVERGENCE_FAILED"];
+export type ManagedDaemonErrorCode = (typeof MANAGED_DAEMON_ERROR_CODES)[number];
+export interface ManagedDaemonErrorPayload {
+    code: ManagedDaemonErrorCode;
+    message: string;
+}
+export interface BootstrapManagedDaemonStartOptions {
+    serverUrl: string;
+    apiKey?: string;
+    env?: Record<string, string>;
+    processEnv?: NodeJS.ProcessEnv;
+    debug?: boolean;
+}
+export interface ManagedDaemonStatusResponse {
+    ok: true;
+    type: 'status';
+    borgeeBaseUrl: string;
+    hostConfigPath: string;
+    logPath?: string;
+    agentCount: number;
+    enabledAgentCount: number;
+    managedRuntimeFingerprint?: string;
+}
+export interface ManagedDaemonUpsertAgentResponse {
+    ok: true;
+    type: 'upsertAgent';
+    agentKey: string;
+    hostConfigPath: string;
+    logPath?: string;
+    agentCount: number;
+}
+export interface ManagedDaemonDescribeSpecResponse {
+    ok: true;
+    type: 'describeSpec';
+    present: boolean;
+    spec?: LocalConfigGenerateSpec;
+}
+export interface ManagedDaemonShutdownResponse {
+    ok: true;
+    type: 'shutdown';
+}
+export interface ManagedDaemonApplySpecResponse {
+    ok: true;
+    type: 'applySpec';
+    hostConfigPath: string;
+    logPath?: string;
+    agentCount: number;
+    enabledAgentCount: number;
+}
+export interface ManagedDaemonErrorResponse {
+    ok: false;
+    error: ManagedDaemonErrorPayload;
+}
+export type ManagedDaemonControlResponse = ManagedDaemonStatusResponse | ManagedDaemonUpsertAgentResponse | ManagedDaemonDescribeSpecResponse | ManagedDaemonShutdownResponse | ManagedDaemonApplySpecResponse | ManagedDaemonErrorResponse;
+export type ManagedDaemonControlRequest = {
+    type: 'status';
+} | {
+    type: 'describeSpec';
+    borgeeBaseUrl: string;
+} | {
+    type: 'upsertAgent';
+    borgeeBaseUrl: string;
+    agent: LocalAgentConfigFile;
+} | {
+    type: 'shutdown';
+} | {
+    type: 'applySpec';
+    borgeeBaseUrl: string;
+    spec: LocalConfigGenerateSpec;
+};
+export interface BootstrapManagedDaemonStartDeps {
+    loadSpec?: (configPath: string) => Promise<LocalConfigGenerateSpec>;
+    materialize?: (rootPath: string, spec: LocalConfigGenerateSpec) => Promise<unknown>;
+    sendRequest?: (rootPath: string, request: ManagedDaemonControlRequest) => Promise<ManagedDaemonControlResponse>;
+    spawnDaemon?: (options: {
+        rootPath: string;
+        debug: boolean;
+    }) => ChildProcess | Promise<ChildProcess>;
+    waitForDaemonReady?: (rootPath: string, sendRequest: NonNullable<BootstrapManagedDaemonStartDeps['sendRequest']>, child: ChildProcess) => Promise<void>;
+    acquireBootstrapLock?: (rootPath: string) => Promise<() => Promise<void>>;
+    waitForShutdown?: (rootPath: string) => Promise<void>;
+}
+export interface ManagedSupervisorControl {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reloadNow(failOnStartError?: boolean): Promise<void>;
+    hasActiveAgent(key: string): boolean;
+}
+export interface ManagedAgentsHostDaemonDeps {
+    createSupervisor?: (configPath: string, debug: boolean) => ManagedSupervisorControl;
+    loadSpec?: (configPath: string) => Promise<LocalConfigGenerateSpec>;
+    materialize?: (rootPath: string, spec: LocalConfigGenerateSpec) => Promise<unknown>;
+    logger?: Pick<Console, 'log' | 'error'>;
+    logPath?: string;
+}
+export interface DescribeManagedSpecOptions {
+    serverUrl: string;
+    processEnv?: NodeJS.ProcessEnv;
+}
+export interface CleanupManagedRuntimeOptions {
+    serverUrl: string;
+    purge?: boolean;
+    processEnv?: NodeJS.ProcessEnv;
+}
+export interface CleanupManagedRuntimeDeps {
+    sendRequest?: (rootPath: string, request: ManagedDaemonControlRequest) => Promise<ManagedDaemonControlResponse>;
+    removeRuntimeRoot?: (rootPath: string) => Promise<void>;
+    canConnectToSocket?: (socketPath: string) => Promise<boolean>;
+    waitForShutdown?: (rootPath: string) => Promise<void>;
+}
+export interface DescribeManagedSpecDeps {
+    loadSpec?: (configPath: string) => Promise<LocalConfigGenerateSpec>;
+    sendRequest?: (rootPath: string, request: ManagedDaemonControlRequest) => Promise<ManagedDaemonControlResponse>;
+}
+export type DescribeManagedSpecResult = {
+    ok: true;
+    present: false;
+} | {
+    ok: true;
+    present: true;
+    spec: LocalConfigGenerateSpec;
+} | ManagedDaemonErrorResponse;
+export interface ApplyManagedSpecOptions {
+    serverUrl: string;
+    spec: unknown;
+    processEnv?: NodeJS.ProcessEnv;
+    debug?: boolean;
+}
+export interface ApplyManagedSpecDeps {
+    loadSpec?: (configPath: string) => Promise<LocalConfigGenerateSpec>;
+    materialize?: (rootPath: string, spec: LocalConfigGenerateSpec) => Promise<unknown>;
+    sendRequest?: (rootPath: string, request: ManagedDaemonControlRequest) => Promise<ManagedDaemonControlResponse>;
+    spawnDaemon?: (options: {
+        rootPath: string;
+        debug: boolean;
+    }) => ChildProcess | Promise<ChildProcess>;
+    waitForDaemonReady?: (rootPath: string, sendRequest: NonNullable<ApplyManagedSpecDeps['sendRequest']>, child: ChildProcess) => Promise<void>;
+    acquireBootstrapLock?: (rootPath: string) => Promise<() => Promise<void>>;
+    createSupervisor?: (configPath: string, debug: boolean) => ManagedSupervisorControl;
+    clearManagedRuntime?: (rootPath: string) => Promise<void>;
+    waitForShutdown?: (rootPath: string) => Promise<void>;
+}
+export type ApplyManagedSpecResult = {
+    ok: true;
+    daemon: 'started' | 'reused';
+    agentCount: number;
+    enabledAgentCount: number;
+    logPath?: string;
+} | ManagedDaemonErrorResponse;
+export interface ManagedDaemonLogFileHandle {
+    logPath: string;
+    fd: number;
+    close(): Promise<void>;
+}
+interface SpawnDetachedManagedProcessOptions {
+    rootPath: string;
+    command: string;
+    args: string[];
+    env?: NodeJS.ProcessEnv;
+}
+interface SpawnDetachedManagedProcessDeps {
+    openLogFile?: (rootPath: string) => Promise<ManagedDaemonLogFileHandle>;
+    spawnProcess?: typeof spawn;
+}
+interface SpawnManagedDaemonProcessDeps {
+    spawnDetachedProcess?: typeof spawnDetachedManagedProcess;
+}
+export declare function resolveManagedAgentKey(apiKey: string): string;
+export declare function buildManagedLocalAgentConfig(options: BootstrapManagedDaemonStartOptions): {
+    rootPath: string;
+    hostConfigPath: string;
+    borgeeBaseUrl: string;
+    agent: LocalAgentConfigFile;
+};
+export declare function acquireBootstrapLock(rootPath: string): Promise<() => Promise<void>>;
+export declare function sendManagedDaemonRequest(rootPath: string, request: ManagedDaemonControlRequest): Promise<ManagedDaemonControlResponse>;
+export declare function waitForManagedDaemonReady(rootPath: string, sendRequest: (rootPath: string, request: ManagedDaemonControlRequest) => Promise<ManagedDaemonControlResponse>, child: ChildProcess): Promise<void>;
+export declare function cleanupManagedRuntime(options: CleanupManagedRuntimeOptions, deps?: CleanupManagedRuntimeDeps): Promise<void>;
+export declare function openManagedDaemonLogFile(rootPath: string): Promise<ManagedDaemonLogFileHandle>;
+export declare function spawnDetachedManagedProcess(options: SpawnDetachedManagedProcessOptions, deps?: SpawnDetachedManagedProcessDeps): Promise<ChildProcess>;
+export declare function spawnManagedDaemonProcess(options: {
+    rootPath: string;
+    debug: boolean;
+    processEnv?: NodeJS.ProcessEnv;
+}, deps?: SpawnManagedDaemonProcessDeps): Promise<ChildProcess>;
+export declare function bootstrapManagedDaemonStart(options: BootstrapManagedDaemonStartOptions, deps?: BootstrapManagedDaemonStartDeps): Promise<void>;
+export declare function describeManagedSpec(options: DescribeManagedSpecOptions, deps?: DescribeManagedSpecDeps): Promise<DescribeManagedSpecResult>;
+export declare function applyManagedSpec(options: ApplyManagedSpecOptions, deps?: ApplyManagedSpecDeps): Promise<ApplyManagedSpecResult>;
+export declare class ManagedAgentsHostDaemon {
+    private readonly rootPath;
+    private readonly hostConfigPath;
+    private readonly socketPath;
+    private readonly createSupervisor;
+    private readonly supervisor;
+    private readonly loadSpec;
+    private readonly materialize;
+    private readonly managedRuntimeFingerprint;
+    private readonly logger;
+    private readonly logPath;
+    private readonly server;
+    private requestQueue;
+    private started;
+    private ready;
+    private ownsSocket;
+    private shutdownRequested;
+    private ownedSocketInode;
+    constructor(rootPath: string, debug?: boolean, deps?: ManagedAgentsHostDaemonDeps);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private listen;
+    private handleSocket;
+    private respond;
+    private handleRequest;
+    private enqueue;
+    private publishSpecWithRollback;
+}
+export {};