@messenger-agent/codex-agent 0.24.0-alpha.2

package/dist/config.js

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { z } from "zod";
+import { normalizeOptional, parseAgentAuthConfig, parseAgentWorkspacesConfig, parseGitInitConfig, } from "@messenger-agent/shared/agent-config";
+import { logger, normalizeLogLevel, setLogFile, setLogLevel } from "@messenger-agent/shared/logger";
+const defaultTunnelServerUrl = "wss://m.elevo.vip/agent-bridge/tunnel";
+const defaultCodexBaseUrl = "https://m.elevo.vip/agent-bridge/llm/v1";
+const RawConfigSchema = z
+    .object({
+    log_level: z.string().optional(),
+    port: z.coerce.number().int().positive().optional(),
+    auth_tokens: z.record(z.string(), z.string()).optional(),
+    workspaces: z
+        .array(z.object({
+        id: z.string().optional(),
+        name: z.string().optional(),
+        path: z.string().optional(),
+    }))
+        .optional(),
+    file_uploads: z
+        .object({
+        temp_dir: z.string().optional(),
+    })
+        .optional(),
+    data_dir: z.string().optional(),
+    codex: z
+        .object({
+        port: z.coerce.number().int().positive().optional(),
+        data_dir: z.string().optional(),
+        file_uploads: z.object({ temp_dir: z.string().optional() }).optional(),
+        api_key: z.string().optional(),
+        base_url: z.string().optional(),
+    })
+        .optional(),
+    openai: z
+        .object({
+        api_key: z.string().optional(),
+        base_url: z.string().optional(),
+        image_model: z.string().optional(),
+    })
+        .optional(),
+    gitlab: z
+        .object({
+        ca_cert_path: z.string().optional(),
+        host: z.string().optional(),
+    })
+        .optional(),
+    git: z
+        .object({
+        co_authors: z.array(z.string()).optional(),
+    })
+        .optional(),
+    tunnel: z
+        .object({
+        enabled: z.boolean().optional(),
+        server_url: z.string().optional(),
+        tunnel_id: z.string().optional(),
+        token: z.string().optional(),
+        reconnect_initial_ms: z.number().int().positive().optional(),
+        reconnect_max_ms: z.number().int().positive().optional(),
+        heartbeat_interval_ms: z.number().int().positive().optional(),
+    })
+        .optional(),
+})
+    .loose();
+function loadConfig() {
+    const configPath = process.env.AGENT_CONFIG_PATH ?? "./agent-config.yaml";
+    if (!existsSync(configPath)) {
+        const dataDir = "./data";
+        const logFile = join(dataDir, "logs", "codex-agent.log");
+        setLogLevel("info");
+        setLogFile(logFile);
+        logger.warn(`Config file not found at ${configPath}`);
+        return {
+            configPath,
+            logLevel: "info",
+            logFile,
+            port: 3000,
+            fileUploads: { tempDir: join(tmpdir(), "codex-agent-uploads") },
+            dataDir,
+            sessionsDbPath: join(dataDir, "sessions.db"),
+            codex: {},
+            openai: { imageModel: "gpt-image-2" },
+            tunnel: {
+                enabled: false,
+                reconnectInitialMs: 1000,
+                reconnectMaxMs: 30000,
+                heartbeatIntervalMs: 30000,
+            },
+            ...parseAgentAuthConfig({}),
+            ...parseAgentWorkspacesConfig({}),
+            ...parseGitInitConfig({}),
+        };
+    }
+    let parsedYaml;
+    try {
+        parsedYaml = parse(readFileSync(configPath, "utf-8"));
+    }
+    catch (err) {
+        logger.error(`Failed to parse config file at ${configPath}:`, err);
+        parsedYaml = {};
+    }
+    const raw = RawConfigSchema.safeParse(parsedYaml ?? {});
+    if (!raw.success) {
+        logger.error(`Invalid config format at ${configPath}:`, raw.error.issues);
+    }
+    const data = raw.success ? raw.data : {};
+    const logLevel = normalizeLogLevel(data.log_level);
+    const dataDir = normalizeOptional(data.codex?.data_dir) ?? normalizeOptional(data.data_dir) ?? "./data";
+    const logFile = join(dataDir, "logs", "codex-agent.log");
+    const tunnelEnabled = data.tunnel?.enabled ?? false;
+    const tunnelToken = normalizeOptional(data.tunnel?.token);
+    setLogLevel(logLevel);
+    setLogFile(logFile);
+    const config = {
+        configPath,
+        logLevel,
+        logFile,
+        port: data.codex?.port ?? data.port ?? 3000,
+        fileUploads: {
+            tempDir: normalizeOptional(data.codex?.file_uploads?.temp_dir) ??
+                normalizeOptional(data.file_uploads?.temp_dir) ??
+                join(tmpdir(), "codex-agent-uploads"),
+        },
+        dataDir,
+        sessionsDbPath: join(dataDir, "sessions.db"),
+        codex: {
+            apiKey: normalizeOptional(data.codex?.api_key) ?? (tunnelEnabled ? tunnelToken : undefined),
+            baseUrl: normalizeOptional(data.codex?.base_url) ?? (tunnelEnabled ? defaultCodexBaseUrl : undefined),
+        },
+        openai: {
+            apiKey: normalizeOptional(data.openai?.api_key) ?? (tunnelEnabled ? tunnelToken : undefined),
+            baseUrl: normalizeOptional(data.openai?.base_url) ?? (tunnelEnabled ? defaultCodexBaseUrl : undefined),
+            imageModel: normalizeOptional(data.openai?.image_model) ?? "gpt-image-2",
+        },
+        tunnel: {
+            enabled: tunnelEnabled,
+            serverUrl: normalizeOptional(data.tunnel?.server_url) ?? (tunnelEnabled ? defaultTunnelServerUrl : undefined),
+            tunnelId: normalizeOptional(data.tunnel?.tunnel_id),
+            token: tunnelToken,
+            reconnectInitialMs: data.tunnel?.reconnect_initial_ms ?? 1000,
+            reconnectMaxMs: data.tunnel?.reconnect_max_ms ?? 30000,
+            heartbeatIntervalMs: data.tunnel?.heartbeat_interval_ms ?? 30000,
+        },
+        ...parseAgentAuthConfig(data),
+        ...parseAgentWorkspacesConfig(data),
+        ...parseGitInitConfig(data),
+    };
+    logger.info(`Loaded agent config from ${configPath}`);
+    return config;
+}
+export const appConfig = loadConfig();

