@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/src/createApiServer/uiStateParsers.ts

@@ -0,0 +1,255 @@
+import { type PersistedUiState, isTerminalCompletionSoundId } from "../terminalRuntime";
+
+export const parseUiStatePatch = (
+  payload: unknown,
+): { patch: PersistedUiState | null; error: string | null } => {
+  if (payload === null || payload === undefined || typeof payload !== "object") {
+    return {
+      patch: null,
+      error: "Expected a JSON object body.",
+    };
+  }
+
+  const record = payload as Record<string, unknown>;
+  const patch: PersistedUiState = {};
+
+  if (record.activePrimaryNav !== undefined) {
+    if (
+      typeof record.activePrimaryNav !== "number" ||
+      !Number.isInteger(record.activePrimaryNav) ||
+      record.activePrimaryNav < 1
+    ) {
+      return {
+        patch: null,
+        error: "activePrimaryNav must be a positive integer.",
+      };
+    }
+    patch.activePrimaryNav = record.activePrimaryNav;
+  }
+
+  if (record.isAgentsSidebarVisible !== undefined) {
+    if (typeof record.isAgentsSidebarVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isAgentsSidebarVisible must be a boolean.",
+      };
+    }
+    patch.isAgentsSidebarVisible = record.isAgentsSidebarVisible;
+  }
+
+  if (record.sidebarWidth !== undefined) {
+    if (typeof record.sidebarWidth !== "number" || !Number.isFinite(record.sidebarWidth)) {
+      return {
+        patch: null,
+        error: "sidebarWidth must be a finite number.",
+      };
+    }
+    patch.sidebarWidth = record.sidebarWidth;
+  }
+
+  if (record.isActiveAgentsSectionExpanded !== undefined) {
+    if (typeof record.isActiveAgentsSectionExpanded !== "boolean") {
+      return {
+        patch: null,
+        error: "isActiveAgentsSectionExpanded must be a boolean.",
+      };
+    }
+    patch.isActiveAgentsSectionExpanded = record.isActiveAgentsSectionExpanded;
+  }
+
+  if (record.isRuntimeStatusStripVisible !== undefined) {
+    if (typeof record.isRuntimeStatusStripVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isRuntimeStatusStripVisible must be a boolean.",
+      };
+    }
+    patch.isRuntimeStatusStripVisible = record.isRuntimeStatusStripVisible;
+  }
+
+  if (record.isMonitorVisible !== undefined) {
+    if (typeof record.isMonitorVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isMonitorVisible must be a boolean.",
+      };
+    }
+    patch.isMonitorVisible = record.isMonitorVisible;
+  }
+
+  if (record.isBottomTelemetryVisible !== undefined) {
+    if (typeof record.isBottomTelemetryVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isBottomTelemetryVisible must be a boolean.",
+      };
+    }
+    patch.isBottomTelemetryVisible = record.isBottomTelemetryVisible;
+  }
+
+  if (record.isCodexUsageVisible !== undefined) {
+    if (typeof record.isCodexUsageVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isCodexUsageVisible must be a boolean.",
+      };
+    }
+    patch.isCodexUsageVisible = record.isCodexUsageVisible;
+  }
+
+  if (record.isClaudeUsageVisible !== undefined) {
+    if (typeof record.isClaudeUsageVisible !== "boolean") {
+      return {
+        patch: null,
+        error: "isClaudeUsageVisible must be a boolean.",
+      };
+    }
+    patch.isClaudeUsageVisible = record.isClaudeUsageVisible;
+  }
+
+  if (record.isClaudeUsageSectionExpanded !== undefined) {
+    if (typeof record.isClaudeUsageSectionExpanded !== "boolean") {
+      return {
+        patch: null,
+        error: "isClaudeUsageSectionExpanded must be a boolean.",
+      };
+    }
+    patch.isClaudeUsageSectionExpanded = record.isClaudeUsageSectionExpanded;
+  }
+
+  if (record.isCodexUsageSectionExpanded !== undefined) {
+    if (typeof record.isCodexUsageSectionExpanded !== "boolean") {
+      return {
+        patch: null,
+        error: "isCodexUsageSectionExpanded must be a boolean.",
+      };
+    }
+    patch.isCodexUsageSectionExpanded = record.isCodexUsageSectionExpanded;
+  }
+
+  const completionSoundKey = record.terminalCompletionSound;
+  if (completionSoundKey !== undefined) {
+    if (!isTerminalCompletionSoundId(completionSoundKey)) {
+      return {
+        patch: null,
+        error: "terminalCompletionSound must be one of the supported sound identifiers.",
+      };
+    }
+    patch.terminalCompletionSound = completionSoundKey;
+  }
+
+  const minimizedKey = record.minimizedTerminalIds;
+  if (minimizedKey !== undefined) {
+    if (!Array.isArray(minimizedKey)) {
+      return {
+        patch: null,
+        error: "minimizedTerminalIds must be an array of strings.",
+      };
+    }
+
+    const minimizedTerminalIds = minimizedKey.filter((id): id is string => typeof id === "string");
+    if (minimizedTerminalIds.length !== minimizedKey.length) {
+      return {
+        patch: null,
+        error: "minimizedTerminalIds must be an array of strings.",
+      };
+    }
+    patch.minimizedTerminalIds = [...new Set(minimizedTerminalIds)];
+  }
+
+  const widthsKey = record.terminalWidths;
+  if (widthsKey !== undefined) {
+    if (widthsKey === null || typeof widthsKey !== "object" || Array.isArray(widthsKey)) {
+      return {
+        patch: null,
+        error: "terminalWidths must be an object map of numbers.",
+      };
+    }
+
+    const terminalWidths = Object.entries(widthsKey).reduce<Record<string, number>>(
+      (acc, [id, width]) => {
+        if (typeof width === "number" && Number.isFinite(width)) {
+          acc[id] = width;
+        }
+        return acc;
+      },
+      {},
+    );
+    if (Object.keys(terminalWidths).length !== Object.keys(widthsKey).length) {
+      return {
+        patch: null,
+        error: "terminalWidths must be an object map of numbers.",
+      };
+    }
+    patch.terminalWidths = terminalWidths;
+  }
+
+  if (record.canvasOpenTerminalIds !== undefined) {
+    if (!Array.isArray(record.canvasOpenTerminalIds)) {
+      return {
+        patch: null,
+        error: "canvasOpenTerminalIds must be an array of strings.",
+      };
+    }
+
+    const canvasOpenTerminalIds = record.canvasOpenTerminalIds.filter(
+      (id): id is string => typeof id === "string",
+    );
+    if (canvasOpenTerminalIds.length !== record.canvasOpenTerminalIds.length) {
+      return {
+        patch: null,
+        error: "canvasOpenTerminalIds must be an array of strings.",
+      };
+    }
+    patch.canvasOpenTerminalIds = canvasOpenTerminalIds;
+  }
+
+  if (record.canvasOpenTentacleIds !== undefined) {
+    if (!Array.isArray(record.canvasOpenTentacleIds)) {
+      return {
+        patch: null,
+        error: "canvasOpenTentacleIds must be an array of strings.",
+      };
+    }
+
+    const canvasOpenTentacleIds = record.canvasOpenTentacleIds.filter(
+      (id): id is string => typeof id === "string",
+    );
+    if (canvasOpenTentacleIds.length !== record.canvasOpenTentacleIds.length) {
+      return {
+        patch: null,
+        error: "canvasOpenTentacleIds must be an array of strings.",
+      };
+    }
+    patch.canvasOpenTentacleIds = canvasOpenTentacleIds;
+  }
+
+  if (record.canvasTerminalsPanelWidth !== undefined) {
+    if (
+      typeof record.canvasTerminalsPanelWidth !== "number" ||
+      !Number.isFinite(record.canvasTerminalsPanelWidth)
+    ) {
+      return {
+        patch: null,
+        error: "canvasTerminalsPanelWidth must be a finite number.",
+      };
+    }
+    patch.canvasTerminalsPanelWidth = record.canvasTerminalsPanelWidth;
+  }
+
+  if (record.terminalInactivityThresholdMs !== undefined) {
+    if (
+      typeof record.terminalInactivityThresholdMs !== "number" ||
+      !Number.isFinite(record.terminalInactivityThresholdMs) ||
+      record.terminalInactivityThresholdMs <= 0
+    ) {
+      return {
+        patch: null,
+        error: "terminalInactivityThresholdMs must be a positive number.",
+      };
+    }
+    patch.terminalInactivityThresholdMs = record.terminalInactivityThresholdMs;
+  }
+
+  return { patch, error: null };
+};

