@adhdev/daemon-core 0.8.29 → 0.8.31

package/src/cli-adapters/provider-cli-config.ts

@@ -0,0 +1,66 @@
+import type { CliProviderModule } from './provider-cli-shared.js';
+
+export interface ProviderResolutionMeta {
+    type: string;
+    name: string;
+    resolvedVersion: string | null;
+    resolvedOs: string | null;
+    providerDir: string | null;
+    scriptDir: string | null;
+    scriptsPath: string | null;
+    scriptsSource: string | null;
+    versionWarning: string | null;
+}
+
+export interface ResolvedCliAdapterConfig {
+    timeouts: {
+        ptyFlush: number;
+        dialogAccept: number;
+        approvalCooldown: number;
+        generatingIdle: number;
+        idleFinish: number;
+        maxResponse: number;
+        shutdownGrace: number;
+        outputSettle: number;
+    };
+    approvalKeys: Record<number, string>;
+    sendDelayMs: number;
+    sendKey: string;
+    submitStrategy: 'wait_for_echo' | 'immediate';
+    providerResolutionMeta: ProviderResolutionMeta;
+}
+
+export function resolveCliAdapterConfig(provider: CliProviderModule): ResolvedCliAdapterConfig {
+    const t = provider.timeouts || {};
+    const rawKeys = provider.approvalKeys;
+
+    return {
+        timeouts: {
+            ptyFlush: t.ptyFlush ?? 50,
+            dialogAccept: t.dialogAccept ?? 300,
+            approvalCooldown: t.approvalCooldown ?? 3000,
+            generatingIdle: t.generatingIdle ?? 6000,
+            idleFinish: t.idleFinish ?? 5000,
+            maxResponse: t.maxResponse ?? 300000,
+            shutdownGrace: t.shutdownGrace ?? 1000,
+            outputSettle: t.outputSettle ?? 300,
+        },
+        approvalKeys: (rawKeys && typeof rawKeys === 'object') ? rawKeys : {},
+        sendDelayMs: typeof provider.sendDelayMs === 'number' ? Math.max(0, provider.sendDelayMs) : 0,
+        sendKey: typeof provider.sendKey === 'string' && provider.sendKey.length > 0
+            ? provider.sendKey
+            : '\r',
+        submitStrategy: provider.submitStrategy === 'immediate' ? 'immediate' : 'wait_for_echo',
+        providerResolutionMeta: {
+            type: provider.type,
+            name: provider.name,
+            resolvedVersion: provider._resolvedVersion || null,
+            resolvedOs: provider._resolvedOs || null,
+            providerDir: provider._resolvedProviderDir || null,
+            scriptDir: provider._resolvedScriptDir || null,
+            scriptsPath: provider._resolvedScriptsPath || null,
+            scriptsSource: provider._resolvedScriptsSource || null,
+            versionWarning: provider._versionWarning || null,
+        },
+    };
+}

package/src/cli-adapters/provider-cli-parse.ts

