telecodex 0.1.0

package/dist/bot/inputService.js

@@ -0,0 +1,372 @@
+import { applySessionRuntimeEvent } from "../runtime/sessionRuntime.js";
+import { sendPlainChunks } from "../telegram/delivery.js";
+import { isAbortError } from "../codex/sdkRuntime.js";
+import { numericChatId, numericMessageThreadId } from "./session.js";
+import { describeBusyStatus, formatIsoTimestamp, isSessionBusy, sessionBufferKey, sessionLogFields, truncateSingleLine, } from "./sessionFlow.js";
+export async function handleUserText(input) {
+    return handleUserInput({
+        prompt: input.text,
+        session: input.session,
+        store: input.store,
+        codex: input.codex,
+        buffers: input.buffers,
+        bot: input.bot,
+        ...(input.logger ? { logger: input.logger } : {}),
+        ...(input.enqueueIfBusy == null ? {} : { enqueueIfBusy: input.enqueueIfBusy }),
+    });
+}
+export async function handleUserInput(input) {
+    const { prompt, store, codex, buffers, bot, logger } = input;
+    const enqueueIfBusy = input.enqueueIfBusy ?? true;
+    const session = await refreshSessionIfActiveTurnIsStale(input.session, store, codex, bot, logger);
+    if (isSessionBusy(session) || codex.isRunning(session.sessionKey)) {
+        if (!enqueueIfBusy) {
+            return {
+                status: "busy",
+                consumed: false,
+            };
+        }
+        const queued = store.enqueueInput(session.sessionKey, prompt);
+        const queueDepth = store.getQueuedInputCount(session.sessionKey);
+        await sendPlainChunks(bot, {
+            chatId: numericChatId(session),
+            messageThreadId: numericMessageThreadId(session),
+            text: [
+                `The current Codex task is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
+                `queue position: ${queueDepth}`,
+                `queued at: ${formatIsoTimestamp(queued.createdAt)}`,
+                "It will be processed automatically after the current run finishes.",
+            ].join("\n"),
+        }, logger);
+        return {
+            status: "queued",
+            consumed: true,
+        };
+    }
+    await applySessionRuntimeEvent({
+        bot,
+        store,
+        sessionKey: session.sessionKey,
+        event: {
+            type: "turn.preparing",
+            detail: "starting codex sdk run",
+        },
+        logger,
+    });
+    const bufferKey = sessionBufferKey(session.sessionKey);
+    let outputMessageId;
+    try {
+        outputMessageId = await buffers.create(bufferKey, {
+            chatId: numericChatId(session),
+            messageThreadId: numericMessageThreadId(session),
+        });
+    }
+    catch (error) {
+        store.setOutputMessage(session.sessionKey, null);
+        await applySessionRuntimeEvent({
+            bot,
+            store,
+            sessionKey: session.sessionKey,
+            event: {
+                type: "turn.failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+            logger,
+        });
+        return {
+            status: "failed",
+            consumed: false,
+        };
+    }
+    store.setOutputMessage(session.sessionKey, outputMessageId);
+    const turnId = createLocalTurnId();
+    await applySessionRuntimeEvent({
+        bot,
+        store,
+        sessionKey: session.sessionKey,
+        event: {
+            type: "turn.started",
+            turnId,
+        },
+        logger,
+    });
+    void runSessionPrompt({
+        sessionKey: session.sessionKey,
+        prompt,
+        store,
+        codex,
+        buffers,
+        bot,
+        turnId,
+        bufferKey,
+        ...(logger ? { logger } : {}),
+    });
+    return {
+        status: "started",
+        consumed: true,
+    };
+}
+export async function refreshSessionIfActiveTurnIsStale(session, store, codex, bot, logger) {
+    const latest = store.get(session.sessionKey) ?? session;
+    if (!isSessionBusy(latest))
+        return latest;
+    if (codex.isRunning(latest.sessionKey))
+        return latest;
+    store.setOutputMessage(latest.sessionKey, null);
+    await applySessionRuntimeEvent({
+        bot,
+        store,
+        sessionKey: latest.sessionKey,
+        event: {
+            type: "turn.failed",
+            turnId: latest.activeTurnId,
+            message: "The previous run was lost. Send the message again.",
+        },
+        logger,
+    });
+    logger?.warn("reset stale in-memory codex run state", {
+        ...sessionLogFields(latest),
+    });
+    return store.get(latest.sessionKey) ?? latest;
+}
+export async function recoverActiveTopicSessions(store, codex, _buffers, bot, logger) {
+    const sessions = store.listTopicSessions().filter((session) => isSessionBusy(session));
+    if (sessions.length === 0)
+        return;
+    logger?.warn("recovering stale sdk-backed sessions after startup", {
+        activeSessions: sessions.length,
+    });
+    for (const session of sessions) {
+        const refreshed = await refreshSessionIfActiveTurnIsStale(session, store, codex, bot, logger);
+        await sendPlainChunks(bot, {
+            chatId: numericChatId(refreshed),
+            messageThreadId: numericMessageThreadId(refreshed),
+            text: "telecodex restarted and cannot resume the previous streamed run state. Send the message again if you want to continue.",
+        }, logger).catch((error) => {
+            logger?.warn("failed to notify session about stale sdk recovery", {
+                ...sessionLogFields(refreshed),
+                error,
+            });
+        });
+    }
+}
+export async function processNextQueuedInputForSession(sessionKey, store, codex, buffers, bot, logger) {
+    const session = store.get(sessionKey);
+    if (!session || isSessionBusy(session) || codex.isRunning(sessionKey))
+        return;
+    const next = store.peekNextQueuedInput(sessionKey);
+    if (!next)
+        return;
+    try {
+        const result = await handleUserInput({
+            prompt: next.input,
+            session,
+            store,
+            codex,
+            buffers,
+            bot,
+            enqueueIfBusy: false,
+            ...(logger ? { logger } : {}),
+        });
+        if (result.consumed) {
+            store.removeQueuedInput(next.id);
+        }
+    }
+    catch (error) {
+        logger?.warn("failed to process queued telegram input", {
+            sessionKey,
+            queuedInputId: next.id,
+            error,
+        });
+    }
+}
+async function runSessionPrompt(input) {
+    const { sessionKey, prompt, store, codex, buffers, bot, turnId, bufferKey, logger } = input;
+    const session = store.get(sessionKey);
+    if (!session)
+        return;
+    try {
+        const result = await codex.run({
+            profile: {
+                sessionKey,
+                threadId: session.codexThreadId,
+                cwd: session.cwd,
+                model: session.model,
+                sandboxMode: session.sandboxMode,
+                approvalPolicy: session.approvalPolicy,
+                reasoningEffort: session.reasoningEffort,
+                webSearchMode: session.webSearchMode,
+                networkAccessEnabled: session.networkAccessEnabled,
+                skipGitRepoCheck: session.skipGitRepoCheck,
+                additionalDirectories: session.additionalDirectories,
+                outputSchema: parseOutputSchema(session.outputSchema),
+            },
+            prompt: toSdkInput(prompt),
+            callbacks: {
+                onThreadStarted: async (threadId) => {
+                    store.bindThread(sessionKey, threadId);
+                },
+                onEvent: async (event) => {
+                    await projectEventToTelegramBuffer(buffers, bufferKey, event);
+                },
+            },
+        });
+        const latest = store.get(sessionKey);
+        if (latest) {
+            store.bindThread(sessionKey, result.threadId);
+            store.setOutputMessage(sessionKey, null);
+            await applySessionRuntimeEvent({
+                bot,
+                store,
+                sessionKey,
+                event: {
+                    type: "turn.completed",
+                    turnId,
+                },
+                logger,
+            });
+        }
+        await buffers.complete(bufferKey, result.finalResponse || undefined);
+    }
+    catch (error) {
+        const latest = store.get(sessionKey);
+        if (latest) {
+            store.setOutputMessage(sessionKey, null);
+            await applySessionRuntimeEvent({
+                bot,
+                store,
+                sessionKey,
+                event: isAbortError(error)
+                    ? {
+                        type: "turn.interrupted",
+                        turnId,
+                    }
+                    : {
+                        type: "turn.failed",
+                        turnId,
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                logger,
+            });
+        }
+        if (isAbortError(error)) {
+            await buffers.fail(bufferKey, "Current run interrupted.");
+        }
+        else {
+            await buffers.fail(bufferKey, error instanceof Error ? error.message : String(error));
+        }
+    }
+    finally {
+        await processNextQueuedInputForSession(sessionKey, store, codex, buffers, bot, logger);
+    }
+}
+async function projectEventToTelegramBuffer(buffers, key, event) {
+    switch (event.type) {
+        case "thread.started":
+            buffers.note(key, `thread started: ${event.thread_id}`);
+            return;
+        case "turn.started":
+            buffers.note(key, "started processing");
+            return;
+        case "turn.completed":
+            buffers.note(key, `token usage: in ${event.usage.input_tokens}, out ${event.usage.output_tokens}, cached ${event.usage.cached_input_tokens}`);
+            return;
+        case "item.started":
+        case "item.updated":
+        case "item.completed":
+            projectItem(buffers, key, event.item, event.type);
+            return;
+        case "turn.failed":
+            buffers.note(key, `run failed: ${event.error.message}`);
+            return;
+        case "error":
+            buffers.note(key, `error: ${event.message}`);
+            return;
+    }
+}
+function projectItem(buffers, key, item, phase) {
+    switch (item.type) {
+        case "agent_message":
+            buffers.setReplyDraft(key, item.text);
+            return;
+        case "reasoning":
+            buffers.setReasoningSummary(key, item.text);
+            return;
+        case "command_execution":
+            projectCommandExecution(buffers, key, item, phase);
+            return;
+        case "file_change":
+            projectFileChange(buffers, key, item, phase);
+            return;
+        case "mcp_tool_call":
+            projectMcpToolCall(buffers, key, item, phase);
+            return;
+        case "web_search":
+            projectWebSearch(buffers, key, item, phase);
+            return;
+        case "todo_list":
+            projectTodoList(buffers, key, item);
+            return;
+        case "error":
+            buffers.note(key, `error: ${truncateSingleLine(item.message, 120)}`);
+            return;
+    }
+}
+function projectCommandExecution(buffers, key, item, phase) {
+    if (phase === "item.started") {
+        buffers.note(key, `command: ${truncateSingleLine(item.command, 120)}`);
+    }
+    else if (phase === "item.completed") {
+        const exitCode = item.exit_code == null ? "?" : String(item.exit_code);
+        const prefix = item.status === "failed" ? "command failed" : "command completed";
+        buffers.note(key, `${prefix}: ${truncateSingleLine(item.command, 96)} (exit ${exitCode})`);
+    }
+    if (item.aggregated_output.trim()) {
+        buffers.setToolOutput(key, item.aggregated_output);
+    }
+}
+function projectFileChange(buffers, key, item, phase) {
+    if (phase === "item.started") {
+        buffers.note(key, `file changes: ${item.changes.length} entries`);
+        return;
+    }
+    if (phase === "item.completed") {
+        const prefix = item.status === "failed" ? "file changes failed" : "file changes completed";
+        buffers.note(key, `${prefix}: ${item.changes.length} entries`);
+    }
+}
+function projectMcpToolCall(buffers, key, item, phase) {
+    if (phase === "item.started") {
+        buffers.note(key, `MCP: ${item.server}/${item.tool}`);
+        return;
+    }
+    if (phase === "item.completed") {
+        buffers.note(key, item.error ? `MCP failed: ${item.server}/${item.tool}` : `MCP completed: ${item.server}/${item.tool}`);
+    }
+}
+function projectWebSearch(buffers, key, item, phase) {
+    if (phase === "item.completed") {
+        buffers.note(key, `web search completed: ${truncateSingleLine(item.query, 120)}`);
+        return;
+    }
+    buffers.note(key, `web search: ${truncateSingleLine(item.query, 120)}`);
+}
+function projectTodoList(buffers, key, item) {
+    const lines = item.items
+        .slice(0, 6)
+        .map((entry) => `${entry.completed ? "[done]" : "[todo]"} ${truncateSingleLine(entry.text, 96)}`);
+    if (lines.length > 0) {
+        buffers.setPlan(key, lines.join("\n"));
+    }
+}
+function createLocalTurnId() {
+    return `sdk-turn-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function toSdkInput(input) {
+    return input;
+}
+function parseOutputSchema(value) {
+    if (!value)
+        return undefined;
+    return JSON.parse(value);
+}

package/dist/bot/registerHandlers.js

@@ -0,0 +1,10 @@
+import { registerMessageHandlers } from "./handlers/messageHandlers.js";
+import { registerOperationalHandlers } from "./handlers/operationalHandlers.js";
+import { registerProjectHandlers } from "./handlers/projectHandlers.js";
+import { registerSessionConfigHandlers } from "./handlers/sessionConfigHandlers.js";
+export function registerHandlers(deps) {
+    registerOperationalHandlers(deps);
+    registerProjectHandlers(deps);
+    registerSessionConfigHandlers(deps);
+    registerMessageHandlers(deps);
+}

package/dist/bot/session.js

@@ -0,0 +1,22 @@
+import { makeSessionKey } from "../store/sessions.js";
+export function sessionFromContext(ctx, store, config) {
+    const chatId = ctx.chat?.id;
+    if (chatId == null)
+        throw new Error("Missing Telegram chat id");
+    const messageThreadId = ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id ?? null;
+    const sessionKey = makeSessionKey(chatId, messageThreadId);
+    return store.getOrCreate({
+        sessionKey,
+        chatId: String(chatId),
+        messageThreadId: messageThreadId == null ? null : String(messageThreadId),
+        telegramTopicName: null,
+        defaultCwd: config.defaultCwd,
+        defaultModel: config.defaultModel,
+    });
+}
+export function numericChatId(session) {
+    return Number(session.chatId);
+}
+export function numericMessageThreadId(session) {
+    return session.messageThreadId == null ? null : Number(session.messageThreadId);
+}

package/dist/bot/sessionFlow.js

@@ -0,0 +1,51 @@
+export function sessionBufferKey(sessionKey) {
+    return `session:${sessionKey}`;
+}
+export function formatIsoTimestamp(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return value;
+    return date.toLocaleString("en-GB", {
+        hour12: false,
+    });
+}
+export function truncateSingleLine(text, maxLength) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function sessionLogFields(session) {
+    return {
+        sessionKey: session.sessionKey,
+        chatId: session.chatId,
+        messageThreadId: session.messageThreadId,
+        cwd: session.cwd,
+        model: session.model,
+        sandboxMode: session.sandboxMode,
+        approvalPolicy: session.approvalPolicy,
+        reasoningEffort: session.reasoningEffort,
+        webSearchMode: session.webSearchMode,
+        networkAccessEnabled: session.networkAccessEnabled ? "true" : "false",
+        skipGitRepoCheck: session.skipGitRepoCheck ? "true" : "false",
+        runtimeStatus: session.runtimeStatus,
+        runtimeStatusDetail: session.runtimeStatusDetail,
+        codexThreadId: session.codexThreadId,
+        activeTurnId: session.activeTurnId,
+    };
+}
+export function isSessionBusy(session) {
+    return session.runtimeStatus === "preparing" || session.runtimeStatus === "running" || session.activeTurnId != null;
+}
+export function describeBusyStatus(status) {
+    switch (status) {
+        case "preparing":
+            return "preparing";
+        case "running":
+            return "running";
+        case "failed":
+            return "recovering after a failed run";
+        default:
+            return "processing";
+    }
+}

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { note } from "@clack/prompts";
+import { startTelecodex } from "./runtime/startTelecodex.js";
+function printHelp() {
+    note("Run `telecodex` with no environment variables. The first launch will guide setup.", "telecodex");
+}
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    printHelp();
+    process.exit(0);
+}
+startTelecodex().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/codex/sdkRuntime.js

@@ -0,0 +1,165 @@
+import { Codex, } from "@openai/codex-sdk";
+export class CodexSdkRuntime {
+    input;
+    codex;
+    activeRuns = new Map();
+    configOverrides;
+    injectedCodex;
+    constructor(input) {
+        this.input = input;
+        this.configOverrides = input.configOverrides;
+        this.injectedCodex = input.codex ?? null;
+        this.codex = input.codex ?? this.createCodex();
+    }
+    setConfigOverrides(configOverrides) {
+        this.configOverrides = configOverrides;
+        if (!this.injectedCodex) {
+            this.codex = this.createCodex();
+        }
+    }
+    isRunning(sessionKey) {
+        return this.activeRuns.has(sessionKey);
+    }
+    getActiveRun(sessionKey) {
+        return this.activeRuns.get(sessionKey) ?? null;
+    }
+    interrupt(sessionKey) {
+        const run = this.activeRuns.get(sessionKey);
+        if (!run)
+            return false;
+        run.abortController.abort();
+        return true;
+    }
+    interruptAll() {
+        for (const run of this.activeRuns.values()) {
+            run.abortController.abort();
+        }
+    }
+    createCodex() {
+        return new Codex({
+            codexPathOverride: this.input.codexBin,
+            ...(this.configOverrides ? { config: this.configOverrides } : {}),
+        });
+    }
+    async run(input) {
+        if (this.activeRuns.has(input.profile.sessionKey)) {
+            throw new Error("Codex run already active for this session");
+        }
+        const threadOptions = toThreadOptions(input.profile);
+        const thread = input.profile.threadId
+            ? this.codex.resumeThread(input.profile.threadId, threadOptions)
+            : this.codex.startThread(threadOptions);
+        const abortController = new AbortController();
+        const runPromise = this.consumeStream({
+            thread,
+            prompt: input.prompt,
+            signal: abortController.signal,
+            initialThreadId: input.profile.threadId,
+            sessionKey: input.profile.sessionKey,
+            outputSchema: input.profile.outputSchema,
+            ...(input.callbacks ? { callbacks: input.callbacks } : {}),
+        });
+        const startedAt = new Date().toISOString();
+        this.activeRuns.set(input.profile.sessionKey, {
+            sessionKey: input.profile.sessionKey,
+            startedAt,
+            threadId: input.profile.threadId,
+            lastEventAt: startedAt,
+            lastEventType: null,
+            abortController,
+            promise: runPromise,
+        });
+        try {
+            const result = await runPromise;
+            return result;
+        }
+        finally {
+            this.activeRuns.delete(input.profile.sessionKey);
+        }
+    }
+    async consumeStream(input) {
+        const streamed = await input.thread.runStreamed(input.prompt, {
+            signal: input.signal,
+            ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
+        });
+        const items = new Map();
+        let finalResponse = "";
+        let usage = null;
+        let threadId = input.initialThreadId;
+        for await (const event of streamed.events) {
+            const activeRun = this.activeRuns.get(input.sessionKey);
+            if (activeRun) {
+                activeRun.lastEventAt = new Date().toISOString();
+                activeRun.lastEventType = event.type;
+            }
+            if (event.type === "thread.started") {
+                threadId = event.thread_id;
+                const activeRun = this.activeRuns.get(input.sessionKey);
+                if (activeRun) {
+                    activeRun.threadId = event.thread_id;
+                }
+                await input.callbacks?.onThreadStarted?.(event.thread_id);
+            }
+            else if (event.type === "item.started" ||
+                event.type === "item.updated" ||
+                event.type === "item.completed") {
+                items.set(event.item.id, event.item);
+                if (event.item.type === "agent_message") {
+                    finalResponse = event.item.text;
+                }
+            }
+            else if (event.type === "turn.completed") {
+                usage = event.usage;
+            }
+            else if (event.type === "turn.failed") {
+                throw new Error(event.error.message);
+            }
+            else if (event.type === "error") {
+                throw new Error(event.message);
+            }
+            await input.callbacks?.onEvent?.(event);
+        }
+        if (!threadId) {
+            throw new Error("Codex SDK run finished without a thread id");
+        }
+        return {
+            threadId,
+            items: [...items.values()],
+            finalResponse,
+            usage,
+        };
+    }
+}
+export function isAbortError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return error.name === "AbortError" || message.includes("aborted") || message.includes("aborterror");
+}
+function toThreadOptions(profile) {
+    const modelReasoningEffort = profile.reasoningEffort == null || profile.reasoningEffort === "none"
+        ? undefined
+        : profile.reasoningEffort;
+    return {
+        model: profile.model,
+        sandboxMode: toSandboxMode(profile.sandboxMode),
+        workingDirectory: profile.cwd,
+        skipGitRepoCheck: profile.skipGitRepoCheck,
+        ...(modelReasoningEffort ? { modelReasoningEffort } : {}),
+        networkAccessEnabled: profile.networkAccessEnabled,
+        ...(profile.webSearchMode ? { webSearchMode: toWebSearchMode(profile.webSearchMode) } : {}),
+        ...(profile.additionalDirectories.length > 0 ? { additionalDirectories: profile.additionalDirectories } : {}),
+        approvalPolicy: toApprovalMode(profile.approvalPolicy),
+    };
+}
+function toSandboxMode(value) {
+    return value;
+}
+function toApprovalMode(value) {
+    if (value === "on-failure")
+        return "on-failure";
+    return value;
+}
+function toWebSearchMode(value) {
+    return value;
+}