telecodex 0.1.0

package/dist/bot/handlers/operationalHandlers.js

@@ -0,0 +1,131 @@
+import { presetFromProfile } from "../../config.js";
+import { formatSessionRuntimeStatus } from "../../runtime/sessionRuntime.js";
+import { refreshSessionIfActiveTurnIsStale } from "../inputService.js";
+import { contextLogFields, formatHelpText, formatPrivateStatus, formatProjectStatus, formatReasoningEffort, getProjectForContext, getScopedSession, hasTopicContext, isPrivateChat, parseSubcommand, } from "../commandSupport.js";
+import { formatIsoTimestamp, sessionLogFields } from "../sessionFlow.js";
+export function registerOperationalHandlers(deps) {
+    const { bot, config, store, projects, codex, logger } = deps;
+    bot.command(["start", "help"], async (ctx) => {
+        await ctx.reply(formatHelpText(ctx, projects));
+    });
+    bot.command("status", async (ctx) => {
+        if (isPrivateChat(ctx)) {
+            await ctx.reply(formatPrivateStatus(store, projects));
+            return;
+        }
+        const project = getProjectForContext(ctx, projects);
+        if (!project) {
+            await ctx.reply("This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.");
+            return;
+        }
+        if (!hasTopicContext(ctx)) {
+            await ctx.reply(formatProjectStatus(project));
+            return;
+        }
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const latestSession = await refreshSessionIfActiveTurnIsStale(session, store, codex, bot, logger);
+        const queueDepth = store.getQueuedInputCount(latestSession.sessionKey);
+        const queuedPreview = store.listQueuedInputs(latestSession.sessionKey, 3);
+        const activeRun = codex.getActiveRun(latestSession.sessionKey);
+        await ctx.reply([
+            "Status",
+            `project: ${project.name}`,
+            `root: ${project.cwd}`,
+            `thread: ${latestSession.codexThreadId ?? "not created"}`,
+            `state: ${formatSessionRuntimeStatus(latestSession.runtimeStatus)}`,
+            `state detail: ${latestSession.runtimeStatusDetail ?? "none"}`,
+            `state updated: ${formatIsoTimestamp(latestSession.runtimeStatusUpdatedAt)}`,
+            `active turn: ${latestSession.activeTurnId ?? "none"}`,
+            `active run: ${activeRun ? formatIsoTimestamp(activeRun.startedAt) : "none"}`,
+            `active run thread: ${activeRun?.threadId ?? "none"}`,
+            `active run last event: ${activeRun?.lastEventType ?? "none"}`,
+            `active run last update: ${activeRun ? formatIsoTimestamp(activeRun.lastEventAt) : "none"}`,
+            `queue: ${queueDepth}`,
+            `queue next: ${formatQueuedPreview(queuedPreview)}`,
+            `cwd: ${latestSession.cwd}`,
+            `preset: ${presetFromProfile(latestSession)}`,
+            `sandbox: ${latestSession.sandboxMode}`,
+            `approval: ${latestSession.approvalPolicy}`,
+            `network: ${latestSession.networkAccessEnabled ? "on" : "off"}`,
+            `web: ${latestSession.webSearchMode ?? "codex-default"}`,
+            `git check: ${latestSession.skipGitRepoCheck ? "skip" : "enforce"}`,
+            `add dirs: ${latestSession.additionalDirectories.length}`,
+            `schema: ${latestSession.outputSchema ? "set" : "none"}`,
+            `model: ${latestSession.model}`,
+            `effort: ${formatReasoningEffort(latestSession.reasoningEffort)}`,
+        ].join("\n"));
+    });
+    bot.command("queue", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const { command, args } = parseSubcommand(ctx.match.trim());
+        if (!command) {
+            const queued = store.listQueuedInputs(session.sessionKey, 5);
+            const queueDepth = store.getQueuedInputCount(session.sessionKey);
+            await ctx.reply([
+                "Queue",
+                `state: ${formatSessionRuntimeStatus(session.runtimeStatus)}`,
+                `active turn: ${session.activeTurnId ?? "none"}`,
+                `queue: ${queueDepth}`,
+                queued.length > 0 ? `items:\n${formatQueuedItems(queued)}` : "items: none",
+                "Usage: /queue | /queue drop <id> | /queue clear",
+            ].join("\n"));
+            return;
+        }
+        if (command === "clear") {
+            const removed = store.clearQueuedInputs(session.sessionKey);
+            await ctx.reply(`Cleared the queue and removed ${removed} pending message(s).`);
+            return;
+        }
+        if (command === "drop") {
+            const id = Number(args);
+            if (!Number.isInteger(id) || id <= 0) {
+                await ctx.reply("Usage: /queue drop <id>");
+                return;
+            }
+            const removed = store.removeQueuedInputForSession(session.sessionKey, id);
+            await ctx.reply(removed ? `Removed queued item #${id}.` : `Queued item #${id} was not found.`);
+            return;
+        }
+        await ctx.reply("Usage: /queue | /queue drop <id> | /queue clear");
+    });
+    bot.command("stop", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const latest = store.get(session.sessionKey) ?? session;
+        if (!codex.isRunning(session.sessionKey)) {
+            await ctx.reply("There is no active Codex SDK turn right now.");
+            return;
+        }
+        try {
+            codex.interrupt(session.sessionKey);
+            await ctx.reply("Interrupt requested for the current run. Waiting for Codex SDK to stop.");
+        }
+        catch (error) {
+            logger?.warn("interrupt turn failed", {
+                ...contextLogFields(ctx),
+                ...sessionLogFields(latest),
+                error,
+            });
+            await ctx.reply(`Interrupt failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+function formatQueuedPreview(items) {
+    if (items.length === 0)
+        return "none";
+    return items.map((item) => singleLinePreview(item.text)).join(" | ");
+}
+function formatQueuedItems(items) {
+    return items.map((item) => `#${item.id} ${singleLinePreview(item.text)} (${formatIsoTimestamp(item.createdAt)})`).join("\n");
+}
+function singleLinePreview(text, maxLength = 48) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 3)}...`;
+}

package/dist/bot/handlers/projectHandlers.js

@@ -0,0 +1,192 @@
+import { contextLogFields, ensureTopicSession, formatPrivateProjectList, formatProjectStatus, formatTopicName, getProjectForContext, getScopedSession, hasTopicContext, isPrivateChat, isSupergroupChat, parseSubcommand, postTopicReadyMessage, resolveExistingDirectory, } from "../commandSupport.js";
+import { formatSessionRuntimeStatus } from "../../runtime/sessionRuntime.js";
+const PROJECT_REQUIRED_MESSAGE = "This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.";
+export function registerProjectHandlers(deps) {
+    const { bot, config, store, projects, logger } = deps;
+    bot.command("project", async (ctx) => {
+        const { command, args } = parseSubcommand(ctx.match.trim());
+        if (isPrivateChat(ctx)) {
+            if (!command || command === "list" || command === "status") {
+                await ctx.reply(formatPrivateProjectList(projects));
+                return;
+            }
+            await ctx.reply("Use /project bind inside a supergroup with topics enabled. Private chat is only for admin entry points.");
+            return;
+        }
+        if (!isSupergroupChat(ctx)) {
+            await ctx.reply("Use telecodex inside a supergroup with forum topics enabled.");
+            return;
+        }
+        if (!command || command === "status") {
+            const project = getProjectForContext(ctx, projects);
+            await ctx.reply(project ? formatProjectStatus(project) : PROJECT_REQUIRED_MESSAGE);
+            return;
+        }
+        if (command === "bind") {
+            if (!args) {
+                await ctx.reply("Usage: /project bind <absolute-path>");
+                return;
+            }
+            try {
+                const cwd = resolveExistingDirectory(args);
+                const project = projects.upsert({
+                    chatId: String(ctx.chat.id),
+                    cwd,
+                });
+                logger?.info("project bound", {
+                    ...contextLogFields(ctx),
+                    project: project.name,
+                    cwd: project.cwd,
+                });
+                const session = getScopedSession(ctx, store, projects, config, { requireTopic: false });
+                if (session && session.cwd !== project.cwd) {
+                    store.setCwd(session.sessionKey, project.cwd);
+                }
+                await ctx.reply([
+                    "Project binding updated.",
+                    `project: ${project.name}`,
+                    `root: ${project.cwd}`,
+                    "This supergroup now represents one project, and each topic maps to one Codex thread.",
+                ].join("\n"));
+            }
+            catch (error) {
+                await ctx.reply(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        if (command === "unbind") {
+            logger?.info("project unbound", {
+                ...contextLogFields(ctx),
+            });
+            projects.remove(String(ctx.chat.id));
+            await ctx.reply("Removed the project binding for this supergroup.");
+            return;
+        }
+        await ctx.reply("Usage:\n/project\n/project bind <absolute-path>\n/project unbind");
+    });
+    bot.command("thread", async (ctx) => {
+        if (isPrivateChat(ctx)) {
+            await ctx.reply("The thread command is only available inside project supergroups.");
+            return;
+        }
+        const { command, args } = parseSubcommand(ctx.match.trim());
+        if (!command) {
+            if (hasTopicContext(ctx)) {
+                const session = getScopedSession(ctx, store, projects, config);
+                if (!session)
+                    return;
+                await ctx.reply([
+                    `Current thread: ${session.codexThreadId ?? "not created"}`,
+                    `state: ${formatSessionRuntimeStatus(session.runtimeStatus)}`,
+                    `state detail: ${session.runtimeStatusDetail ?? "none"}`,
+                    `queue: ${store.getQueuedInputCount(session.sessionKey)}`,
+                    `cwd: ${session.cwd}`,
+                    "Manage threads in this project:",
+                    "/thread resume <threadId>",
+                    "/thread new <topic-name>",
+                ].join("\n"));
+                return;
+            }
+            await ctx.reply("Usage:\n/thread resume <threadId>\n/thread new <topic-name>");
+            return;
+        }
+        if (command === "resume") {
+            if (!args) {
+                await ctx.reply("Usage: /thread resume <threadId>");
+                return;
+            }
+            await resumeThreadIntoTopic(ctx, deps, args);
+            return;
+        }
+        if (command === "new") {
+            await createFreshThreadTopic(ctx, deps, args);
+            return;
+        }
+        await ctx.reply("Usage:\n/thread resume <threadId>\n/thread new <topic-name>");
+    });
+    bot.on(["message:forum_topic_created", "message:forum_topic_edited"], async (ctx) => {
+        const threadId = ctx.message.message_thread_id;
+        if (threadId == null)
+            return;
+        const topicName = ctx.message.forum_topic_created?.name ?? ctx.message.forum_topic_edited?.name ?? null;
+        if (!topicName)
+            return;
+        const sessionKey = `${ctx.chat.id}:${threadId}`;
+        const session = store.get(sessionKey);
+        if (!session)
+            return;
+        store.setTelegramTopicName(sessionKey, topicName);
+    });
+}
+async function resumeThreadIntoTopic(ctx, deps, threadId) {
+    const { bot, config, store, projects, logger } = deps;
+    const project = getProjectForContext(ctx, projects);
+    if (!project) {
+        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        return;
+    }
+    const topicName = formatTopicName(`Resumed ${threadId.slice(0, 8)}`, "Resumed Thread");
+    const forumTopic = await bot.api.createForumTopic(ctx.chat.id, topicName);
+    const session = ensureTopicSession({
+        store,
+        config,
+        project,
+        chatId: ctx.chat.id,
+        messageThreadId: forumTopic.message_thread_id,
+        topicName: forumTopic.name,
+        threadId,
+    });
+    logger?.info("thread id bound into topic", {
+        ...contextLogFields(ctx),
+        sessionKey: session.sessionKey,
+        threadId,
+        topicName: forumTopic.name,
+    });
+    await ctx.reply([
+        "Created a topic and bound it to the existing thread id.",
+        `topic: ${forumTopic.name}`,
+        `topic id: ${forumTopic.message_thread_id}`,
+        `thread: ${threadId}`,
+        "Future messages in this topic will continue on that thread through the Codex SDK.",
+    ].join("\n"));
+    await postTopicReadyMessage(bot, session, [
+        "This topic is now bound to an existing Codex thread id.",
+        `thread: ${threadId}`,
+        "Send a message to continue.",
+    ].join("\n"));
+}
+async function createFreshThreadTopic(ctx, deps, requestedName) {
+    const { bot, config, store, projects, logger } = deps;
+    const project = getProjectForContext(ctx, projects);
+    if (!project) {
+        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        return;
+    }
+    const topicName = formatTopicName(requestedName, "New Thread");
+    const forumTopic = await bot.api.createForumTopic(ctx.chat.id, topicName);
+    const session = ensureTopicSession({
+        store,
+        config,
+        project,
+        chatId: ctx.chat.id,
+        messageThreadId: forumTopic.message_thread_id,
+        topicName: forumTopic.name,
+    });
+    logger?.info("new thread topic created", {
+        ...contextLogFields(ctx),
+        sessionKey: session.sessionKey,
+        topicName: forumTopic.name,
+    });
+    await ctx.reply([
+        "Created a new topic.",
+        `topic: ${forumTopic.name}`,
+        `topic id: ${forumTopic.message_thread_id}`,
+        "Your first normal message will start a new Codex SDK thread.",
+    ].join("\n"));
+    await postTopicReadyMessage(bot, session, [
+        "New topic created.",
+        "Send a message to start a new Codex thread.",
+        `cwd: ${session.cwd}`,
+        `model: ${session.model}`,
+    ].join("\n"));
+}

package/dist/bot/handlers/sessionConfigHandlers.js

@@ -0,0 +1,319 @@
+import { APPROVAL_POLICIES, MODE_PRESETS, REASONING_EFFORTS, SANDBOX_MODES, WEB_SEARCH_MODES, isSessionApprovalPolicy, isSessionModePreset, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, presetFromProfile, profileFromPreset, } from "../../config.js";
+import { assertProjectScopedPath, formatProfileReply, formatReasoningEffort, getProjectForContext, getScopedSession, resolveExistingDirectory, } from "../commandSupport.js";
+export function registerSessionConfigHandlers(deps) {
+    const { bot, config, store, projects, codex } = deps;
+    bot.command("cwd", async (ctx) => {
+        const project = getProjectForContext(ctx, projects);
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!project || !session)
+            return;
+        const cwd = ctx.match.trim();
+        if (!cwd) {
+            await ctx.reply(`Current directory: ${session.cwd}\nProject root: ${project.cwd}`);
+            return;
+        }
+        try {
+            const allowed = assertProjectScopedPath(cwd, project.cwd);
+            store.setCwd(session.sessionKey, allowed);
+            await ctx.reply(`Set cwd:\n${allowed}`);
+        }
+        catch (error) {
+            await ctx.reply(error instanceof Error ? error.message : String(error));
+        }
+    });
+    bot.command("mode", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const preset = ctx.match.trim();
+        if (!preset) {
+            await ctx.reply([
+                `Current preset: ${presetFromProfile(session)}`,
+                `sandbox: ${session.sandboxMode}`,
+                `approval: ${session.approvalPolicy}`,
+                `Usage: /mode ${MODE_PRESETS.join("|")}`,
+            ].join("\n"));
+            return;
+        }
+        if (!isSessionModePreset(preset)) {
+            await ctx.reply(`Invalid preset.\nUsage: /mode ${MODE_PRESETS.join("|")}`);
+            return;
+        }
+        const profile = profileFromPreset(preset);
+        store.setSandboxMode(session.sessionKey, profile.sandboxMode);
+        store.setApprovalPolicy(session.sessionKey, profile.approvalPolicy);
+        await ctx.reply(formatProfileReply("Preset updated.", profile.sandboxMode, profile.approvalPolicy));
+    });
+    bot.command("sandbox", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const sandboxMode = ctx.match.trim();
+        if (!sandboxMode) {
+            await ctx.reply(`Current sandbox: ${session.sandboxMode}\nUsage: /sandbox ${SANDBOX_MODES.join("|")}`);
+            return;
+        }
+        if (!isSessionSandboxMode(sandboxMode)) {
+            await ctx.reply(`Invalid sandbox.\nUsage: /sandbox ${SANDBOX_MODES.join("|")}`);
+            return;
+        }
+        store.setSandboxMode(session.sessionKey, sandboxMode);
+        await ctx.reply(formatProfileReply("Sandbox updated.", sandboxMode, session.approvalPolicy));
+    });
+    bot.command("approval", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const approvalPolicy = ctx.match.trim();
+        if (!approvalPolicy) {
+            await ctx.reply(`Current approval: ${session.approvalPolicy}\nUsage: /approval ${APPROVAL_POLICIES.join("|")}`);
+            return;
+        }
+        if (!isSessionApprovalPolicy(approvalPolicy)) {
+            await ctx.reply(`Invalid approval policy.\nUsage: /approval ${APPROVAL_POLICIES.join("|")}`);
+            return;
+        }
+        store.setApprovalPolicy(session.sessionKey, approvalPolicy);
+        await ctx.reply(formatProfileReply("Approval policy updated.", session.sandboxMode, approvalPolicy));
+    });
+    bot.command("yolo", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const value = ctx.match.trim().toLowerCase();
+        if (!value) {
+            const enabled = session.sandboxMode === "danger-full-access" && session.approvalPolicy === "never";
+            await ctx.reply(`Current yolo: ${enabled ? "on" : "off"}\nUsage: /yolo on|off`);
+            return;
+        }
+        if (value !== "on" && value !== "off") {
+            await ctx.reply("Usage: /yolo on|off");
+            return;
+        }
+        const profile = profileFromPreset(value === "on" ? "yolo" : "write");
+        store.setSandboxMode(session.sessionKey, profile.sandboxMode);
+        store.setApprovalPolicy(session.sessionKey, profile.approvalPolicy);
+        await ctx.reply(formatProfileReply(value === "on" ? "YOLO enabled." : "YOLO disabled. Restored the write preset.", profile.sandboxMode, profile.approvalPolicy));
+    });
+    bot.command("model", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const model = ctx.match.trim();
+        if (!model) {
+            await ctx.reply(`Current model: ${session.model}`);
+            return;
+        }
+        store.setModel(session.sessionKey, model);
+        await ctx.reply(`Set model: ${model}`);
+    });
+    bot.command("effort", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const value = ctx.match.trim().toLowerCase();
+        if (!value) {
+            await ctx.reply(`Current reasoning effort: ${formatReasoningEffort(session.reasoningEffort)}\nUsage: /effort default|${REASONING_EFFORTS.join("|")}`);
+            return;
+        }
+        if (value !== "default" && !isSessionReasoningEffort(value)) {
+            await ctx.reply(`Invalid reasoning effort.\nUsage: /effort default|${REASONING_EFFORTS.join("|")}`);
+            return;
+        }
+        if (value === "default") {
+            store.setReasoningEffort(session.sessionKey, null);
+        }
+        else {
+            store.setReasoningEffort(session.sessionKey, value);
+        }
+        await ctx.reply(`Set reasoning effort: ${value === "default" ? "codex-default" : value}`);
+    });
+    bot.command("web", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const value = ctx.match.trim().toLowerCase();
+        if (!value) {
+            await ctx.reply(`Current web search: ${session.webSearchMode ?? "codex-default"}\nUsage: /web default|${WEB_SEARCH_MODES.join("|")}`);
+            return;
+        }
+        if (value !== "default" && !isSessionWebSearchMode(value)) {
+            await ctx.reply(`Invalid web search mode.\nUsage: /web default|${WEB_SEARCH_MODES.join("|")}`);
+            return;
+        }
+        store.setWebSearchMode(session.sessionKey, value === "default" ? null : value);
+        await ctx.reply(`Set web search: ${value === "default" ? "codex-default" : value}`);
+    });
+    bot.command("network", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const value = ctx.match.trim().toLowerCase();
+        if (!value) {
+            await ctx.reply(`Current network access: ${session.networkAccessEnabled ? "on" : "off"}\nUsage: /network on|off`);
+            return;
+        }
+        if (value !== "on" && value !== "off") {
+            await ctx.reply("Usage: /network on|off");
+            return;
+        }
+        store.setNetworkAccessEnabled(session.sessionKey, value === "on");
+        await ctx.reply(`Set network access: ${value}`);
+    });
+    bot.command("gitcheck", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const value = ctx.match.trim().toLowerCase();
+        if (!value) {
+            await ctx.reply(`Current git repo check: ${session.skipGitRepoCheck ? "skip" : "enforce"}\nUsage: /gitcheck skip|enforce`);
+            return;
+        }
+        if (value !== "skip" && value !== "enforce") {
+            await ctx.reply("Usage: /gitcheck skip|enforce");
+            return;
+        }
+        store.setSkipGitRepoCheck(session.sessionKey, value === "skip");
+        await ctx.reply(`Set git repo check: ${value}`);
+    });
+    bot.command("adddir", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const [command, ...rest] = ctx.match.trim().split(/\s+/).filter(Boolean);
+        const args = rest.join(" ");
+        if (!command || command === "list") {
+            await ctx.reply(session.additionalDirectories.length === 0
+                ? "additional directories: none\nUsage: /adddir add <absolute-path> | /adddir drop <index> | /adddir clear"
+                : [
+                    "additional directories:",
+                    ...session.additionalDirectories.map((directory, index) => `${index + 1}. ${directory}`),
+                    "Usage: /adddir add <absolute-path> | /adddir drop <index> | /adddir clear",
+                ].join("\n"));
+            return;
+        }
+        if (command === "add") {
+            if (!args) {
+                await ctx.reply("Usage: /adddir add <absolute-path>");
+                return;
+            }
+            try {
+                const directory = resolveExistingDirectory(args);
+                const next = [...session.additionalDirectories.filter((entry) => entry !== directory), directory];
+                store.setAdditionalDirectories(session.sessionKey, next);
+                await ctx.reply(`Added additional directory:\n${directory}`);
+            }
+            catch (error) {
+                await ctx.reply(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        if (command === "drop") {
+            const index = Number(args);
+            if (!Number.isInteger(index) || index <= 0 || index > session.additionalDirectories.length) {
+                await ctx.reply("Usage: /adddir drop <index>");
+                return;
+            }
+            const next = session.additionalDirectories.filter((_entry, entryIndex) => entryIndex !== index - 1);
+            store.setAdditionalDirectories(session.sessionKey, next);
+            await ctx.reply(`Removed additional directory #${index}.`);
+            return;
+        }
+        if (command === "clear") {
+            store.setAdditionalDirectories(session.sessionKey, []);
+            await ctx.reply("Cleared additional directories.");
+            return;
+        }
+        await ctx.reply("Usage: /adddir list | /adddir add <absolute-path> | /adddir drop <index> | /adddir clear");
+    });
+    bot.command("schema", async (ctx) => {
+        const session = getScopedSession(ctx, store, projects, config);
+        if (!session)
+            return;
+        const raw = ctx.match.trim();
+        if (!raw || raw === "show") {
+            await ctx.reply(session.outputSchema ? `Current output schema:\n${session.outputSchema}` : "Current output schema: none\nUsage: /schema set <JSON object> | /schema clear");
+            return;
+        }
+        if (raw === "clear") {
+            store.setOutputSchema(session.sessionKey, null);
+            await ctx.reply("Cleared output schema.");
+            return;
+        }
+        if (!raw.startsWith("set ")) {
+            await ctx.reply("Usage: /schema show | /schema set <JSON object> | /schema clear");
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw.slice(4).trim());
+            if (!isPlainObject(parsed)) {
+                await ctx.reply("Output schema must be a JSON object.");
+                return;
+            }
+            const normalized = JSON.stringify(parsed);
+            store.setOutputSchema(session.sessionKey, normalized);
+            await ctx.reply(`Set output schema:\n${normalized}`);
+        }
+        catch (error) {
+            await ctx.reply(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    bot.command("codexconfig", async (ctx) => {
+        const raw = ctx.match.trim();
+        if (!raw || raw === "show") {
+            const current = store.getAppState("codex_config_overrides");
+            await ctx.reply(current ? `Current Codex config overrides:\n${current}` : "Current Codex config overrides: none\nUsage: /codexconfig set <JSON object> | /codexconfig clear");
+            return;
+        }
+        if (raw === "clear") {
+            store.deleteAppState("codex_config_overrides");
+            codex.setConfigOverrides(undefined);
+            await ctx.reply("Cleared Codex config overrides. They will apply to future runs.");
+            return;
+        }
+        if (!raw.startsWith("set ")) {
+            await ctx.reply("Usage: /codexconfig show | /codexconfig set <JSON object> | /codexconfig clear");
+            return;
+        }
+        try {
+            const configOverrides = parseCodexConfigOverrides(raw.slice(4).trim());
+            const serialized = JSON.stringify(configOverrides);
+            store.setAppState("codex_config_overrides", serialized);
+            codex.setConfigOverrides(configOverrides);
+            await ctx.reply(`Set Codex config overrides. They will apply to future runs.\n${serialized}`);
+        }
+        catch (error) {
+            await ctx.reply(error instanceof Error ? error.message : String(error));
+        }
+    });
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseCodexConfigOverrides(raw) {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+        throw new Error("Codex config overrides must be a JSON object.");
+    }
+    assertCodexConfigValue(parsed, "config");
+    return parsed;
+}
+function assertCodexConfigValue(value, path) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return;
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            assertCodexConfigValue(value[index], `${path}[${index}]`);
+        }
+        return;
+    }
+    if (isPlainObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            if (!key)
+                throw new Error("Codex config override key cannot be empty.");
+            assertCodexConfigValue(child, `${path}.${key}`);
+        }
+        return;
+    }
+    throw new Error(`${path} may only contain string, number, boolean, array, or object values.`);
+}