package/apps/octogent/apps/api/src/createApiServer/upgradeHandler.ts

@@ -0,0 +1,38 @@
+import type { IncomingMessage } from "node:http";
+import type { Socket } from "node:net";
+
+import { isAllowedHostHeader, isAllowedOriginHeader, readHeaderValue } from "./security";
+
+type TerminalRuntime = ReturnType<typeof import("../terminalRuntime").createTerminalRuntime>;
+
+type CreateUpgradeHandlerOptions = {
+  runtime: TerminalRuntime;
+  allowRemoteAccess: boolean;
+};
+
+export const createUpgradeHandler = ({
+  runtime,
+  allowRemoteAccess,
+}: CreateUpgradeHandlerOptions) => {
+  return (request: IncomingMessage, socket: Socket, head: Buffer) => {
+    const originHeader = readHeaderValue(request.headers.origin);
+    const hostHeader = readHeaderValue(request.headers.host);
+    if (!isAllowedHostHeader(hostHeader, allowRemoteAccess)) {
+      socket.destroy();
+      return;
+    }
+
+    if (!isAllowedOriginHeader(originHeader, allowRemoteAccess)) {
+      socket.destroy();
+      return;
+    }
+
+    try {
+      if (!runtime.handleUpgrade(request, socket, head)) {
+        socket.destroy();
+      }
+    } catch {
+      socket.destroy();
+    }
+  };
+};