@@ -0,0 +1,202 @@
+import {
+    buildCliScreenSnapshot,
+    normalizeComparableMessageContent,
+    sanitizeTerminalText,
+    type CliChatMessage,
+    type CliScriptInput,
+} from './provider-cli-shared.js';
+
+export interface TurnParseScope {
+    prompt: string;
+    startedAt: number;
+    bufferStart: number;
+    rawBufferStart: number;
+}
+
+function sliceFromOffset(text: string, start: number): string {
+    if (!text) return '';
+    if (!Number.isFinite(start) || start <= 0) return text;
+    if (start >= text.length) return '';
+    return text.slice(start);
+}
+
+export function hydrateCliParsedMessages(
+    parsedMessages: any[],
+    options: {
+        committedMessages: CliChatMessage[];
+        scope?: TurnParseScope | null;
+        lastOutputAt: number;
+        now?: number;
+    },
+): any[] {
+    const { committedMessages, scope, lastOutputAt } = options;
+    const referenceMessages = [...committedMessages];
+    const usedReferenceIndexes = new Set<number>();
+    const now = options.now ?? Date.now();
+
+    const findReferenceTimestamp = (role: 'user' | 'assistant', content: string, parsedIndex: number): number | undefined => {
+        const normalizedContent = normalizeComparableMessageContent(content);
+        if (!normalizedContent) return undefined;
+
+        const sameIndex = referenceMessages[parsedIndex];
+        if (
+            sameIndex
+            && !usedReferenceIndexes.has(parsedIndex)
+            && sameIndex.role === role
+            && normalizeComparableMessageContent(sameIndex.content) === normalizedContent
+            && typeof sameIndex.timestamp === 'number'
+            && Number.isFinite(sameIndex.timestamp)
+        ) {
+            usedReferenceIndexes.add(parsedIndex);
+            return sameIndex.timestamp;
+        }
+
+        for (let i = 0; i < referenceMessages.length; i++) {
+            if (usedReferenceIndexes.has(i)) continue;
+            const candidate = referenceMessages[i];
+            if (!candidate || candidate.role !== role) continue;
+            const candidateContent = normalizeComparableMessageContent(candidate.content);
+            if (!candidateContent) continue;
+            const exactMatch = candidateContent === normalizedContent;
+            const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
+            if (!exactMatch && !fuzzyMatch) continue;
+            if (typeof candidate.timestamp === 'number' && Number.isFinite(candidate.timestamp)) {
+                usedReferenceIndexes.add(i);
+                return candidate.timestamp;
+            }
+        }
+
+        return undefined;
+    };
+
+    return parsedMessages
+        .filter((message) => message && (message.role === 'user' || message.role === 'assistant'))
+        .map((message, index) => {
+            const role = message.role as 'user' | 'assistant';
+            const content = typeof message.content === 'string' ? message.content : String(message.content || '');
+            const parsedTimestamp = typeof message.timestamp === 'number' && Number.isFinite(message.timestamp)
+                ? message.timestamp
+                : undefined;
+            const referenceTimestamp = parsedTimestamp ?? findReferenceTimestamp(role, content, index);
+            const fallbackTimestamp = role === 'user'
+                ? (scope?.startedAt || now)
+                : (lastOutputAt || scope?.startedAt || now);
+            const timestamp = referenceTimestamp ?? fallbackTimestamp;
+            return {
+                ...message,
+                role,
+                content,
+                timestamp,
+                receivedAt: typeof message.receivedAt === 'number' && Number.isFinite(message.receivedAt)
+                    ? message.receivedAt
+                    : timestamp,
+            };
+        });
+}
+
+export function normalizeCliParsedMessages(
+    parsedMessages: any[],
+    options: {
+        committedMessages: CliChatMessage[];
+        scope?: TurnParseScope | null;
+        lastOutputAt: number;
+        now?: number;
+    },
+): CliChatMessage[] {
+    return hydrateCliParsedMessages(parsedMessages, options).map((message) => ({
+        role: message.role,
+        content: message.content,
+        timestamp: message.timestamp,
+        receivedAt: message.receivedAt,
+        kind: message.kind,
+        id: message.id,
+        index: message.index,
+        meta: message.meta,
+        senderName: message.senderName,
+    }));
+}
+
+export function buildCliParseInput(options: {
+    accumulatedBuffer: string;
+    accumulatedRawBuffer: string;
+    recentOutputBuffer: string;
+    terminalScreenText: string;
+    baseMessages: CliChatMessage[];
+    partialResponse: string;
+    scope?: TurnParseScope | null;
+    runtimeSettings: Record<string, any>;
+}): CliScriptInput {
+    const {
+        accumulatedBuffer,
+        accumulatedRawBuffer,
+        recentOutputBuffer,
+        terminalScreenText,
+        baseMessages,
+        partialResponse,
+        scope,
+        runtimeSettings,
+    } = options;
+    const buffer = scope
+        ? (sliceFromOffset(accumulatedBuffer, scope.bufferStart) || accumulatedBuffer)
+        : accumulatedBuffer;
+    const rawBuffer = scope
+        ? (sliceFromOffset(accumulatedRawBuffer, scope.rawBufferStart) || accumulatedRawBuffer)
+        : accumulatedRawBuffer;
+    const screenText = terminalScreenText;
+    const recentBuffer = buffer.slice(-1000) || recentOutputBuffer;
+
+    return {
+        buffer,
+        rawBuffer,
+        recentBuffer,
+        screenText,
+        screen: buildCliScreenSnapshot(screenText),
+        bufferScreen: buildCliScreenSnapshot(buffer),
+        recentScreen: buildCliScreenSnapshot(recentBuffer),
+        messages: [...baseMessages],
+        partialResponse,
+        promptText: scope?.prompt || '',
+        settings: { ...runtimeSettings },
+    };
+}
+
+export function summarizeCliTraceText(text: string, max = 800): string {
+    const value = sanitizeTerminalText(String(text || ''));
+    if (value.length <= max) return value;
+    return `…${value.slice(-max)}`;
+}
+
+export function summarizeCliTraceMessages(
+    messages: CliChatMessage[],
+    limit = 3,
+): { role: string; content: string; timestamp?: number }[] {
+    return messages.slice(-limit).map((message) => ({
+        role: message.role,
+        content: summarizeCliTraceText(message.content, 240),
+        timestamp: message.timestamp,
+    }));
+}
+
+export function buildCliTraceParseSnapshot(options: {
+    accumulatedBuffer: string;
+    accumulatedRawBuffer: string;
+    responseBuffer: string;
+    partialResponse?: string;
+    scope?: TurnParseScope | null;
+}): Record<string, any> {
+    const { accumulatedBuffer, accumulatedRawBuffer, responseBuffer, partialResponse, scope } = options;
+    const scopedBuffer = scope
+        ? (sliceFromOffset(accumulatedBuffer, scope.bufferStart) || accumulatedBuffer)
+        : accumulatedBuffer;
+    const scopedRawBuffer = scope
+        ? (sliceFromOffset(accumulatedRawBuffer, scope.rawBufferStart) || accumulatedRawBuffer)
+        : accumulatedRawBuffer;
+    return {
+        currentTurnScope: scope || null,
+        responseBuffer: summarizeCliTraceText(responseBuffer, 1200),
+        partialResponse: summarizeCliTraceText(partialResponse || responseBuffer, 1200),
+        turnBuffer: summarizeCliTraceText(scopedBuffer, 1600),
+        turnRawPreview: summarizeCliTraceText(scopedRawBuffer, 1600),
+        turnSanitizedRawPreview: summarizeCliTraceText(sanitizeTerminalText(scopedRawBuffer), 1600),
+    };
+}

