@borgee/agents-host 0.2.35 → 0.2.56

package/dist/managed-daemon.js

@@ -2,13 +2,15 @@ import { createHash, randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createConnection, createServer } from 'node:net';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
-import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.js';
+import { resolveChannelWorkspaceDirectory, resolveChannelWorkspaceRootDirectory, resolveManagedWorkspaceCollectionRoot, resolveTaskWorkspaceDirectory, } from './context/injection.js';
+import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, serializeManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
 import { DEFAULT_PROVIDER_COMMAND_CONFIG, hasLegacyClaudeOneShotArgs, loadConfigFromEnv, } from './config.js';
 import { loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
-import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonLogPath, resolveManagedDaemonSocketPath, resolveManagedRuntimeRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
+import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedStateRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
 const MANAGED_ROOT_MODE = 0o700;
 const MANAGED_CONFIG_MODE = 0o600;
 const BOOTSTRAP_LOCK_WAIT_MS = 10_000;
@@ -48,6 +50,9 @@ function isAlreadyExistsError(error) {
 function isSocketBusyError(error) {
     return isNodeErrorWithCode(error, 'EADDRINUSE');
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function delay(milliseconds) {
     return new Promise((resolveDelay) => {
         setTimeout(resolveDelay, milliseconds);
@@ -157,6 +162,7 @@ function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
         compatibilityGates,
         providerImplementationOverrides,
         internalPolicyMode: snapshot.internalPolicyMode,
+        projectionStrategy: snapshot.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     };
 }
 function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
@@ -178,11 +184,19 @@ function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
     if (record.internalPolicyMode !== 'audit-only' && record.internalPolicyMode !== 'enforce') {
         throw new Error(`Invalid ${sourceLabel}: expected internalPolicyMode to be "audit-only" or "enforce"`);
     }
+    const rawProjectionStrategy = typeof record.projectionStrategy === 'string'
+        ? record.projectionStrategy
+        : record.claudePromptStrategy;
+    const projectionStrategy = normalizeProjectionStrategy(rawProjectionStrategy);
+    if (rawProjectionStrategy !== undefined && !projectionStrategy) {
+        throw new Error(`Invalid ${sourceLabel}: expected projectionStrategy to be "session-brief", "turn-full", "message-only", "turn-thin", or "file-brief"`);
+    }
     return normalizeManagedRuntimeSettingsSnapshot({
         schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
         compatibilityGates: [...record.compatibilityGates],
         providerImplementationOverrides: [...record.providerImplementationOverrides],
         internalPolicyMode: record.internalPolicyMode,
+        projectionStrategy: projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     });
 }
 async function loadManagedRuntimeSettingsSnapshot(rootPath) {
@@ -205,7 +219,7 @@ async function writeManagedRuntimeSettingsSnapshot(rootPath, snapshot) {
     await ensureDirectory(rootPath, MANAGED_ROOT_MODE);
     const settingsPath = resolveManagedRuntimeSettingsPath(rootPath);
     const normalizedSnapshot = normalizeManagedRuntimeSettingsSnapshot(snapshot);
-    await fs.writeFile(settingsPath, `${JSON.stringify(normalizedSnapshot)}\n`, {
+    await fs.writeFile(settingsPath, `${serializeManagedRuntimeSettingsSnapshot(normalizedSnapshot)}\n`, {
         encoding: 'utf8',
         mode: MANAGED_CONFIG_MODE,
     });
@@ -226,6 +240,7 @@ function buildManagedRuntimeSettingsEnv(baseEnv, snapshot) {
         [INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV]: resolveDisabledDefaultCompatibilityGates(snapshot.compatibilityGates).join(','),
         [INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]: snapshot.providerImplementationOverrides.join(','),
         [INTERNAL_POLICY_MODE_ENV]: snapshot.internalPolicyMode,
+        [INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV]: snapshot.projectionStrategy,
     };
 }
 function buildDesiredManagedRuntimeSettingsFromSnapshot(snapshot) {
@@ -599,8 +614,11 @@ async function canConnectToSocket(socketPath) {
         socket.once('error', () => finalize(false));
     });
 }
-async function removeStaleControlSocket(socketPath) {
-    const stats = await fs.lstat(socketPath).catch((error) => {
+async function removeStaleControlSocket(endpoint) {
+    if (endpoint.kind === 'named-pipe') {
+        return false;
+    }
+    const stats = await fs.lstat(endpoint.address).catch((error) => {
         if (isNotFoundError(error)) {
             return undefined;
         }
@@ -610,15 +628,15 @@ async function removeStaleControlSocket(socketPath) {
         return false;
     }
     if (stats.isDirectory() || stats.isSymbolicLink()) {
-        throw new Error(`Managed control socket path has an unexpected value: ${socketPath}`);
+        throw new Error(`Managed control socket path has an unexpected value: ${endpoint.address}`);
     }
-    if (await canConnectToSocket(socketPath)) {
+    if (await canConnectToSocket(endpoint.address)) {
         return false;
     }
     if (!stats.isSocket() && !stats.isFile()) {
-        throw new Error(`Managed control socket path has an unexpected value: ${socketPath}`);
+        throw new Error(`Managed control socket path has an unexpected value: ${endpoint.address}`);
     }
-    await fs.rm(socketPath, { force: true });
+    await fs.rm(endpoint.address, { force: true });
     return true;
 }
 function parseDaemonResponse(raw) {
@@ -655,12 +673,12 @@ function isManagedDaemonConnectionError(error) {
         isNodeErrorWithCode(error, 'ECONNRESET'));
 }
 export async function sendManagedDaemonRequest(rootPath, request) {
-    const socketPath = resolveManagedDaemonSocketPath(rootPath);
+    const endpoint = resolveManagedDaemonEndpoint(rootPath);
     const requestTimeoutMs = request.type === 'upsertAgent' || request.type === 'applySpec'
         ? DAEMON_RECONCILE_WAIT_MS
         : DAEMON_READY_WAIT_MS;
     return new Promise((resolveRequest, rejectRequest) => {
-        const socket = createConnection(socketPath);
+        const socket = createConnection(endpoint.address);
         let settled = false;
         let responseBuffer = '';
         const rejectOnce = (error) => {
@@ -681,7 +699,7 @@ export async function sendManagedDaemonRequest(rootPath, request) {
         };
         socket.setEncoding('utf8');
         socket.setTimeout(requestTimeoutMs);
-        socket.once('timeout', () => rejectOnce(new Error(`Timed out talking to managed daemon: ${socketPath}`)));
+        socket.once('timeout', () => rejectOnce(new Error(`Timed out talking to managed daemon: ${endpoint.address}`)));
         socket.once('error', rejectOnce);
         socket.on('data', (chunk) => {
             responseBuffer += chunk;
@@ -790,9 +808,9 @@ async function readReadyManagedDaemonStatus(rootPath, sendRequest) {
 }
 async function waitForManagedDaemonShutdown(rootPath, canConnect) {
     const deadline = Date.now() + DAEMON_READY_WAIT_MS;
-    const socketPath = resolveManagedDaemonSocketPath(rootPath);
+    const endpoint = resolveManagedDaemonEndpoint(rootPath);
     while (Date.now() < deadline) {
-        const listening = await canConnect(socketPath).catch((error) => {
+        const listening = await canConnect(endpoint.address).catch((error) => {
             if (isNodeErrorWithCode(error, 'ENOENT')) {
                 return false;
             }
@@ -816,6 +834,101 @@ async function shutdownManagedDaemon(rootPath, sendRequest, waitForShutdown) {
     }
     await waitForShutdown(rootPath);
 }
+function resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, owningChannelId, rootPath) {
+    if (!owningChannelId || !isAbsolute(rootPath)) {
+        return null;
+    }
+    const expectedWorkspacePath = resolveChannelWorkspaceDirectory(workspaceCollectionRoot, owningChannelId);
+    if (rootPath !== expectedWorkspacePath) {
+        return null;
+    }
+    return resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, owningChannelId);
+}
+async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
+    const trustedWorkspaceCollectionRoots = new Set([
+        resolveManagedWorkspaceCollectionRoot(undefined, processEnv),
+    ]);
+    const managedStateRoot = resolveManagedStateRoot(rootPath);
+    const agentStateEntries = await fs.readdir(managedStateRoot, { withFileTypes: true }).catch((error) => {
+        if (isNotFoundError(error)) {
+            return [];
+        }
+        throw error;
+    });
+    const workspaceRoots = new Set();
+    for (const agentStateEntry of agentStateEntries) {
+        if (!agentStateEntry.isDirectory()) {
+            continue;
+        }
+        const channelContextRoot = join(managedStateRoot, agentStateEntry.name, 'channel-context');
+        const channelEntries = await fs.readdir(channelContextRoot, { withFileTypes: true }).catch((error) => {
+            if (isNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        });
+        for (const channelEntry of channelEntries) {
+            if (!channelEntry.isDirectory()) {
+                continue;
+            }
+            const payloadPath = join(channelContextRoot, channelEntry.name, 'context.json');
+            const payload = await fs.readFile(payloadPath, 'utf8').catch((error) => {
+                if (isNotFoundError(error)) {
+                    return undefined;
+                }
+                throw error;
+            });
+            if (!payload) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(parsed) || typeof parsed.channelId !== 'string' || !isRecord(parsed.resolvedWorkspace)) {
+                continue;
+            }
+            const resolvedWorkspace = parsed.resolvedWorkspace;
+            if ((resolvedWorkspace.authority !== 'channel' && resolvedWorkspace.authority !== 'task')
+                || typeof resolvedWorkspace.rootPath !== 'string'
+                || !isAbsolute(resolvedWorkspace.rootPath)) {
+                continue;
+            }
+            for (const workspaceCollectionRoot of trustedWorkspaceCollectionRoots) {
+                if (resolvedWorkspace.authority === 'channel') {
+                    if (typeof resolvedWorkspace.owningChannelId !== 'string'
+                        || resolvedWorkspace.owningChannelId.length === 0) {
+                        continue;
+                    }
+                    const trustedChannelWorkspaceRoot = resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, resolvedWorkspace.owningChannelId, resolvedWorkspace.rootPath);
+                    if (!trustedChannelWorkspaceRoot) {
+                        continue;
+                    }
+                    workspaceRoots.add(trustedChannelWorkspaceRoot);
+                    break;
+                }
+                const expectedWorkspacePath = resolvedWorkspace.authority === 'task'
+                    ? typeof resolvedWorkspace.taskId === 'string' && resolvedWorkspace.taskId.length > 0
+                        ? resolveTaskWorkspaceDirectory(workspaceCollectionRoot, parsed.channelId, resolvedWorkspace.taskId)
+                        : null
+                    : null;
+                if (!expectedWorkspacePath) {
+                    continue;
+                }
+                if (resolvedWorkspace.rootPath !== expectedWorkspacePath) {
+                    continue;
+                }
+                workspaceRoots.add(dirname(expectedWorkspacePath));
+                workspaceRoots.add(resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, parsed.channelId));
+                break;
+            }
+        }
+    }
+    return [...workspaceRoots].sort((left, right) => left.localeCompare(right));
+}
 export async function cleanupManagedRuntime(options, deps = {}) {
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const removeRuntimeRoot = deps.removeRuntimeRoot ??
@@ -852,6 +965,9 @@ export async function cleanupManagedRuntime(options, deps = {}) {
         await waitForShutdown(resolved.rootPath);
     }
     if (options.purge === true) {
+        for (const workspaceRoot of await discoverManagedWorkspaceRootsForPurge(resolved.rootPath, options.processEnv ?? process.env)) {
+            await fs.rm(workspaceRoot, { recursive: true, force: true });
+        }
         await removeRuntimeRoot(resolved.rootPath);
     }
 }
@@ -897,16 +1013,16 @@ export async function spawnManagedDaemonProcess(options, deps = {}) {
     }
     const thisPath = fileURLToPath(import.meta.url);
     const cliEntrypointPath = join(dirname(thisPath), thisPath.endsWith('.ts') ? 'cli.ts' : 'cli.js');
+    const baseEnv = {
+        ...process.env,
+        ...(options.processEnv ?? {}),
+    };
     return spawnDetachedProcess({
         rootPath: options.rootPath,
         command: process.execPath,
         env: {
-            ...buildManagedRuntimeSettingsEnv({
-                ...process.env,
-                ...(options.processEnv ?? {}),
-            }, managedRuntimeSettingsSnapshot),
+            ...buildManagedRuntimeSettingsEnv(baseEnv, managedRuntimeSettingsSnapshot),
             AGENTS_HOST_MANAGED_DAEMON_LOG_PATH: resolveManagedDaemonLogPath(options.rootPath),
-            AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR: options.rootPath,
         },
         args: [
             ...process.execArgv,
@@ -1481,7 +1597,7 @@ export async function applyManagedSpec(options, deps = {}) {
 export class ManagedAgentsHostDaemon {
     rootPath;
     hostConfigPath;
-    socketPath;
+    endpoint;
     createSupervisor;
     supervisor;
     loadSpec;
@@ -1493,14 +1609,14 @@ export class ManagedAgentsHostDaemon {
     requestQueue = Promise.resolve();
     started = false;
     ready = false;
-    ownsSocket = false;
+    ownsEndpoint = false;
     shutdownRequested = false;
     ownedSocketInode = null;
     constructor(rootPath, debug = false, deps = {}) {
         const layout = resolveLocalConfigLayout(rootPath);
         this.rootPath = layout.root;
         this.hostConfigPath = layout.hostConfigPath;
-        this.socketPath = resolveManagedDaemonSocketPath(this.rootPath);
+        this.endpoint = resolveManagedDaemonEndpoint(this.rootPath, deps.platform);
         this.createSupervisor =
             deps.createSupervisor ??
                 ((configPath, daemonDebug) => new AgentsHostSupervisor(configPath, { debug: daemonDebug }));
@@ -1535,22 +1651,34 @@ export class ManagedAgentsHostDaemon {
             this.logger.log('[agents-host] managed daemon ready', {
                 rootPath: this.rootPath,
                 hostConfigPath: this.hostConfigPath,
-                socketPath: this.socketPath,
+                socketPath: this.endpoint.address,
             });
         }
         catch (error) {
             this.started = false;
             this.ready = false;
-            await this.stop().catch(() => undefined);
+            try {
+                await this.stop();
+            }
+            catch (cleanupError) {
+                this.logger.error('[agents-host] managed daemon startup cleanup failed', {
+                    rootPath: this.rootPath,
+                    error: cleanupError,
+                });
+            }
             throw error;
         }
     }
     async stop() {
         this.ready = false;
+        let stopError;
         try {
             await this.supervisor.stop();
         }
-        finally {
+        catch (error) {
+            stopError = error;
+        }
+        try {
             await new Promise((resolveStop) => {
                 if (!this.server.listening) {
                     resolveStop();
@@ -1558,17 +1686,38 @@ export class ManagedAgentsHostDaemon {
                 }
                 this.server.close(() => resolveStop());
             });
-            if (this.ownsSocket) {
-                const socketStats = await fs.lstat(this.socketPath).catch(() => undefined);
+            if (this.ownsEndpoint && this.endpoint.kind === 'unix-socket') {
+                const socketStats = await fs.lstat(this.endpoint.address).catch((error) => {
+                    if (isNotFoundError(error)) {
+                        return undefined;
+                    }
+                    throw error;
+                });
                 if (socketStats && socketStats.ino === this.ownedSocketInode) {
-                    await fs.rm(this.socketPath, { force: true }).catch(() => undefined);
+                    await fs.rm(this.endpoint.address, { force: true });
                 }
-                this.ownsSocket = false;
-                this.ownedSocketInode = null;
             }
+        }
+        catch (cleanupError) {
+            if (stopError) {
+                this.logger.error('[agents-host] managed daemon control endpoint cleanup failed', {
+                    rootPath: this.rootPath,
+                    error: cleanupError,
+                });
+            }
+            else {
+                stopError = cleanupError;
+            }
+        }
+        finally {
+            this.ownsEndpoint = false;
+            this.ownedSocketInode = null;
             this.started = false;
             this.shutdownRequested = false;
         }
+        if (stopError) {
+            throw stopError;
+        }
     }
     async listen() {
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -1584,20 +1733,32 @@ export class ManagedAgentsHostDaemon {
                     };
                     this.server.once('error', onError);
                     this.server.once('listening', onListening);
-                    this.server.listen(this.socketPath);
+                    this.server.listen(this.endpoint.address);
                 });
-                await fs.chmod(this.socketPath, MANAGED_CONFIG_MODE);
-                this.ownedSocketInode = (await fs.lstat(this.socketPath)).ino;
-                this.ownsSocket = true;
+                if (this.endpoint.kind === 'unix-socket') {
+                    await fs.chmod(this.endpoint.address, MANAGED_CONFIG_MODE);
+                    this.ownedSocketInode = (await fs.lstat(this.endpoint.address)).ino;
+                }
+                this.ownsEndpoint = true;
                 return;
             }
             catch (error) {
-                if (!isSocketBusyError(error) || !(await removeStaleControlSocket(this.socketPath))) {
+                if (!isSocketBusyError(error)) {
+                    throw error;
+                }
+                if (this.endpoint.kind === 'named-pipe') {
+                    if (await canConnectToSocket(this.endpoint.address)) {
+                        throw error;
+                    }
+                    await delay(DAEMON_READY_RETRY_MS);
+                    continue;
+                }
+                if (!(await removeStaleControlSocket(this.endpoint))) {
                     throw error;
                 }
             }
         }
-        throw new Error(`Unable to bind managed daemon control socket: ${this.socketPath}`);
+        throw new Error(`Unable to bind managed daemon control endpoint: ${this.endpoint.address}`);
     }
     async handleSocket(socket) {
         let buffer = '';