codex-devtools 0.1.1

package/dist-electron/main/index.cjs

@@ -0,0 +1,250 @@
+"use strict";
+const electron = require("electron");
+const fs = require("node:fs");
+const path = require("node:path");
+const CodexServiceContext = require("./chunks/CodexServiceContext-CRkTP14W.cjs");
+require("node:os");
+require("node:events");
+require("node:buffer");
+require("node:readline");
+const IPC_CHANNELS = {
+  SESSIONS_GET_PROJECTS: "get-projects",
+  SESSIONS_GET_SESSIONS: "get-sessions",
+  SESSIONS_GET_DETAIL: "get-session-detail",
+  SESSIONS_GET_CHUNKS: "get-session-chunks",
+  SEARCH_SESSIONS: "search-sessions",
+  CONFIG_GET: "config:get",
+  CONFIG_UPDATE: "config:update",
+  UTILITY_GET_APP_VERSION: "get-app-version",
+  EVENTS_FILE_CHANGE: "file-change"
+};
+const logger$5 = CodexServiceContext.createLogger("IPC:config");
+let serviceContext$3;
+function initializeConfigHandlers(context) {
+  serviceContext$3 = context;
+}
+function registerConfigHandlers(ipcMain) {
+  ipcMain.handle(IPC_CHANNELS.CONFIG_GET, handleGetConfig);
+  ipcMain.handle(IPC_CHANNELS.CONFIG_UPDATE, handleUpdateConfig);
+  logger$5.info("Config handlers registered");
+}
+function removeConfigHandlers(ipcMain) {
+  ipcMain.removeHandler(IPC_CHANNELS.CONFIG_GET);
+  ipcMain.removeHandler(IPC_CHANNELS.CONFIG_UPDATE);
+  logger$5.info("Config handlers removed");
+}
+async function handleGetConfig(_event) {
+  return serviceContext$3.getConfig();
+}
+async function handleUpdateConfig(_event, key, value) {
+  try {
+    return serviceContext$3.updateConfig(key, value);
+  } catch (error) {
+    logger$5.error(`Error in config:update for key ${String(key)}`, error);
+    return null;
+  }
+}
+const logger$4 = CodexServiceContext.createLogger("IPC:search");
+let serviceContext$2;
+function initializeSearchHandlers(context) {
+  serviceContext$2 = context;
+}
+function registerSearchHandlers(ipcMain) {
+  ipcMain.handle(IPC_CHANNELS.SEARCH_SESSIONS, handleSearchSessions);
+  logger$4.info("Search handlers registered");
+}
+function removeSearchHandlers(ipcMain) {
+  ipcMain.removeHandler(IPC_CHANNELS.SEARCH_SESSIONS);
+  logger$4.info("Search handlers removed");
+}
+async function handleSearchSessions(_event, query) {
+  try {
+    return await serviceContext$2.searchSessions(query);
+  } catch (error) {
+    logger$4.error("Error in search-sessions", error);
+    return {
+      query,
+      totalMatches: 0,
+      sessionsSearched: 0,
+      results: []
+    };
+  }
+}
+const logger$3 = CodexServiceContext.createLogger("IPC:sessions");
+let serviceContext$1;
+function initializeSessionHandlers(context) {
+  serviceContext$1 = context;
+}
+function registerSessionHandlers(ipcMain) {
+  ipcMain.handle(IPC_CHANNELS.SESSIONS_GET_PROJECTS, handleGetProjects);
+  ipcMain.handle(IPC_CHANNELS.SESSIONS_GET_SESSIONS, handleGetSessions);
+  ipcMain.handle(IPC_CHANNELS.SESSIONS_GET_DETAIL, handleGetSessionDetail);
+  ipcMain.handle(IPC_CHANNELS.SESSIONS_GET_CHUNKS, handleGetSessionChunks);
+  logger$3.info("Session handlers registered");
+}
+function removeSessionHandlers(ipcMain) {
+  ipcMain.removeHandler(IPC_CHANNELS.SESSIONS_GET_PROJECTS);
+  ipcMain.removeHandler(IPC_CHANNELS.SESSIONS_GET_SESSIONS);
+  ipcMain.removeHandler(IPC_CHANNELS.SESSIONS_GET_DETAIL);
+  ipcMain.removeHandler(IPC_CHANNELS.SESSIONS_GET_CHUNKS);
+  logger$3.info("Session handlers removed");
+}
+async function handleGetProjects(_event) {
+  try {
+    return await serviceContext$1.getProjects();
+  } catch (error) {
+    logger$3.error("Error in get-projects", error);
+    return [];
+  }
+}
+async function handleGetSessions(_event, projectCwd) {
+  try {
+    return await serviceContext$1.getSessions(projectCwd);
+  } catch (error) {
+    logger$3.error(`Error in get-sessions for ${projectCwd}`, error);
+    return [];
+  }
+}
+async function handleGetSessionDetail(_event, sessionId) {
+  try {
+    return await serviceContext$1.getSessionDetail(sessionId);
+  } catch (error) {
+    logger$3.error(`Error in get-session-detail for ${sessionId}`, error);
+    return null;
+  }
+}
+async function handleGetSessionChunks(_event, sessionId) {
+  try {
+    return await serviceContext$1.getSessionChunks(sessionId);
+  } catch (error) {
+    logger$3.error(`Error in get-session-chunks for ${sessionId}`, error);
+    return null;
+  }
+}
+const logger$2 = CodexServiceContext.createLogger("IPC:utility");
+let getAppVersion = () => "0.0.0";
+function initializeUtilityHandlers(options = {}) {
+  if (options.getVersion) {
+    getAppVersion = options.getVersion;
+  }
+}
+function registerUtilityHandlers(ipcMain) {
+  ipcMain.handle(IPC_CHANNELS.UTILITY_GET_APP_VERSION, handleGetAppVersion);
+  logger$2.info("Utility handlers registered");
+}
+function removeUtilityHandlers(ipcMain) {
+  ipcMain.removeHandler(IPC_CHANNELS.UTILITY_GET_APP_VERSION);
+  logger$2.info("Utility handlers removed");
+}
+function handleGetAppVersion(_event) {
+  try {
+    return getAppVersion();
+  } catch (error) {
+    logger$2.error("Error in get-app-version", error);
+    return "0.0.0";
+  }
+}
+const logger$1 = CodexServiceContext.createLogger("IPC:handlers");
+const initializeIpcHandlers = (serviceContext2, targetIpcMain, options = {}) => {
+  initializeSessionHandlers(serviceContext2);
+  initializeSearchHandlers(serviceContext2);
+  initializeConfigHandlers(serviceContext2);
+  initializeUtilityHandlers({ getVersion: options.getVersion });
+  registerSessionHandlers(targetIpcMain);
+  registerSearchHandlers(targetIpcMain);
+  registerConfigHandlers(targetIpcMain);
+  registerUtilityHandlers(targetIpcMain);
+  logger$1.info("All handlers registered");
+};
+const removeIpcHandlers = (targetIpcMain) => {
+  removeSessionHandlers(targetIpcMain);
+  removeSearchHandlers(targetIpcMain);
+  removeConfigHandlers(targetIpcMain);
+  removeUtilityHandlers(targetIpcMain);
+  logger$1.info("All handlers removed");
+};
+const logger = CodexServiceContext.createLogger("Main");
+let mainWindow = null;
+let serviceContext = null;
+let removeFileChangeListener = null;
+function getRendererIndexPath() {
+  const candidates = [
+    path.join(__dirname, "../../out/renderer/index.html"),
+    path.join(__dirname, "../renderer/index.html")
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) ?? candidates[0];
+}
+const createWindow = () => {
+  const window = new electron.BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.cjs"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  if (process.env.ELECTRON_RENDERER_URL) {
+    void window.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    void window.loadFile(getRendererIndexPath());
+  }
+  return window;
+};
+function wireFileWatcherEvents() {
+  if (!serviceContext) {
+    return;
+  }
+  if (removeFileChangeListener) {
+    removeFileChangeListener();
+    removeFileChangeListener = null;
+  }
+  removeFileChangeListener = serviceContext.onFileChange((event) => {
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.webContents.send(IPC_CHANNELS.EVENTS_FILE_CHANGE, event);
+    }
+  });
+}
+function initializeServices() {
+  serviceContext = new CodexServiceContext.CodexServiceContext({
+    sessionsPath: process.env.CODEX_SESSIONS_PATH
+  });
+  serviceContext.start();
+  wireFileWatcherEvents();
+  initializeIpcHandlers(serviceContext, electron.ipcMain, { getVersion: () => electron.app.getVersion() });
+}
+function disposeServices() {
+  if (removeFileChangeListener) {
+    removeFileChangeListener();
+    removeFileChangeListener = null;
+  }
+  removeIpcHandlers(electron.ipcMain);
+  if (serviceContext) {
+    serviceContext.dispose();
+    serviceContext = null;
+  }
+}
+void electron.app.whenReady().then(() => {
+  initializeServices();
+  mainWindow = createWindow();
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) {
+      mainWindow = createWindow();
+      wireFileWatcherEvents();
+    }
+  });
+});
+electron.app.on("before-quit", () => {
+  disposeServices();
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});
+process.on("unhandledRejection", (reason) => {
+  logger.error("Unhandled promise rejection in main process", reason);
+});
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught exception in main process", error);
+});