package/src/cli-adapters/provider-cli-runtime.ts

@@ -0,0 +1,142 @@
+import * as os from 'os';
+import * as path from 'path';
+import type { PtySpawnOptions, PtyRuntimeTransport } from './pty-transport.js';
+import type { TerminalScreen } from './terminal-screen.js';
+import {
+    buildCliSpawnEnv,
+    findBinary,
+    isScriptBinary,
+    looksLikeMachOOrElf,
+    shSingleQuote,
+    type CliProviderModule,
+} from './provider-cli-shared.js';
+
+export interface CliSpawnPlan {
+    binaryPath: string;
+    allArgs: string[];
+    shellCmd: string;
+    shellArgs: string[];
+    ptyOptions: PtySpawnOptions;
+    isWin: boolean;
+    useShell: boolean;
+}
+
+export function resolveCliSpawnPlan(options: {
+    provider: CliProviderModule;
+    runtimeSettings: Record<string, any>;
+    workingDir: string;
+    extraArgs: string[];
+}): CliSpawnPlan {
+    const { provider, runtimeSettings, workingDir, extraArgs } = options;
+    const { spawn: spawnConfig } = provider;
+    const configuredCommand = typeof runtimeSettings.executablePath === 'string' && runtimeSettings.executablePath.trim()
+        ? runtimeSettings.executablePath.trim()
+        : spawnConfig.command;
+    const binaryPath = findBinary(configuredCommand);
+    const isWin = os.platform() === 'win32';
+    const allArgs = [...spawnConfig.args, ...extraArgs];
+
+    let shellCmd: string;
+    let shellArgs: string[];
+    const useShellUnix = !isWin && (
+        !!spawnConfig.shell
+        || !path.isAbsolute(binaryPath)
+        || isScriptBinary(binaryPath)
+        || !looksLikeMachOOrElf(binaryPath)
+    );
+    const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
+    const useShellWin = !!spawnConfig.shell
+        || isCmdShim
+        || !path.isAbsolute(binaryPath)
+        || isScriptBinary(binaryPath);
+    const useShell = isWin ? useShellWin : useShellUnix;
+
+    if (useShell) {
+        shellCmd = isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh');
+        if (isWin) {
+            shellArgs = ['/c', binaryPath, ...allArgs];
+        } else {
+            const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(' ');
+            shellArgs = ['-l', '-c', fullCmd];
+        }
+    } else {
+        shellCmd = binaryPath;
+        shellArgs = allArgs;
+    }
+
+    return {
+        binaryPath,
+        allArgs,
+        shellCmd,
+        shellArgs,
+        isWin,
+        useShell,
+        ptyOptions: {
+            cols: 80,
+            rows: 24,
+            cwd: workingDir,
+            env: buildCliSpawnEnv(process.env, spawnConfig.env),
+        },
+    };
+}
+
+export function buildCliLoginShellRetry(plan: Pick<CliSpawnPlan, 'binaryPath' | 'allArgs'>): {
+    shellCmd: string;
+    shellArgs: string[];
+} {
+    const shellCmd = process.env.SHELL || '/bin/zsh';
+    const fullCmd = [plan.binaryPath, ...plan.allArgs].map(shSingleQuote).join(' ');
+    return {
+        shellCmd,
+        shellArgs: ['-l', '-c', fullCmd],
+    };
+}
+
+export function getCliSpawnErrorHint(message: string, shellCmd: string, isWin: boolean): string | null {
+    if (!isWin) return null;
+    if (/error code 267|ERROR_DIRECTORY/i.test(message)) {
+        return ' (working directory does not exist or is not a directory)';
+    }
+    if (/error code 740|elevation/i.test(message)) {
+        return ' (requires administrator privileges)';
+    }
+    if (/error code 2|ENOENT|not found/i.test(message)) {
+        return ` (executable not found: ${shellCmd})`;
+    }
+    return null;
+}
+
+export function respondToCliTerminalQueries(options: {
+    ptyProcess: PtyRuntimeTransport | null;
+    pendingTail: string;
+    data: string;
+    terminalScreen: TerminalScreen;
+}): string {
+    const { ptyProcess, pendingTail, data, terminalScreen } = options;
+    if (!ptyProcess || !data) return pendingTail;
+
+    const combined = pendingTail + data;
+    const regex = /\x1b\[(\?)?6n/g;
+    let match: RegExpExecArray | null;
+
+    while ((match = regex.exec(combined)) !== null) {
+        const cursor = terminalScreen.getCursorPosition();
+        const row = Math.max(1, (cursor.row | 0) + 1);
+        const col = Math.max(1, (cursor.col | 0) + 1);
+        const response = match[1]
+            ? `\x1b[?${row};${col}R`
+            : `\x1b[${row};${col}R`;
+        ptyProcess.write(response);
+    }
+
+    const prefixes = ['\x1b[6n', '\x1b[?6n'];
+    const maxLength = prefixes.reduce((n, value) => Math.max(n, value.length), 0) - 1;
+    const start = Math.max(0, combined.length - maxLength);
+    for (let i = start; i < combined.length; i++) {
+        const suffix = combined.slice(i);
+        if (prefixes.some((pattern) => suffix.length < pattern.length && pattern.startsWith(suffix))) {
+            return suffix;
+        }
+    }
+    return '';
+}