package/dist/db.d.ts

@@ -0,0 +1,10 @@
+export type SessionRow = {
+    sessionId: string;
+    workdir: string;
+    createdAt: number;
+    botName: string;
+    llmProxyBinding?: string;
+};
+export declare function persistSession(row: SessionRow): void;
+export declare function loadAllSessions(): SessionRow[];
+export declare function getSession(sessionId: string): SessionRow | undefined;

package/dist/db.js

@@ -0,0 +1,32 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { appConfig } from "./config.js";
+const DB_PATH = appConfig.sessionsDbPath;
+mkdirSync(dirname(DB_PATH), { recursive: true });
+const db = new DatabaseSync(DB_PATH);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS sessions (
+    sessionId  TEXT PRIMARY KEY,
+    workdir    TEXT NOT NULL,
+    createdAt  INTEGER NOT NULL,
+    botName    TEXT NOT NULL DEFAULT 'main',
+    llmProxyBinding TEXT
+  )
+`);
+const sessionColumns = db.prepare("PRAGMA table_info(sessions)").all();
+if (!sessionColumns.some((column) => column.name === "llmProxyBinding")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN llmProxyBinding TEXT");
+}
+const stmtInsert = db.prepare(`INSERT OR REPLACE INTO sessions (sessionId, workdir, createdAt, botName, llmProxyBinding) VALUES (?, ?, ?, ?, ?)`);
+const stmtGetAll = db.prepare(`SELECT * FROM sessions`);
+const stmtGet = db.prepare(`SELECT * FROM sessions WHERE sessionId = ?`);
+export function persistSession(row) {
+    stmtInsert.run(row.sessionId, row.workdir, row.createdAt, row.botName, row.llmProxyBinding ?? null);
+}
+export function loadAllSessions() {
+    return stmtGetAll.all();
+}
+export function getSession(sessionId) {
+    return stmtGet.get(sessionId);
+}

package/dist/dynamic-tools.d.ts

@@ -0,0 +1,14 @@
+import type { MatrixTaskEvent } from "@messenger-agent/shared/workspace-tasks";
+import type { DynamicToolCallParams, DynamicToolCallResponse, DynamicToolSpec } from "./app-server-protocol.js";
+type ManagedTaskToolContext = {
+    workspaceRoot: string;
+    threadRef?: string;
+    matrixEvent?: Omit<MatrixTaskEvent, "kind">;
+    llmProxyBinding?: string;
+};
+export declare function setManagedTaskToolContext(threadId: string, context: ManagedTaskToolContext): void;
+export declare function inheritManagedTaskToolContext(parentThreadId: string, childThreadIds: string[]): void;
+export declare function inheritManagedTaskToolContextFromNotification(method: string, params: unknown): void;
+export declare function dynamicToolSpecs(): DynamicToolSpec[];
+export declare function handleDynamicToolCall(params: DynamicToolCallParams): Promise<DynamicToolCallResponse>;
+export {};

package/dist/dynamic-tools.js

@@ -0,0 +1,172 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { generateImage } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { Agent, fetch as undiciFetch } from "undici";
+import { z } from "zod";
+import { executeManagedTaskTool, isManagedTaskToolName, MANAGED_TASK_TOOL_DEFINITIONS, } from "@messenger-agent/shared/managed-task-tools";
+import { AgentFileError, resolveAgentFilePath } from "@messenger-agent/shared/agent-files";
+const GENERATE_IMAGE_TIMEOUT_MS = 20 * 60 * 1000;
+const generateImageDispatcher = new Agent({
+    headersTimeout: GENERATE_IMAGE_TIMEOUT_MS,
+    bodyTimeout: GENERATE_IMAGE_TIMEOUT_MS,
+});
+const generateImageFetch = (input, init) => undiciFetch(input, {
+    ...init,
+    dispatcher: generateImageDispatcher,
+});
+const GenerateImageArgsSchema = z.object({
+    prompt: z.string().describe("The text prompt describing the image to generate"),
+    store_path: z
+        .string()
+        .describe("Absolute file path (including filename) to save the image. If omitted, saves to the current working directory with an auto-generated name.")
+        .optional(),
+    size: z
+        .enum(["1024x1024", "1536x1024", "1024x1536"])
+        .describe("Image size. Leave it undefined to use the auto size.")
+        .optional(),
+});
+const SendFileArgsSchema = z.object({
+    path: z
+        .string()
+        .describe("File to send. Absolute paths use the system path; relative paths resolve from the active workspace."),
+});
+const generateImageInputSchema = z.toJSONSchema(GenerateImageArgsSchema);
+const sendFileInputSchema = z.toJSONSchema(SendFileArgsSchema);
+function taskToolResponse(data) {
+    return { contentItems: [{ type: "inputText", text: JSON.stringify(data) }], success: true };
+}
+const taskToolContexts = new Map();
+export function setManagedTaskToolContext(threadId, context) {
+    const threadRef = context.threadRef?.trim();
+    taskToolContexts.set(threadId, {
+        workspaceRoot: context.workspaceRoot,
+        ...(threadRef ? { threadRef } : null),
+        ...(context.matrixEvent ? { matrixEvent: context.matrixEvent } : null),
+        ...(context.llmProxyBinding ? { llmProxyBinding: context.llmProxyBinding } : null),
+    });
+}
+export function inheritManagedTaskToolContext(parentThreadId, childThreadIds) {
+    const context = taskToolContexts.get(parentThreadId);
+    if (!context)
+        return;
+    for (const childThreadId of childThreadIds) {
+        if (childThreadId && childThreadId !== parentThreadId) {
+            setManagedTaskToolContext(childThreadId, context);
+        }
+    }
+}
+export function inheritManagedTaskToolContextFromNotification(method, params) {
+    if (method !== "item/started" && method !== "item/completed")
+        return;
+    if (!params || typeof params !== "object")
+        return;
+    const record = params;
+    const item = record.item;
+    if (!item || typeof item !== "object")
+        return;
+    const itemRecord = item;
+    if (itemRecord.type === "subAgentActivity" &&
+        itemRecord.kind === "started" &&
+        typeof record.threadId === "string" &&
+        typeof itemRecord.agentThreadId === "string") {
+        inheritManagedTaskToolContext(record.threadId, [itemRecord.agentThreadId]);
+        return;
+    }
+    if (itemRecord.type === "collabAgentToolCall" &&
+        itemRecord.tool === "spawnAgent" &&
+        typeof itemRecord.senderThreadId === "string" &&
+        Array.isArray(itemRecord.receiverThreadIds)) {
+        inheritManagedTaskToolContext(itemRecord.senderThreadId, itemRecord.receiverThreadIds.filter((threadId) => typeof threadId === "string"));
+    }
+}
+async function workspaceRootForTasks(threadId) {
+    const context = taskToolContexts.get(threadId);
+    if (context)
+        return context.workspaceRoot;
+    const { sessionManager } = await import("./codex.js");
+    const workdir = sessionManager.workdirFor(threadId);
+    if (!workdir) {
+        throw new Error(`No workspace context for thread ${threadId}; the session may not exist in this process`);
+    }
+    return workdir;
+}
+async function loadOpenAIConfig(threadId) {
+    const { appConfig } = await import("./config.js");
+    if (!appConfig.openai.apiKey) {
+        throw new Error("Missing openai.api_key in LLM config");
+    }
+    return {
+        apiKey: appConfig.openai.apiKey,
+        baseURL: appConfig.openai.baseUrl,
+        imageModel: appConfig.openai.imageModel,
+        llmProxyBinding: taskToolContexts.get(threadId)?.llmProxyBinding,
+    };
+}
+export function dynamicToolSpecs() {
+    return [
+        {
+            name: "generate_image",
+            description: "Generate an image from a text prompt. The image is saved to the specified path (absolute path including filename) or the current working directory if not specified. Returns the saved file path.",
+            inputSchema: generateImageInputSchema,
+        },
+        {
+            name: "send_file",
+            description: "Send any readable file to the client. Absolute paths use the system path; relative paths resolve from the active workspace. The agent runtime captures this tool call and performs the actual send.",
+            inputSchema: sendFileInputSchema,
+        },
+        ...MANAGED_TASK_TOOL_DEFINITIONS.map((definition) => ({
+            name: definition.name,
+            description: definition.description,
+            inputSchema: definition.inputSchema,
+        })),
+    ];
+}
+export async function handleDynamicToolCall(params) {
+    try {
+        if (params.tool === "generate_image") {
+            const args = GenerateImageArgsSchema.parse(params.arguments);
+            const config = await loadOpenAIConfig(params.threadId);
+            const openai = createOpenAI({
+                apiKey: config.apiKey,
+                baseURL: config.baseURL,
+                fetch: generateImageFetch,
+                ...(config.llmProxyBinding ? { headers: { "X-Elevo-LLM-Binding": config.llmProxyBinding } } : null),
+            });
+            const { image } = await generateImage({
+                model: openai.image(config.imageModel),
+                prompt: args.prompt,
+                size: args.size,
+                maxRetries: 0,
+                abortSignal: AbortSignal.timeout(GENERATE_IMAGE_TIMEOUT_MS),
+            });
+            const filePath = args.store_path
+                ? path.resolve(args.store_path)
+                : path.join(process.cwd(), `generated_${Date.now()}.png`);
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, Buffer.from(image.uint8Array));
+            return { contentItems: [{ type: "inputText", text: filePath }], success: true };
+        }
+        if (params.tool === "send_file") {
+            const args = SendFileArgsSchema.parse(params.arguments);
+            const filePath = await resolveAgentFilePath(args.path, await workspaceRootForTasks(params.threadId));
+            return {
+                contentItems: [{ type: "inputText", text: JSON.stringify({ path: filePath }) }],
+                success: true,
+            };
+        }
+        if (isManagedTaskToolName(params.tool)) {
+            const result = await executeManagedTaskTool(await workspaceRootForTasks(params.threadId), params.tool, params.arguments, taskToolContexts.get(params.threadId));
+            return taskToolResponse(result);
+        }
+        throw new Error(`Unknown dynamic tool: ${params.tool}`);
+    }
+    catch (err) {
+        const message = err instanceof AgentFileError && err.code === "INVALID_PATH"
+            ? err.message
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        return { contentItems: [{ type: "inputText", text: message }], success: false };
+    }
+}

package/dist/git-init.d.ts

@@ -0,0 +1 @@
+export { initGit, initGitCoAuthorsHook, initGitLab, initGitProxy } from "@messenger-agent/shared/git-init";

package/dist/git-init.js

@@ -0,0 +1 @@
+export { initGit, initGitCoAuthorsHook, initGitLab, initGitProxy } from "@messenger-agent/shared/git-init";

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,19 @@
+import { serve } from "@hono/node-server";
+import app from "./app.js";
+import { appConfig } from "./config.js";
+import { initGit } from "./git-init.js";
+import { startCodexTunnelClient } from "./tunnel-client.js";
+import { logger } from "@messenger-agent/shared/logger";
+const port = appConfig.port;
+try {
+    await initGit(appConfig);
+}
+catch (err) {
+    logger.warn("Git initialization failed; continuing agent startup:", err);
+}
+const tunnelClient = startCodexTunnelClient(appConfig.tunnel);
+if (!tunnelClient) {
+    serve({ fetch: app.fetch, port }, () => {
+        logger.info(`codex-agent listening on http://0.0.0.0:${port}`);
+    });
+}

