telecodex 0.1.1 → 0.1.3

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,
-    };
-}

package/dist/store/sessions.js

@@ -1,24 +1,23 @@
-import { DEFAULT_SESSION_PROFILE, isSessionApprovalPolicy, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, } from "../config.js";
+import { DEFAULT_SESSION_PROFILE, } from "../config.js";
 export const BINDING_CODE_TTL_MS = 15 * 60 * 1000;
 export const BINDING_CODE_MAX_ATTEMPTS = 5;
 export class SessionStore {
-    db;
-    constructor(db) {
-        this.db = db;
+    storage;
+    runtimeStateBySession = new Map();
+    outputMessageBySession = new Map();
+    queueBySession = new Map();
+    nextQueuedInputId = 1;
+    constructor(storage) {
+        this.storage = storage;
     }
     getAppState(key) {
-        const row = this.db.prepare("SELECT value FROM app_state WHERE key = ?").get(key);
-        return row?.value ?? null;
+        return this.storage.getAppState(key);
     }
     setAppState(key, value) {
-        this.db
-            .prepare(`INSERT INTO app_state (key, value, updated_at)
-         VALUES (?, ?, ?)
-         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
-            .run(key, value, new Date().toISOString());
+        this.storage.setAppState(key, value);
     }
     deleteAppState(key) {
-        this.db.prepare("DELETE FROM app_state WHERE key = ?").run(key);
+        this.storage.deleteAppState(key);
     }
     getAuthorizedUserId() {
         const value = this.getAppState("authorized_user_id");
@@ -123,11 +122,11 @@ export class SessionStore {
         const existing = this.getAuthorizedUserId();
         if (existing != null)
             return existing;
-        this.db.prepare("INSERT OR IGNORE INTO app_state (key, value, updated_at) VALUES ('authorized_user_id', ?, ?)").run(String(userId), new Date().toISOString());
+        this.setAppState("authorized_user_id", String(userId));
+        this.clearBindingCode();
         const current = this.getAuthorizedUserId();
         if (current == null)
             throw new Error("Failed to persist authorized Telegram user id");
-        this.clearBindingCode();
         return current;
     }
     rebindAuthorizedUserId(userId) {
@@ -143,237 +142,201 @@ export class SessionStore {
         if (existing)
             return existing;
         const now = new Date().toISOString();
-        this.db
-            .prepare(`INSERT INTO sessions (
-          session_key, chat_id, message_thread_id, telegram_topic_name, cwd, model, sandbox_mode, approval_policy, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(input.sessionKey, input.chatId, input.messageThreadId, input.telegramTopicName ?? null, input.defaultCwd, input.defaultModel, DEFAULT_SESSION_PROFILE.sandboxMode, DEFAULT_SESSION_PROFILE.approvalPolicy, now, now);
+        this.storage.putSession({
+            sessionKey: input.sessionKey,
+            chatId: input.chatId,
+            messageThreadId: input.messageThreadId,
+            telegramTopicName: input.telegramTopicName ?? null,
+            codexThreadId: null,
+            cwd: input.defaultCwd,
+            model: input.defaultModel,
+            sandboxMode: DEFAULT_SESSION_PROFILE.sandboxMode,
+            approvalPolicy: DEFAULT_SESSION_PROFILE.approvalPolicy,
+            reasoningEffort: null,
+            webSearchMode: null,
+            networkAccessEnabled: true,
+            skipGitRepoCheck: true,
+            additionalDirectories: [],
+            outputSchema: null,
+            createdAt: now,
+            updatedAt: now,
+        });
         const created = this.get(input.sessionKey);
         if (!created)
             throw new Error("Session insert failed");
         return created;
     }
     get(sessionKey) {
-        const row = this.db
-            .prepare("SELECT * FROM sessions WHERE session_key = ?")
-            .get(sessionKey);
-        return row ? mapSessionRow(row) : null;
+        const stored = this.storage.getSession(sessionKey);
+        return mapStoredSession(stored, this.runtimeStateBySession.get(sessionKey), this.outputMessageBySession.get(sessionKey));
     }
     getByThreadId(threadId) {
-        const row = this.db
-            .prepare("SELECT * FROM sessions WHERE codex_thread_id = ? LIMIT 1")
-            .get(threadId);
-        return row ? mapSessionRow(row) : null;
+        const stored = this.storage.getSessionByThreadId(threadId);
+        return stored ? mapStoredSession(stored, this.runtimeStateBySession.get(stored.sessionKey), this.outputMessageBySession.get(stored.sessionKey)) : null;
     }
     listTopicSessions() {
-        const rows = this.db
-            .prepare("SELECT * FROM sessions WHERE message_thread_id IS NOT NULL ORDER BY session_key ASC")
-            .all();
-        return rows.map(mapSessionRow);
+        return this.storage
+            .listSessions()
+            .filter((session) => session.messageThreadId != null)
+            .map((session) => mapStoredSession(session, this.runtimeStateBySession.get(session.sessionKey), this.outputMessageBySession.get(session.sessionKey)))
+            .filter((session) => session != null);
     }
     remove(sessionKey) {
-        this.db.prepare("DELETE FROM queued_inputs WHERE session_key = ?").run(sessionKey);
-        this.db.prepare("DELETE FROM sessions WHERE session_key = ?").run(sessionKey);
+        this.queueBySession.delete(sessionKey);
+        this.runtimeStateBySession.delete(sessionKey);
+        this.outputMessageBySession.delete(sessionKey);
+        this.storage.removeSession(sessionKey);
     }
     enqueueInput(sessionKey, input) {
         const now = new Date().toISOString();
-        const text = formatCodexInputPreview(input);
-        const result = this.db
-            .prepare(`INSERT INTO queued_inputs (session_key, text, input_json, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?)`)
-            .run(sessionKey, text, JSON.stringify(input), now, now);
-        const id = Number(result.lastInsertRowid);
-        const queued = this.getQueuedInput(id);
-        if (!queued)
-            throw new Error("Queued input insert failed");
-        return queued;
+        const queued = {
+            id: this.nextQueuedInputId,
+            sessionKey,
+            text: formatCodexInputPreview(input),
+            input: cloneStoredCodexInput(input),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.nextQueuedInputId += 1;
+        const queue = this.queueBySession.get(sessionKey) ?? [];
+        queue.push(queued);
+        this.queueBySession.set(sessionKey, queue);
+        return cloneQueuedInput(queued);
     }
     getQueuedInput(id) {
-        const row = this.db.prepare("SELECT * FROM queued_inputs WHERE id = ?").get(id);
-        return row ? mapQueuedInputRow(row) : null;
+        for (const queue of this.queueBySession.values()) {
+            const match = queue.find((item) => item.id === id);
+            if (match)
+                return cloneQueuedInput(match);
+        }
+        return null;
     }
     getQueuedInputCount(sessionKey) {
-        const row = this.db
-            .prepare("SELECT COUNT(*) AS count FROM queued_inputs WHERE session_key = ?")
-            .get(sessionKey);
-        return row?.count ?? 0;
+        return this.queueBySession.get(sessionKey)?.length ?? 0;
     }
     peekNextQueuedInput(sessionKey) {
-        const row = this.db
-            .prepare("SELECT * FROM queued_inputs WHERE session_key = ? ORDER BY id ASC LIMIT 1")
-            .get(sessionKey);
-        return row ? mapQueuedInputRow(row) : null;
+        const queue = this.queueBySession.get(sessionKey);
+        const [next] = queue ?? [];
+        return next ? cloneQueuedInput(next) : null;
     }
     listQueuedInputs(sessionKey, limit = 5) {
-        const rows = this.db
-            .prepare("SELECT * FROM queued_inputs WHERE session_key = ? ORDER BY id ASC LIMIT ?")
-            .all(sessionKey, limit);
-        return rows.map(mapQueuedInputRow);
+        const queue = this.queueBySession.get(sessionKey) ?? [];
+        return queue.slice(0, limit).map(cloneQueuedInput);
     }
     removeQueuedInput(id) {
-        this.db.prepare("DELETE FROM queued_inputs WHERE id = ?").run(id);
+        for (const [sessionKey, queue] of this.queueBySession.entries()) {
+            const index = queue.findIndex((item) => item.id === id);
+            if (index < 0)
+                continue;
+            queue.splice(index, 1);
+            if (queue.length === 0) {
+                this.queueBySession.delete(sessionKey);
+            }
+            return;
+        }
     }
     removeQueuedInputForSession(sessionKey, id) {
-        const result = this.db
-            .prepare("DELETE FROM queued_inputs WHERE session_key = ? AND id = ?")
-            .run(sessionKey, id);
-        return (result.changes ?? 0) > 0;
+        const queue = this.queueBySession.get(sessionKey);
+        if (!queue)
+            return false;
+        const index = queue.findIndex((item) => item.id === id);
+        if (index < 0)
+            return false;
+        queue.splice(index, 1);
+        if (queue.length === 0) {
+            this.queueBySession.delete(sessionKey);
+        }
+        return true;
     }
     clearQueuedInputs(sessionKey) {
-        const result = this.db.prepare("DELETE FROM queued_inputs WHERE session_key = ?").run(sessionKey);
-        return result.changes ?? 0;
+        const queue = this.queueBySession.get(sessionKey) ?? [];
+        this.queueBySession.delete(sessionKey);
+        return queue.length;
     }
     bindThread(sessionKey, threadId) {
-        this.patch(sessionKey, {
-            codex_thread_id: threadId,
+        this.patchDurableSession(sessionKey, {
+            codexThreadId: threadId,
         });
     }
     setTelegramTopicName(sessionKey, topicName) {
-        this.patch(sessionKey, { telegram_topic_name: topicName });
+        this.patchDurableSession(sessionKey, {
+            telegramTopicName: topicName,
+        });
     }
     setRuntimeState(sessionKey, state) {
-        this.patch(sessionKey, {
-            runtime_status: state.status,
-            runtime_status_detail: state.detail,
-            runtime_status_updated_at: state.updatedAt,
-            active_turn_id: state.activeTurnId,
-        });
+        this.runtimeStateBySession.set(sessionKey, state);
     }
     setOutputMessage(sessionKey, messageId) {
-        this.patch(sessionKey, { output_message_id: messageId });
+        if (messageId == null) {
+            this.outputMessageBySession.delete(sessionKey);
+            return;
+        }
+        this.outputMessageBySession.set(sessionKey, messageId);
     }
     setCwd(sessionKey, cwd) {
-        this.patch(sessionKey, { cwd });
+        this.patchDurableSession(sessionKey, { cwd });
     }
     setModel(sessionKey, model) {
-        this.patch(sessionKey, { model });
+        this.patchDurableSession(sessionKey, { model });
     }
     setSandboxMode(sessionKey, sandboxMode) {
-        this.patch(sessionKey, {
-            sandbox_mode: sandboxMode,
-        });
+        this.patchDurableSession(sessionKey, { sandboxMode });
     }
     setApprovalPolicy(sessionKey, approvalPolicy) {
-        this.patch(sessionKey, { approval_policy: approvalPolicy });
+        this.patchDurableSession(sessionKey, { approvalPolicy });
     }
     setReasoningEffort(sessionKey, reasoningEffort) {
-        this.patch(sessionKey, { reasoning_effort: reasoningEffort });
+        this.patchDurableSession(sessionKey, { reasoningEffort });
     }
     setWebSearchMode(sessionKey, webSearchMode) {
-        this.patch(sessionKey, { web_search_mode: webSearchMode });
+        this.patchDurableSession(sessionKey, { webSearchMode });
     }
     setNetworkAccessEnabled(sessionKey, enabled) {
-        this.patch(sessionKey, { network_access_enabled: enabled ? 1 : 0 });
+        this.patchDurableSession(sessionKey, { networkAccessEnabled: enabled });
     }
     setSkipGitRepoCheck(sessionKey, skip) {
-        this.patch(sessionKey, { skip_git_repo_check: skip ? 1 : 0 });
+        this.patchDurableSession(sessionKey, { skipGitRepoCheck: skip });
     }
     setAdditionalDirectories(sessionKey, directories) {
-        this.patch(sessionKey, { additional_directories: JSON.stringify(directories) });
+        this.patchDurableSession(sessionKey, { additionalDirectories: [...directories] });
     }
     setOutputSchema(sessionKey, outputSchema) {
-        this.patch(sessionKey, { output_schema: outputSchema });
+        this.patchDurableSession(sessionKey, { outputSchema });
     }
-    patch(sessionKey, fields) {
-        const entries = Object.entries(fields);
-        if (entries.length === 0)
-            return;
-        const setSql = entries.map(([key]) => `${key} = ?`).join(", ");
-        const values = entries.map(([, value]) => value);
-        values.push(new Date().toISOString(), sessionKey);
-        this.db.prepare(`UPDATE sessions SET ${setSql}, updated_at = ? WHERE session_key = ?`).run(...values);
+    patchDurableSession(sessionKey, patch) {
+        this.storage.patchSession(sessionKey, patch);
     }
 }
 export function makeSessionKey(chatId, messageThreadId) {
     return messageThreadId == null ? String(chatId) : `${chatId}:${messageThreadId}`;
 }
-function mapSessionRow(row) {
+function mapStoredSession(stored, runtimeState, outputMessageId) {
+    if (!stored)
+        return null;
+    const runtime = runtimeState ?? {
+        status: "idle",
+        detail: null,
+        updatedAt: stored.updatedAt,
+        activeTurnId: null,
+    };
     return {
-        sessionKey: row.session_key,
-        chatId: row.chat_id,
-        messageThreadId: row.message_thread_id,
-        telegramTopicName: row.telegram_topic_name ?? null,
-        codexThreadId: row.codex_thread_id,
-        cwd: row.cwd,
-        model: row.model,
-        sandboxMode: normalizeSandboxMode(row.sandbox_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),
-        runtimeStatus: normalizeRuntimeStatus(row.runtime_status, row.active_turn_id),
-        runtimeStatusDetail: row.runtime_status_detail ?? null,
-        runtimeStatusUpdatedAt: row.runtime_status_updated_at ?? row.updated_at,
-        activeTurnId: row.active_turn_id,
-        outputMessageId: row.output_message_id,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
+        ...stored,
+        additionalDirectories: [...stored.additionalDirectories],
+        runtimeStatus: runtime.status,
+        runtimeStatusDetail: runtime.detail,
+        runtimeStatusUpdatedAt: runtime.updatedAt,
+        activeTurnId: runtime.activeTurnId,
+        outputMessageId: outputMessageId ?? null,
     };
 }
-function mapQueuedInputRow(row) {
+function cloneQueuedInput(input) {
     return {
-        id: row.id,
-        sessionKey: row.session_key,
-        text: row.text,
-        input: parseStoredCodexInput(row.input_json, row.text),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
+        ...input,
+        input: cloneStoredCodexInput(input.input),
     };
 }
-function normalizeSandboxMode(value) {
-    return value && isSessionSandboxMode(value) ? value : DEFAULT_SESSION_PROFILE.sandboxMode;
-}
-function normalizeApprovalPolicy(value) {
-    return value && isSessionApprovalPolicy(value) ? value : DEFAULT_SESSION_PROFILE.approvalPolicy;
-}
-function normalizeReasoningEffort(value) {
-    return value && isSessionReasoningEffort(value) ? value : null;
-}
-function normalizeWebSearchMode(value) {
-    return value && isSessionWebSearchMode(value) ? value : null;
-}
-function normalizeBoolean(value, fallback) {
-    if (value == null)
-        return fallback;
-    return Number(value) !== 0;
-}
-function normalizeStringArray(value) {
-    if (!value)
-        return [];
-    try {
-        const parsed = JSON.parse(value);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
-    }
-    catch {
-        return [];
-    }
-}
-function normalizeOutputSchema(value) {
-    if (!value?.trim())
-        return null;
-    try {
-        const parsed = JSON.parse(value);
-        return isPlainObject(parsed) ? JSON.stringify(parsed) : null;
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeRuntimeStatus(value, activeTurnId) {
-    switch (value) {
-        case "idle":
-        case "preparing":
-        case "running":
-        case "failed":
-            return value;
-        default:
-            return activeTurnId ? "running" : "idle";
-    }
+function cloneStoredCodexInput(input) {
+    return typeof input === "string" ? input : input.map((item) => ({ ...item }));
 }
 function normalizeBindingCodeMode(value) {
     return value === "rebind" ? "rebind" : "bootstrap";
@@ -390,44 +353,9 @@ function normalizeOptionalUserId(value) {
     const parsed = Number(value);
     return Number.isSafeInteger(parsed) ? parsed : null;
 }
-function parseStoredCodexInput(inputJson, fallbackText) {
-    if (!inputJson)
-        return fallbackText;
-    try {
-        const parsed = JSON.parse(inputJson);
-        return normalizeStoredCodexInput(parsed) ?? fallbackText;
-    }
-    catch {
-        return fallbackText;
-    }
-}
-function normalizeStoredCodexInput(value) {
-    if (typeof value === "string")
-        return value;
-    if (!Array.isArray(value))
-        return null;
-    const items = [];
-    for (const item of value) {
-        if (!isPlainObject(item))
-            return null;
-        if (item.type === "text" && typeof item.text === "string") {
-            items.push({ type: "text", text: item.text });
-        }
-        else if (item.type === "local_image" && typeof item.path === "string") {
-            items.push({ type: "local_image", path: item.path });
-        }
-        else {
-            return null;
-        }
-    }
-    return items;
-}
 export function formatCodexInputPreview(input) {
     if (typeof input === "string")
         return input;
     const parts = input.map((item) => (item.type === "text" ? item.text : `[image: ${item.path}]`));
     return parts.join(" ").trim() || "[image]";
 }
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}