@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/web/tests/runtimeEndpoints.test.tsx

@@ -0,0 +1,240 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildClaudeUsageUrl,
+  buildCodexUsageUrl,
+  buildConversationExportUrl,
+  buildConversationSessionUrl,
+  buildConversationsUrl,
+  buildGithubSummaryUrl,
+  buildMonitorConfigUrl,
+  buildMonitorFeedUrl,
+  buildMonitorRefreshUrl,
+  buildTentacleGitCommitUrl,
+  buildTentacleGitPullRequestMergeUrl,
+  buildTentacleGitPullRequestUrl,
+  buildTentacleGitPushUrl,
+  buildTentacleGitStatusUrl,
+  buildTentacleGitSyncUrl,
+  buildTentacleRenameUrl,
+  buildTerminalEventsSocketUrl,
+  buildTerminalSnapshotsUrl,
+  buildTerminalSocketUrl,
+  buildTerminalsUrl,
+  buildUiStateUrl,
+  buildWorkspaceSetupStepUrl,
+  buildWorkspaceSetupUrl,
+} from "../src/runtime/runtimeEndpoints";
+
+describe("runtimeEndpoints", () => {
+  it("returns same-origin API path when runtime base URL is not configured", () => {
+    expect(buildTerminalSnapshotsUrl()).toBe("/api/terminal-snapshots");
+  });
+
+  it("builds absolute API URL when runtime base URL is configured", () => {
+    expect(buildTerminalSnapshotsUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/terminal-snapshots",
+    );
+  });
+
+  it("builds terminal creation URL on same origin by default", () => {
+    expect(buildTerminalsUrl()).toBe("/api/terminals");
+  });
+
+  it("builds absolute terminal creation URL when runtime base URL is configured", () => {
+    expect(buildTerminalsUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/terminals",
+    );
+  });
+
+  it("builds codex usage URL on same origin by default", () => {
+    expect(buildCodexUsageUrl()).toBe("/api/codex/usage");
+  });
+
+  it("builds absolute codex usage URL when runtime base URL is configured", () => {
+    expect(buildCodexUsageUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/codex/usage",
+    );
+  });
+
+  it("builds claude usage URL on same origin by default", () => {
+    expect(buildClaudeUsageUrl()).toBe("/api/claude/usage");
+  });
+
+  it("builds absolute claude usage URL when runtime base URL is configured", () => {
+    expect(buildClaudeUsageUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/claude/usage",
+    );
+  });
+
+  it("builds github summary URL on same origin by default", () => {
+    expect(buildGithubSummaryUrl()).toBe("/api/github/summary");
+  });
+
+  it("builds absolute github summary URL when runtime base URL is configured", () => {
+    expect(buildGithubSummaryUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/github/summary",
+    );
+  });
+
+  it("builds monitor config URL on same origin by default", () => {
+    expect(buildMonitorConfigUrl()).toBe("/api/monitor/config");
+  });
+
+  it("builds monitor feed URL on same origin by default", () => {
+    expect(buildMonitorFeedUrl()).toBe("/api/monitor/feed");
+  });
+
+  it("builds monitor refresh URL on same origin by default", () => {
+    expect(buildMonitorRefreshUrl()).toBe("/api/monitor/refresh");
+  });
+
+  it("builds conversations URLs on same origin by default", () => {
+    expect(buildConversationsUrl()).toBe("/api/conversations");
+    expect(buildConversationSessionUrl("tentacle-1-root")).toBe(
+      "/api/conversations/tentacle-1-root",
+    );
+    expect(buildConversationExportUrl("tentacle-1-root", "json")).toBe(
+      "/api/conversations/tentacle-1-root/export?format=json",
+    );
+    expect(buildConversationExportUrl("tentacle-1-root", "md")).toBe(
+      "/api/conversations/tentacle-1-root/export?format=md",
+    );
+  });
+
+  it("builds absolute conversations URLs when runtime base URL is configured", () => {
+    expect(buildConversationsUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/conversations",
+    );
+    expect(buildConversationSessionUrl("tentacle-1-root", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/conversations/tentacle-1-root",
+    );
+    expect(
+      buildConversationExportUrl("tentacle-1-root", "json", "https://runtime.example.com"),
+    ).toBe("https://runtime.example.com/api/conversations/tentacle-1-root/export?format=json");
+  });
+
+  it("builds absolute monitor URLs when runtime base URL is configured", () => {
+    expect(buildMonitorConfigUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/monitor/config",
+    );
+    expect(buildMonitorFeedUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/monitor/feed",
+    );
+    expect(buildMonitorRefreshUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/monitor/refresh",
+    );
+  });
+
+  it("builds ui state URL on same origin by default", () => {
+    expect(buildUiStateUrl()).toBe("/api/ui-state");
+  });
+
+  it("builds absolute ui state URL when runtime base URL is configured", () => {
+    expect(buildUiStateUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/ui-state",
+    );
+  });
+
+  it("builds workspace setup URLs on same origin by default", () => {
+    expect(buildWorkspaceSetupUrl()).toBe("/api/setup");
+    expect(buildWorkspaceSetupStepUrl("ensure-gitignore")).toBe(
+      "/api/setup/steps/ensure-gitignore",
+    );
+  });
+
+  it("builds absolute workspace setup URLs when runtime base URL is configured", () => {
+    expect(buildWorkspaceSetupUrl("https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/setup",
+    );
+    expect(buildWorkspaceSetupStepUrl("ensure-gitignore", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/setup/steps/ensure-gitignore",
+    );
+  });
+
+  it("builds tentacle rename URL on same origin by default", () => {
+    expect(buildTentacleRenameUrl("tentacle-main")).toBe("/api/tentacles/tentacle-main");
+  });
+
+  it("builds absolute tentacle rename URL when runtime base URL is configured", () => {
+    expect(buildTentacleRenameUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main",
+    );
+  });
+
+  it("builds tentacle git lifecycle URLs on same origin by default", () => {
+    expect(buildTentacleGitStatusUrl("tentacle-main")).toBe(
+      "/api/tentacles/tentacle-main/git/status",
+    );
+    expect(buildTentacleGitCommitUrl("tentacle-main")).toBe(
+      "/api/tentacles/tentacle-main/git/commit",
+    );
+    expect(buildTentacleGitPushUrl("tentacle-main")).toBe("/api/tentacles/tentacle-main/git/push");
+    expect(buildTentacleGitSyncUrl("tentacle-main")).toBe("/api/tentacles/tentacle-main/git/sync");
+    expect(buildTentacleGitPullRequestUrl("tentacle-main")).toBe(
+      "/api/tentacles/tentacle-main/git/pr",
+    );
+    expect(buildTentacleGitPullRequestMergeUrl("tentacle-main")).toBe(
+      "/api/tentacles/tentacle-main/git/pr/merge",
+    );
+  });
+
+  it("builds absolute tentacle git lifecycle URLs when runtime base URL is configured", () => {
+    expect(buildTentacleGitStatusUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main/git/status",
+    );
+    expect(buildTentacleGitCommitUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main/git/commit",
+    );
+    expect(buildTentacleGitPushUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main/git/push",
+    );
+    expect(buildTentacleGitSyncUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main/git/sync",
+    );
+    expect(buildTentacleGitPullRequestUrl("tentacle-main", "https://runtime.example.com")).toBe(
+      "https://runtime.example.com/api/tentacles/tentacle-main/git/pr",
+    );
+    expect(
+      buildTentacleGitPullRequestMergeUrl("tentacle-main", "https://runtime.example.com"),
+    ).toBe("https://runtime.example.com/api/tentacles/tentacle-main/git/pr/merge");
+  });
+
+  it("builds same-origin websocket URL by default", () => {
+    expect(
+      buildTerminalSocketUrl(
+        "tentacle-main",
+        undefined,
+        new URL("https://workspace.example.com/dashboard") as unknown as Location,
+      ),
+    ).toBe("wss://workspace.example.com/api/terminals/tentacle-main/ws");
+  });
+
+  it("builds websocket URL from configured runtime base URL", () => {
+    expect(
+      buildTerminalSocketUrl(
+        "tentacle-main",
+        "http://127.0.0.1:8787",
+        new URL("https://workspace.example.com/dashboard") as unknown as Location,
+      ),
+    ).toBe("ws://127.0.0.1:8787/api/terminals/tentacle-main/ws");
+  });
+
+  it("builds same-origin terminal events websocket URL by default", () => {
+    expect(
+      buildTerminalEventsSocketUrl(
+        undefined,
+        new URL("https://workspace.example.com/dashboard") as unknown as Location,
+      ),
+    ).toBe("wss://workspace.example.com/api/terminal-events/ws");
+  });
+
+  it("builds terminal events websocket URL from configured runtime base URL", () => {
+    expect(
+      buildTerminalEventsSocketUrl(
+        "http://127.0.0.1:8787",
+        new URL("https://workspace.example.com/dashboard") as unknown as Location,
+      ),
+    ).toBe("ws://127.0.0.1:8787/api/terminal-events/ws");
+  });
+});

package/apps/octogent/apps/web/tests/setup.ts

@@ -0,0 +1,39 @@
+import "@testing-library/jest-dom/vitest";
+import { cleanup } from "@testing-library/react";
+import { afterEach } from "vitest";
+
+import { MockWebSocket } from "./test-utils/appTestHarness";
+
+afterEach(() => {
+  cleanup();
+});
+
+globalThis.ResizeObserver = class ResizeObserver {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};
+
+const canvasContextStub = {
+  imageSmoothingEnabled: true,
+  clearRect() {},
+  fillRect() {},
+  save() {},
+  restore() {},
+  beginPath() {},
+  moveTo() {},
+  quadraticCurveTo() {},
+  lineTo() {},
+  closePath() {},
+  stroke() {},
+  fill() {},
+  ellipse() {},
+  arc() {},
+};
+
+Object.defineProperty(HTMLCanvasElement.prototype, "getContext", {
+  configurable: true,
+  value: () => canvasContextStub,
+});
+
+globalThis.WebSocket = MockWebSocket as unknown as typeof WebSocket;

package/apps/octogent/apps/web/tests/tentacle-pod.test.tsx

@@ -0,0 +1,62 @@
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+import { TentaclePod } from "../src/components/deck/TentaclePod";
+
+describe("TentaclePod skill editor", () => {
+  it("saves suggested skills from the deck pod", async () => {
+    const onSaveSuggestedSkills = vi.fn().mockResolvedValue(true);
+
+    render(
+      <TentaclePod
+        tentacle={{
+          tentacleId: "docs",
+          displayName: "Docs",
+          description: "Docs and knowledge.",
+          status: "idle",
+          color: "#ff6b2b",
+          octopus: {
+            animation: null,
+            expression: null,
+            accessory: null,
+            hairColor: null,
+          },
+          scope: { paths: [], tags: [] },
+          vaultFiles: ["todo.md"],
+          todoTotal: 0,
+          todoDone: 0,
+          todoItems: [],
+          suggestedSkills: ["docs-writer"],
+        }}
+        visuals={{
+          color: "#ff6b2b",
+          animation: "sway",
+          expression: "happy",
+          accessory: "none",
+        }}
+        isFocused={false}
+        availableSkills={[
+          {
+            name: "docs-writer",
+            description: "Keeps docs aligned with the product.",
+            source: "project",
+          },
+          {
+            name: "release-helper",
+            description: "Helps with release coordination.",
+            source: "user",
+          },
+        ]}
+        onSaveSuggestedSkills={onSaveSuggestedSkills}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Skills" }));
+    fireEvent.click(screen.getByLabelText(/release-helper/i));
+    fireEvent.click(screen.getByRole("button", { name: /save skills/i }));
+
+    await waitFor(() => {
+      expect(onSaveSuggestedSkills).toHaveBeenCalledWith("docs", ["docs-writer", "release-helper"]);
+    });
+  });
+});

package/apps/octogent/apps/web/tests/terminalReplay.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { replayTerminalHistory } from "../src/components/terminalReplay";
+
+describe("replayTerminalHistory", () => {
+  it("clears selection and restores the previous scroll position after replay", () => {
+    const reset = vi.fn();
+    const clearSelection = vi.fn();
+    const refresh = vi.fn();
+    const terminal = {
+      reset,
+      clearSelection,
+      refresh,
+      rows: 24,
+      write: vi.fn((_: string, callback?: () => void) => {
+        callback?.();
+      }),
+    };
+    const viewport = {
+      clientHeight: 120,
+      scrollHeight: 1_400,
+      scrollTop: 360,
+    };
+    const requestAnimationFrameSpy = vi
+      .spyOn(window, "requestAnimationFrame")
+      .mockImplementation((callback: FrameRequestCallback) => {
+        callback(0);
+        return 1;
+      });
+
+    replayTerminalHistory(terminal, "history payload", viewport);
+
+    expect(clearSelection).toHaveBeenCalledTimes(2);
+    expect(reset).toHaveBeenCalledTimes(1);
+    expect(terminal.write).toHaveBeenCalledWith("history payload", expect.any(Function));
+    expect(refresh).toHaveBeenCalledWith(0, 23);
+    expect(viewport.scrollTop).toBe(360);
+
+    requestAnimationFrameSpy.mockRestore();
+  });
+
+  it("pins the viewport to the bottom when it was already near the bottom", () => {
+    const terminal = {
+      reset: vi.fn(),
+      clearSelection: vi.fn(),
+      refresh: vi.fn(),
+      rows: 30,
+      write: vi.fn((_: string, callback?: () => void) => {
+        callback?.();
+      }),
+    };
+    const viewport = {
+      clientHeight: 300,
+      scrollHeight: 910,
+      scrollTop: 604,
+    };
+    const requestAnimationFrameSpy = vi
+      .spyOn(window, "requestAnimationFrame")
+      .mockImplementation((callback: FrameRequestCallback) => {
+        viewport.scrollHeight = 1_280;
+        callback(0);
+        return 1;
+      });
+
+    replayTerminalHistory(terminal, "history payload", viewport);
+
+    expect(viewport.scrollTop).toBe(1_280);
+
+    requestAnimationFrameSpy.mockRestore();
+  });
+});

package/apps/octogent/apps/web/tests/terminalState.test.tsx

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+
+import { retainActiveTerminalEntries, retainActiveTerminalIds } from "../src/app/terminalState";
+
+describe("terminalState helpers", () => {
+  it("retains active terminal ids and preserves reference when unchanged", () => {
+    const currentTerminalIds = ["tentacle-1", "tentacle-2"];
+    const activeTerminalIds = new Set(["tentacle-1", "tentacle-2", "tentacle-3"]);
+
+    const nextTerminalIds = retainActiveTerminalIds(currentTerminalIds, activeTerminalIds);
+
+    expect(nextTerminalIds).toBe(currentTerminalIds);
+  });
+
+  it("filters removed terminal ids", () => {
+    const currentTerminalIds = ["tentacle-1", "tentacle-2"];
+    const activeTerminalIds = new Set(["tentacle-2"]);
+
+    const nextTerminalIds = retainActiveTerminalIds(currentTerminalIds, activeTerminalIds);
+
+    expect(nextTerminalIds).toEqual(["tentacle-2"]);
+  });
+
+  it("retains active terminal state entries and preserves reference when unchanged", () => {
+    const currentState = {
+      "tentacle-1": "idle",
+      "tentacle-2": "processing",
+    };
+    const activeTerminalIds = new Set(["tentacle-1", "tentacle-2"]);
+
+    const nextState = retainActiveTerminalEntries(currentState, activeTerminalIds);
+
+    expect(nextState).toBe(currentState);
+  });
+
+  it("filters removed terminal state entries", () => {
+    const currentState = {
+      "tentacle-1": "idle",
+      "tentacle-2": "processing",
+    };
+    const activeTerminalIds = new Set(["tentacle-2"]);
+
+    const nextState = retainActiveTerminalEntries(currentState, activeTerminalIds);
+
+    expect(nextState).toEqual({
+      "tentacle-2": "processing",
+    });
+  });
+});

package/apps/octogent/apps/web/tests/terminalWheel.test.tsx

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  readViewportY,
+  shouldUseManualWheelScroll,
+  wheelDeltaToScrollLines,
+} from "../src/components/terminalWheel";
+
+describe("wheelDeltaToScrollLines", () => {
+  it("returns zero for invalid or neutral wheel deltas", () => {
+    expect(wheelDeltaToScrollLines(0, WheelEvent.DOM_DELTA_PIXEL)).toBe(0);
+    expect(wheelDeltaToScrollLines(Number.NaN, WheelEvent.DOM_DELTA_PIXEL)).toBe(0);
+  });
+
+  it("converts pixel wheel delta to signed terminal lines", () => {
+    expect(wheelDeltaToScrollLines(120, WheelEvent.DOM_DELTA_PIXEL)).toBe(3);
+    expect(wheelDeltaToScrollLines(-120, WheelEvent.DOM_DELTA_PIXEL)).toBe(-3);
+  });
+
+  it("converts line/page delta modes to sensible line movement", () => {
+    expect(wheelDeltaToScrollLines(3, WheelEvent.DOM_DELTA_LINE)).toBe(1);
+    expect(wheelDeltaToScrollLines(1, WheelEvent.DOM_DELTA_PAGE)).toBe(4);
+  });
+});
+
+describe("shouldUseManualWheelScroll", () => {
+  it("returns false for alternate-screen buffers", () => {
+    expect(shouldUseManualWheelScroll({ baseY: 100, type: "alternate" })).toBe(false);
+  });
+
+  it("returns false when there is no scrollback history", () => {
+    expect(shouldUseManualWheelScroll({ baseY: 0, type: "normal" })).toBe(false);
+    expect(shouldUseManualWheelScroll({ type: "normal" })).toBe(false);
+  });
+
+  it("returns true for normal buffers with scrollback history", () => {
+    expect(shouldUseManualWheelScroll({ baseY: 1, type: "normal" })).toBe(true);
+  });
+});
+
+describe("readViewportY", () => {
+  it("returns null for missing or invalid viewport values", () => {
+    expect(readViewportY(undefined)).toBeNull();
+    expect(readViewportY({ viewportY: Number.NaN })).toBeNull();
+    expect(readViewportY({})).toBeNull();
+  });
+
+  it("returns viewport row when available", () => {
+    expect(readViewportY({ viewportY: 42 })).toBe(42);
+  });
+});

package/apps/octogent/apps/web/tests/test-utils/appTestHarness.ts

@@ -0,0 +1,48 @@
+import { vi } from "vitest";
+
+export class MockWebSocket {
+  static instances: MockWebSocket[] = [];
+  readonly url: string;
+  private listeners = new Map<string, Set<(event: { data: unknown }) => void>>();
+
+  close = vi.fn();
+  send = vi.fn();
+
+  constructor(url: string) {
+    this.url = url;
+    MockWebSocket.instances.push(this);
+  }
+
+  addEventListener(type: string, listener: (event: { data: unknown }) => void) {
+    const bucket = this.listeners.get(type) ?? new Set<(event: { data: unknown }) => void>();
+    bucket.add(listener);
+    this.listeners.set(type, bucket);
+  }
+
+  removeEventListener(type: string, listener: (event: { data: unknown }) => void) {
+    this.listeners.get(type)?.delete(listener);
+  }
+
+  emit(type: string, data?: unknown) {
+    const event = { data };
+    for (const listener of this.listeners.get(type) ?? []) {
+      listener(event);
+    }
+  }
+}
+
+export const resetAppTestHarness = () => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+  MockWebSocket.instances = [];
+};
+
+export const jsonResponse = (payload: unknown, status = 200) =>
+  new Response(JSON.stringify(payload), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+export const notFoundResponse = () => new Response("not-found", { status: 404 });

package/apps/octogent/apps/web/tests/uiPrimitives.test.tsx

@@ -0,0 +1,31 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { ActionButton } from "../src/components/ui/ActionButton";
+import { StatusBadge } from "../src/components/ui/StatusBadge";
+
+describe("UI primitives", () => {
+  it("renders action button variants and size classes", () => {
+    render(
+      <ActionButton size="compact" variant="danger">
+        Delete
+      </ActionButton>,
+    );
+
+    expect(screen.getByRole("button", { name: "Delete" })).toHaveClass(
+      "action-button",
+      "action-button--danger",
+      "action-button--compact",
+    );
+  });
+
+  it("renders status badges with semantic tone classes", () => {
+    render(<StatusBadge tone="processing" />);
+
+    expect(screen.getByText("PROCESSING").closest(".status-badge")).toHaveClass(
+      "status-badge",
+      "pill",
+      "processing",
+    );
+  });
+});

package/apps/octogent/apps/web/tests/useAgentRuntimeStates.test.tsx

@@ -0,0 +1,47 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { useAgentRuntimeStates } from "../src/app/hooks/useAgentRuntimeStates";
+import { createTerminalRuntimeStateStore } from "../src/app/terminalRuntimeStateStore";
+import type { TerminalView } from "../src/app/types";
+
+const HookProbe = ({ columns }: { columns: TerminalView }) => {
+  const runtimeStateStore = createTerminalRuntimeStateStore();
+  runtimeStateStore.syncFromTerminals(columns);
+  const runtimeStates = useAgentRuntimeStates(runtimeStateStore, columns);
+  return (
+    <output aria-label="runtime-states">
+      {JSON.stringify(Array.from(runtimeStates.entries()))}
+    </output>
+  );
+};
+
+describe("useAgentRuntimeStates", () => {
+  it("derives per-terminal runtime state from snapshots without opening passive sockets", () => {
+    const socketSpy = globalThis.WebSocket;
+    const columns = [
+      {
+        terminalId: "tentacle-idle",
+        label: "tentacle-idle",
+        state: "live",
+        tentacleId: "docs-knowledge",
+        createdAt: "2026-04-09T10:00:00.000Z",
+      },
+      {
+        terminalId: "docs-knowledge-swarm-parent",
+        label: "docs-knowledge-swarm-parent",
+        state: "live",
+        tentacleId: "docs-knowledge",
+        createdAt: "2026-04-09T10:05:00.000Z",
+        agentRuntimeState: "processing",
+      },
+    ] satisfies TerminalView;
+
+    render(<HookProbe columns={columns} />);
+
+    expect(screen.getByLabelText("runtime-states").textContent).toBe(
+      JSON.stringify([["docs-knowledge-swarm-parent", { state: "processing" }]]),
+    );
+    expect(globalThis.WebSocket).toBe(socketSpy);
+  });
+});

package/apps/octogent/apps/web/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "types": ["vite/client", "vitest/globals"]
+  },
+  "include": ["src", "tests", "vite.config.ts"]
+}

package/apps/octogent/apps/web/vite.api.bundle.config.mts

@@ -0,0 +1,32 @@
+import { builtinModules } from "node:module";
+import { resolve } from "node:path";
+
+import { defineConfig } from "vite";
+
+const externals = [
+  ...builtinModules,
+  ...builtinModules.map((moduleName) => `node:${moduleName}`),
+  "node-pty",
+  "ws",
+];
+
+export default defineConfig({
+  build: {
+    outDir: resolve(__dirname, "../../dist/api"),
+    emptyOutDir: false,
+    lib: {
+      entry: resolve(__dirname, "../api/src/cli.ts"),
+      formats: ["es"],
+      fileName: () => "cli.js",
+    },
+    minify: false,
+    sourcemap: true,
+    target: "node22",
+    rollupOptions: {
+      external: externals,
+      output: {
+        entryFileNames: "cli.js",
+      },
+    },
+  },
+});