@borgee/agents-host 0.2.2 → 0.2.28

package/dist/providers/codex/project-doc.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedPromptContext } from '../../types.js';
+export declare function buildCodexProjectDocument(context: PreparedPromptContext | undefined): string;
+export declare function assertCodexProjectDocumentSize(content: string): void;

package/dist/providers/codex/project-doc.js

@@ -0,0 +1,90 @@
+import { basename } from 'node:path';
+import { buildAttentionSummaryLines } from '../../context/attention.js';
+import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from '../../context/collaboration-capabilities-diagnostics.js';
+import { buildCollaborationOutcomeSummaryLines } from '../../context/collaboration-outcome.js';
+import { buildTaskThreadCollaborationSummaryLines } from '../../context/task-thread-collaboration.js';
+const PROJECT_DOC_MAX_BYTES = 32 * 1024;
+function buildSkillRuntimeLines(context) {
+    if (!context?.skillRuntime || !context.channelContextPayloadPath) {
+        return [];
+    }
+    return [
+        'Read-only local skill runtime bootstrap is available in this workspace.',
+        `Context payload: ${context.channelContextPayloadPath}`,
+        `Skill guide: ${context.skillRuntime.skillMarkdownPath}`,
+        `Node CLI: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
+        `Python CLI: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
+        'These CLIs are local-only, may only access the loopback gateway surfaced by the host, and must not mutate files or the local environment.',
+    ];
+}
+function buildGatewayLines(context) {
+    if (!context?.localhostGateway || !context.channelContextPayloadPath) {
+        return [];
+    }
+    const lines = [
+        'A loopback-only localhost gateway may be available for this channel.',
+        `Gateway base URL: ${context.localhostGateway.baseUrl}`,
+        'Use the packaged local CLI with the context payload above for gateway access.',
+    ];
+    if (context.gatewayAuthPath) {
+        lines.push(`Per-turn gateway auth sidecar: ${context.gatewayAuthPath}`, 'If a later turn prompt advertises a different auth sidecar path, prefer the prompt-visible path for that turn.');
+    }
+    return lines;
+}
+export function buildCodexProjectDocument(context) {
+    const lines = [
+        '# Borgee channel workspace',
+        '',
+        'This workspace belongs to one Borgee channel session hosted by agents-host.',
+        'Keep visible replies concise, do not claim actions you did not perform, and prefer the per-turn prompt when it provides newer turn-local details.',
+        ...(context?.channelContextPayloadPath
+            ? [
+                '',
+                `Context payload file: ${context.channelContextPayloadPath}`,
+                `Workspace anchor: ${basename(context.channelContextPayloadPath)}`,
+            ]
+            : []),
+        ...(context?.taskWorkspace
+            ? [
+                '',
+                `Writable task workspace root: ${context.taskWorkspace.rootPath}`,
+                'That writable task workspace is local to agents-host for the current task thread and does not imply that the target repository has already been checked out there.',
+            ]
+            : []),
+        ...(() => {
+            const collaborationOutcomeLines = buildCollaborationOutcomeSummaryLines(context?.collaborationOutcome);
+            return collaborationOutcomeLines.length > 0 ? ['', ...collaborationOutcomeLines] : [];
+        })(),
+        ...(() => {
+            const attentionLines = buildAttentionSummaryLines(context?.attentionSnapshot);
+            return attentionLines.length > 0 ? ['', ...attentionLines] : [];
+        })(),
+        ...(() => {
+            const capabilityLines = buildCollaborationCapabilityDeclarationSummaryLines(context?.collaborationCapabilities);
+            return capabilityLines.length > 0 ? ['', ...capabilityLines] : [];
+        })(),
+        ...(() => {
+            const diagnosticLines = buildMissedCollaborationDiagnosticSummaryLines(context?.missedCollaborationDiagnostic);
+            return diagnosticLines.length > 0 ? ['', ...diagnosticLines] : [];
+        })(),
+        ...(() => {
+            const taskThreadLines = buildTaskThreadCollaborationSummaryLines(context?.taskThreadCollaborationContract);
+            return taskThreadLines.length > 0 ? ['', ...taskThreadLines] : [];
+        })(),
+        ...(() => {
+            const skillRuntimeLines = buildSkillRuntimeLines(context);
+            return skillRuntimeLines.length > 0 ? ['', ...skillRuntimeLines] : [];
+        })(),
+        ...(() => {
+            const gatewayLines = buildGatewayLines(context);
+            return gatewayLines.length > 0 ? ['', ...gatewayLines] : [];
+        })(),
+    ];
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function assertCodexProjectDocumentSize(content) {
+    const size = Buffer.byteLength(content, 'utf8');
+    if (size > PROJECT_DOC_MAX_BYTES) {
+        throw new Error(`Codex project document exceeds ${PROJECT_DOC_MAX_BYTES} bytes (${size} bytes)`);
+    }
+}

package/dist/providers/codex/session-store.d.ts

@@ -0,0 +1,38 @@
+export interface CodexChannelSessionStore {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+    close?(): Promise<void> | void;
+}
+export interface FileCodexChannelSessionStoreOptions {
+    resolvePath(agentId: string): string;
+    fileSystem?: CodexSessionStoreFileSystem;
+    platform?: NodeJS.Platform;
+}
+interface CodexSessionStoreDirectoryHandle {
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+interface CodexSessionStoreFileHandle extends CodexSessionStoreDirectoryHandle {
+    writeFile(data: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<void>;
+}
+interface CodexSessionStoreFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<void>;
+    openDirectory(path: string): Promise<CodexSessionStoreDirectoryHandle>;
+    openFile(path: string, flags: string, mode: number): Promise<CodexSessionStoreFileHandle>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+}
+export declare class FileCodexChannelSessionStore implements CodexChannelSessionStore {
+    private readonly options;
+    constructor(options: FileCodexChannelSessionStoreOptions);
+    private loadFromPath;
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}
+export {};

package/dist/providers/codex/session-store.js

@@ -0,0 +1,150 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const nodeFileSystem = {
+    async mkdir(path, options) {
+        await mkdir(path, options);
+    },
+    async openDirectory(path) {
+        return open(path, 'r');
+    },
+    async openFile(path, flags, mode) {
+        return open(path, flags, mode);
+    },
+    async readFile(path, encoding) {
+        return readFile(path, encoding);
+    },
+    async rename(from, to) {
+        await rename(from, to);
+    },
+    async unlink(path) {
+        await unlink(path);
+    },
+};
+function shouldIgnoreDirectorySyncError(platform, error) {
+    const code = error.code;
+    return platform === 'win32' && (code === 'EPERM' || code === 'EINVAL');
+}
+async function syncDirectory(path, fileSystem, platform) {
+    let directoryHandle;
+    try {
+        try {
+            directoryHandle = await fileSystem.openDirectory(path);
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+            return;
+        }
+        try {
+            await directoryHandle.sync();
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (directoryHandle) {
+            try {
+                await directoryHandle.close();
+            }
+            catch {
+                // Preserve the original directory durability failure.
+            }
+        }
+        throw error;
+    }
+    if (directoryHandle) {
+        await directoryHandle.close();
+    }
+}
+function normalizePersistedSessions(raw, filePath) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new Error(`invalid Codex session file: ${filePath}`);
+    }
+    const entries = Object.entries(raw);
+    const sessions = {};
+    for (const [channelId, sessionId] of entries) {
+        if (typeof sessionId !== 'string' || sessionId.trim().length === 0) {
+            throw new Error(`invalid Codex session file: ${filePath}`);
+        }
+        sessions[channelId] = sessionId;
+    }
+    return sessions;
+}
+export class FileCodexChannelSessionStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async loadFromPath(filePath) {
+        const raw = await (this.options.fileSystem ?? nodeFileSystem).readFile(filePath, 'utf8');
+        return normalizePersistedSessions(JSON.parse(raw), filePath);
+    }
+    async load(agentId) {
+        const filePath = this.options.resolvePath(agentId);
+        try {
+            return await this.loadFromPath(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            return {};
+        }
+    }
+    async save(agentId, sessions) {
+        const filePath = this.options.resolvePath(agentId);
+        const parentPath = dirname(filePath);
+        const fileSystem = this.options.fileSystem ?? nodeFileSystem;
+        const platform = this.options.platform ?? process.platform;
+        await fileSystem.mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await fileSystem.unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath, fileSystem, platform);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await fileSystem.openFile(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await fileSystem.rename(temporaryPath, filePath);
+            await syncDirectory(parentPath, fileSystem, platform);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await fileSystem.unlink(temporaryPath);
+            }
+            catch {
+                // Cleanup is best effort.
+            }
+            throw error;
+        }
+    }
+}

