@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/tests/sessionRuntime.test.ts

@@ -0,0 +1,608 @@
+import { EventEmitter } from "node:events";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import type { IncomingMessage } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Duplex } from "node:stream";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { createShellEnvironmentMock, ensureSpawnHelperMock, spawnMock } = vi.hoisted(() => ({
+  createShellEnvironmentMock: vi.fn(() => ({})),
+  ensureSpawnHelperMock: vi.fn(),
+  spawnMock: vi.fn(),
+}));
+
+vi.mock("node-pty", () => ({
+  spawn: spawnMock,
+}));
+
+vi.mock("../src/terminalRuntime/ptyEnvironment", () => ({
+  createShellEnvironment: createShellEnvironmentMock,
+  ensureNodePtySpawnHelperExecutable: ensureSpawnHelperMock,
+}));
+
+import { createSessionRuntime } from "../src/terminalRuntime/sessionRuntime";
+import type { PersistedTerminal, TerminalSession } from "../src/terminalRuntime/types";
+
+class FakePty extends EventEmitter {
+  write = vi.fn();
+  resize = vi.fn();
+  kill = vi.fn();
+
+  onData(listener: (chunk: string) => void) {
+    this.on("data", listener);
+    return {
+      dispose: () => {
+        this.off("data", listener);
+      },
+    };
+  }
+
+  onExit(listener: (event: { exitCode: number; signal: number }) => void) {
+    this.on("exit", listener);
+    return {
+      dispose: () => {
+        this.off("exit", listener);
+      },
+    };
+  }
+
+  emitData(chunk: string) {
+    this.emit("data", chunk);
+  }
+}
+
+class FakeWebSocket extends EventEmitter {
+  readyState = 1;
+  sentMessages: string[] = [];
+  send = vi.fn((payload: string) => {
+    this.sentMessages.push(payload);
+  });
+  close = vi.fn(() => {
+    if (this.readyState !== 1) {
+      return;
+    }
+
+    this.readyState = 3;
+    this.emit("close");
+  });
+}
+
+class FakeWebSocketServer {
+  nextSocket: FakeWebSocket | null = null;
+
+  handleUpgrade = vi.fn(
+    (
+      _request: IncomingMessage,
+      _socket: Duplex,
+      _head: Buffer,
+      callback: (socket: FakeWebSocket) => void,
+    ) => {
+      if (!this.nextSocket) {
+        throw new Error("Missing websocket for upgrade.");
+      }
+
+      const socket = this.nextSocket;
+      this.nextSocket = null;
+      callback(socket);
+    },
+  );
+}
+
+const createUpgradeRequest = (tentacleId: string) =>
+  ({
+    url: `/api/terminals/${tentacleId}/ws`,
+  }) as IncomingMessage;
+
+const parseSentMessages = (socket: FakeWebSocket) =>
+  socket.sentMessages.map((raw) => JSON.parse(raw) as { type: string; data?: string });
+
+describe("createSessionRuntime", () => {
+  const temporaryDirectories: string[] = [];
+
+  const createTemporaryDirectory = () => {
+    const directory = mkdtempSync(join(tmpdir(), "octogent-session-runtime-test-"));
+    temporaryDirectories.push(directory);
+    return directory;
+  };
+
+  beforeEach(() => {
+    createShellEnvironmentMock.mockClear();
+    ensureSpawnHelperMock.mockClear();
+    spawnMock.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    for (const directory of temporaryDirectories) {
+      rmSync(directory, { recursive: true, force: true });
+    }
+    temporaryDirectories.length = 0;
+  });
+
+  it("keeps a session alive across reconnects and replays scrollback history", () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 1024,
+    });
+
+    const firstSocket = new FakeWebSocket();
+    websocketServer.nextSocket = firstSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    pty.emitData("first line\r\n");
+    pty.emitData("second line\r\n");
+    firstSocket.close();
+    expect(sessions.has(tentacleId)).toBe(true);
+
+    const secondSocket = new FakeWebSocket();
+    websocketServer.nextSocket = secondSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    const secondMessages = parseSentMessages(secondSocket);
+    expect(secondMessages.find((message) => message.type === "history")).toEqual({
+      type: "history",
+      data: "first line\r\nsecond line\r\n",
+    });
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    expect(pty.write).toHaveBeenCalledTimes(1);
+
+    runtime.close();
+  });
+
+  it("closes idle sessions after the configured grace timeout", () => {
+    vi.useFakeTimers();
+
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 1000,
+      scrollbackMaxBytes: 1024,
+    });
+
+    const socket = new FakeWebSocket();
+    websocketServer.nextSocket = socket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+    socket.close();
+
+    expect(sessions.has(tentacleId)).toBe(true);
+    vi.advanceTimersByTime(999);
+    expect(sessions.has(tentacleId)).toBe(true);
+
+    vi.advanceTimersByTime(1);
+    expect(pty.kill).toHaveBeenCalledTimes(1);
+    expect(sessions.has(tentacleId)).toBe(false);
+
+    runtime.close();
+  });
+
+  it("truncates oversize chunks to the configured scrollback size", () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 8,
+    });
+
+    const firstSocket = new FakeWebSocket();
+    websocketServer.nextSocket = firstSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+    pty.emitData("123456789012");
+    firstSocket.close();
+
+    const secondSocket = new FakeWebSocket();
+    websocketServer.nextSocket = secondSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    const secondMessages = parseSentMessages(secondSocket);
+    expect(secondMessages.find((message) => message.type === "history")).toEqual({
+      type: "history",
+      data: "56789012",
+    });
+
+    runtime.close();
+  });
+
+  it("strips a broken leading ANSI fragment from replayed history after truncation", () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 18,
+    });
+
+    const firstSocket = new FakeWebSocket();
+    websocketServer.nextSocket = firstSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+    pty.emitData("\u001b[48;2;55;55;55mHELLO\r\n");
+    firstSocket.close();
+
+    const secondSocket = new FakeWebSocket();
+    websocketServer.nextSocket = secondSocket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    const secondMessages = parseSentMessages(secondSocket);
+    expect(secondMessages.find((message) => message.type === "history")).toEqual({
+      type: "history",
+      data: "HELLO\r\n",
+    });
+
+    runtime.close();
+  });
+
+  it("ignores duplicate resize payloads for the same terminal size", () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 1024,
+    });
+
+    const socket = new FakeWebSocket();
+    websocketServer.nextSocket = socket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    socket.emit("message", JSON.stringify({ type: "resize", cols: 120, rows: 35 }));
+    socket.emit("message", JSON.stringify({ type: "resize", cols: 120, rows: 35 }));
+    socket.emit("message", JSON.stringify({ type: "resize", cols: 121, rows: 35 }));
+
+    expect(pty.resize).toHaveBeenCalledTimes(1);
+    expect(pty.resize).toHaveBeenLastCalledWith(121, 35);
+
+    runtime.close();
+  });
+
+  it("writes normalized transcript events for each terminal session", async () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 1024,
+    });
+
+    const socket = new FakeWebSocket();
+    websocketServer.nextSocket = socket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    socket.emit("message", JSON.stringify({ type: "input", data: "echo hi\r" }));
+    pty.emitData("\u001b[31mred\u001b[0m\r\n");
+    runtime.close();
+
+    const transcriptPath = join(transcriptDirectoryPath, `${encodeURIComponent(tentacleId)}.jsonl`);
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      if (existsSync(transcriptPath)) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    const transcriptEvents = readFileSync(transcriptPath, "utf8")
+      .trim()
+      .split(/\r?\n/)
+      .map((line) => JSON.parse(line) as { type: string; text?: string; reason?: string });
+
+    expect(transcriptEvents.some((event) => event.type === "session_start")).toBe(true);
+    expect(
+      transcriptEvents.some(
+        (event) => event.type === "session_end" && event.reason === "session_close",
+      ),
+    ).toBe(true);
+  });
+
+  it("can start a prompted session headlessly and submits the prompt automatically", () => {
+    vi.useFakeTimers();
+
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+          initialPrompt: "Investigate and report back.",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 1000,
+      scrollbackMaxBytes: 1024,
+    });
+
+    expect(runtime.startSession(tentacleId)).toBe(true);
+    expect(sessions.has(tentacleId)).toBe(true);
+    expect(pty.write).toHaveBeenNthCalledWith(1, "claude\r");
+
+    vi.advanceTimersByTime(4_000);
+    expect(pty.write).toHaveBeenNthCalledWith(
+      2,
+      "\u001b[200~Investigate and report back.\u001b[201~",
+    );
+
+    vi.advanceTimersByTime(150);
+    expect(pty.write).toHaveBeenNthCalledWith(3, "\r");
+
+    vi.advanceTimersByTime(10_000);
+    expect(sessions.has(tentacleId)).toBe(true);
+
+    runtime.close();
+  });
+
+  it("pastes an initial input draft without submitting it", () => {
+    vi.useFakeTimers();
+
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+          initialInputDraft: "You are working on docs.",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 1_000,
+      scrollbackMaxBytes: 1_024,
+    });
+
+    const socket = new FakeWebSocket();
+    websocketServer.nextSocket = socket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    expect(pty.write).toHaveBeenNthCalledWith(1, "claude\r");
+
+    vi.advanceTimersByTime(4_000);
+    expect(pty.write).toHaveBeenNthCalledWith(2, "\u001b[200~You are working on docs.\u001b[201~");
+
+    vi.advanceTimersByTime(150);
+    expect(pty.write).toHaveBeenCalledTimes(2);
+
+    runtime.close();
+  });
+
+  it("reports runtime state changes through the state-change callback", () => {
+    const tentacleId = "tentacle-1";
+    const terminals = new Map<string, PersistedTerminal>([
+      [
+        tentacleId,
+        {
+          terminalId: tentacleId,
+          tentacleId,
+          tentacleName: tentacleId,
+          createdAt: new Date().toISOString(),
+          workspaceMode: "shared",
+        },
+      ],
+    ]);
+    const sessions = new Map<string, TerminalSession>();
+    const websocketServer = new FakeWebSocketServer();
+    const pty = new FakePty();
+    const transcriptDirectoryPath = createTemporaryDirectory();
+    const onStateChange = vi.fn();
+    spawnMock.mockReturnValue(pty);
+
+    const runtime = createSessionRuntime({
+      websocketServer: websocketServer as unknown as import("ws").WebSocketServer,
+      terminals,
+      sessions,
+      getTentacleWorkspaceCwd: () => process.cwd(),
+      isDebugPtyLogsEnabled: false,
+      ptyLogDir: process.cwd(),
+      transcriptDirectoryPath,
+      sessionIdleGraceMs: 60_000,
+      scrollbackMaxBytes: 1024,
+      onStateChange,
+    });
+
+    const socket = new FakeWebSocket();
+    websocketServer.nextSocket = socket;
+    expect(
+      runtime.handleUpgrade(createUpgradeRequest(tentacleId), {} as Duplex, Buffer.alloc(0)),
+    ).toBe(true);
+
+    socket.emit("message", JSON.stringify({ type: "input", data: "echo hi\r" }));
+
+    expect(onStateChange).toHaveBeenCalledWith(tentacleId, "processing", undefined);
+
+    runtime.close();
+  });
+});