package/dist/platform-instructions.d.ts

@@ -0,0 +1,2 @@
+export declare function loadCodexPlatformInstructions(templatePath?: string): string;
+export declare const codexPlatformInstructions: string;

package/dist/platform-instructions.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { logger } from "@messenger-agent/shared/logger";
+const DEFAULT_TEMPLATE_PATHS = [
+    fileURLToPath(new URL("./assets/codex-home/AGENTS.md", import.meta.url)),
+    fileURLToPath(new URL("../../../assets/codex-home/AGENTS.md", import.meta.url)),
+    "/app/assets/codex-home/AGENTS.md",
+];
+const CODEX_MANAGED_TASK_TOOLS = `## Codex Managed Task Tools
+
+When using managed task tools in Codex, call these tool names directly: \`search_managed_tasks\`, \`get_managed_task\`, \`create_managed_task\`, \`update_managed_task\`, \`apply_managed_task_patch\`, and \`delete_managed_task\`.
+`;
+export function loadCodexPlatformInstructions(templatePath) {
+    const path = [templatePath ?? process.env.CODEX_AGENTS_TEMPLATE_PATH, ...DEFAULT_TEMPLATE_PATHS].find((candidate) => Boolean(candidate && existsSync(candidate)));
+    if (!path) {
+        logger.warn("Codex platform instructions template not found");
+        return CODEX_MANAGED_TASK_TOOLS;
+    }
+    return `${readFileSync(path, "utf-8").trimEnd()}\n\n${CODEX_MANAGED_TASK_TOOLS}`;
+}
+export const codexPlatformInstructions = loadCodexPlatformInstructions();

