telecodex 0.1.0 → 0.1.2

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);
+}

package/dist/store/legacyMigration.js

@@ -0,0 +1,160 @@
+import { existsSync, rmSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { DEFAULT_SESSION_PROFILE, isSessionApprovalPolicy, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, } from "../config.js";
+const LEGACY_IMPORT_MARKER_KEY = "__telecodex_legacy_sqlite_import_completed_at";
+const LEGACY_SQLITE_ARTIFACT_SUFFIXES = ["", "-shm", "-wal", "-journal"];
+export function migrateLegacySqliteState(input) {
+    if (input.storage.getAppState(LEGACY_IMPORT_MARKER_KEY) != null) {
+        cleanupLegacySqliteArtifacts(input.legacyDbPath);
+        return { imported: false };
+    }
+    if (!existsSync(input.legacyDbPath)) {
+        return { imported: false };
+    }
+    let imported = false;
+    const db = new DatabaseSync(input.legacyDbPath);
+    try {
+        const appState = hasTable(db, "app_state") ? readAppState(db) : {};
+        const projects = hasTable(db, "projects") ? readProjects(db) : [];
+        const sessions = hasTable(db, "sessions") ? readSessions(db) : [];
+        input.storage.mergeImportedAppState(appState);
+        input.storage.mergeImportedProjects(projects);
+        input.storage.mergeImportedSessions(sessions);
+        input.storage.setAppState(LEGACY_IMPORT_MARKER_KEY, new Date().toISOString());
+        imported = true;
+    }
+    finally {
+        db.close();
+    }
+    cleanupLegacySqliteArtifacts(input.legacyDbPath);
+    return { imported };
+}
+function readAppState(db) {
+    const rows = db.prepare("SELECT key, value FROM app_state").all();
+    const values = {};
+    for (const row of rows) {
+        if (typeof row.key !== "string" || typeof row.value !== "string")
+            continue;
+        values[row.key] = row.value;
+    }
+    return values;
+}
+function readProjects(db) {
+    const rows = db.prepare("SELECT * FROM projects").all();
+    const projects = [];
+    for (const row of rows) {
+        if (typeof row.chat_id !== "string" || typeof row.cwd !== "string")
+            continue;
+        const cwd = row.cwd.trim();
+        if (!cwd)
+            continue;
+        const now = new Date().toISOString();
+        projects.push({
+            chatId: row.chat_id,
+            name: typeof row.name === "string" && row.name.trim() ? row.name : cwd,
+            cwd,
+            createdAt: typeof row.created_at === "string" ? row.created_at : now,
+            updatedAt: typeof row.updated_at === "string" ? row.updated_at : now,
+        });
+    }
+    return projects;
+}
+function readSessions(db) {
+    const rows = db.prepare("SELECT * FROM sessions").all();
+    const sessions = [];
+    for (const row of rows) {
+        if (typeof row.session_key !== "string" ||
+            typeof row.chat_id !== "string" ||
+            typeof row.cwd !== "string" ||
+            typeof row.model !== "string") {
+            continue;
+        }
+        const now = new Date().toISOString();
+        sessions.push({
+            sessionKey: row.session_key,
+            chatId: row.chat_id,
+            messageThreadId: typeof row.message_thread_id === "string" ? row.message_thread_id : null,
+            telegramTopicName: typeof row.telegram_topic_name === "string" ? row.telegram_topic_name : null,
+            codexThreadId: typeof row.codex_thread_id === "string" ? row.codex_thread_id : null,
+            cwd: row.cwd,
+            model: row.model,
+            sandboxMode: normalizeSandboxMode(row.sandbox_mode, row.mode),
+            approvalPolicy: normalizeApprovalPolicy(row.approval_policy),
+            reasoningEffort: normalizeReasoningEffort(row.reasoning_effort),
+            webSearchMode: normalizeWebSearchMode(row.web_search_mode),
+            networkAccessEnabled: normalizeBoolean(row.network_access_enabled, true),
+            skipGitRepoCheck: normalizeBoolean(row.skip_git_repo_check, true),
+            additionalDirectories: normalizeStringArray(row.additional_directories),
+            outputSchema: normalizeOutputSchema(row.output_schema),
+            createdAt: typeof row.created_at === "string" ? row.created_at : now,
+            updatedAt: typeof row.updated_at === "string" ? row.updated_at : now,
+        });
+    }
+    return sessions;
+}
+function hasTable(db, tableName) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1")
+        .get(tableName);
+    return typeof row?.name === "string";
+}
+function normalizeSandboxMode(current, legacyMode) {
+    if (typeof current === "string" && isSessionSandboxMode(current))
+        return current;
+    if (legacyMode === "write")
+        return "workspace-write";
+    return 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 (typeof value !== "string" || !value.trim())
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeOutputSchema(value) {
+    if (typeof value !== "string" || !value.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? JSON.stringify(parsed) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupLegacySqliteArtifacts(legacyDbPath) {
+    for (const suffix of LEGACY_SQLITE_ARTIFACT_SUFFIXES) {
+        const filePath = `${legacyDbPath}${suffix}`;
+        if (!existsSync(filePath))
+            continue;
+        try {
+            rmSync(filePath, { force: true });
+        }
+        catch {
+            // Retry on the next startup; legacy files are no longer a source of truth.
+        }
+    }
+}

package/dist/store/projects.js

@@ -1,47 +1,25 @@
 import path from "node:path";
 export class ProjectStore {
-    db;
-    constructor(db) {
-        this.db = db;
+    storage;
+    constructor(storage) {
+        this.storage = storage;
     }
     get(chatId) {
-        const row = this.db.prepare("SELECT * FROM projects WHERE chat_id = ?").get(chatId);
-        return row ? mapRow(row) : null;
+        return this.storage.getProject(chatId);
     }
     upsert(input) {
-        const now = new Date().toISOString();
         const cwd = path.resolve(input.cwd);
         const name = input.name?.trim() || path.basename(cwd) || cwd;
-        this.db
-            .prepare(`INSERT INTO projects (chat_id, name, cwd, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(chat_id) DO UPDATE SET
-           name = excluded.name,
-           cwd = excluded.cwd,
-           updated_at = excluded.updated_at`)
-            .run(input.chatId, name, cwd, now, now);
-        const project = this.get(input.chatId);
-        if (!project) {
-            throw new Error("Project upsert failed");
-        }
-        return project;
+        return this.storage.upsertProject({
+            chatId: input.chatId,
+            cwd,
+            name,
+        });
     }
     remove(chatId) {
-        this.db.prepare("DELETE FROM projects WHERE chat_id = ?").run(chatId);
+        this.storage.removeProject(chatId);
     }
     list() {
-        const rows = this.db
-            .prepare("SELECT * FROM projects ORDER BY updated_at DESC")
-            .all();
-        return rows.map(mapRow);
+        return this.storage.listProjects();
     }
 }
-function mapRow(row) {
-    return {
-        chatId: row.chat_id,
-        name: row.name,
-        cwd: row.cwd,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}