telecodex 0.1.2 → 0.1.4

package/dist/codex/sessionCatalog.js

@@ -4,20 +4,25 @@ import path from "node:path";
 import { createInterface } from "node:readline";
 export class CodexSessionCatalog {
     sessionsRoot;
+    cacheTtlMs;
+    index = new Map();
+    sortedPaths = [];
+    pathByThreadId = new Map();
+    refreshPromise = null;
+    lastRefreshedAt = 0;
     constructor(input) {
         this.sessionsRoot = input?.sessionsRoot ?? defaultSessionsRoot();
         this.logger = input?.logger;
+        this.cacheTtlMs = Math.max(0, input?.cacheTtlMs ?? 5_000);
     }
     logger;
     async listProjectThreads(input) {
+        await this.ensureIndexFresh();
         const projectRoot = canonicalizePath(input.projectRoot);
         const limit = Math.max(1, input.limit ?? 8);
-        const files = listSessionFiles(this.sessionsRoot)
-            .filter((entry) => entry.mtimeMs > 0)
-            .sort((left, right) => right.mtimeMs - left.mtimeMs);
         const matches = [];
-        for (const file of files) {
-            const summary = await readSessionSummary(file.path, file.updatedAt);
+        for (const filePath of this.sortedPaths) {
+            const summary = this.index.get(filePath)?.summary ?? null;
             if (!summary)
                 continue;
             if (!isPathWithinRoot(summary.cwd, projectRoot))
@@ -29,17 +34,14 @@ export class CodexSessionCatalog {
         return matches;
     }
     async findProjectThreadById(input) {
+        await this.ensureIndexFresh();
         const projectRoot = canonicalizePath(input.projectRoot);
         const threadId = input.threadId.trim();
         if (!threadId)
             return null;
-        const files = listSessionFiles(this.sessionsRoot).sort((left, right) => right.mtimeMs - left.mtimeMs);
-        for (const file of files) {
-            const summary = await readSessionSummary(file.path, file.updatedAt);
-            if (!summary)
-                continue;
-            if (summary.id !== threadId)
-                continue;
+        const filePath = this.pathByThreadId.get(threadId);
+        const summary = filePath ? this.index.get(filePath)?.summary ?? null : null;
+        if (summary) {
             if (!isPathWithinRoot(summary.cwd, projectRoot))
                 return null;
             return summary;
@@ -51,6 +53,58 @@ export class CodexSessionCatalog {
         });
         return null;
     }
+    async ensureIndexFresh() {
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+        }
+        else {
+            const now = Date.now();
+            if (now - this.lastRefreshedAt >= this.cacheTtlMs || this.sortedPaths.length === 0) {
+                this.refreshPromise = this.refreshIndex().finally(() => {
+                    this.lastRefreshedAt = Date.now();
+                    this.refreshPromise = null;
+                });
+                await this.refreshPromise;
+            }
+        }
+    }
+    async refreshIndex() {
+        const files = listSessionFiles(this.sessionsRoot).filter((entry) => entry.mtimeMs > 0);
+        const seenPaths = new Set(files.map((entry) => entry.path));
+        for (const existingPath of this.index.keys()) {
+            if (!seenPaths.has(existingPath)) {
+                this.index.delete(existingPath);
+            }
+        }
+        for (const file of files) {
+            const cached = this.index.get(file.path);
+            if (cached && cached.mtimeMs === file.mtimeMs) {
+                if (cached.updatedAt !== file.updatedAt) {
+                    cached.updatedAt = file.updatedAt;
+                }
+                continue;
+            }
+            this.index.set(file.path, {
+                path: file.path,
+                mtimeMs: file.mtimeMs,
+                updatedAt: file.updatedAt,
+                summary: await readSessionSummary(file.path, file.updatedAt),
+            });
+        }
+        this.rebuildDerivedIndexes();
+    }
+    rebuildDerivedIndexes() {
+        this.sortedPaths = [...this.index.values()]
+            .sort((left, right) => right.mtimeMs - left.mtimeMs)
+            .map((entry) => entry.path);
+        this.pathByThreadId.clear();
+        for (const filePath of this.sortedPaths) {
+            const summary = this.index.get(filePath)?.summary ?? null;
+            if (!summary || this.pathByThreadId.has(summary.id))
+                continue;
+            this.pathByThreadId.set(summary.id, filePath);
+        }
+    }
 }
 function defaultSessionsRoot() {
     const codexHome = process.env.CODEX_HOME?.trim();

package/dist/runtime/bootstrap.js

@@ -15,17 +15,7 @@ import { PLAINTEXT_TOKEN_FALLBACK_ENV, SecretStore, } from "./secrets.js";
 const MAC_CODEX_BIN = "/Applications/Codex.app/Contents/Resources/codex";
 export async function bootstrapRuntime() {
     intro("telecodex");
-    const stateDir = getStateDir();
-    const storage = new FileStateStorage(stateDir);
-    migrateLegacySqliteState({
-        storage,
-        legacyDbPath: getLegacyStateDbPath(),
-    });
-    const store = new SessionStore(storage);
-    const projects = new ProjectStore(storage);
-    const secrets = new SecretStore(store, {
-        allowPlaintextFallback: process.env[PLAINTEXT_TOKEN_FALLBACK_ENV] === "1",
-    });
+    const { store, projects, secrets } = initializeRuntimePersistence();
     const codexBin = await ensureCodexBin(store);
     await ensureCodexLogin(codexBin);
     const { token, botUsername, storageMode } = await ensureTelegramBotToken(secrets);
@@ -37,32 +27,14 @@ export async function bootstrapRuntime() {
         defaultCwd: process.cwd(),
         codexBin,
     });
-    let bootstrapCode = null;
-    if (store.getAuthorizedUserId() == null) {
-        let binding = store.getBindingCodeState();
-        if (!binding || binding.mode !== "bootstrap") {
-            binding = store.issueBindingCode({
-                code: generateBindingCode("bootstrap"),
-                mode: "bootstrap",
-            });
-        }
-        bootstrapCode = binding.code;
-    }
-    else if (store.getBindingCodeState()?.mode === "bootstrap") {
-        store.clearBindingCode();
-    }
-    if (bootstrapCode) {
-        const binding = store.getBindingCodeState();
-        const copied = await copyBootstrapCode(bootstrapCode);
-        note([
-            `Bot: ${botUsername ? `@${botUsername}` : "unknown"}`,
-            `Workspace: ${config.defaultCwd}`,
-            copied ? "Binding code copied to the clipboard." : "Failed to copy the binding code. Copy it manually.",
-            `Binding code expires at: ${binding?.expiresAt ?? "unknown"}`,
-            `Max failed attempts: ${binding?.maxAttempts ?? BINDING_CODE_MAX_ATTEMPTS}`,
-            "",
-            bootstrapCode,
-        ].join("\n"), "Admin Binding");
+    const binding = resolveBootstrapBindingState(store);
+    const bootstrapCode = binding?.code ?? null;
+    if (binding) {
+        await showBootstrapBindingNote({
+            binding,
+            botUsername,
+            workspace: config.defaultCwd,
+        });
     }
     return {
         config,
@@ -72,6 +44,45 @@ export async function bootstrapRuntime() {
         botUsername,
     };
 }
+export function initializeRuntimePersistence(input) {
+    const stateDir = input?.stateDir ?? getStateDir();
+    const storage = new FileStateStorage(stateDir);
+    migrateLegacySqliteState({
+        storage,
+        legacyDbPath: getLegacyStateDbPath(),
+    });
+    const store = new SessionStore(storage);
+    const projects = new ProjectStore(storage);
+    const secrets = new SecretStore(store, {
+        allowPlaintextFallback: input?.allowPlaintextFallback ?? process.env[PLAINTEXT_TOKEN_FALLBACK_ENV] === "1",
+    });
+    return {
+        storage,
+        store,
+        projects,
+        secrets,
+    };
+}
+export function resolveBootstrapBindingState(store, generateCode = () => generateBindingCode("bootstrap")) {
+    if (store.getAuthorizedUserId() != null) {
+        if (store.getBindingCodeState()?.mode === "bootstrap") {
+            store.clearBindingCode();
+        }
+        return null;
+    }
+    let binding = store.getBindingCodeState();
+    if (!binding || binding.mode !== "bootstrap") {
+        binding = store.issueBindingCode({
+            code: generateCode(),
+            mode: "bootstrap",
+        });
+    }
+    return {
+        code: binding.code,
+        expiresAt: binding.expiresAt,
+        maxAttempts: binding.maxAttempts,
+    };
+}
 async function ensureTelegramBotToken(secrets) {
     const existing = secrets.getTelegramBotToken();
     if (existing) {
@@ -211,6 +222,18 @@ async function copyBootstrapCode(code) {
         return false;
     }
 }
+async function showBootstrapBindingNote(input) {
+    const copied = await copyBootstrapCode(input.binding.code);
+    note([
+        `Bot: ${input.botUsername ? `@${input.botUsername}` : "unknown"}`,
+        `Workspace: ${input.workspace}`,
+        copied ? "Binding code copied to the clipboard." : "Failed to copy the binding code. Copy it manually.",
+        `Binding code expires at: ${input.binding.expiresAt}`,
+        `Max failed attempts: ${input.binding.maxAttempts ?? BINDING_CODE_MAX_ATTEMPTS}`,
+        "",
+        input.binding.code,
+    ].join("\n"), "Admin Binding");
+}
 function requirePromptValue(value) {
     if (isCancel(value))
         exitCancelled();

package/dist/runtime/startTelecodex.js

@@ -1,5 +1,6 @@
 import { run } from "@grammyjs/runner";
 import { createBot } from "../bot/createBot.js";
+import { tryParseCodexConfigOverrides } from "../codex/configOverrides.js";
 import { CodexSessionCatalog } from "../codex/sessionCatalog.js";
 import { CodexSdkRuntime } from "../codex/sdkRuntime.js";
 import { bootstrapRuntime } from "./bootstrap.js";
@@ -24,7 +25,14 @@ export async function startTelecodex() {
             pid: process.pid,
         });
         const { config, store, projects, bootstrapCode, botUsername } = await bootstrapRuntime();
-        const configOverrides = parseCodexConfigOverrides(store.getAppState("codex_config_overrides"));
+        const storedConfigOverrides = store.getAppState("codex_config_overrides");
+        const { value: configOverrides, error: configOverridesError } = tryParseCodexConfigOverrides(storedConfigOverrides);
+        if (configOverridesError) {
+            store.deleteAppState("codex_config_overrides");
+            logger.warn("cleared invalid stored codex config overrides", {
+                error: configOverridesError.message,
+            });
+        }
         const codex = new CodexSdkRuntime({
             codexBin: config.codexBin,
             logger: logger.child("codex-sdk"),
@@ -57,14 +65,26 @@ export async function startTelecodex() {
             console.warn("Telegram may take a few minutes to apply the change");
         }
         const runner = run(bot);
+        let shuttingDown = false;
         const stopRuntime = (signal) => {
-            logger.info("received shutdown signal", { signal });
-            codex.interruptAll();
-            runner.stop();
-            instanceLock?.release();
-            instanceLock = null;
-            logger.flush();
-            process.exit(0);
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            void (async () => {
+                logger.info("received shutdown signal", { signal });
+                codex.interruptAll();
+                runner.stop();
+                try {
+                    await store.flush();
+                }
+                catch (error) {
+                    logger.warn("failed to flush pending telecodex state during shutdown", { error });
+                }
+                instanceLock?.release();
+                instanceLock = null;
+                logger.flush();
+                process.exit(0);
+            })();
         };
         process.once("SIGINT", () => stopRuntime("SIGINT"));
         process.once("SIGTERM", () => stopRuntime("SIGTERM"));
@@ -94,19 +114,6 @@ export async function startTelecodex() {
         throw error;
     }
 }
-function parseCodexConfigOverrides(value) {
-    if (!value)
-        return undefined;
-    try {
-        const parsed = JSON.parse(value);
-        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-            ? parsed
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function installProcessErrorHandlers(logger) {
     if (processHandlersInstalled)
         return;

package/dist/store/fileState.js

@@ -1,7 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
 import path from "node:path";
 import { DEFAULT_SESSION_PROFILE, isSessionApprovalPolicy, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, } from "../config.js";
 const FILE_STATE_VERSION = 1;
+const require = createRequire(import.meta.url);
+const writeFileAtomic = require("write-file-atomic");
 export class FileStateStorage {
     rootDir;
     appPath;
@@ -10,6 +13,7 @@ export class FileStateStorage {
     appState = new Map();
     projects = new Map();
     sessions = new Map();
+    flushStateByPath = new Map();
     constructor(rootDir) {
         this.rootDir = rootDir;
         mkdirSync(rootDir, { recursive: true });
@@ -143,23 +147,111 @@ export class FileStateStorage {
             this.flushSessions();
     }
     flushAppState() {
-        writeJsonFile(this.appPath, {
+        this.scheduleJsonWrite(this.appPath, {
             version: FILE_STATE_VERSION,
             values: Object.fromEntries([...this.appState.entries()].sort(([left], [right]) => left.localeCompare(right))),
         });
     }
     flushProjects() {
-        writeJsonFile(this.projectsPath, {
+        this.scheduleJsonWrite(this.projectsPath, {
             version: FILE_STATE_VERSION,
             projects: [...this.projects.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
         });
     }
     flushSessions() {
-        writeJsonFile(this.sessionsPath, {
+        this.scheduleJsonWrite(this.sessionsPath, {
             version: FILE_STATE_VERSION,
             sessions: [...this.sessions.values()].sort((left, right) => left.sessionKey.localeCompare(right.sessionKey)),
         });
     }
+    async flush() {
+        for (;;) {
+            await Promise.resolve();
+            const active = [...this.flushStateByPath.values()].map((state) => state.draining).filter((entry) => entry != null);
+            if (active.length > 0) {
+                await Promise.all(active);
+                continue;
+            }
+            this.throwPendingFlushErrors();
+            let started = false;
+            for (const [filePath, state] of this.flushStateByPath.entries()) {
+                if (state.scheduled || state.draining || state.pendingJson === undefined)
+                    continue;
+                this.startDrainWhenReady(filePath, state);
+                started = true;
+            }
+            if (!started && [...this.flushStateByPath.values()].every((state) => !state.scheduled && state.pendingJson === undefined)) {
+                this.throwPendingFlushErrors();
+                return;
+            }
+        }
+    }
+    scheduleJsonWrite(filePath, value) {
+        const state = this.getOrCreateFlushState(filePath);
+        state.pendingJson = `${JSON.stringify(value, null, 2)}\n`;
+        state.error = null;
+        this.startDrainWhenReady(filePath, state);
+    }
+    startDrainWhenReady(filePath, state) {
+        if (state.scheduled || state.draining)
+            return;
+        state.scheduled = true;
+        queueMicrotask(() => {
+            state.scheduled = false;
+            if (state.draining)
+                return;
+            state.draining = this.drainJsonWrites(filePath, state)
+                .catch((error) => {
+                state.error = error;
+            })
+                .finally(() => {
+                state.draining = null;
+                if (state.pendingJson !== undefined && !state.scheduled && state.error == null) {
+                    this.startDrainWhenReady(filePath, state);
+                }
+            });
+        });
+    }
+    getOrCreateFlushState(filePath) {
+        let state = this.flushStateByPath.get(filePath);
+        if (state)
+            return state;
+        state = {
+            pendingJson: undefined,
+            scheduled: false,
+            draining: null,
+            error: null,
+        };
+        this.flushStateByPath.set(filePath, state);
+        return state;
+    }
+    async drainJsonWrites(filePath, state) {
+        for (;;) {
+            const nextJson = state.pendingJson;
+            if (nextJson === undefined) {
+                return;
+            }
+            state.pendingJson = undefined;
+            try {
+                await writeJsonFile(filePath, nextJson);
+            }
+            catch (error) {
+                if (state.pendingJson === undefined) {
+                    state.pendingJson = nextJson;
+                }
+                throw error;
+            }
+        }
+    }
+    throwPendingFlushErrors() {
+        for (const state of this.flushStateByPath.values()) {
+            if (state.error == null)
+                continue;
+            const error = state.error;
+            state.error = null;
+            throw error;
+        }
+    }
 }
 function loadAppStateFile(filePath) {
     try {
@@ -289,11 +381,11 @@ function normalizeStoredSessionRecord(value) {
         updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : now,
     };
 }
-function writeJsonFile(filePath, value) {
+async function writeJsonFile(filePath, value) {
     mkdirSync(path.dirname(filePath), { recursive: true });
-    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-    renameSync(tempPath, filePath);
+    await writeFileAtomic(filePath, value, {
+        encoding: "utf8",
+    });
 }
 function readJsonFile(filePath) {
     try {

package/dist/store/projects.js

@@ -4,6 +4,9 @@ export class ProjectStore {
     constructor(storage) {
         this.storage = storage;
     }
+    flush() {
+        return this.storage.flush();
+    }
     get(chatId) {
         return this.storage.getProject(chatId);
     }

package/dist/store/sessions.js

@@ -10,6 +10,9 @@ export class SessionStore {
     constructor(storage) {
         this.storage = storage;
     }
+    flush() {
+        return this.storage.flush();
+    }
     getAppState(key) {
         return this.storage.getAppState(key);
     }

package/dist/telegram/delivery.js

@@ -1,8 +1,9 @@
 import { GrammyError } from "grammy";
 import { renderPlainChunksForTelegram } from "./renderer.js";
 import { splitTelegramHtml } from "./splitMessage.js";
+const telegramCooldownByClient = new WeakMap();
 export async function sendHtmlMessage(bot, input, logger) {
-    return retryTelegramCall(() => bot.api.sendMessage(input.chatId, input.text, {
+    return retryTelegramCall(bot.api, () => bot.api.sendMessage(input.chatId, input.text, {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
@@ -26,7 +27,7 @@ export async function sendPlainChunks(bot, input, logger) {
     return messages;
 }
 export async function sendTypingAction(bot, input, logger) {
-    await retryTelegramCall(() => bot.api.sendChatAction(input.chatId, "typing", {
+    await retryTelegramCall(bot.api, () => bot.api.sendChatAction(input.chatId, "typing", {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
     }), logger, "telegram chat action rate limited", {
         chatId: input.chatId,
@@ -80,7 +81,7 @@ export async function replaceOrSendHtmlChunks(bot, input, logger) {
     return firstMessageId ?? null;
 }
 export async function editHtmlMessage(bot, input, logger) {
-    await retryTelegramCall(() => bot.api.editMessageText(input.chatId, input.messageId, input.text, {
+    await retryTelegramCall(bot.api, () => bot.api.editMessageText(input.chatId, input.messageId, input.text, {
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
     }), logger, "telegram edit rate limited", {
@@ -115,8 +116,9 @@ function retryAfterMs(error) {
 function descriptionOf(error) {
     return typeof error.description === "string" ? error.description : null;
 }
-export async function retryTelegramCall(operation, logger, message, context) {
+export async function retryTelegramCall(cooldownKey, operation, logger, message, context) {
     for (let attempt = 0;; attempt += 1) {
+        await waitForTelegramCooldown(cooldownKey);
         try {
             return await operation();
         }
@@ -125,16 +127,50 @@ export async function retryTelegramCall(operation, logger, message, context) {
             if (waitMs == null || attempt >= 5) {
                 throw error;
             }
+            const cooldownMs = waitMs + 250;
             logger?.warn(message, {
                 ...context,
                 attempt: attempt + 1,
                 retryAfterMs: waitMs,
+                sharedCooldownMs: cooldownMs,
                 error,
             });
-            await sleep(waitMs + 250);
+            await applyTelegramCooldown(cooldownKey, cooldownMs);
         }
     }
 }
+async function waitForTelegramCooldown(cooldownKey) {
+    for (;;) {
+        const cooldown = telegramCooldownByClient.get(cooldownKey)?.cooldown ?? null;
+        if (!cooldown)
+            return;
+        await cooldown;
+    }
+}
+async function applyTelegramCooldown(cooldownKey, delayMs) {
+    const state = getTelegramCooldownState(cooldownKey);
+    const previous = state.cooldown;
+    const baseCooldown = previous
+        ? previous.then(() => sleep(delayMs))
+        : sleep(delayMs);
+    const cooldown = baseCooldown.finally(() => {
+        if (state.cooldown === cooldown) {
+            state.cooldown = null;
+        }
+    });
+    state.cooldown = cooldown;
+    await state.cooldown;
+}
+function getTelegramCooldownState(cooldownKey) {
+    let state = telegramCooldownByClient.get(cooldownKey);
+    if (state)
+        return state;
+    state = {
+        cooldown: null,
+    };
+    telegramCooldownByClient.set(cooldownKey, state);
+    return state;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }