telecodex 0.1.1 → 0.1.3

package/dist/codex/sessionCatalog.js

@@ -0,0 +1,215 @@
+import { createReadStream, existsSync, opendirSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline";
+export class CodexSessionCatalog {
+    sessionsRoot;
+    constructor(input) {
+        this.sessionsRoot = input?.sessionsRoot ?? defaultSessionsRoot();
+        this.logger = input?.logger;
+    }
+    logger;
+    async listProjectThreads(input) {
+        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);
+            if (!summary)
+                continue;
+            if (!isPathWithinRoot(summary.cwd, projectRoot))
+                continue;
+            matches.push(summary);
+            if (matches.length >= limit)
+                break;
+        }
+        return matches;
+    }
+    async findProjectThreadById(input) {
+        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;
+            if (!isPathWithinRoot(summary.cwd, projectRoot))
+                return null;
+            return summary;
+        }
+        this.logger?.debug("codex thread not found in saved sessions", {
+            projectRoot,
+            threadId,
+            sessionsRoot: this.sessionsRoot,
+        });
+        return null;
+    }
+}
+function defaultSessionsRoot() {
+    const codexHome = process.env.CODEX_HOME?.trim();
+    const root = codexHome ? path.resolve(codexHome) : path.join(homedir(), ".codex");
+    return path.join(root, "sessions");
+}
+function listSessionFiles(root) {
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let directory;
+        try {
+            directory = opendirSync(current);
+        }
+        catch {
+            continue;
+        }
+        for (let entry = directory.readSync(); entry != null; entry = directory.readSync()) {
+            const resolved = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(resolved);
+                continue;
+            }
+            if (!entry.isFile() || !resolved.endsWith(".jsonl"))
+                continue;
+            try {
+                const stat = statSync(resolved);
+                files.push({
+                    path: resolved,
+                    updatedAt: stat.mtime.toISOString(),
+                    mtimeMs: stat.mtimeMs,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        directory.closeSync();
+    }
+    return files;
+}
+async function readSessionSummary(filePath, updatedAt) {
+    const input = createReadStream(filePath, { encoding: "utf8" });
+    const reader = createInterface({
+        input,
+        crlfDelay: Infinity,
+    });
+    let meta = null;
+    let preview = "";
+    try {
+        for await (const line of reader) {
+            const parsed = parseJsonLine(line);
+            if (!parsed)
+                continue;
+            if (!meta) {
+                meta = parseSessionMeta(parsed);
+            }
+            if (!preview) {
+                preview = parseUserPreview(parsed);
+            }
+            if (meta && preview)
+                break;
+        }
+    }
+    finally {
+        reader.close();
+        input.destroy();
+    }
+    if (!meta?.id || !meta.cwd)
+        return null;
+    return {
+        id: meta.id,
+        cwd: canonicalizePath(meta.cwd),
+        createdAt: typeof meta.timestamp === "string" ? meta.timestamp : null,
+        updatedAt,
+        preview: preview || "(no user message preview)",
+        source: typeof meta.source === "string" ? meta.source : null,
+        modelProvider: typeof meta.model_provider === "string" ? meta.model_provider : null,
+        sessionPath: filePath,
+    };
+}
+function parseJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionMeta(parsed) {
+    if (parsed.type !== "session_meta")
+        return null;
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (!payload)
+        return null;
+    if (typeof payload.id !== "string" || typeof payload.cwd !== "string")
+        return null;
+    return {
+        id: payload.id,
+        cwd: payload.cwd,
+        ...(typeof payload.timestamp === "string" ? { timestamp: payload.timestamp } : {}),
+        ...(typeof payload.source === "string" ? { source: payload.source } : {}),
+        ...(typeof payload.model_provider === "string" ? { model_provider: payload.model_provider } : {}),
+    };
+}
+function parseUserPreview(parsed) {
+    if (parsed.type === "event_msg") {
+        const payload = isRecord(parsed.payload) ? parsed.payload : null;
+        if (payload?.type === "user_message" && typeof payload.message === "string") {
+            return normalizePreview(payload.message);
+        }
+    }
+    if (parsed.type !== "response_item")
+        return "";
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (!payload || payload.type !== "message" || payload.role !== "user")
+        return "";
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    for (const item of content) {
+        if (!isRecord(item) || item.type !== "input_text" || typeof item.text !== "string")
+            continue;
+        const preview = normalizePreview(item.text);
+        if (preview)
+            return preview;
+    }
+    return "";
+}
+function normalizePreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "";
+    if (normalized.startsWith("# AGENTS.md instructions") ||
+        normalized.startsWith("<environment_context>") ||
+        normalized.startsWith("<app-context>") ||
+        normalized.startsWith("<permissions instructions>")) {
+        return "";
+    }
+    if (normalized.length <= 96)
+        return normalized;
+    return `${normalized.slice(0, 93)}...`;
+}
+function isPathWithinRoot(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+function canonicalizePath(value) {
+    const resolved = path.resolve(value);
+    try {
+        return realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/config.js

@@ -14,7 +14,6 @@ export function buildConfig(input) {
         telegramBotToken: input.telegramBotToken,
         defaultCwd,
         defaultModel: input.defaultModel?.trim() || "gpt-5.4",
-        dbPath: path.resolve(input.dbPath),
         codexBin: input.codexBin,
         updateIntervalMs: input.updateIntervalMs ?? 700,
     };

package/dist/runtime/appPaths.js

@@ -3,7 +3,10 @@ import path from "node:path";
 export function getAppHome() {
     return path.join(homedir(), ".telecodex");
 }
-export function getStateDbPath() {
+export function getStateDir() {
+    return path.join(getAppHome(), "state");
+}
+export function getLegacyStateDbPath() {
     return path.join(getAppHome(), "state.sqlite");
 }
 export function getLogsDir() {

package/dist/runtime/bootstrap.js

@@ -5,19 +5,24 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { Bot, GrammyError, HttpError } from "grammy";
 import { buildConfig } from "../config.js";
-import { openDatabase } from "../store/db.js";
+import { FileStateStorage } from "../store/fileState.js";
+import { migrateLegacySqliteState } from "../store/legacyMigration.js";
 import { ProjectStore } from "../store/projects.js";
 import { BINDING_CODE_MAX_ATTEMPTS, SessionStore } from "../store/sessions.js";
-import { getStateDbPath } from "./appPaths.js";
+import { getLegacyStateDbPath, getStateDir } from "./appPaths.js";
 import { generateBindingCode } from "./bindingCodes.js";
 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 dbPath = getStateDbPath();
-    const db = openDatabase(dbPath);
-    const store = new SessionStore(db);
-    const projects = new ProjectStore(db);
+    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",
     });
@@ -30,7 +35,6 @@ export async function bootstrapRuntime() {
     const config = buildConfig({
         telegramBotToken: token,
         defaultCwd: process.cwd(),
-        dbPath,
         codexBin,
     });
     let bootstrapCode = null;

package/dist/runtime/startTelecodex.js

@@ -1,5 +1,6 @@
 import { run } from "@grammyjs/runner";
 import { createBot } from "../bot/createBot.js";
+import { CodexSessionCatalog } from "../codex/sessionCatalog.js";
 import { CodexSdkRuntime } from "../codex/sdkRuntime.js";
 import { bootstrapRuntime } from "./bootstrap.js";
 import { acquireInstanceLock } from "./instanceLock.js";
@@ -29,11 +30,15 @@ export async function startTelecodex() {
             logger: logger.child("codex-sdk"),
             ...(configOverrides ? { configOverrides } : {}),
         });
+        const threadCatalog = new CodexSessionCatalog({
+            logger: logger.child("codex-sessions"),
+        });
         const bot = createBot({
             config,
             store,
             projects,
             codex,
+            threadCatalog,
             bootstrapCode,
             logger: logger.child("bot"),
             onAdminBound: () => {

package/dist/store/fileState.js

@@ -0,0 +1,370 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { DEFAULT_SESSION_PROFILE, isSessionApprovalPolicy, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, } from "../config.js";
+const FILE_STATE_VERSION = 1;
+export class FileStateStorage {
+    rootDir;
+    appPath;
+    projectsPath;
+    sessionsPath;
+    appState = new Map();
+    projects = new Map();
+    sessions = new Map();
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        mkdirSync(rootDir, { recursive: true });
+        this.appPath = path.join(rootDir, "app.json");
+        this.projectsPath = path.join(rootDir, "projects.json");
+        this.sessionsPath = path.join(rootDir, "sessions.json");
+        for (const [key, value] of Object.entries(loadAppStateFile(this.appPath).values)) {
+            this.appState.set(key, value);
+        }
+        for (const project of loadProjectsFile(this.projectsPath).projects) {
+            this.projects.set(project.chatId, normalizeStoredProjectBinding(project));
+        }
+        for (const session of loadSessionsFile(this.sessionsPath).sessions) {
+            this.sessions.set(session.sessionKey, normalizeStoredSessionRecord(session));
+        }
+    }
+    getAppState(key) {
+        return this.appState.get(key) ?? null;
+    }
+    setAppState(key, value) {
+        this.appState.set(key, value);
+        this.flushAppState();
+    }
+    deleteAppState(key) {
+        if (!this.appState.delete(key))
+            return;
+        this.flushAppState();
+    }
+    mergeImportedAppState(values) {
+        let changed = false;
+        for (const [key, value] of Object.entries(values)) {
+            if (this.appState.has(key))
+                continue;
+            this.appState.set(key, value);
+            changed = true;
+        }
+        if (changed)
+            this.flushAppState();
+    }
+    getProject(chatId) {
+        return cloneProjectBinding(this.projects.get(chatId) ?? null);
+    }
+    upsertProject(input) {
+        const existing = this.projects.get(input.chatId);
+        const now = input.now ?? new Date().toISOString();
+        const project = {
+            chatId: input.chatId,
+            cwd: path.resolve(input.cwd),
+            name: input.name.trim(),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        };
+        this.projects.set(project.chatId, project);
+        this.flushProjects();
+        return cloneProjectBinding(project);
+    }
+    removeProject(chatId) {
+        if (!this.projects.delete(chatId))
+            return;
+        this.flushProjects();
+    }
+    listProjects() {
+        return [...this.projects.values()]
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .map((project) => cloneProjectBinding(project))
+            .filter((project) => project != null);
+    }
+    mergeImportedProjects(projects) {
+        let changed = false;
+        for (const project of projects) {
+            if (this.projects.has(project.chatId))
+                continue;
+            this.projects.set(project.chatId, normalizeStoredProjectBinding(project));
+            changed = true;
+        }
+        if (changed)
+            this.flushProjects();
+    }
+    getSession(sessionKey) {
+        return cloneSessionRecord(this.sessions.get(sessionKey) ?? null);
+    }
+    listSessions() {
+        return [...this.sessions.values()]
+            .sort((left, right) => left.sessionKey.localeCompare(right.sessionKey))
+            .map((session) => cloneSessionRecord(session))
+            .filter((session) => session != null);
+    }
+    getSessionByThreadId(threadId) {
+        for (const session of this.sessions.values()) {
+            if (session.codexThreadId === threadId) {
+                return cloneSessionRecord(session);
+            }
+        }
+        return null;
+    }
+    putSession(session) {
+        const normalized = normalizeStoredSessionRecord(session);
+        this.sessions.set(normalized.sessionKey, normalized);
+        this.flushSessions();
+        return cloneSessionRecord(normalized);
+    }
+    patchSession(sessionKey, patch) {
+        const existing = this.sessions.get(sessionKey);
+        if (!existing)
+            return null;
+        const next = normalizeStoredSessionRecord({
+            ...existing,
+            ...patch,
+            sessionKey,
+            createdAt: existing.createdAt,
+            updatedAt: new Date().toISOString(),
+        });
+        this.sessions.set(sessionKey, next);
+        this.flushSessions();
+        return cloneSessionRecord(next);
+    }
+    removeSession(sessionKey) {
+        if (!this.sessions.delete(sessionKey))
+            return;
+        this.flushSessions();
+    }
+    mergeImportedSessions(sessions) {
+        let changed = false;
+        for (const session of sessions) {
+            if (this.sessions.has(session.sessionKey))
+                continue;
+            this.sessions.set(session.sessionKey, normalizeStoredSessionRecord(session));
+            changed = true;
+        }
+        if (changed)
+            this.flushSessions();
+    }
+    flushAppState() {
+        writeJsonFile(this.appPath, {
+            version: FILE_STATE_VERSION,
+            values: Object.fromEntries([...this.appState.entries()].sort(([left], [right]) => left.localeCompare(right))),
+        });
+    }
+    flushProjects() {
+        writeJsonFile(this.projectsPath, {
+            version: FILE_STATE_VERSION,
+            projects: [...this.projects.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+        });
+    }
+    flushSessions() {
+        writeJsonFile(this.sessionsPath, {
+            version: FILE_STATE_VERSION,
+            sessions: [...this.sessions.values()].sort((left, right) => left.sessionKey.localeCompare(right.sessionKey)),
+        });
+    }
+}
+function loadAppStateFile(filePath) {
+    try {
+        const parsed = readJsonFile(filePath);
+        if (!parsed) {
+            return {
+                version: FILE_STATE_VERSION,
+                values: {},
+            };
+        }
+        if (!isRecord(parsed) || !isRecord(parsed.values)) {
+            throw new Error(`Invalid app state file: ${filePath}`);
+        }
+        const values = {};
+        for (const [key, value] of Object.entries(parsed.values)) {
+            if (typeof value === "string")
+                values[key] = value;
+        }
+        return {
+            version: FILE_STATE_VERSION,
+            values,
+        };
+    }
+    catch (error) {
+        recoverCorruptStateFile(filePath, error);
+        return {
+            version: FILE_STATE_VERSION,
+            values: {},
+        };
+    }
+}
+function loadProjectsFile(filePath) {
+    try {
+        const parsed = readJsonFile(filePath);
+        if (!parsed) {
+            return {
+                version: FILE_STATE_VERSION,
+                projects: [],
+            };
+        }
+        if (!isRecord(parsed) || !Array.isArray(parsed.projects)) {
+            throw new Error(`Invalid projects state file: ${filePath}`);
+        }
+        return {
+            version: FILE_STATE_VERSION,
+            projects: parsed.projects.map((project) => normalizeStoredProjectBinding(project)),
+        };
+    }
+    catch (error) {
+        recoverCorruptStateFile(filePath, error);
+        return {
+            version: FILE_STATE_VERSION,
+            projects: [],
+        };
+    }
+}
+function loadSessionsFile(filePath) {
+    try {
+        const parsed = readJsonFile(filePath);
+        if (!parsed) {
+            return {
+                version: FILE_STATE_VERSION,
+                sessions: [],
+            };
+        }
+        if (!isRecord(parsed) || !Array.isArray(parsed.sessions)) {
+            throw new Error(`Invalid sessions state file: ${filePath}`);
+        }
+        return {
+            version: FILE_STATE_VERSION,
+            sessions: parsed.sessions.map((session) => normalizeStoredSessionRecord(session)),
+        };
+    }
+    catch (error) {
+        recoverCorruptStateFile(filePath, error);
+        return {
+            version: FILE_STATE_VERSION,
+            sessions: [],
+        };
+    }
+}
+function normalizeStoredProjectBinding(value) {
+    if (!isRecord(value)) {
+        throw new Error("Invalid stored project binding");
+    }
+    if (typeof value.chatId !== "string" || typeof value.cwd !== "string") {
+        throw new Error("Stored project binding is missing required fields");
+    }
+    const cwd = path.resolve(value.cwd);
+    const now = new Date().toISOString();
+    return {
+        chatId: value.chatId,
+        cwd,
+        name: typeof value.name === "string" && value.name.trim() ? value.name : path.basename(cwd) || cwd,
+        createdAt: typeof value.createdAt === "string" ? value.createdAt : now,
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : now,
+    };
+}
+function normalizeStoredSessionRecord(value) {
+    if (!isRecord(value)) {
+        throw new Error("Invalid stored session");
+    }
+    if (typeof value.sessionKey !== "string" ||
+        typeof value.chatId !== "string" ||
+        typeof value.cwd !== "string" ||
+        typeof value.model !== "string") {
+        throw new Error("Stored session is missing required fields");
+    }
+    const now = new Date().toISOString();
+    return {
+        sessionKey: value.sessionKey,
+        chatId: value.chatId,
+        messageThreadId: typeof value.messageThreadId === "string" ? value.messageThreadId : null,
+        telegramTopicName: typeof value.telegramTopicName === "string" ? value.telegramTopicName : null,
+        codexThreadId: typeof value.codexThreadId === "string" ? value.codexThreadId : null,
+        cwd: path.resolve(value.cwd),
+        model: value.model.trim() || "gpt-5.4",
+        sandboxMode: normalizeSandboxMode(value.sandboxMode),
+        approvalPolicy: normalizeApprovalPolicy(value.approvalPolicy),
+        reasoningEffort: normalizeReasoningEffort(value.reasoningEffort),
+        webSearchMode: normalizeWebSearchMode(value.webSearchMode),
+        networkAccessEnabled: normalizeBoolean(value.networkAccessEnabled, true),
+        skipGitRepoCheck: normalizeBoolean(value.skipGitRepoCheck, true),
+        additionalDirectories: normalizeStringArray(value.additionalDirectories),
+        outputSchema: normalizeOutputSchema(value.outputSchema),
+        createdAt: typeof value.createdAt === "string" ? value.createdAt : now,
+        updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : now,
+    };
+}
+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);
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}
+function recoverCorruptStateFile(filePath, error) {
+    if (isMissingFileError(error) || !existsSync(filePath))
+        return;
+    const recoveredPath = `${filePath}.corrupt-${Date.now()}`;
+    try {
+        renameSync(filePath, recoveredPath);
+    }
+    catch {
+        // Keep startup resilient even if the corrupt file cannot be moved.
+    }
+}
+function cloneProjectBinding(project) {
+    return project ? { ...project } : null;
+}
+function cloneSessionRecord(session) {
+    return session
+        ? {
+            ...session,
+            additionalDirectories: [...session.additionalDirectories],
+        }
+        : null;
+}
+function normalizeSandboxMode(value) {
+    return typeof value === "string" && isSessionSandboxMode(value) ? value : DEFAULT_SESSION_PROFILE.sandboxMode;
+}
+function normalizeApprovalPolicy(value) {
+    return typeof value === "string" && isSessionApprovalPolicy(value) ? value : DEFAULT_SESSION_PROFILE.approvalPolicy;
+}
+function normalizeReasoningEffort(value) {
+    return typeof value === "string" && isSessionReasoningEffort(value) ? value : null;
+}
+function normalizeWebSearchMode(value) {
+    return typeof value === "string" && isSessionWebSearchMode(value) ? value : null;
+}
+function normalizeBoolean(value, fallback) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number" || typeof value === "bigint")
+        return Number(value) !== 0;
+    return fallback;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function normalizeOutputSchema(value) {
+    if (typeof value !== "string" || !value.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? JSON.stringify(parsed) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}