package/dist-electron/main/standalone.cjs

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fastifyCors = require("@fastify/cors");
+const fastifyStatic = require("@fastify/static");
+const Fastify = require("fastify");
+const path = require("node:path");
+const node_url = require("node:url");
+const CodexServiceContext = require("./chunks/CodexServiceContext-CRkTP14W.cjs");
+const fs = require("node:fs");
+require("node:os");
+require("node:events");
+require("node:buffer");
+require("node:readline");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const logger$6 = CodexServiceContext.createLogger("HTTP:config");
+const registerConfigRoutes = (app, services) => {
+  app.get("/config", async () => {
+    return services.getConfig();
+  });
+  app.put("/config", async (request) => {
+    try {
+      return services.updateConfig(request.body.key, request.body.value);
+    } catch (error) {
+      logger$6.error("Error in PUT /config", error);
+      return null;
+    }
+  });
+};
+const logger$5 = CodexServiceContext.createLogger("HTTP:events");
+const KEEPALIVE_INTERVAL_MS = 3e4;
+const sseClients = /* @__PURE__ */ new Set();
+const registerEventRoutes = (app) => {
+  app.get("/events", async (request, reply) => {
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    sseClients.add(reply);
+    logger$5.info(`SSE client connected (total: ${sseClients.size})`);
+    const timer = setInterval(() => {
+      reply.raw.write(":ping\n\n");
+    }, KEEPALIVE_INTERVAL_MS);
+    request.raw.on("close", () => {
+      clearInterval(timer);
+      sseClients.delete(reply);
+      logger$5.info(`SSE client disconnected (total: ${sseClients.size})`);
+    });
+    await reply;
+  });
+};
+const broadcastEvent = (channel, data) => {
+  const payload = `event: ${channel}
+data: ${JSON.stringify(data)}
+
+`;
+  for (const client of sseClients) {
+    try {
+      client.raw.write(payload);
+    } catch {
+      sseClients.delete(client);
+    }
+  }
+};
+const broadcastFileChangeEvent = (event) => {
+  broadcastEvent("file-change", event);
+};
+const logger$4 = CodexServiceContext.createLogger("HTTP:projects");
+function decodeCwd(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+const registerProjectRoutes = (app, services) => {
+  app.get("/projects", async () => {
+    try {
+      return await services.getProjects();
+    } catch (error) {
+      logger$4.error("Error in GET /projects", error);
+      return [];
+    }
+  });
+  app.get("/projects/:cwd/sessions", async (request) => {
+    const cwd = decodeCwd(request.params.cwd);
+    try {
+      return await services.getSessions(cwd);
+    } catch (error) {
+      logger$4.error(`Error in GET /projects/${cwd}/sessions`, error);
+      return [];
+    }
+  });
+};
+const logger$3 = CodexServiceContext.createLogger("HTTP:search");
+const registerSearchRoutes = (app, services) => {
+  app.get("/search", async (request) => {
+    const query = request.query.q ?? "";
+    try {
+      return await services.searchSessions(query);
+    } catch (error) {
+      logger$3.error("Error in GET /search", error);
+      return {
+        query,
+        totalMatches: 0,
+        sessionsSearched: 0,
+        results: []
+      };
+    }
+  });
+};
+const logger$2 = CodexServiceContext.createLogger("HTTP:sessions");
+const registerSessionRoutes = (app, services) => {
+  app.get("/sessions/:id", async (request) => {
+    try {
+      return await services.getSessionDetail(request.params.id);
+    } catch (error) {
+      logger$2.error(`Error in GET /sessions/${request.params.id}`, error);
+      return null;
+    }
+  });
+  app.get("/sessions/:id/chunks", async (request) => {
+    try {
+      return await services.getSessionChunks(request.params.id);
+    } catch (error) {
+      logger$2.error(`Error in GET /sessions/${request.params.id}/chunks`, error);
+      return null;
+    }
+  });
+};
+const readVersionFromPackageJson = () => {
+  const candidatePaths = [
+    path__namespace.resolve(__dirname, "../../package.json"),
+    path__namespace.resolve(__dirname, "../../../package.json"),
+    path__namespace.resolve(process.cwd(), "package.json")
+  ];
+  try {
+    for (const candidate of candidatePaths) {
+      if (!fs__namespace.existsSync(candidate)) {
+        continue;
+      }
+      const packageJson = JSON.parse(fs__namespace.readFileSync(candidate, "utf8"));
+      if (packageJson.version) {
+        return packageJson.version;
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+};
+const registerUtilityRoutes = (app, getVersion) => {
+  app.get("/version", async () => {
+    if (getVersion) {
+      return getVersion();
+    }
+    return readVersionFromPackageJson();
+  });
+};
+const logger$1 = CodexServiceContext.createLogger("HTTP:routes");
+const registerHttpRoutes = (app, services) => {
+  registerProjectRoutes(app, services.serviceContext);
+  registerSessionRoutes(app, services.serviceContext);
+  registerSearchRoutes(app, services.serviceContext);
+  registerConfigRoutes(app, services.serviceContext);
+  registerUtilityRoutes(app, services.getVersion);
+  registerEventRoutes(app);
+  logger$1.info("All HTTP routes registered");
+};
+const logger = CodexServiceContext.createLogger("Standalone");
+const __filename$1 = node_url.fileURLToPath(require("url").pathToFileURL(__filename).href);
+const __dirname$1 = path.dirname(__filename$1);
+const createStandaloneServer = async (options = {}) => {
+  const app = Fastify({ logger: true });
+  const serviceContext = new CodexServiceContext.CodexServiceContext({
+    sessionsPath: options.sessionsPath ?? process.env.CODEX_SESSIONS_PATH,
+    configPath: options.configPath
+  });
+  serviceContext.start();
+  const removeFileChangeListener = serviceContext.onFileChange((event) => {
+    broadcastFileChangeEvent(event);
+  });
+  app.addHook("onClose", async () => {
+    removeFileChangeListener();
+    serviceContext.dispose();
+  });
+  await app.register(fastifyCors, { origin: true });
+  await app.register(fastifyStatic, {
+    root: path.join(__dirname$1, "../../out/renderer"),
+    prefix: "/"
+  });
+  registerHttpRoutes(app, {
+    serviceContext,
+    getVersion: readVersionFromPackageJson
+  });
+  return { app, serviceContext };
+};
+const startStandalone = async () => {
+  const { app } = await createStandaloneServer();
+  const host = process.env.HOST ?? "0.0.0.0";
+  const port = Number(process.env.PORT ?? "3456");
+  await app.listen({ host, port });
+  logger.info(`Standalone server listening on http://${host}:${port}`);
+};
+const startStandaloneCli = (start = startStandalone) => {
+  void start().catch((error) => {
+    logger.error("Standalone startup failed", error);
+    process.exitCode = 1;
+  });
+};
+if (process.argv[1] && node_url.fileURLToPath(require("url").pathToFileURL(__filename).href) === process.argv[1]) {
+  startStandaloneCli();
+}
+exports.createStandaloneServer = createStandaloneServer;
+exports.startStandaloneCli = startStandaloneCli;

package/dist-electron/preload/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+const electron = require("electron");
+const IPC_CHANNELS = {
+  SESSIONS_GET_PROJECTS: "get-projects",
+  SESSIONS_GET_SESSIONS: "get-sessions",
+  SESSIONS_GET_DETAIL: "get-session-detail",
+  SESSIONS_GET_CHUNKS: "get-session-chunks",
+  SEARCH_SESSIONS: "search-sessions",
+  CONFIG_GET: "config:get",
+  CONFIG_UPDATE: "config:update",
+  UTILITY_GET_APP_VERSION: "get-app-version",
+  EVENTS_FILE_CHANGE: "file-change"
+};
+function createCodexDevtoolsApi(renderer = electron.ipcRenderer) {
+  return {
+    channels: IPC_CHANNELS,
+    getProjects: () => renderer.invoke(IPC_CHANNELS.SESSIONS_GET_PROJECTS),
+    getSessions: (projectCwd) => renderer.invoke(IPC_CHANNELS.SESSIONS_GET_SESSIONS, projectCwd),
+    getSessionDetail: (sessionId) => renderer.invoke(IPC_CHANNELS.SESSIONS_GET_DETAIL, sessionId),
+    getSessionChunks: (sessionId) => renderer.invoke(IPC_CHANNELS.SESSIONS_GET_CHUNKS, sessionId),
+    searchSessions: (query) => renderer.invoke(IPC_CHANNELS.SEARCH_SESSIONS, query),
+    getConfig: () => renderer.invoke(IPC_CHANNELS.CONFIG_GET),
+    updateConfig: (key, value) => renderer.invoke(IPC_CHANNELS.CONFIG_UPDATE, key, value),
+    getAppVersion: () => renderer.invoke(IPC_CHANNELS.UTILITY_GET_APP_VERSION),
+    onFileChange: (callback) => {
+      const listener = (_event, payload) => {
+        callback(payload);
+      };
+      renderer.on(IPC_CHANNELS.EVENTS_FILE_CHANGE, listener);
+      return () => {
+        renderer.removeListener(IPC_CHANNELS.EVENTS_FILE_CHANGE, listener);
+      };
+    }
+  };
+}
+const api = createCodexDevtoolsApi();
+electron.contextBridge.exposeInMainWorld("codexDevtools", api);