telecodex 0.1.0

package/dist/store/db.js

@@ -0,0 +1,267 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export const LATEST_DB_SCHEMA_VERSION = 12;
+export function openDatabase(dbPath) {
+    mkdirSync(path.dirname(dbPath), { recursive: true });
+    const db = new DatabaseSync(dbPath);
+    runMigrations(db);
+    return db;
+}
+const MIGRATIONS = [
+    {
+        version: 1,
+        apply(db) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS app_state (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS projects (
+          chat_id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          cwd TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          session_key TEXT PRIMARY KEY,
+          chat_id TEXT NOT NULL,
+          message_thread_id TEXT,
+          codex_thread_id TEXT,
+          cwd TEXT NOT NULL,
+          model TEXT NOT NULL,
+          active_turn_id TEXT,
+          output_message_id INTEGER,
+          sandbox_mode TEXT NOT NULL DEFAULT 'read-only',
+          approval_policy TEXT NOT NULL DEFAULT 'on-request',
+          telegram_topic_name TEXT,
+          reasoning_effort TEXT,
+          web_search_mode TEXT,
+          network_access_enabled INTEGER NOT NULL DEFAULT 1,
+          skip_git_repo_check INTEGER NOT NULL DEFAULT 1,
+          additional_directories TEXT,
+          output_schema TEXT,
+          runtime_status TEXT NOT NULL DEFAULT 'idle',
+          runtime_status_detail TEXT,
+          runtime_status_updated_at TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS sessions_codex_thread_id_idx
+          ON sessions (codex_thread_id);
+
+        CREATE TABLE IF NOT EXISTS queued_inputs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_key TEXT NOT NULL,
+          text TEXT NOT NULL,
+          input_json TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS queued_inputs_session_key_idx
+          ON queued_inputs (session_key, id);
+      `);
+        },
+    },
+    {
+        version: 2,
+        apply(db) {
+            const addedSandboxMode = ensureTableColumn(db, "sessions", "sandbox_mode", "ALTER TABLE sessions ADD COLUMN sandbox_mode TEXT NOT NULL DEFAULT 'read-only'");
+            const addedApprovalPolicy = ensureTableColumn(db, "sessions", "approval_policy", "ALTER TABLE sessions ADD COLUMN approval_policy TEXT NOT NULL DEFAULT 'on-request'");
+            ensureTableColumn(db, "sessions", "telegram_topic_name", "ALTER TABLE sessions ADD COLUMN telegram_topic_name TEXT");
+            ensureTableColumn(db, "sessions", "reasoning_effort", "ALTER TABLE sessions ADD COLUMN reasoning_effort TEXT");
+            if (addedSandboxMode) {
+                db.exec(`
+          UPDATE sessions
+          SET sandbox_mode = CASE mode
+            WHEN 'write' THEN 'workspace-write'
+            ELSE 'read-only'
+          END
+        `);
+            }
+            if (addedApprovalPolicy) {
+                db.exec(`
+          UPDATE sessions
+          SET approval_policy = 'on-request'
+        `);
+            }
+        },
+    },
+    {
+        version: 5,
+        apply(db) {
+            ensureTableColumn(db, "sessions", "runtime_status", "ALTER TABLE sessions ADD COLUMN runtime_status TEXT NOT NULL DEFAULT 'idle'");
+            ensureTableColumn(db, "sessions", "runtime_status_detail", "ALTER TABLE sessions ADD COLUMN runtime_status_detail TEXT");
+            const addedRuntimeStatusUpdatedAt = ensureTableColumn(db, "sessions", "runtime_status_updated_at", "ALTER TABLE sessions ADD COLUMN runtime_status_updated_at TEXT");
+            db.exec(`
+        UPDATE sessions
+        SET runtime_status = CASE
+          WHEN active_turn_id IS NOT NULL THEN 'running'
+          ELSE 'idle'
+        END
+        WHERE runtime_status IS NULL
+           OR runtime_status NOT IN ('idle', 'preparing', 'running', 'failed')
+      `);
+            if (addedRuntimeStatusUpdatedAt) {
+                db.exec(`
+          UPDATE sessions
+          SET runtime_status_updated_at = updated_at
+          WHERE runtime_status_updated_at IS NULL
+        `);
+            }
+        },
+    },
+    {
+        version: 6,
+        apply(db) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS queued_inputs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_key TEXT NOT NULL,
+          text TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS queued_inputs_session_key_idx
+          ON queued_inputs (session_key, id)
+      `);
+        },
+    },
+    {
+        version: 10,
+        apply(db) {
+            db.exec(`
+        DROP INDEX IF EXISTS turn_deliveries_thread_id_idx;
+        DROP INDEX IF EXISTS turn_deliveries_session_key_idx;
+        DROP INDEX IF EXISTS turn_deliveries_status_idx;
+        DROP INDEX IF EXISTS pending_interactions_session_key_idx;
+        DROP TABLE IF EXISTS turn_deliveries;
+        DROP TABLE IF EXISTS pending_interactions;
+      `);
+        },
+    },
+    {
+        version: 11,
+        apply(db) {
+            db.exec(`
+        CREATE TABLE sessions_v11 (
+          session_key TEXT PRIMARY KEY,
+          chat_id TEXT NOT NULL,
+          message_thread_id TEXT,
+          codex_thread_id TEXT,
+          cwd TEXT NOT NULL,
+          model TEXT NOT NULL,
+          active_turn_id TEXT,
+          output_message_id INTEGER,
+          sandbox_mode TEXT NOT NULL DEFAULT 'read-only',
+          approval_policy TEXT NOT NULL DEFAULT 'on-request',
+          telegram_topic_name TEXT,
+          reasoning_effort TEXT,
+          runtime_status TEXT NOT NULL DEFAULT 'idle',
+          runtime_status_detail TEXT,
+          runtime_status_updated_at TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        INSERT INTO sessions_v11 (
+          session_key,
+          chat_id,
+          message_thread_id,
+          codex_thread_id,
+          cwd,
+          model,
+          active_turn_id,
+          output_message_id,
+          sandbox_mode,
+          approval_policy,
+          telegram_topic_name,
+          reasoning_effort,
+          runtime_status,
+          runtime_status_detail,
+          runtime_status_updated_at,
+          created_at,
+          updated_at
+        )
+        SELECT
+          session_key,
+          chat_id,
+          message_thread_id,
+          codex_thread_id,
+          cwd,
+          model,
+          active_turn_id,
+          output_message_id,
+          sandbox_mode,
+          approval_policy,
+          telegram_topic_name,
+          reasoning_effort,
+          runtime_status,
+          runtime_status_detail,
+          runtime_status_updated_at,
+          created_at,
+          updated_at
+        FROM sessions;
+
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v11 RENAME TO sessions;
+
+        CREATE INDEX IF NOT EXISTS sessions_codex_thread_id_idx
+          ON sessions (codex_thread_id);
+      `);
+        },
+    },
+    {
+        version: 12,
+        apply(db) {
+            ensureTableColumn(db, "sessions", "web_search_mode", "ALTER TABLE sessions ADD COLUMN web_search_mode TEXT");
+            ensureTableColumn(db, "sessions", "network_access_enabled", "ALTER TABLE sessions ADD COLUMN network_access_enabled INTEGER NOT NULL DEFAULT 1");
+            ensureTableColumn(db, "sessions", "skip_git_repo_check", "ALTER TABLE sessions ADD COLUMN skip_git_repo_check INTEGER NOT NULL DEFAULT 1");
+            ensureTableColumn(db, "sessions", "additional_directories", "ALTER TABLE sessions ADD COLUMN additional_directories TEXT");
+            ensureTableColumn(db, "sessions", "output_schema", "ALTER TABLE sessions ADD COLUMN output_schema TEXT");
+            ensureTableColumn(db, "queued_inputs", "input_json", "ALTER TABLE queued_inputs ADD COLUMN input_json TEXT");
+        },
+    },
+];
+function runMigrations(db) {
+    const currentVersion = getSchemaVersion(db);
+    if (currentVersion >= LATEST_DB_SCHEMA_VERSION) {
+        return;
+    }
+    for (const migration of MIGRATIONS) {
+        if (migration.version <= currentVersion)
+            continue;
+        db.exec("BEGIN");
+        try {
+            migration.apply(db);
+            setSchemaVersion(db, migration.version);
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+}
+function ensureTableColumn(db, tableName, columnName, sql) {
+    const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    if (columns.some((column) => column.name === columnName)) {
+        return false;
+    }
+    db.exec(sql);
+    return true;
+}
+function getSchemaVersion(db) {
+    const row = db.prepare("PRAGMA user_version").get();
+    return row?.user_version ?? 0;
+}
+function setSchemaVersion(db, version) {
+    db.exec(`PRAGMA user_version = ${version}`);
+}

package/dist/store/projects.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+export class ProjectStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(chatId) {
+        const row = this.db.prepare("SELECT * FROM projects WHERE chat_id = ?").get(chatId);
+        return row ? mapRow(row) : null;
+    }
+    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;
+    }
+    remove(chatId) {
+        this.db.prepare("DELETE FROM projects WHERE chat_id = ?").run(chatId);
+    }
+    list() {
+        const rows = this.db
+            .prepare("SELECT * FROM projects ORDER BY updated_at DESC")
+            .all();
+        return rows.map(mapRow);
+    }
+}
+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