package/apps/octogent/apps/api/src/createApiServer/usageRoutes.ts

@@ -0,0 +1,84 @@
+import type { ApiRouteHandler } from "./routeHelpers";
+import { writeJson, writeMethodNotAllowed } from "./routeHelpers";
+
+export const handleCodexUsageRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { readCodexUsageSnapshot },
+) => {
+  if (requestUrl.pathname !== "/api/codex/usage") {
+    return false;
+  }
+
+  if (request.method !== "GET") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const payload = await readCodexUsageSnapshot();
+  writeJson(response, 200, payload, corsOrigin);
+  return true;
+};
+
+export const handleClaudeUsageRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { readClaudeUsageSnapshot, readClaudeOauthUsageSnapshot, readClaudeCliUsageSnapshot },
+) => {
+  if (
+    requestUrl.pathname !== "/api/claude/usage" &&
+    requestUrl.pathname !== "/api/claude/usage/oauth" &&
+    requestUrl.pathname !== "/api/claude/usage/cli"
+  ) {
+    return false;
+  }
+
+  if (request.method !== "GET") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const payload =
+    requestUrl.pathname === "/api/claude/usage/oauth"
+      ? await readClaudeOauthUsageSnapshot()
+      : requestUrl.pathname === "/api/claude/usage/cli"
+        ? await readClaudeCliUsageSnapshot()
+        : await readClaudeUsageSnapshot();
+  writeJson(response, 200, payload, corsOrigin);
+  return true;
+};
+
+export const handleUsageHeatmapRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { scanUsageHeatmap },
+) => {
+  if (requestUrl.pathname !== "/api/analytics/usage-heatmap") {
+    return false;
+  }
+
+  if (request.method !== "GET") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const scope = requestUrl.searchParams.get("scope") === "project" ? "project" : "all";
+  const payload = await scanUsageHeatmap(scope);
+  writeJson(response, 200, payload, corsOrigin);
+  return true;
+};
+
+export const handleGithubSummaryRoute: ApiRouteHandler = async (
+  { request, response, requestUrl, corsOrigin },
+  { readGithubRepoSummary },
+) => {
+  if (requestUrl.pathname !== "/api/github/summary") {
+    return false;
+  }
+
+  if (request.method !== "GET") {
+    writeMethodNotAllowed(response, corsOrigin);
+    return true;
+  }
+
+  const payload = await readGithubRepoSummary();
+  writeJson(response, 200, payload, corsOrigin);
+  return true;
+};