package/apps/octogent/apps/api/tests/startupPrerequisites.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  collectStartupPrerequisiteReport,
+  formatStartupPrerequisiteReport,
+  isCommandAvailable,
+} from "../src/startupPrerequisites";
+
+describe("startup prerequisites", () => {
+  it("passes cleanly when every prerequisite is installed", () => {
+    const report = collectStartupPrerequisiteReport(() => true);
+
+    expect(report.errors).toEqual([]);
+    expect(report.warnings).toEqual([]);
+    expect(formatStartupPrerequisiteReport(report)).toEqual([]);
+  });
+
+  it("fails startup when no agent CLI is installed", () => {
+    const report = collectStartupPrerequisiteReport((command) => command === "git");
+
+    expect(report.errors).toHaveLength(1);
+    expect(report.errors[0]?.summary).toContain("Neither `claude` nor `codex`");
+    expect(report.warnings.map((issue) => issue.command)).toEqual(["gh", "curl"]);
+  });
+
+  it("warns for degraded optional integrations when one provider is available", () => {
+    const report = collectStartupPrerequisiteReport((command) => command === "codex");
+
+    expect(report.errors).toEqual([]);
+    expect(report.warnings.map((issue) => issue.command)).toEqual(["claude", "git", "gh", "curl"]);
+    expect(formatStartupPrerequisiteReport(report)).toEqual([
+      "Octogent startup preflight:",
+      "  Warning: `claude` is not installed.",
+      "    Claude-backed terminals are unavailable. Install Claude Code and run `claude login` if you want the default Claude provider.",
+      "  Warning: `git` is not installed.",
+      "    Worktree terminals and git lifecycle actions are unavailable. Install Git to enable branch/worktree flows.",
+      "  Warning: `gh` is not installed.",
+      "    GitHub pull request features are unavailable. Install GitHub CLI and run `gh auth login` to enable PR actions.",
+      "  Warning: `curl` is not installed.",
+      "    Claude hook command callbacks for SessionStart, UserPromptSubmit, and Stop are unavailable. Install curl to restore full Claude hook delivery.",
+    ]);
+  });
+
+  it("uses where on Windows and which elsewhere when checking commands", () => {
+    const calls: Array<{ file: string; args: string[] }> = [];
+
+    const windowsAvailable = isCommandAvailable("claude", {
+      platform: "win32",
+      execFileSyncImpl: ((file, args) => {
+        calls.push({ file, args: args as string[] });
+        return Buffer.from("");
+      }) as typeof import("node:child_process").execFileSync,
+    });
+
+    const unixAvailable = isCommandAvailable("codex", {
+      platform: "linux",
+      execFileSyncImpl: ((file, args) => {
+        calls.push({ file, args: args as string[] });
+        return Buffer.from("");
+      }) as typeof import("node:child_process").execFileSync,
+    });
+
+    expect(windowsAvailable).toBe(true);
+    expect(unixAvailable).toBe(true);
+    expect(calls).toEqual([
+      { file: "where", args: ["claude"] },
+      { file: "which", args: ["codex"] },
+    ]);
+  });
+});