@scotthuang/agent-knock-knock 0.12.10 → 0.12.12

package/dist/src/terminal-acceptance-cli-adapter.d.ts

@@ -0,0 +1,210 @@
+import type { CodexOpenRootRolloutInventory, CodingAgentSessionProvider } from "./agent-session-provider.js";
+import type { ClaudeAgentRow } from "./claude-terminal-agent-adapter.js";
+import { type AgentMessage, type Conversation, type Executor } from "./protocol.js";
+import type { ExecutorKind } from "./executors.js";
+import { type ManagedSessionState } from "./managed-session.js";
+import type { TerminalControlRef, TerminalDurableCompletionRequest, TerminalRuntimeIdentity } from "./terminal-agent-adapter.js";
+import { type TerminalNativeIdentity } from "./terminal-binding-authority.js";
+import type { TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
+import type { TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
+import { TerminalDispatchExecutionService, type NativeAgentSessionIdentityObservation, type NativeIdentityResolutionRequest } from "./terminal-dispatch-execution.js";
+import { type VirginBindingRecoveryState } from "./terminal-acceptance-application-service.js";
+import type { DeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
+import type { FileLockAcquisitionOptions } from "./file-lock-cli-adapter.js";
+export interface TerminalAcceptanceCliOptions {
+    claudeHome?: string;
+    gatewayMethod?: string;
+    gatewaySession?: string;
+    gatewayUrl?: string;
+    hardLimit?: number | string;
+    logDir?: string;
+    messageId?: string;
+    openclawBin?: string;
+    openclawSession?: string;
+    scrollbackLines?: number | string;
+    softLimit?: number | string;
+    storeDir?: string;
+    type?: string;
+    [option: string]: unknown;
+}
+export interface TerminalAcceptanceBridge {
+    proveExactDraftStillPresent(executor: ExecutorKind, terminalControl: TerminalControlRef, requestText: string, options: {
+        scrollbackLines: number;
+        runtime: TerminalRuntimeIdentity;
+    }): Promise<boolean>;
+    resolveStoredTerminal(agent: "codex", pid: number, terminalControl: TerminalControlRef, expected: {
+        pid: number;
+    }): Promise<TerminalDispatchTerminal>;
+}
+interface ManagedTerminalTurn {
+    conversation: Conversation;
+    nextConversation: Conversation;
+    statePath: string;
+    logPath: string;
+    executor: Executor;
+    message: AgentMessage;
+}
+interface DeferredTurnAuthority {
+    conversation: Conversation;
+    statePath: string;
+    submission: {
+        message_body_hash?: unknown;
+    };
+}
+interface TerminalAcceptanceRepositoryPorts {
+    acquireStateLock(lockPath: string, options?: FileLockAcquisitionOptions): () => void;
+    acquireTerminalLock(storeDir: string, terminalControl: TerminalControlRef, options?: FileLockAcquisitionOptions): () => void;
+    loadLedger(terminalControl: TerminalControlRef): TerminalDispatchLedgerDocument | undefined;
+    saveLedger(terminalControl: TerminalControlRef, ledger: TerminalDispatchLedgerDocument): void;
+    reconcileLedger(terminalControl: TerminalControlRef, ledger?: TerminalDispatchLedgerDocument): TerminalDispatchLedgerDocument | undefined;
+    bindingFields(conversation: Conversation): Partial<TerminalDispatchLedgerDocument>;
+}
+export interface TerminalAcceptanceCliDependencies {
+    native: {
+        codexProvider(options: TerminalAcceptanceCliOptions): CodingAgentSessionProvider;
+        codexProcessIncarnation(pid: number): {
+            processUuid: string;
+            processBirth: string;
+        };
+        assertExclusive(input: {
+            options: TerminalAcceptanceCliOptions;
+            agent: "codex";
+            currentPid: number;
+            nativeThreadId: string;
+            storeDir: string;
+            terminalControl: TerminalControlRef;
+            excludedManagedSessionId: string;
+        }): Promise<void>;
+    };
+    terminal: {
+        runtime(options: TerminalAcceptanceCliOptions): {
+            loadClaudeAgentRows(observation?: {
+                required?: boolean;
+            }): readonly ClaudeAgentRow[];
+            createBridge(): TerminalAcceptanceBridge;
+        };
+        durableRequest(conversation: Conversation, terminalControl: TerminalControlRef): TerminalDurableCompletionRequest;
+        runtimeIdentity(conversation: Conversation, terminalControl: TerminalControlRef): TerminalRuntimeIdentity;
+    };
+    authority: {
+        assertTurnCurrent(conversation: Conversation, operation: string): void;
+        terminalControl(value: unknown): TerminalControlRef | undefined;
+        isDiscoverableTurn(conversation: Conversation): boolean;
+        workspaceMatches(configured: unknown, observed: unknown): boolean;
+    };
+    repository: TerminalAcceptanceRepositoryPorts;
+    deferred: {
+        recover(input: {
+            options: TerminalAcceptanceCliOptions;
+            terminal: TerminalDispatchTerminal;
+        }): Promise<void>;
+        loadAuthority(input: {
+            storeDir: string;
+            terminal: TerminalDispatchTerminal;
+            transfer: DeferredForegroundTransfer;
+        }): DeferredTurnAuthority;
+        assertLedgerAuthority(input: {
+            storeDir: string;
+            terminal: Pick<TerminalDispatchTerminal, "terminalControl">;
+            transfer: DeferredForegroundTransfer;
+            ledger: TerminalDispatchLedgerDocument;
+            statePath: string;
+            expectedMessageBodyHash?: string;
+        }): void;
+        loadTransfer(storeDir: string, transferId: string): DeferredForegroundTransfer;
+    };
+}
+export interface TerminalAcceptanceCliFacade {
+    execution(options: TerminalAcceptanceCliOptions, bridge?: TerminalAcceptanceBridge): TerminalDispatchExecutionService;
+    recoverVirgin(input: {
+        options: TerminalAcceptanceCliOptions;
+        conversation: Conversation;
+        statePath: string;
+        logPath: string;
+        terminalLockHeld?: boolean;
+    }): Promise<{
+        conversation: Conversation;
+        state: VirginBindingRecoveryState;
+    }>;
+    reconcileMonitor(input: {
+        options: TerminalAcceptanceCliOptions;
+        conversation: Conversation;
+        statePath: string;
+        logPath: string;
+        terminalControl: TerminalControlRef;
+        executor: Executor;
+        terminalBridge: TerminalAcceptanceBridge;
+    }): Promise<{
+        outcome: "accepted";
+        conversation: Conversation;
+    } | {
+        outcome: "pending";
+    } | {
+        outcome: "not_accepted";
+        conversation: Conversation;
+    }>;
+    markUncertain(input: {
+        conversation: Conversation;
+        statePath: string;
+        logPath: string;
+        terminalControl: TerminalControlRef;
+        reason: string;
+    }): Conversation;
+    inspectCodexOpenRoots(input: {
+        options: TerminalAcceptanceCliOptions;
+        pid: number;
+        cwd?: string;
+    }): Promise<CodexOpenRootRolloutInventory>;
+    resolveNativeIdentity(request: NativeIdentityResolutionRequest & {
+        options: TerminalAcceptanceCliOptions;
+    }): Promise<TerminalNativeIdentity | undefined>;
+    observeNativeIdentity(request: NativeIdentityResolutionRequest & {
+        options: TerminalAcceptanceCliOptions;
+    }): Promise<NativeAgentSessionIdentityObservation>;
+    assertTurnIdentity(input: {
+        conversation: Conversation;
+        currentIdentity: TerminalNativeIdentity | undefined;
+        operation: string;
+    }): void;
+    withNativeIdentity(conversation: Conversation, identity: TerminalNativeIdentity): Conversation;
+    storeDirForConversation(conversation: Conversation): string | undefined;
+    refineSessionIdentity(input: {
+        storeDir: string;
+        session: ManagedSessionState;
+        terminalControl: TerminalControlRef;
+        identity?: TerminalNativeIdentity;
+    }): ManagedSessionState;
+    persistSessionIdentity(input: {
+        conversation: Conversation;
+        terminalControl: TerminalControlRef;
+        identity: TerminalNativeIdentity;
+        storeDir: string;
+    }): ManagedSessionState | undefined;
+    quarantineSession(input: {
+        conversation: Conversation;
+        reason: string;
+        storeDir: string;
+    }): void;
+    turnsForSession(storeDir: string, sessionId: string): Conversation[];
+    assertSessionCanStartTurn(turns: Conversation[]): void;
+    turnMatchesTerminal(input: {
+        conversation: Conversation;
+        terminal: TerminalDispatchTerminal;
+        currentIdentity?: TerminalNativeIdentity;
+    }): boolean;
+    createManagedTurn(input: {
+        options: TerminalAcceptanceCliOptions;
+        conversationId: string;
+        agent: ExecutorKind;
+        pid: number;
+        messageBody: string;
+        terminalControl: TerminalControlRef;
+        previousTurn?: Conversation;
+        managedSession?: ManagedSessionState;
+        nativeAgentIdentity?: TerminalNativeIdentity;
+        deferredForegroundTransferId?: string;
+    }): ManagedTerminalTurn;
+}
+/** Factory-scoped CLI composition; it retains no mutable module runtime. */
+export declare function createTerminalAcceptanceCliFacade(dependencies: TerminalAcceptanceCliDependencies): TerminalAcceptanceCliFacade;
+export {};