@undefineds.co/models 0.1.1 → 0.2.1

package/dist/watch/index.d.ts

@@ -0,0 +1,226 @@
+export type WatchBackend = 'codex' | 'claude' | 'codebuddy';
+export type WatchMode = 'manual' | 'smart' | 'auto';
+export type WatchSessionStatus = 'running' | 'completed' | 'failed';
+export type WatchOutputStream = 'stdout' | 'stderr' | 'system';
+export type WatchCredentialSource = 'auto' | 'local' | 'cloud';
+export type WatchResolvedCredentialSource = 'local' | 'cloud';
+export type WatchApprovalSource = 'local' | 'remote' | 'hybrid';
+export type WatchRuntime = 'local';
+export type WatchTransport = 'native' | 'acp';
+export type WatchAuthState = 'authenticated' | 'unauthenticated' | 'unknown';
+export interface WatchAuthStatus {
+    state: WatchAuthState;
+    message?: string;
+}
+export interface WatchAuthFailure {
+    message: string;
+}
+export type WatchCloudCredentialProbeStatus = 'available' | 'unavailable' | 'error';
+export interface WatchCloudCredentialProbe {
+    status: WatchCloudCredentialProbeStatus;
+    message?: string;
+}
+export interface WatchCredentialSourceResolution {
+    requestedSource: WatchCredentialSource;
+    resolvedSource?: WatchResolvedCredentialSource;
+    authStatus: WatchAuthStatus;
+    error?: string;
+}
+export interface WatchSessionRecord {
+    id: string;
+    backend: WatchBackend;
+    runtime: WatchRuntime;
+    transport?: WatchTransport;
+    mode: WatchMode;
+    cwd: string;
+    model?: string;
+    prompt?: string;
+    passthroughArgs: string[];
+    credentialSource: WatchCredentialSource;
+    resolvedCredentialSource?: WatchResolvedCredentialSource;
+    approvalSource?: WatchApprovalSource;
+    command: string;
+    args: string[];
+    status: WatchSessionStatus;
+    startedAt: string;
+    endedAt?: string;
+    exitCode?: number | null;
+    signal?: string | null;
+    error?: string;
+    backendSessionId?: string;
+    archiveDir: string;
+    eventsFile: string;
+}
+export type WatchApprovalRequestKind = 'command-approval' | 'file-change-approval' | 'permissions-approval' | 'codex-approval';
+export type WatchInteractionRequestKind = WatchApprovalRequestKind | 'user-input';
+export type WatchApprovalDecision = 'accept' | 'accept_for_session' | 'decline' | 'cancel';
+interface WatchInteractionRequestBase {
+    kind: WatchInteractionRequestKind;
+    message: string;
+    raw?: unknown;
+}
+export interface WatchCommandApprovalRequest extends WatchInteractionRequestBase {
+    kind: 'command-approval';
+    command?: string;
+    cwd?: string;
+}
+export interface WatchFileChangeApprovalRequest extends WatchInteractionRequestBase {
+    kind: 'file-change-approval';
+    reason?: string;
+}
+export interface WatchPermissionsApprovalRequest extends WatchInteractionRequestBase {
+    kind: 'permissions-approval';
+    permissions: Record<string, unknown>;
+}
+export interface WatchCodexApprovalRequest extends WatchInteractionRequestBase {
+    kind: 'codex-approval';
+}
+export interface WatchUserInputOption {
+    label: string;
+    description?: string;
+}
+export interface WatchUserInputQuestion {
+    id: string;
+    header: string;
+    question: string;
+    options: WatchUserInputOption[];
+}
+export interface WatchUserInputRequest extends WatchInteractionRequestBase {
+    kind: 'user-input';
+    questions: WatchUserInputQuestion[];
+}
+export type WatchApprovalRequest = WatchCommandApprovalRequest | WatchFileChangeApprovalRequest | WatchPermissionsApprovalRequest | WatchCodexApprovalRequest;
+export type WatchInteractionRequest = WatchApprovalRequest | WatchUserInputRequest;
+export interface WatchUserInputAnswerRecord {
+    answers: string[];
+}
+export type WatchUserInputAnswers = Record<string, WatchUserInputAnswerRecord>;
+export interface WatchToolCallEvent {
+    type: 'tool.call';
+    name: string;
+    arguments?: Record<string, unknown>;
+    raw?: unknown;
+}
+export interface WatchApprovalRequiredEvent {
+    type: 'approval.required';
+    message: string;
+    request?: WatchApprovalRequest;
+    raw?: unknown;
+}
+export interface WatchInputRequiredEvent {
+    type: 'input.required';
+    message: string;
+    request: WatchUserInputRequest;
+    raw?: unknown;
+}
+export interface WatchAssistantDeltaEvent {
+    type: 'assistant.delta';
+    text: string;
+    raw?: unknown;
+}
+export interface WatchAssistantDoneEvent {
+    type: 'assistant.done';
+    text?: string;
+    raw?: unknown;
+}
+export interface WatchNoteEvent {
+    type: 'session.note';
+    message: string;
+    raw?: unknown;
+}
+export type WatchNormalizedEvent = WatchToolCallEvent | WatchApprovalRequiredEvent | WatchInputRequiredEvent | WatchAssistantDeltaEvent | WatchAssistantDoneEvent | WatchNoteEvent;
+export interface WatchEventLogEntry {
+    timestamp: string;
+    stream: WatchOutputStream;
+    line: string;
+    events: WatchNormalizedEvent[];
+}
+export interface WatchThreadMetadata extends Record<string, unknown> {
+    kind: 'watch';
+    delegatedTo: 'secretary';
+    sessionId: string;
+    backend: WatchBackend;
+    runtime: WatchRuntime;
+    transport?: WatchTransport;
+    mode: WatchMode;
+    cwd: string;
+    model?: string;
+    credentialSource: WatchCredentialSource;
+    resolvedCredentialSource?: WatchResolvedCredentialSource;
+    approvalSource?: WatchApprovalSource;
+    status: WatchSessionStatus;
+    backendSessionId?: string;
+}
+export type WatchTranscriptMessageRole = 'user' | 'assistant' | 'system';
+export interface WatchTranscriptMessage {
+    role: WatchTranscriptMessageRole;
+    content: string;
+    createdAt: string;
+}
+export interface CreateWatchSessionIdOptions {
+    now?: Date;
+    randomId?: string;
+}
+export interface WatchArchiveRelativePaths {
+    sessionDir: string;
+    sessionFile: string;
+    eventsFile: string;
+}
+export declare const WATCH_HOME_DIRNAME = "watch";
+export declare const WATCH_SESSIONS_DIRNAME = "sessions";
+export declare const WATCH_SESSION_FILE_NAME = "session.json";
+export declare const WATCH_EVENTS_FILE_NAME = "events.jsonl";
+export declare function normalizeWatchUserInputQuestion(value: unknown, fallbackId?: string): WatchUserInputQuestion | null;
+export declare function resolveWatchQuestionAnswer(question: WatchUserInputQuestion, answer: string): string[];
+export declare function createWatchSessionId(options?: CreateWatchSessionIdOptions): string;
+export declare function normalizeWatchCredentialSource(source?: WatchCredentialSource | null): WatchCredentialSource;
+export declare function shouldAttemptCloudCredentialProbe(requestedSource: WatchCredentialSource, localAuthStatus: WatchAuthStatus): boolean;
+export declare function formatWatchAutoFallbackMessage(localMessage: string, detail: string): string;
+export declare function resolveWatchCredentialSourceResolution(input: {
+    requestedSource?: WatchCredentialSource | null;
+    localAuthStatus: WatchAuthStatus;
+    cloudCredentialProbe?: WatchCloudCredentialProbe;
+    defaultLocalMessage?: string;
+}): WatchCredentialSourceResolution;
+export declare function resolveWatchAutoApprovalDecision(input: {
+    mode: WatchMode;
+    request: WatchApprovalRequest;
+}): WatchApprovalDecision | null;
+export declare function getWatchAuthLoginCommand(backend: WatchBackend): string | null;
+export declare function formatWatchBackendAuthMessage(backend: WatchBackend, detail?: string): string;
+export declare function looksLikeWatchAuthFailureText(text: string): boolean;
+export declare function parseWatchClaudeAuthStatus(stdout: string): WatchAuthStatus;
+export declare function detectWatchAuthFailure(backend: WatchBackend, line: string): WatchAuthFailure | null;
+export declare function parseWatchJsonLine(line: string): Record<string, unknown> | null;
+export declare function extractWatchSessionIdFromJsonLine(line: string): string | undefined;
+export declare function isTrustedWatchCommand(command: string | null | undefined): boolean;
+export declare function normalizeCodexAppServerInteractionRequest(message: Record<string, unknown>): WatchInteractionRequest | null;
+export declare function resolveWatchInteractionAutoResponse(input: {
+    mode: WatchMode;
+    request: WatchInteractionRequest;
+}): unknown | null;
+export declare function buildCodexApprovalResponse(request: WatchApprovalRequest, decision: WatchApprovalDecision): unknown;
+export declare function buildCodexUserInputResponse(answers: WatchUserInputAnswers): {
+    answers: WatchUserInputAnswers;
+};
+export declare function buildWatchUserInputResponse(answers: WatchUserInputAnswers): {
+    answers: WatchUserInputAnswers;
+};
+export declare function normalizeAcpInteractionRequest(message: Record<string, unknown>): WatchInteractionRequest | null;
+export declare function normalizeAcpRequest(message: Record<string, unknown>): WatchNormalizedEvent[];
+export declare function normalizeAcpSessionNotification(message: Record<string, unknown>): WatchNormalizedEvent[];
+export declare function buildAcpPermissionResponse(request: WatchApprovalRequest, decision: WatchApprovalDecision): {
+    outcome: {
+        outcome: 'selected';
+        optionId: string;
+    } | {
+        outcome: 'cancelled';
+    };
+};
+export declare function parseWatchJsonProtocolLine(line: string): WatchNormalizedEvent[];
+export declare function normalizeCodexAppServerNotification(message: Record<string, unknown>): WatchNormalizedEvent[];
+export declare function normalizeCodexAppServerRequest(message: Record<string, unknown>): WatchNormalizedEvent[];
+export declare function getWatchArchiveRelativePaths(sessionId: string): WatchArchiveRelativePaths;
+export declare function buildWatchThreadMetadata(record: WatchSessionRecord): WatchThreadMetadata;
+export declare function buildWatchTranscriptMessages(entries: WatchEventLogEntry[]): WatchTranscriptMessage[];
+export {};