@borgee/agents-host 0.2.29 → 0.2.32

package/dist/gateway/localhost-gateway.js

@@ -505,6 +505,33 @@ class LoopbackLocalhostGatewayController {
                     this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
                     return;
                 }
+                case 'task-history': {
+                    // The thread this reads is the one the server recorded on the task: thread_id is
+                    // written once by task creation and is not part of the task update whitelist, so no
+                    // client can repoint an in-scope task at another channel's messages after the check.
+                    const task = await this.loadAuthorizedTask(binding.channelId, decision.route);
+                    if (!task.threadId) {
+                        this.sendJson(response, 404, { error: 'not_found' });
+                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    const url = new URL(request.url ?? '/', baseUrl);
+                    const limit = clampHistoryLimit(url.searchParams.get('limit'));
+                    const before = parseOptionalInteger(url.searchParams.get('before'));
+                    const after = parseOptionalInteger(url.searchParams.get('after'));
+                    const messages = await this.controlPlane.readChannelHistory({
+                        channelId: task.threadId,
+                        before,
+                        after,
+                        limit,
+                    });
+                    this.sendJson(response, 200, { messages });
+                    // Presence of `readChannelId` is the cross-channel disclosure signal, so it is
+                    // stamped only when the thread really is another channel; a task read from inside
+                    // its own thread would otherwise imply a disclosure that never happened.
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding, task.threadId === binding.channelId ? undefined : { readChannelId: task.threadId });
+                    return;
+                }
                 case 'users': {
                     if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
                         this.sendJson(response, 404, { error: 'not_found' });
@@ -604,7 +631,7 @@ class LoopbackLocalhostGatewayController {
         response.setHeader('content-type', 'application/json; charset=utf-8');
         response.end(`${JSON.stringify(payload)}\n`);
     }
-    recordAudit(reason, status, path, method, binding) {
+    recordAudit(reason, status, path, method, binding, readTarget) {
         if (!this.policyAuditGateEnabled) {
             return;
         }
@@ -616,6 +643,7 @@ class LoopbackLocalhostGatewayController {
             reason,
             agentId: binding?.agentId,
             channelId: binding?.channelId,
+            ...readTarget,
             method,
             path,
             status,
@@ -778,8 +806,12 @@ function parseUpdateTaskInput(taskId, body) {
         status: readOptionalString(body.status),
         assigneeId: readOptionalString(body.assigneeId) ?? readOptionalString(body.assignee_id),
         title: readOptionalString(body.title),
+        description: readOptionalString(body.description),
     };
-    if (input.status === undefined && input.assigneeId === undefined && input.title === undefined) {
+    if (input.status === undefined &&
+        input.assigneeId === undefined &&
+        input.title === undefined &&
+        input.description === undefined) {
         throw new GatewayHttpError(400, { error: 'no_updates' }, 'bad-request');
     }
     return input;

package/dist/index.js

@@ -1,11 +1,14 @@
 import { resolveAgentsHostDebugMode } from './debug.js';
 import { runMain } from './run.js';
+import { emitUpdateNotice } from './update/update-notice.js';
 // 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) => {
+emitUpdateNotice({ env: process.env })
+    .then(() => runMain({ debug: resolveAgentsHostDebugMode(false, process.env) }))
+    .catch((error) => {
     console.error('[agents-host] fatal error:', error);
     process.exitCode = 1;
 });

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 { assertProviderCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, assertProviderCommandCompatibility, 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';
@@ -186,6 +186,8 @@ export function parseGenerateConfigSpec(value, sourceLabel, env = process.env) {
             throw new Error(`Invalid generate-config agents[${index}] in ${sourceLabel}: expected an object`);
         }
         const agent = parseAgentConfigFile(`generate-config agents[${index}] in ${sourceLabel}`, entry, env);
+        const providerConfig = resolveAgentProviderCommandConfig(host.defaults, agent);
+        assertProviderCommandCompatibility(agent.provider, providerConfig, `generate-config agents[${index}] in ${sourceLabel}`);
         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}`);
@@ -598,6 +600,7 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
         ...host.defaults,
         ...parseProviderCommandOverrides(agent, `agent config ${sourcePath}`),
     });
+    assertProviderCommandCompatibility(agent.provider, providerConfig, `agent config ${sourcePath}`);
     const config = {
         borgeeBaseUrl: host.borgeeBaseUrl,
         stateRootDir: resolveLocalConfigAgentStateRoot(stateRootBaseDir, agent.key),
@@ -614,6 +617,20 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
         config,
     };
 }
+function resolveAgentProviderCommandConfig(hostDefaults, agent) {
+    return resolveProviderCommandConfig({
+        ...hostDefaults,
+        ...(agent.claudeCommand !== undefined ? { claudeCommand: agent.claudeCommand } : {}),
+        ...(agent.claudeArgs !== undefined ? { claudeArgs: agent.claudeArgs } : {}),
+        ...(agent.codexCommand !== undefined ? { codexCommand: agent.codexCommand } : {}),
+        ...(agent.codexArgs !== undefined ? { codexArgs: agent.codexArgs } : {}),
+        ...(agent.copilotCommand !== undefined ? { copilotCommand: agent.copilotCommand } : {}),
+        ...(agent.copilotArgs !== undefined ? { copilotArgs: agent.copilotArgs } : {}),
+        ...(agent.copilotSessionTtlMinutes !== undefined
+            ? { copilotSessionTtlMinutes: agent.copilotSessionTtlMinutes }
+            : {}),
+    });
+}
 export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
     const fileSystem = deps.fileSystem ?? nodeFileSystem;
     const absoluteHostConfigPath = resolve(hostConfigPath);
@@ -698,6 +715,8 @@ export async function loadLocalConfigGenerateSpec(hostConfigPath, deps = {}) {
             }
             const agentRecord = await loadParsedDocument(fileSystem, agentFilePath, 'agent config');
             const agentConfig = parseAgentConfigFile(agentFilePath, agentRecord, deps.env);
+            const providerConfig = resolveAgentProviderCommandConfig(hostConfig.defaults, agentConfig);
+            assertProviderCommandCompatibility(agentConfig.provider, providerConfig, `agent config ${agentFilePath}`);
             const existingPath = seenKeys.get(agentConfig.key);
             if (existingPath) {
                 throw new Error(`Duplicate agent key "${agentConfig.key}" in ${existingPath} and ${agentFilePath}`);

package/dist/managed-daemon.js

@@ -5,8 +5,8 @@ import { createConnection, createServer } from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
-import { 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 { loadConfigFromEnv } from './config.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_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';
 const MANAGED_ROOT_MODE = 0o700;
@@ -149,8 +149,9 @@ function resolveDesiredManagedRuntimeSettings(env = process.env) {
 function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
     const compatibilityGates = [...new Set(snapshot.compatibilityGates.map((gate) => gate.trim()))]
         .filter((gate) => gate.length > 0)
+        .filter((gate) => gate !== CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE)
         .sort((left, right) => left.localeCompare(right));
-    const providerImplementationOverrides = normalizeInternalProviderImplementationOverrides(snapshot.providerImplementationOverrides.join(','));
+    const providerImplementationOverrides = normalizeInternalProviderImplementationOverrides(snapshot.providerImplementationOverrides.join(',')).filter((assignment) => !assignment.startsWith('claude:'));
     return {
         schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
         compatibilityGates,
@@ -341,9 +342,18 @@ export function buildManagedLocalAgentConfig(options) {
         },
     };
 }
-function mergeManagedLocalAgentConfig(existingAgent, generatedAgent, envOverrides) {
+function mergeManagedLocalAgentConfig(hostDefaults, existingAgent, generatedAgent, envOverrides) {
     const overrides = envOverrides ?? {};
     const hasOverride = (key) => Object.prototype.hasOwnProperty.call(overrides, key);
+    const effectiveExistingClaudeCommand = existingAgent.claudeCommand ?? hostDefaults?.claudeCommand;
+    const effectiveExistingClaudeArgs = existingAgent.claudeArgs ?? hostDefaults?.claudeArgs ?? [];
+    const hasLegacyClaudeDefaults = effectiveExistingClaudeCommand === 'claude' && hasLegacyClaudeOneShotArgs(effectiveExistingClaudeArgs);
+    const shouldRefreshLegacyClaudeDefaults = hasLegacyClaudeDefaults
+        && generatedAgent.claudeCommand === DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand
+        && JSON.stringify(generatedAgent.claudeArgs ?? []) === JSON.stringify(DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs);
+    const shouldResetLegacyClaudeArgsForCommandOverride = hasLegacyClaudeDefaults
+        && hasOverride('CLAUDE_COMMAND')
+        && !hasOverride('CLAUDE_ARGS');
     return {
         ...cloneLocalAgentConfig(existingAgent),
         key: generatedAgent.key,
@@ -351,8 +361,12 @@ function mergeManagedLocalAgentConfig(existingAgent, generatedAgent, envOverride
         enabled: true,
         name: hasOverride('BORGEE_AGENT_NAME') ? generatedAgent.name : existingAgent.name,
         provider: hasOverride('RUNTIME_PROVIDER') ? generatedAgent.provider : existingAgent.provider,
-        claudeCommand: hasOverride('CLAUDE_COMMAND') ? generatedAgent.claudeCommand : existingAgent.claudeCommand,
+        claudeCommand: hasOverride('CLAUDE_COMMAND') || shouldRefreshLegacyClaudeDefaults
+            ? generatedAgent.claudeCommand
+            : existingAgent.claudeCommand,
         claudeArgs: hasOverride('CLAUDE_ARGS')
+            || shouldRefreshLegacyClaudeDefaults
+            || shouldResetLegacyClaudeArgsForCommandOverride
             ? [...(generatedAgent.claudeArgs ?? [])]
             : [...(existingAgent.claudeArgs ?? [])],
         codexCommand: hasOverride('CODEX_COMMAND') ? generatedAgent.codexCommand : existingAgent.codexCommand,
@@ -1005,7 +1019,7 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
                 return existingAgent
                     ? {
                         ...generatedManagedAgent,
-                        agent: mergeManagedLocalAgentConfig(existingAgent, generatedManagedAgent.agent, explicitManagedAgentOverrides),
+                        agent: mergeManagedLocalAgentConfig(currentManagedSpec?.host.defaults, existingAgent, generatedManagedAgent.agent, explicitManagedAgentOverrides),
                     }
                     : generatedManagedAgent;
             })();

package/dist/policy/authorization-audit.d.ts

@@ -9,6 +9,7 @@ export interface AuthorizationAuditRecord {
     reason: string;
     agentId?: string;
     channelId?: string;
+    readChannelId?: string;
     selectedOptionKind?: string;
     policyOutcome?: string;
     policySelectedOptionKind?: string;

package/dist/policy/gateway-authorization.d.ts

@@ -6,7 +6,7 @@ export interface GatewayChannelRoute {
 }
 export interface GatewayTaskRoute {
     taskId: string;
-    resource: 'task';
+    resource: 'task' | 'task-history';
 }
 export interface GatewayAuthorizationBinding {
     channelId: string;

package/dist/policy/gateway-authorization.js

@@ -16,6 +16,20 @@ export function parseBearerToken(value) {
     const token = trimmed.slice(prefix.length);
     return token.length > 0 && !/\s/.test(token) ? token : null;
 }
+// A segment carrying a malformed percent-escape names neither a channel nor a task, so it
+// is not a route match. Decoding it unguarded would instead throw out of the routing step,
+// which runs before the request handler's error mapping and would answer an unaudited 500.
+function decodePathSegment(segment) {
+    if (segment == null) {
+        return null;
+    }
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return null;
+    }
+}
 export function matchChannelRoute(pathname, allowCollaborationRoutes = false) {
     const resources = allowCollaborationRoutes
         ? '(bootstrap|me|history|draft|users|messages|tasks|current-task)'
@@ -24,19 +38,27 @@ export function matchChannelRoute(pathname, allowCollaborationRoutes = false) {
     if (!match) {
         return null;
     }
+    const channelId = decodePathSegment(match[1]);
+    if (channelId == null) {
+        return null;
+    }
     return {
-        channelId: decodeURIComponent(match[1] ?? ''),
+        channelId,
         resource: match[2],
     };
 }
 export function matchTaskRoute(pathname) {
-    const match = /^\/v1\/tasks\/([^/]+)$/.exec(pathname);
+    const match = /^\/v1\/tasks\/([^/]+)(\/history)?$/.exec(pathname);
     if (!match) {
         return null;
     }
+    const taskId = decodePathSegment(match[1]);
+    if (taskId == null) {
+        return null;
+    }
     return {
-        taskId: decodeURIComponent(match[1] ?? ''),
-        resource: 'task',
+        taskId,
+        resource: match[2] ? 'task-history' : 'task',
     };
 }
 function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
@@ -47,6 +69,7 @@ function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
         case 'history':
         case 'draft':
         case 'users':
+        case 'task-history':
             return ['GET'];
         case 'messages':
             return collaborationRoutesEnabled ? ['POST'] : [];

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

@@ -1,19 +1,25 @@
 import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
 import { type DebugLogger } from '../../debug.js';
 import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
-interface ClaudeCliRuntime {
+interface ClaudeAcpRuntime {
     spawn: typeof spawn;
+    client: typeof client;
+    ndJsonStream: typeof ndJsonStream;
+    methods: typeof methods;
+    protocolVersion: typeof PROTOCOL_VERSION;
     cwd: string;
+    shutdownGracePeriodMs: number;
+    shutdownForceKillWaitMs: number;
 }
 /**
- * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
- * native provider-session continuity.
+ * Persistent ACP-backed client for the Claude ACP adapter.
  *
- * Claude session memory remains entirely inside the Claude CLI. This client
- * only pins one native session id per routed provider session and serializes
- * turns per route so `--resume` is never called concurrently for the same
- * native session.
+ * The public caller surface intentionally stays stable: callers still create a
+ * `ClaudeCliClient`, then call `generateReply()` and `dispose()`. Internally,
+ * the shipped runtime now runs one Claude ACP adapter process and reuses one
+ * ACP session per routed Borgee channel.
  */
 export declare class ClaudeCliClient {
     private readonly command;
@@ -24,28 +30,61 @@ export declare class ClaudeCliClient {
     private readonly runtime;
     private readonly channels;
     private readonly persistedSessions;
+    private readonly closingSessions;
+    private readonly pendingSessionStarts;
+    private readonly pendingSessionCloses;
+    private readonly pendingSessionStoreOperations;
+    private readonly fatalPromise;
+    private rejectFatalPromise;
+    private child?;
+    private connection?;
+    private startPromise?;
+    private shutdownPromise?;
+    private childExitPromise?;
+    private resolveChildExit?;
+    private fatalError;
+    private disposing;
+    private backendClosed;
     private loadedSessionStoreAgentId;
-    private stopped;
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
-    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    private sessionCapabilities;
+    private childStderr;
+    constructor(command: string, args?: string[], runtimeOverrides?: Partial<ClaudeAcpRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
+    private ensureStarted;
+    private startBackend;
     private getOrCreateChannelState;
     private processChannelQueue;
+    private getOrCreateSession;
+    private startFreshSession;
+    private restoreOrCreateSession;
+    private restoreSession;
+    private clearBufferedSessionReplay;
+    private resolveSessionCwd;
+    private recycleSessionIfScopeChanged;
     private runTurn;
-    private runTurnAttempt;
+    private raceWithFatal;
+    private failAll;
+    private handlePermissionRequest;
+    private invalidateSession;
+    private closeSession;
+    private rejectQueuedTurnsAfterSessionTaint;
+    private findChannelIdBySessionId;
     private currentSessionStoreAgentId;
     private ensureSessionStoreLoaded;
-    private hydrateChannelState;
+    private readPersistedSessionId;
     private persistSession;
     private persistSessionBestEffort;
-    private resetPersistedSession;
-    private resolveTurnCwd;
-    private resetSessionIfCwdChanged;
-    private resetPersistedSessionBestEffort;
+    private clearPersistedSession;
+    private clearPersistedSessionBestEffort;
     private enqueueSessionStoreWrite;
-    private run;
+    private trackSessionStoreOperation;
+    private shutdownBackend;
+    private waitForPendingSessionStarts;
+    private waitForPendingSessionCloses;
+    private waitForChildExit;
 }
 export {};