package/dist/prompts/plan-mode-system-reminder.txt

@@ -0,0 +1,26 @@
+<system-reminder>
+# Plan Mode - System Reminder
+
+CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
+ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
+or ANY other bash command to manipulate files - commands may ONLY read/inspect.
+This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
+edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
+is a critical violation. ZERO exceptions.
+
+---
+
+## Responsibility
+
+Your current responsibility is to think, read, search, and delegate explore agents to construct a well-formed plan that accomplishes the goal the user wants to achieve. Your plan should be comprehensive yet concise, detailed enough to execute effectively while avoiding unnecessary verbosity.
+
+Ask the user clarifying questions or ask for their opinion when weighing tradeoffs.
+
+**NOTE:** At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.
+
+---
+
+## Important
+
+The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
+</system-reminder>

package/dist/prompts/question-tool-description.txt

@@ -0,0 +1,12 @@
+Use this tool when you need to ask the user questions during execution. This allows you to:
+1. Gather user preferences or requirements
+2. Clarify ambiguous instructions
+3. Get decisions on implementation choices as you work
+4. Offer choices to the user about what direction to take.
+
+Important: This tool returns immediately; it does not block or wait for the user's answer. After calling this tool, immediately stop and wait for the user to reply in the next message before continuing.
+
+Usage notes:
+- By default, a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned in the user's next message; set `multiple: true` to allow selecting more than one
+- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label

package/dist/routes/chat.d.ts

@@ -0,0 +1,27 @@
+import { Hono } from "hono";
+import { type ChatBody } from "../schemas.js";
+declare const chat: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function codexActivitySnapshot(): {
+    active: number;
+    waiting: number;
+};
+export declare class ChatRequestError extends Error {
+    readonly status: 400 | 409;
+    constructor(status: 400 | 409, message: string);
+}
+export type ChatStreamRequest = {
+    body: ChatBody;
+    headers?: Headers;
+    signal?: AbortSignal;
+};
+export type ChatStreamWriter = {
+    writeData(data: unknown): Promise<void>;
+    writeDone(): Promise<void>;
+};
+export type PreparedChatStream = {
+    run(writer: ChatStreamWriter, signal?: AbortSignal): Promise<void>;
+};
+export declare function cancelCodexConversation(conversationId: string): Promise<boolean>;
+export declare function prepareCodexChatStream({ body, headers }: ChatStreamRequest): Promise<PreparedChatStream>;
+export declare function handleCodexChatStream({ body, headers, signal }: ChatStreamRequest, writer: ChatStreamWriter): Promise<void>;
+export default chat;