funolio-agent 1.0.47 → 1.0.49

package/dist/local-cli-pty-manager.js

@@ -0,0 +1,645 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCliPtySessionManager = void 0;
+exports.parseClaudeSessionRecord = parseClaudeSessionRecord;
+exports.parseCodexSessionRecord = parseCodexSessionRecord;
+exports.getLocalCliPtySessionManager = getLocalCliPtySessionManager;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const claude_cli_prompt_1 = require("./providers/claude-cli-prompt");
+let _ptyModule = null;
+let _manager = null;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sessionKey(conversationId, botId) {
+    return `${conversationId}::${botId}`;
+}
+function getAppDirFromExec(execDir) {
+    return path.basename(execDir).toLowerCase() === 'binaries'
+        ? path.dirname(execDir)
+        : execDir;
+}
+function findExecutableOnPath(commandName) {
+    const pathValue = process.env.PATH || '';
+    if (!pathValue)
+        return null;
+    const pathextValue = process.platform === 'win32'
+        ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+        : '';
+    const pathExts = process.platform === 'win32'
+        ? pathextValue.split(';').filter(Boolean)
+        : [''];
+    const candidates = commandName.includes('.')
+        ? [commandName]
+        : pathExts.map((ext) => `${commandName}${ext.toLowerCase()}`);
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        for (const candidate of candidates) {
+            const fullPath = path.join(dir, candidate);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+function loadNodePtyModule() {
+    if (_ptyModule)
+        return _ptyModule;
+    const dynamicRequire = eval('require');
+    try {
+        _ptyModule = dynamicRequire('@homebridge/node-pty-prebuilt-multiarch');
+        return _ptyModule;
+    }
+    catch (firstErr) {
+        const execDir = path.dirname(process.execPath);
+        const appDir = getAppDirFromExec(execDir);
+        const candidates = [
+            path.join(execDir, 'resources', 'node-pty-prebuilt', 'lib', 'index.js'),
+            path.join(appDir, 'resources', 'node-pty-prebuilt', 'lib', 'index.js'),
+        ];
+        for (const candidate of candidates) {
+            if (!fs.existsSync(candidate))
+                continue;
+            _ptyModule = dynamicRequire(candidate);
+            return _ptyModule;
+        }
+        throw new Error(`Failed to load PTY runtime. Tried package import and packaged resource candidates. Original error: ${firstErr instanceof Error ? firstErr.message : String(firstErr)}`);
+    }
+}
+function buildCodexSeedPrompt(systemPrompt, messages) {
+    let fullPrompt = '';
+    if (systemPrompt) {
+        fullPrompt += `[System Instructions]\n${systemPrompt}\n\n`;
+    }
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+    if (messages.length > 0) {
+        const transcriptMessages = lastMessage?.role === 'user' ? messages.slice(0, -1) : messages;
+        if (transcriptMessages.length > 0) {
+            fullPrompt += '[Recent Transcript]\n';
+            for (const msg of transcriptMessages) {
+                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                const label = msg.role === 'user' ? 'USER'
+                    : msg.role === 'assistant' ? 'ASSISTANT'
+                        : msg.role === 'tool' ? `TOOL (${msg.toolName || 'tool'})`
+                            : String(msg.role || 'MESSAGE').toUpperCase();
+                fullPrompt += `${label}:\n${content}\n\n`;
+            }
+        }
+    }
+    if (lastMessage?.role === 'user') {
+        const prompt = typeof lastMessage.content === 'string' ? lastMessage.content : JSON.stringify(lastMessage.content);
+        fullPrompt += `[User Request]\n${prompt}`;
+    }
+    else if (lastMessage) {
+        const content = typeof lastMessage.content === 'string' ? lastMessage.content : JSON.stringify(lastMessage.content);
+        fullPrompt += `[Latest Message]\n${content}\n\nContinue from the transcript above and respond appropriately.`;
+    }
+    else {
+        fullPrompt += '[User Request]\n';
+    }
+    return fullPrompt;
+}
+function buildTurnPrompt(provider, systemPrompt, messages, freshSession) {
+    if (!freshSession) {
+        const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+        if (lastMessage?.role === 'user') {
+            return typeof lastMessage.content === 'string'
+                ? lastMessage.content
+                : JSON.stringify(lastMessage.content);
+        }
+    }
+    if (provider === 'claude-cli') {
+        return (0, claude_cli_prompt_1.buildClaudeCliStylePrompt)({
+            system: systemPrompt,
+            messages,
+            runtimeMode: 'local_desktop',
+        });
+    }
+    return buildCodexSeedPrompt(systemPrompt, messages);
+}
+function getProviderSessionRoot(provider) {
+    if (provider === 'claude-cli') {
+        return path.join(os.homedir(), '.claude', 'projects');
+    }
+    return path.join(os.homedir(), '.codex', 'sessions');
+}
+function listSessionFiles(provider) {
+    const root = getProviderSessionRoot(provider);
+    if (!fs.existsSync(root))
+        return [];
+    const results = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase().endsWith('.jsonl')) {
+                results.push(fullPath);
+            }
+        }
+    }
+    return results;
+}
+function extractUserPromptFromRecord(provider, record) {
+    if (!record || typeof record !== 'object')
+        return '';
+    if (provider === 'claude-cli') {
+        const content = record?.message?.content;
+        return typeof content === 'string' ? content.trim() : '';
+    }
+    if (record.type === 'event_msg' && record.payload?.type === 'user_message' && typeof record.payload?.message === 'string') {
+        return record.payload.message.trim();
+    }
+    return '';
+}
+function recentFileContainsPrompt(provider, filePath, promptText) {
+    const expected = promptText.trim();
+    if (!expected)
+        return false;
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        return false;
+    }
+    const readLength = Math.min(stat.size, 512 * 1024);
+    if (readLength <= 0)
+        return false;
+    const start = stat.size - readLength;
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(readLength);
+        fs.readSync(fd, buffer, 0, readLength, start);
+        const text = buffer.toString('utf8');
+        for (const rawLine of text.split('\n')) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            try {
+                const record = JSON.parse(line);
+                if (extractUserPromptFromRecord(provider, record) === expected) {
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return false;
+}
+function discoverSessionFile(provider, launchSnapshot, startedAtMs, promptLocator) {
+    const candidates = listSessionFiles(provider)
+        .map((candidate) => {
+        let mtimeMs = 0;
+        try {
+            mtimeMs = fs.statSync(candidate).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+        return { candidate, mtimeMs, isNew: !launchSnapshot.has(candidate) };
+    })
+        .filter((item) => !!item)
+        .filter((item) => item.mtimeMs >= (startedAtMs - 5000))
+        .sort((a, b) => {
+        if (a.isNew !== b.isNew)
+            return a.isNew ? -1 : 1;
+        return b.mtimeMs - a.mtimeMs;
+    });
+    if (promptLocator?.trim()) {
+        const matched = candidates.find((item) => recentFileContainsPrompt(provider, item.candidate, promptLocator));
+        if (matched)
+            return matched.candidate;
+    }
+    return candidates[0]?.candidate || null;
+}
+function extractClaudeText(record) {
+    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
+    return blocks
+        .map((block) => {
+        if (!block || typeof block !== 'object')
+            return '';
+        return block.type === 'text' && typeof block.text === 'string' ? block.text : '';
+    })
+        .join('');
+}
+function extractClaudeToolNames(record) {
+    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
+    return blocks
+        .map((block) => (block?.type === 'tool_use' && typeof block?.name === 'string' ? block.name : ''))
+        .filter((name) => !!name);
+}
+function extractCodexAssistantText(record) {
+    if (!record || typeof record !== 'object')
+        return '';
+    if (record.type === 'event_msg') {
+        if (record.payload?.type === 'agent_message' && typeof record.payload?.message === 'string') {
+            return record.payload.message;
+        }
+        if (record.payload?.type === 'task_complete' && typeof record.payload?.last_agent_message === 'string') {
+            return record.payload.last_agent_message;
+        }
+    }
+    if (record.type === 'response_item' && record.payload?.type === 'message' && record.payload?.role === 'assistant') {
+        const blocks = Array.isArray(record.payload?.content) ? record.payload.content : [];
+        return blocks
+            .map((block) => {
+            if (!block || typeof block !== 'object')
+                return '';
+            if (block.type === 'output_text' && typeof block.text === 'string')
+                return block.text;
+            if (block.type === 'text' && typeof block.text === 'string')
+                return block.text;
+            return '';
+        })
+            .join('');
+    }
+    return '';
+}
+function normalizeAssistantContent(text) {
+    return text.replace(/^\s+/, '').replace(/\r/g, '');
+}
+async function emitDetail(tracker, detail, cb) {
+    const trimmed = detail.trim();
+    if (!trimmed)
+        return;
+    if (tracker.detailFingerprints.has(trimmed))
+        return;
+    tracker.detailFingerprints.add(trimmed);
+    await cb?.(trimmed);
+}
+function parseClaudeSessionRecord(record) {
+    const sessionId = typeof record?.sessionId === 'string' ? record.sessionId : undefined;
+    if (record?.type === 'assistant' && record?.message) {
+        const usage = record.message.usage
+            ? {
+                inputTokens: (record.message.usage.input_tokens || 0)
+                    + (record.message.usage.cache_read_input_tokens || 0)
+                    + (record.message.usage.cache_creation_input_tokens || 0),
+                outputTokens: record.message.usage.output_tokens || 0,
+            }
+            : undefined;
+        const toolNames = extractClaudeToolNames(record);
+        if (toolNames.length > 0) {
+            return {
+                sessionId,
+                detail: `Running ${toolNames.join(', ')}...`,
+                usage,
+            };
+        }
+        const text = normalizeAssistantContent(extractClaudeText(record));
+        if (text) {
+            return {
+                sessionId,
+                ...(record.message.stop_reason === 'end_turn'
+                    ? { finalContent: text, done: true, usage }
+                    : { detail: text, usage }),
+            };
+        }
+        return { sessionId, usage };
+    }
+    if (record?.type === 'user' && Array.isArray(record?.message?.content)) {
+        const toolResultText = record.message.content
+            .map((block) => {
+            if (!block || typeof block !== 'object')
+                return '';
+            if (typeof block.tool_use_id === 'string' && typeof block.content === 'string') {
+                return `Tool result (${block.tool_use_id}): ${String(block.content).slice(0, 240)}`;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+        if (toolResultText) {
+            return { sessionId, detail: toolResultText };
+        }
+    }
+    return sessionId ? { sessionId } : {};
+}
+function parseCodexSessionRecord(record) {
+    if (!record || typeof record !== 'object')
+        return {};
+    if (record.type === 'session_meta' && typeof record.payload?.id === 'string') {
+        return { sessionId: record.payload.id };
+    }
+    if (record.type === 'event_msg' && record.payload?.type === 'task_started') {
+        return { detail: 'Task started' };
+    }
+    if (record.type === 'event_msg' && record.payload?.type === 'task_complete') {
+        const finalContent = normalizeAssistantContent(typeof record.payload?.last_agent_message === 'string' ? record.payload.last_agent_message : '');
+        return {
+            finalContent,
+            done: true,
+        };
+    }
+    if (record.type === 'event_msg' && record.payload?.type === 'token_count' && record.payload?.info?.total_token_usage) {
+        return {
+            usage: {
+                inputTokens: (record.payload.info.total_token_usage.input_tokens || 0)
+                    + (record.payload.info.total_token_usage.cached_input_tokens || 0),
+                outputTokens: record.payload.info.total_token_usage.output_tokens || 0,
+            },
+        };
+    }
+    const assistantText = normalizeAssistantContent(extractCodexAssistantText(record));
+    if (assistantText) {
+        return { finalContent: assistantText };
+    }
+    if (record.type === 'event_msg' && typeof record.payload?.type === 'string') {
+        const eventType = record.payload.type;
+        if (!['user_message', 'agent_message', 'token_count', 'task_complete'].includes(eventType)) {
+            return { detail: eventType.replace(/_/g, ' ') };
+        }
+    }
+    return {};
+}
+async function waitForFirstTerminalData(session) {
+    await Promise.race([session.readyPromise, delay(5000)]);
+    await delay(session.startupDelayMs);
+}
+async function writeInteractivePrompt(session, promptText) {
+    if (session.provider === 'codex-cli') {
+        session.pty.write(promptText);
+        await delay(session.submitDelayMs);
+        session.pty.write('\r');
+        return;
+    }
+    session.pty.write(promptText);
+    session.pty.write('\r');
+}
+class LocalCliPtySessionManager {
+    sessions = new Map();
+    async runTurn(opts) {
+        const key = sessionKey(opts.conversationId, opts.botId);
+        let session = this.sessions.get(key);
+        if (session
+            && (opts.forceFreshSession || session.provider !== opts.provider || session.cwd !== opts.cwd || session.closed)) {
+            this.closeSession(key);
+            session = undefined;
+        }
+        if (!session) {
+            session = this.createSession(key, opts.provider, opts.cwd);
+            this.sessions.set(key, session);
+        }
+        const run = async () => this.runTurnInternal(session, opts);
+        const queued = session.chain.then(run, run);
+        session.chain = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    closeSessionByConversation(conversationId, botId) {
+        this.closeSession(sessionKey(conversationId, botId));
+    }
+    closeAll() {
+        for (const key of [...this.sessions.keys()]) {
+            this.closeSession(key);
+        }
+    }
+    closeSession(key) {
+        const session = this.sessions.get(key);
+        if (!session)
+            return;
+        session.closed = true;
+        try {
+            session.pty.kill();
+        }
+        catch {
+            // best effort
+        }
+        this.sessions.delete(key);
+    }
+    createSession(key, provider, cwd) {
+        const ptyModule = loadNodePtyModule();
+        const cleanEnv = { ...process.env };
+        delete cleanEnv.CLAUDECODE;
+        delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+        delete cleanEnv.CLAUDE_CODE_SESSION_ID;
+        let readyResolve = null;
+        const readyPromise = new Promise((resolve) => {
+            readyResolve = resolve;
+        });
+        const pty = provider === 'codex-cli'
+            ? ptyModule.spawn(findExecutableOnPath('codex.cmd') || 'codex.cmd', ['--no-alt-screen'], {
+                cwd,
+                cols: 160,
+                rows: 48,
+                env: cleanEnv,
+                useConpty: true,
+                name: 'xterm-color',
+            })
+            : ptyModule.spawn('cmd.exe', [], {
+                cwd,
+                cols: 160,
+                rows: 48,
+                env: cleanEnv,
+                useConpty: true,
+                name: 'xterm-color',
+            });
+        const session = {
+            key,
+            provider,
+            cwd,
+            pty,
+            createdAtMs: Date.now(),
+            lastUsedAtMs: Date.now(),
+            launchSnapshot: new Set(listSessionFiles(provider)),
+            sessionId: null,
+            sessionFilePath: null,
+            sessionFileOffset: 0,
+            sessionFileCarry: '',
+            readyPromise,
+            readyResolved: false,
+            waitForNextSendMs: 250,
+            startupDelayMs: provider === 'codex-cli' ? 9000 : 1200,
+            submitDelayMs: provider === 'codex-cli' ? 350 : 0,
+            currentPromptLocator: null,
+            currentPromptStartedAtMs: 0,
+            closed: false,
+            chain: Promise.resolve(),
+        };
+        pty.on('data', (chunk) => {
+            if (!session.readyResolved && chunk && chunk.trim()) {
+                session.readyResolved = true;
+                readyResolve?.();
+            }
+        });
+        pty.on('exit', () => {
+            session.closed = true;
+            this.sessions.delete(key);
+        });
+        if (provider === 'claude-cli') {
+            pty.write('claude\r');
+        }
+        return session;
+    }
+    async runTurnInternal(session, opts) {
+        session.lastUsedAtMs = Date.now();
+        await waitForFirstTerminalData(session);
+        if (session.closed) {
+            throw new Error(`${session.provider} PTY session closed before prompt was sent`);
+        }
+        if (session.waitForNextSendMs > 0) {
+            await delay(session.waitForNextSendMs);
+        }
+        const tracker = {
+            done: false,
+            finalContent: '',
+            usage: undefined,
+            lastAssistantText: '',
+            detailFingerprints: new Set(),
+        };
+        const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+        const startedAtMs = Date.now();
+        const promptText = buildTurnPrompt(opts.provider, opts.systemPrompt, opts.messages, opts.forceFreshSession || !session.sessionFilePath);
+        session.currentPromptLocator = promptText.trim();
+        session.currentPromptStartedAtMs = startedAtMs;
+        await writeInteractivePrompt(session, promptText);
+        while (!tracker.done) {
+            if (Date.now() - startedAtMs > timeoutMs) {
+                throw new Error(`${opts.provider} PTY session timed out waiting for a response`);
+            }
+            if (session.closed) {
+                throw new Error(`${opts.provider} PTY session exited while waiting for a response`);
+            }
+            if (!session.sessionFilePath) {
+                const discovered = discoverSessionFile(session.provider, session.launchSnapshot, session.currentPromptStartedAtMs || session.createdAtMs, session.currentPromptLocator);
+                if (discovered) {
+                    session.sessionFilePath = discovered;
+                    session.sessionFileOffset = 0;
+                    session.sessionFileCarry = '';
+                }
+            }
+            if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
+                await this.consumeSessionFile(session, tracker, opts.onDetail);
+            }
+            if (!tracker.done) {
+                await delay(250);
+            }
+        }
+        session.lastUsedAtMs = Date.now();
+        session.waitForNextSendMs = 400;
+        return {
+            content: tracker.finalContent.trim(),
+            sessionId: session.sessionId,
+            usage: tracker.usage,
+        };
+    }
+    async consumeSessionFile(session, tracker, onDetail) {
+        if (!session.sessionFilePath)
+            return;
+        let stat;
+        try {
+            stat = fs.statSync(session.sessionFilePath);
+        }
+        catch {
+            return;
+        }
+        if (stat.size <= session.sessionFileOffset)
+            return;
+        const fd = fs.openSync(session.sessionFilePath, 'r');
+        try {
+            const length = stat.size - session.sessionFileOffset;
+            const buffer = Buffer.alloc(length);
+            fs.readSync(fd, buffer, 0, length, session.sessionFileOffset);
+            session.sessionFileOffset = stat.size;
+            const text = session.sessionFileCarry + buffer.toString('utf8');
+            const lines = text.split('\n');
+            session.sessionFileCarry = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                let record;
+                try {
+                    record = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                await this.applyRecord(session, tracker, record, onDetail);
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    async applyRecord(session, tracker, record, onDetail) {
+        const parsed = session.provider === 'claude-cli'
+            ? parseClaudeSessionRecord(record)
+            : parseCodexSessionRecord(record);
+        if (parsed.sessionId) {
+            session.sessionId = parsed.sessionId;
+        }
+        if (parsed.usage) {
+            tracker.usage = parsed.usage;
+        }
+        if (parsed.detail) {
+            await emitDetail(tracker, parsed.detail, onDetail);
+        }
+        if (parsed.finalContent) {
+            tracker.finalContent = parsed.finalContent;
+            tracker.lastAssistantText = parsed.finalContent;
+        }
+        if (parsed.done) {
+            tracker.done = true;
+        }
+    }
+}
+exports.LocalCliPtySessionManager = LocalCliPtySessionManager;
+function getLocalCliPtySessionManager() {
+    if (!_manager) {
+        _manager = new LocalCliPtySessionManager();
+    }
+    return _manager;
+}
+//# sourceMappingURL=local-cli-pty-manager.js.map