server.js

import { pathToFileURL } from "node:url";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import express from "express";
import OpenAI from "openai";
import { FileConversationStore } from "./conversation-store.js";
import { runCodexExec } from "./codex-runner.js";
import { extractModelName, extractTokenCount } from "./token-usage.js";

const DEFAULT_MODEL = "gpt-5.5";
const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
const PUBLIC_DIR = join(MODULE_DIR, "public");
const DATA_FILE = join(MODULE_DIR, "data", "conversations.json");

function isAuthorized(req, token) {
  return (req.get("Authorization") ?? "") === `Bearer ${token}`;
}

function requireCodexToken(req, res, token) {
  if (!token) {
    res.status(503).json({ error: "CODEX_API_TOKEN is not configured" });
    return false;
  }

  if (!isAuthorized(req, token)) {
    res.status(401).json({ error: "Unauthorized" });
    return false;
  }

  return true;
}

function pad2(value) {
  return String(value).padStart(2, "0");
}

function getApiCallBucketTitle(now) {
  const bucketMinute = now.getMinutes() < 30 ? 0 : 30;
  return [
    "API Calls",
    `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`,
    `${pad2(now.getHours())}:${pad2(bucketMinute)}`,
  ].join(" ");
}

function normalizeUser(user) {
  if (typeof user !== "string") {
    return "default";
  }
  const normalized = user.trim();
  return normalized || "default";
}

async function getApiCallsConversation(store, now, user) {
  const normalizedUser = normalizeUser(user);
  const title = getApiCallBucketTitle(now);
  const conversations = await store.list();
  const existing = conversations.find(
    (conversation) =>
      conversation.title === title && conversation.user === normalizedUser,
  );
  if (existing) {
    return store.get(existing.id);
  }
  return store.create(title, normalizedUser);
}

export function createApp(options = {}) {
  const app = express();
  app.use(express.json());

  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY ?? "";
  const client = options.client ?? (apiKey ? new OpenAI({ apiKey }) : null);
  const codexApiToken = options.codexApiToken ?? process.env.CODEX_API_TOKEN ?? "";
  const codexRunner = options.codexRunner ?? runCodexExec;
  const conversationStore =
    options.conversationStore ?? new FileConversationStore(DATA_FILE);
  const now = options.now ?? (() => new Date());

  app.use("/assets", express.static(PUBLIC_DIR));
  app.get("/", (_req, res) => {
    res.sendFile(join(PUBLIC_DIR, "index.html"));
  });

  app.get("/health", (_req, res) => {
    res.json({ ok: true });
  });

  app.post("/chat", async (req, res) => {
    if (!apiKey) {
      res.status(503).json({ error: "OPENAI_API_KEY is not configured" });
      return;
    }

    const message = req.body?.message;
    if (typeof message !== "string" || !message.trim()) {
      res.status(400).json({ error: "message is required" });
      return;
    }

    try {
      const response = await client.responses.create({
        model: options.model ?? DEFAULT_MODEL,
        input: message,
      });

      res.json({ text: response.output_text });
    } catch (error) {
      res.status(502).json({
        error: "OpenAI request failed",
        detail: error instanceof Error ? error.message : String(error),
      });
    }
  });

  app.post("/codex", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    const prompt = req.body?.prompt;
    if (typeof prompt !== "string" || !prompt.trim()) {
      res.status(400).json({ error: "prompt is required" });
      return;
    }

    const input = {
      prompt,
      model: req.body?.model,
      sandbox: req.body?.sandbox,
      cwd: req.body?.cwd,
      timeoutMs: req.body?.timeoutMs,
    };
    for (const [key, value] of Object.entries(input)) {
      if (value === undefined) {
        delete input[key];
      }
    }

    const result = await codexRunner(input);
    const user = normalizeUser(req.body?.user);
    const conversation = await getApiCallsConversation(conversationStore, now(), user);
    await conversationStore.addMessage(conversation.id, {
      role: "user",
      content: prompt,
      source: "api",
      user,
    });
    await conversationStore.addMessage(conversation.id, {
      role: "assistant",
      content: result.stdout || result.stderr || "",
      source: "api",
      user,
      model: extractModelName(result) || input.model || "default",
      tokenCount: extractTokenCount(result),
      meta: result,
    });

    const status = result.exitCode === 0 && !result.timedOut ? 200 : 502;
    res.status(status).json(result);
  });

  app.get("/api/conversations", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    res.json({ conversations: await conversationStore.list() });
  });

  app.post("/api/conversations", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    const conversation = await conversationStore.create(req.body?.title);
    res.status(201).json(conversation);
  });

  app.get("/api/conversations/:id", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    const conversation = await conversationStore.get(req.params.id);
    if (!conversation) {
      res.status(404).json({ error: "Conversation not found" });
      return;
    }
    res.json({ conversation });
  });

  app.delete("/api/conversations/:id", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    const deleted = await conversationStore.delete(req.params.id);
    if (!deleted) {
      res.status(404).json({ error: "Conversation not found" });
      return;
    }
    res.status(204).end();
  });

  app.post("/api/conversations/:id/messages", async (req, res) => {
    if (!requireCodexToken(req, res, codexApiToken)) {
      return;
    }

    const prompt = req.body?.prompt;
    if (typeof prompt !== "string" || !prompt.trim()) {
      res.status(400).json({ error: "prompt is required" });
      return;
    }

    const userConversation = await conversationStore.addMessage(req.params.id, {
      role: "user",
      content: prompt,
    });
    if (!userConversation) {
      res.status(404).json({ error: "Conversation not found" });
      return;
    }

    const input = {
      prompt,
      model: req.body?.model,
      sandbox: req.body?.sandbox,
      cwd: req.body?.cwd,
      timeoutMs: req.body?.timeoutMs,
    };
    for (const [key, value] of Object.entries(input)) {
      if (value === undefined) {
        delete input[key];
      }
    }

    const result = await codexRunner(input);
    const content = result.stdout || result.stderr || "";
    const conversation = await conversationStore.addMessage(req.params.id, {
      role: "assistant",
      content,
      model: extractModelName(result) || input.model || "default",
      tokenCount: extractTokenCount(result),
      meta: result,
    });
    const status = result.exitCode === 0 && !result.timedOut ? 200 : 502;
    res.status(status).json({ conversation, result });
  });

  return app;
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  const port = Number(process.env.PORT ?? 3000);
  createApp().listen(port, () => {
    console.log(`API listening on http://localhost:${port}`);
  });
}