@@ -0,0 +1,328 @@
+import { DEFAULT_SESSION_PROFILE, isSessionApprovalPolicy, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, } from "../config.js";
+export class SessionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getAppState(key) {
+        const row = this.db.prepare("SELECT value FROM app_state WHERE key = ?").get(key);
+        return row?.value ?? null;
+    }
+    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());
+    }
+    deleteAppState(key) {
+        this.db.prepare("DELETE FROM app_state WHERE key = ?").run(key);
+    }
+    getAuthorizedUserId() {
+        const value = this.getAppState("authorized_user_id");
+        if (value == null)
+            return null;
+        const userId = Number(value);
+        return Number.isSafeInteger(userId) ? userId : null;
+    }
+    getBootstrapCode() {
+        return this.getAppState("bootstrap_code");
+    }
+    setBootstrapCode(code) {
+        this.setAppState("bootstrap_code", code);
+    }
+    clearBootstrapCode() {
+        this.deleteAppState("bootstrap_code");
+    }
+    claimAuthorizedUserId(userId) {
+        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());
+        const current = this.getAuthorizedUserId();
+        if (current == null)
+            throw new Error("Failed to persist authorized Telegram user id");
+        this.clearBootstrapCode();
+        return current;
+    }
+    clearAuthorizedUserId() {
+        this.deleteAppState("authorized_user_id");
+    }
+    getOrCreate(input) {
+        const existing = this.get(input.sessionKey);
+        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);
+        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;
+    }
+    getByThreadId(threadId) {
+        const row = this.db
+            .prepare("SELECT * FROM sessions WHERE codex_thread_id = ? LIMIT 1")
+            .get(threadId);
+        return row ? mapSessionRow(row) : 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);
+    }
+    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);
+    }
+    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;
+    }
+    getQueuedInput(id) {
+        const row = this.db.prepare("SELECT * FROM queued_inputs WHERE id = ?").get(id);
+        return row ? mapQueuedInputRow(row) : null;
+    }
+    getQueuedInputCount(sessionKey) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS count FROM queued_inputs WHERE session_key = ?")
+            .get(sessionKey);
+        return row?.count ?? 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;
+    }
+    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);
+    }
+    removeQueuedInput(id) {
+        this.db.prepare("DELETE FROM queued_inputs WHERE id = ?").run(id);
+    }
+    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;
+    }
+    clearQueuedInputs(sessionKey) {
+        const result = this.db.prepare("DELETE FROM queued_inputs WHERE session_key = ?").run(sessionKey);
+        return result.changes ?? 0;
+    }
+    bindThread(sessionKey, threadId) {
+        this.patch(sessionKey, {
+            codex_thread_id: threadId,
+        });
+    }
+    setTelegramTopicName(sessionKey, topicName) {
+        this.patch(sessionKey, { telegram_topic_name: 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,
+        });
+    }
+    setOutputMessage(sessionKey, messageId) {
+        this.patch(sessionKey, { output_message_id: messageId });
+    }
+    setCwd(sessionKey, cwd) {
+        this.patch(sessionKey, { cwd });
+    }
+    setModel(sessionKey, model) {
+        this.patch(sessionKey, { model });
+    }
+    setSandboxMode(sessionKey, sandboxMode) {
+        this.patch(sessionKey, {
+            sandbox_mode: sandboxMode,
+        });
+    }
+    setApprovalPolicy(sessionKey, approvalPolicy) {
+        this.patch(sessionKey, { approval_policy: approvalPolicy });
+    }
+    setReasoningEffort(sessionKey, reasoningEffort) {
+        this.patch(sessionKey, { reasoning_effort: reasoningEffort });
+    }
+    setWebSearchMode(sessionKey, webSearchMode) {
+        this.patch(sessionKey, { web_search_mode: webSearchMode });
+    }
+    setNetworkAccessEnabled(sessionKey, enabled) {
+        this.patch(sessionKey, { network_access_enabled: enabled ? 1 : 0 });
+    }
+    setSkipGitRepoCheck(sessionKey, skip) {
+        this.patch(sessionKey, { skip_git_repo_check: skip ? 1 : 0 });
+    }
+    setAdditionalDirectories(sessionKey, directories) {
+        this.patch(sessionKey, { additional_directories: JSON.stringify(directories) });
+    }
+    setOutputSchema(sessionKey, outputSchema) {
+        this.patch(sessionKey, { output_schema: 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);
+    }
+}
+export function makeSessionKey(chatId, messageThreadId) {
+    return messageThreadId == null ? String(chatId) : `${chatId}:${messageThreadId}`;
+}
+function mapSessionRow(row) {
+    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,
+    };
+}
+function mapQueuedInputRow(row) {
+    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,
+    };
+}
+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 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);
+}