package/apps/octogent/apps/api/src/createApiServer.ts

@@ -0,0 +1,176 @@
+import { cpSync, existsSync as fsExistsSync, mkdirSync, readdirSync } from "node:fs";
+import { createServer } from "node:http";
+import { join, resolve } from "node:path";
+
+import { scanClaudeUsageChart } from "./claudeSessionScanner";
+import {
+  invalidateUsageCache as invalidateUsageCacheDefault,
+  readClaudeCliUsageSnapshot as readClaudeCliUsageSnapshotDefault,
+  readClaudeOauthUsageSnapshot as readClaudeOauthUsageSnapshotDefault,
+  readClaudeUsageSnapshot as readClaudeUsageSnapshotDefault,
+} from "./claudeUsage";
+import { createCodeIntelStore } from "./codeIntelStore";
+import { readCodexUsageSnapshot as readCodexUsageSnapshotDefault } from "./codexUsage";
+import { createApiRequestHandler } from "./createApiServer/requestHandler";
+import type { CreateApiServerOptions } from "./createApiServer/types";
+import { createUpgradeHandler } from "./createApiServer/upgradeHandler";
+import { readGithubRepoSummary as readGithubRepoSummaryDefault } from "./githubRepoSummary";
+import { createMonitorService } from "./monitor";
+import { createTerminalRuntime } from "./terminalRuntime";
+
+export const createApiServer = ({
+  workspaceCwd,
+  projectStateDir,
+  promptsDir,
+  webDistDir,
+  apiBaseUrl,
+  gitClient,
+  readClaudeUsageSnapshot,
+  readClaudeOauthUsageSnapshot,
+  readClaudeCliUsageSnapshot,
+  readCodexUsageSnapshot = readCodexUsageSnapshotDefault,
+  readGithubRepoSummary,
+  scanUsageHeatmap,
+  monitorService,
+  invalidateClaudeUsageCache = invalidateUsageCacheDefault,
+  allowRemoteAccess = false,
+}: CreateApiServerOptions = {}) => {
+  const resolvedWorkspaceCwd = workspaceCwd ?? process.cwd();
+  // State lives in ~/.octogent/projects/<name>/ when provided, else falls back to <project>/.octogent/
+  const resolvedStateDir = projectStateDir ?? join(resolvedWorkspaceCwd, ".octogent");
+  let resolvedApiBaseUrl = apiBaseUrl ?? "http://127.0.0.1:8787";
+  const getApiBaseUrl = () => resolvedApiBaseUrl;
+  const getApiPort = () => {
+    try {
+      return String(new URL(resolvedApiBaseUrl).port || 80);
+    } catch {
+      return "8787";
+    }
+  };
+  const resolvedUserPromptsDir = join(resolvedStateDir, "prompts");
+  const resolvedCorePromptsDir = join(resolvedStateDir, "prompts", "core");
+
+  // Sync builtin prompts into the project state dir on every start so prompt
+  // changes in the repo take effect without requiring manual cache cleanup.
+  const sourceDir = promptsDir ?? join(resolvedWorkspaceCwd, "prompts");
+  if (fsExistsSync(sourceDir)) {
+    mkdirSync(resolvedCorePromptsDir, { recursive: true });
+    for (const file of readdirSync(sourceDir)) {
+      if (file.endsWith(".md")) {
+        cpSync(join(sourceDir, file), join(resolvedCorePromptsDir, file));
+      }
+    }
+  }
+
+  // Read builtin prompts from the live source directory when available so new
+  // prompt files and prompt edits take effect without restarting the API.
+  // Keep the mirrored state copy as a fallback for packaged/runtime setups
+  // where the source prompts directory is unavailable.
+  const resolvedPromptsDir = fsExistsSync(sourceDir) ? sourceDir : resolvedCorePromptsDir;
+  const readClaudeUsageSnapshotWithDefault =
+    readClaudeUsageSnapshot ??
+    (() =>
+      readClaudeUsageSnapshotDefault({
+        projectStateDir: resolvedStateDir,
+        backgroundRefreshOnly: true,
+      }));
+  const readClaudeOauthUsageSnapshotWithDefault =
+    readClaudeOauthUsageSnapshot ??
+    (() =>
+      readClaudeOauthUsageSnapshotDefault({
+        projectStateDir: resolvedStateDir,
+      }));
+  const readClaudeCliUsageSnapshotWithDefault =
+    readClaudeCliUsageSnapshot ??
+    (() =>
+      readClaudeCliUsageSnapshotDefault({
+        projectStateDir: resolvedStateDir,
+      }));
+  const readGithubRepoSummaryWithDefault =
+    readGithubRepoSummary ??
+    (() =>
+      readGithubRepoSummaryDefault({
+        cwd: resolvedWorkspaceCwd,
+      }));
+
+  const runtimeOptions: Parameters<typeof createTerminalRuntime>[0] = {
+    workspaceCwd: resolvedWorkspaceCwd,
+    projectStateDir: resolvedStateDir,
+    getApiBaseUrl,
+  };
+  if (gitClient) {
+    runtimeOptions.gitClient = gitClient;
+  }
+
+  const runtime = createTerminalRuntime(runtimeOptions);
+  const monitorServiceWithDefault =
+    monitorService ??
+    createMonitorService({
+      projectStateDir: resolvedStateDir,
+    });
+  const scanUsageHeatmapWithDefault =
+    scanUsageHeatmap ??
+    ((scope: "all" | "project") => scanClaudeUsageChart(scope, resolvedWorkspaceCwd));
+
+  const codeIntelStore = createCodeIntelStore(resolvedStateDir);
+
+  const requestHandler = createApiRequestHandler({
+    runtime,
+    workspaceCwd: resolvedWorkspaceCwd,
+    projectStateDir: resolvedStateDir,
+    promptsDir: resolvedPromptsDir,
+    userPromptsDir: resolvedUserPromptsDir,
+    webDistDir,
+    getApiBaseUrl,
+    getApiPort,
+    readClaudeUsageSnapshot: readClaudeUsageSnapshotWithDefault,
+    readClaudeOauthUsageSnapshot: readClaudeOauthUsageSnapshotWithDefault,
+    readClaudeCliUsageSnapshot: readClaudeCliUsageSnapshotWithDefault,
+    readCodexUsageSnapshot,
+    readGithubRepoSummary: readGithubRepoSummaryWithDefault,
+    scanUsageHeatmap: scanUsageHeatmapWithDefault,
+    monitorService: monitorServiceWithDefault,
+    invalidateClaudeUsageCache,
+    codeIntelStore,
+    allowRemoteAccess,
+  });
+
+  const server = createServer(requestHandler);
+
+  server.on(
+    "upgrade",
+    createUpgradeHandler({
+      runtime,
+      allowRemoteAccess,
+    }),
+  );
+
+  return {
+    server,
+    async start(port = 8787, host = "127.0.0.1") {
+      await new Promise<void>((resolveStart, rejectStart) => {
+        server.listen(port, host, () => resolveStart());
+        server.once("error", rejectStart);
+      });
+
+      const address = server.address();
+      const resolvedPort = typeof address === "object" && address ? address.port : port;
+      resolvedApiBaseUrl = `http://${host}:${resolvedPort}`;
+
+      return { host, port: resolvedPort };
+    },
+    async stop() {
+      await runtime.close();
+      await new Promise<void>((resolveStop, rejectStop) => {
+        server.close((error) => {
+          if (error) {
+            rejectStop(error);
+            return;
+          }
+          resolveStop();
+        });
+        server.closeAllConnections();
+      });
+    },
+  };
+};