package/dist/providers/copilot/adapter.d.ts

@@ -1,9 +1,11 @@
 import type { ProviderAdapter } from '../provider-adapter.js';
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { CopilotCliClient } from './cli-client.js';
 export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
-    constructor(cli: CopilotCliClient);
+    private readonly turnPreparer;
+    constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -1,21 +1,17 @@
-import { buildPrompt } from '../../context/prompt.js';
+import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
 export class CopilotProviderAdapter {
     cli;
-    constructor(cli) {
+    turnPreparer;
+    constructor(cli, turnPreparer) {
         this.cli = cli;
+        this.turnPreparer = turnPreparer;
     }
     async generateReply(input, options) {
-        const prompt = buildPrompt({
-            agentName: input.agentName,
-            provider: input.provider,
-            channelId: input.channelId,
-            incomingAuthorId: input.incomingAuthorId,
-            incomingContent: input.incomingContent,
+        const preparedTurn = await this.turnPreparer.prepare(input);
+        const text = await this.cli.generateReply(preparedTurn, {
+            onProgress: createAwaitingUserProgressHandler(options?.onProgress),
         });
-        const text = await this.cli.generateReply(input.channelId, prompt, {
-            onProgress: options?.onProgress,
-        });
-        return { text };
+        return parseProviderReply(text);
     }
     async dispose() {
         await this.cli.dispose();

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

@@ -1,6 +1,9 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
-import type { ProviderGenerateOptions } from '../../types.js';
+import { type DebugLogger } from '../../debug.js';
+import type { InternalPolicyMode } from '../../compatibility-gates.js';
+import type { AuthorizationAuditSinkLike } from '../../policy/authorization-audit.js';
+import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { CopilotChannelSessionStore } from './session-store.js';
 interface CopilotAcpRuntime {
     spawn: typeof spawn;
@@ -13,6 +16,11 @@ interface CopilotAcpRuntime {
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
 }
+interface CopilotPermissionPolicyOptions {
+    gateEnabled?: boolean;
+    policyMode?: InternalPolicyMode;
+    auditSink?: AuthorizationAuditSinkLike;
+}
 /**
  * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
@@ -25,12 +33,15 @@ export declare class CopilotCliClient {
     private readonly command;
     private readonly sessionStore?;
     private readonly resolveSessionStoreAgentId;
+    private readonly logger;
+    private readonly permissionPolicy;
     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?;
@@ -46,7 +57,8 @@ export declare class CopilotCliClient {
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
     private sessionCapabilities;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions);
+    generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private ensureStarted;
@@ -58,20 +70,26 @@ export declare class CopilotCliClient {
     private restoreOrCreateSession;
     private restoreSession;
     private clearBufferedSessionReplay;
+    private resolveSessionCwd;
+    private recycleSessionIfCwdChanged;
     private runTurn;
     private raceWithFatal;
+    private handlePermissionRequest;
     private failAll;
     private invalidateSession;
     private closeSession;
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
+    private findChannelIdBySessionId;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
+    private readPersistedSessionId;
     private persistSession;
     private persistSessionBestEffort;
     private clearPersistedSession;
     private clearPersistedSessionBestEffort;
     private flushSessionStore;
+    private trackSessionStoreOperation;
     private evictIdleChannel;
     private shutdownBackend;
     private waitForPendingSessionStarts;