@golba98/codexa 1.0.1 → 1.0.3

package/src/core/terminal/terminalTitle.test.ts

@@ -1,328 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  acquireTerminalTitleGuard,
-  buildTerminalTitleSequence,
-  computeTerminalTitle,
-  deriveTerminalTitle,
-  formatTerminalTitleLabel,
-  getIntendedTerminalTitle,
-  normalizeTerminalTitle,
-  reassertTerminalTitle,
-  reassertIntendedTerminalTitle,
-  sanitizeTerminalTitle,
-  setIntendedTerminalTitle,
-  setTerminalTitle,
-  startTerminalTitleStartupGuard,
-  beginColdStartSequence,
-  createTerminalTitleSequenceStripper,
-  stripTerminalTitleSequences,
-  stripTerminalTitleSequencesFromChunk,
-  traceTerminalTitleSequences,
-  writeCodexaTerminalTitle,
-  writeGuardedTerminalOutput,
-  __resetTerminalTitleCache,
-} from "./terminalTitle.js";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-test("buildTerminalTitleSequence emits OSC 0 and OSC 2 with sanitized title text", () => {
-  const sequence = buildTerminalTitleSequence("Codexa\u0007!");
-  assert.equal(sequence, "\x1b]0;Codexa !\x07\x1b]2;Codexa !\x07");
-  assert.equal(sanitizeTerminalTitle("  Codexa  "), "Codexa");
-});
-
-test("title normalization never exposes raw Windows paths", () => {
-  assert.equal(normalizeTerminalTitle("C:\\WINDOWS\\system"), "Codexa");
-  assert.equal(normalizeTerminalTitle("c:/Users/example"), "Codexa");
-  assert.equal(normalizeTerminalTitle("\\\\server\\share"), "Codexa");
-  assert.equal(buildTerminalTitleSequence("C:\\WINDOWS\\system"), buildTerminalTitleSequence("Codexa"));
-});
-
-test("stripTerminalTitleSequences removes OSC 0 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC 2 title sequences with BEL terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]2;Codex\x07world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequences preserves normal ANSI SGR colour sequences", () => {
-  const input = "\x1b[31mred\x1b[0m";
-  assert.equal(stripTerminalTitleSequences(input), input);
-});
-
-test("stripTerminalTitleSequences removes title OSC from mixed output while preserving SGR", () => {
-  assert.equal(
-    stripTerminalTitleSequences("start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend"),
-    "startmiddle\x1b[32mok\x1b[0mend",
-  );
-});
-
-test("stripTerminalTitleSequences removes OSC title sequences with ST terminator", () => {
-  assert.equal(
-    stripTerminalTitleSequences("hello\x1b]0;C:\\WINDOWS\\system\x1b\\world"),
-    "helloworld",
-  );
-});
-
-test("stripTerminalTitleSequencesFromChunk handles Buffer input", () => {
-  assert.equal(
-    stripTerminalTitleSequencesFromChunk(Buffer.from("hello\x1b]0;C:\\WINDOWS\\system\x07world", "utf8")),
-    "helloworld",
-  );
-});
-
-test("createTerminalTitleSequenceStripper removes title sequences split across chunks", () => {
-  const stripper = createTerminalTitleSequenceStripper({
-    source: "test",
-    stream: "stdout",
-    origin: "child",
-  });
-
-  assert.equal(stripper.process("hello\x1b]0;C:\\WINDOWS"), "hello");
-  assert.equal(stripper.process("\\system\x07world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("formatTerminalTitleLabel follows the workspace leaf and app-name rules", () => {
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "dir"),
-    "13-Custom-CLI-Normal",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "name"),
-    "Codexa",
-  );
-  assert.equal(
-    formatTerminalTitleLabel("C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal", "simple"),
-    "Codexa",
-  );
-});
-
-test("deriveTerminalTitle follows terminal title mode on startup", () => {
-  const workspaceRoot = "C:\\Development\\1-JavaScript\\13-Custom-CLI-Normal";
-
-  assert.equal(deriveTerminalTitle(workspaceRoot, "dir"), "13-Custom-CLI-Normal");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "name"), "Codexa");
-  assert.equal(deriveTerminalTitle(workspaceRoot, "simple"), "Codexa");
-});
-
-test("computeTerminalTitle follows the requested mapping", () => {
-  const workspaceName = "13-Custom-CLI-Normal";
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", workspaceName }), "13-Custom-CLI-Normal");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "name" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "simple" }), "Codexa");
-  assert.equal(computeTerminalTitle({ terminalTitleMode: "dir", appName: "Other" }), "Other");
-});
-
-test("reassertTerminalTitle writes both title sequences without mutating process title", () => {
-  const writes: string[] = [];
-  const originalTitle = process.title;
-
-  try {
-    reassertTerminalTitle("Codexa", (chunk) => {
-      writes.push(chunk);
-    });
-
-    assert.equal(process.title, originalTitle);
-    assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-  } finally {
-    process.title = originalTitle;
-  }
-});
-
-test("acquireTerminalTitleGuard asserts immediately, ticks while active, and reasserts on release", async () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(10, () => {
-    calls += 1;
-  });
-
-  await sleep(35);
-  release();
-
-  const callsAfterRelease = calls;
-  await sleep(20);
-
-  assert.ok(callsAfterRelease >= 3, `expected at least 3 title assertions, got ${callsAfterRelease}`);
-  assert.equal(calls, callsAfterRelease);
-});
-
-test("acquireTerminalTitleGuard release is idempotent", () => {
-  let calls = 0;
-  const release = acquireTerminalTitleGuard(50, () => {
-    calls += 1;
-  });
-
-  release();
-  const callsAfterFirstRelease = calls;
-  release();
-
-  assert.equal(callsAfterFirstRelease, 2);
-  assert.equal(calls, callsAfterFirstRelease);
-});
-
-test("setTerminalTitle deduplicates identical title writes", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Other", { write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 2);
-  assert.equal(writes[0], buildTerminalTitleSequence("Codexa"));
-  assert.equal(writes[1], buildTerminalTitleSequence("Other"));
-});
-
-test("writeCodexaTerminalTitle delegates to central title writer with force support", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  writeCodexaTerminalTitle("Codexa", { force: true, reason: "test", write: (chunk) => writes.push(chunk) });
-
-  assert.deepEqual(writes, [buildTerminalTitleSequence("Codexa")]);
-});
-
-test("intended terminal title fallback is safe and later replaced by workspace title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("C:\\WINDOWS\\system", {
-    force: true,
-    reason: "test-fallback",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "Codexa");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("Codexa"));
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    reason: "test-workspace",
-    write: (chunk) => writes.push(chunk),
-  });
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.equal(writes.at(-1), buildTerminalTitleSequence("13-Custom-CLI-Normal"));
-});
-
-test("busy idle reassertion keeps the same intended title", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  reassertIntendedTerminalTitle({ reason: "busy-start", write: (chunk) => writes.push(chunk) });
-  reassertIntendedTerminalTitle({ reason: "busy-end", write: (chunk) => writes.push(chunk) });
-
-  assert.equal(getIntendedTerminalTitle(), "13-Custom-CLI-Normal");
-  assert.deepEqual(writes, [
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-    buildTerminalTitleSequence("13-Custom-CLI-Normal"),
-  ]);
-});
-
-test("writeGuardedTerminalOutput strips external title OSC and preserves SGR", () => {
-  const writes: string[] = [];
-  const result = writeGuardedTerminalOutput(
-    (chunk) => {
-      writes.push(chunk);
-      return true;
-    },
-    "start\x1b]0;C:\\WINDOWS\\system\x07middle\x1b[32mok\x1b[0mend",
-    { source: "test", stream: "stdout", origin: "child" },
-  );
-
-  assert.equal(result, true);
-  assert.deepEqual(writes, ["startmiddle\x1b[32mok\x1b[0mend"]);
-});
-
-test("setTerminalTitle force option bypasses dedup", () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setTerminalTitle("Codexa", { write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-  setTerminalTitle("Codexa", { force: true, write: (chunk) => writes.push(chunk) });
-
-  assert.equal(writes.length, 3);
-  writes.forEach((w) => assert.equal(w, buildTerminalTitleSequence("Codexa")));
-});
-
-test("beginColdStartSequence writes immediately then retries", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  const cancel = beginColdStartSequence("Codexa", { write: (chunk) => writes.push(chunk) });
-  
-  assert.equal(writes.length, 1, "should write immediately");
-  
-  await sleep(60);
-  assert.equal(writes.length, 2, "should have retried at 50ms");
-  
-  cancel();
-  await sleep(300);
-  assert.equal(writes.length, 2, "should not have retried further after cancel");
-});
-
-test("startup guard reasserts intended title until cancelled", async () => {
-  const writes: string[] = [];
-  __resetTerminalTitleCache();
-
-  setIntendedTerminalTitle("13-Custom-CLI-Normal", {
-    force: true,
-    write: (chunk) => writes.push(chunk),
-  });
-  const cancel = startTerminalTitleStartupGuard({
-    intervalMs: 10,
-    durationMs: 100,
-    write: (chunk) => writes.push(chunk),
-  });
-
-  await sleep(25);
-  cancel();
-  const writesAfterCancel = writes.length;
-  await sleep(25);
-
-  assert.ok(writesAfterCancel >= 3, `expected guard to reassert title, got ${writesAfterCancel} writes`);
-  assert.equal(writes.length, writesAfterCancel);
-  assert.ok(writes.every((chunk) => chunk === buildTerminalTitleSequence("13-Custom-CLI-Normal")));
-});
-
-test("stripTerminalTitleSequences handles very long unterminated OSC without hanging", () => {
-  const long = "\x1b]0;" + "A".repeat(100_000);
-  const start = Date.now();
-  const result = stripTerminalTitleSequences(long);
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.ok(result.includes("\x1b]0;"), "unterminated sequence passes through unchanged");
-});
-
-test("stripTerminalTitleSequences strips OSC sequence with empty title", () => {
-  assert.equal(stripTerminalTitleSequences("pre\x1b]0;\x07post"), "prepost");
-  assert.equal(stripTerminalTitleSequences("pre\x1b]2;\x1b\\post"), "prepost");
-});
-
-test("createTerminalTitleSequenceStripper handles OSC split across chunks with ST terminator", () => {
-  const stripper = createTerminalTitleSequenceStripper({ source: "test", stream: "stdout", origin: "child" });
-  assert.equal(stripper.process("hello\x1b]2;MyTitle"), "hello");
-  assert.equal(stripper.process("\x1b\\world"), "world");
-  assert.equal(stripper.flush(), "");
-});
-
-test("traceTerminalTitleSequences does not hang on crafted adversarial input", () => {
-  const crafted = "\x1b]0;" + "X".repeat(10_000) + "\x1b]2;" + "Y".repeat(10_000);
-  const start = Date.now();
-  const found = traceTerminalTitleSequences(crafted, { source: "test", stream: "stdout", origin: "child" });
-  assert.ok(Date.now() - start < 100, "must complete in under 100 ms");
-  assert.equal(found, false, "no complete sequences in adversarial input");
-});

package/src/core/workspaceActivity.test.ts

@@ -1,163 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, unlinkSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import test from "node:test";
-import {
-  captureWorkspaceSnapshot,
-  createWorkspaceActivityTracker,
-  createTextDiffExcerpt,
-  diffWorkspaceSnapshots,
-} from "./workspaceActivity.js";
-
-function createTempWorkspace(): string {
-  return mkdtempSync(join(tmpdir(), "codex-workspace-activity-"));
-}
-
-test("detects created files in the workspace snapshot diff", () => {
-  const root = createTempWorkspace();
-  try {
-    const before = captureWorkspaceSnapshot(root);
-    writeFileSync(join(root, "new-file.ts"), "const value = 1;\n", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 123);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "created");
-    assert.equal(activity[0]?.path, "new-file.ts");
-    assert.equal(activity[0]?.addedLines, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("detects modified files with diff preview", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "edited.py");
-    writeFileSync(file, "print('before')\nvalue = 1\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(file, "print('after')\nvalue = 2\nextra = True\n", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 456);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "modified");
-    assert.equal(activity[0]?.path, "edited.py");
-    assert.equal(activity[0]?.addedLines, 3);
-    assert.equal(activity[0]?.removedLines, 2);
-    assert.equal(activity[0]?.diffLines?.[0]?.kind, "removed");
-    assert.equal(activity[0]?.diffLines?.at(-1)?.kind, "added");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("detects deleted files", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "gone.txt");
-    writeFileSync(file, "goodbye\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    unlinkSync(file);
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 789);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "deleted");
-    assert.equal(activity[0]?.path, "gone.txt");
-    assert.equal(activity[0]?.removedLines, 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("ignores excluded directories like node_modules and .git", () => {
-  const root = createTempWorkspace();
-  try {
-    const before = captureWorkspaceSnapshot(root);
-    mkdirSync(join(root, "node_modules"), { recursive: true });
-    mkdirSync(join(root, ".git"), { recursive: true });
-    writeFileSync(join(root, "node_modules", "ignored.js"), "console.log('x')", "utf8");
-    writeFileSync(join(root, ".git", "ignored.txt"), "internal", "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 111);
-
-    assert.equal(activity.length, 0);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("workspace activity tracker can reuse a provided initial snapshot", async () => {
-  const root = createTempWorkspace();
-  try {
-    writeFileSync(join(root, "edited.txt"), "before\n", "utf8");
-    writeFileSync(join(root, "gone.txt"), "delete me\n", "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(join(root, "new-file.ts"), "const value = 1;\n", "utf8");
-    writeFileSync(join(root, "edited.txt"), "after\n", "utf8");
-    unlinkSync(join(root, "gone.txt"));
-
-    const activity = await new Promise<ReturnType<typeof diffWorkspaceSnapshots>>((resolve, reject) => {
-      let tracker: ReturnType<typeof createWorkspaceActivityTracker> | null = null;
-      const timeout = setTimeout(() => {
-        tracker?.stop();
-        reject(new Error("Timed out waiting for workspace activity."));
-      }, 500);
-      tracker = createWorkspaceActivityTracker({
-        rootDir: root,
-        initialSnapshot: before,
-        pollIntervalMs: 10,
-        onActivity: (items) => {
-          clearTimeout(timeout);
-          tracker?.stop();
-          resolve(items);
-        },
-      });
-    });
-
-    const operationsByPath = new Map(activity.map((item) => [item.path, item.operation]));
-    assert.equal(operationsByPath.get("new-file.ts"), "created");
-    assert.equal(operationsByPath.get("edited.txt"), "modified");
-    assert.equal(operationsByPath.get("gone.txt"), "deleted");
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("skips inline diff previews for oversized files", () => {
-  const root = createTempWorkspace();
-  try {
-    const file = join(root, "large.txt");
-    const largeContent = `${"a".repeat(129 * 1024)}\n`;
-    writeFileSync(file, largeContent, "utf8");
-    const before = captureWorkspaceSnapshot(root);
-
-    writeFileSync(file, `${largeContent}tail\n`, "utf8");
-    const after = captureWorkspaceSnapshot(root);
-    const activity = diffWorkspaceSnapshots(before, after, 222);
-
-    assert.equal(activity.length, 1);
-    assert.equal(activity[0]?.operation, "modified");
-    assert.equal(activity[0]?.diffLines, undefined);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("creates green/red diff excerpts for mixed edits", () => {
-  const diff = createTextDiffExcerpt(
-    ["alpha", "beta", "gamma"].join("\n"),
-    ["alpha", "beta-2", "gamma", "delta"].join("\n"),
-  );
-
-  assert(diff);
-  assert.equal(diff.addedLines, 2);
-  assert.equal(diff.removedLines, 1);
-  assert.equal(diff.diffLines?.some((line) => line.kind === "added"), true);
-  assert.equal(diff.diffLines?.some((line) => line.kind === "removed"), true);
-});

package/src/core/workspaceGuard.test.ts

@@ -1,151 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  containsDirectoryNavigationCommand,
-  findOutsideWorkspacePaths,
-  getPromptWorkspaceGuardMessage,
-  getShellWorkspaceGuardMessage,
-  isPathInsideAllowedRoots,
-  isPathInsideWorkspace,
-  resolveWorkspacePath,
-} from "./workspaceGuard.js";
-import { normalizeWorkspaceRoot } from "./workspaceRoot.js";
-
-const workspaceRoot = normalizeWorkspaceRoot("C:/Users/Example/OneDrive/Desktop/3-Python/Programs/2-Personal/20-Tester");
-
-test("allows absolute paths inside the locked workspace", () => {
-  const violations = findOutsideWorkspacePaths(
-    "Please update C:\\Users\\Example\\OneDrive\\Desktop\\3-Python\\Programs\\2-Personal\\20-Tester\\src\\main.py",
-    workspaceRoot,
-  );
-
-  assert.deepEqual(violations, []);
-});
-
-test("blocks absolute paths outside the locked workspace", () => {
-  const violations = findOutsideWorkspacePaths(
-    "Please edit C:\\Users\\Example\\Desktop\\Other\\notes.txt",
-    workspaceRoot,
-  );
-
-  assert.equal(violations.length, 1);
-  assert.equal(
-    violations[0]?.normalizedPath,
-    "C:\\Users\\Example\\Desktop\\Other\\notes.txt",
-  );
-});
-
-test("parses quoted windows paths with spaces", () => {
-  const violations = findOutsideWorkspacePaths(
-    "Use \"C:\\Users\\Example\\Desktop\\Other Folder\\notes file.txt\" instead",
-    workspaceRoot,
-  );
-
-  assert.equal(violations.length, 1);
-  assert.equal(
-    violations[0]?.normalizedPath,
-    "C:\\Users\\Example\\Desktop\\Other Folder\\notes file.txt",
-  );
-});
-
-test("resolves relative paths inside the workspace", () => {
-  assert.equal(
-    resolveWorkspacePath("src\\main.py", workspaceRoot),
-    "C:\\Users\\Example\\OneDrive\\Desktop\\3-Python\\Programs\\2-Personal\\20-Tester\\src\\main.py",
-  );
-  assert.equal(isPathInsideWorkspace("src\\main.py", workspaceRoot), true);
-});
-
-test("blocks explicit relative paths that escape the workspace", () => {
-  const violations = findOutsideWorkspacePaths("Edit ..\\outside.txt", workspaceRoot);
-
-  assert.equal(violations.length, 1);
-  assert.equal(
-    violations[0]?.normalizedPath,
-    "C:\\Users\\Example\\OneDrive\\Desktop\\3-Python\\Programs\\2-Personal\\outside.txt",
-  );
-});
-
-test("treats same-path drive letter case differences as inside the workspace", () => {
-  assert.equal(
-    isPathInsideWorkspace(
-      "c:\\users\\Example\\onedrive\\desktop\\3-python\\programs\\2-personal\\20-tester\\src\\main.py",
-      workspaceRoot,
-    ),
-    true,
-  );
-});
-
-test("allows configured writable roots outside the locked workspace", () => {
-  const extraRoot = "C:\\Users\\Example\\Desktop\\Allowed Root";
-
-  assert.equal(
-    isPathInsideAllowedRoots("C:\\Users\\Example\\Desktop\\Allowed Root\\notes.txt", workspaceRoot, [extraRoot]),
-    true,
-  );
-
-  const promptMessage = getPromptWorkspaceGuardMessage(
-    "Edit \"C:\\Users\\Example\\Desktop\\Allowed Root\\notes.txt\"",
-    workspaceRoot,
-    [extraRoot],
-  );
-  assert.equal(promptMessage, null);
-
-  const shellMessage = getShellWorkspaceGuardMessage(
-    "type \"C:\\Users\\Example\\Desktop\\Allowed Root\\notes.txt\"",
-    workspaceRoot,
-    [extraRoot],
-  );
-  assert.equal(shellMessage, null);
-});
-
-test("still blocks paths outside the workspace and configured writable roots", () => {
-  const extraRoot = "C:\\Users\\Example\\Desktop\\Allowed Root";
-  const message = getPromptWorkspaceGuardMessage(
-    "Edit C:\\Users\\Example\\Desktop\\Other\\notes.txt",
-    workspaceRoot,
-    [extraRoot],
-  );
-
-  assert(message);
-  assert.match(message, /Allowed writable roots:/i);
-  assert.match(message, /Allowed Root/i);
-});
-
-test("returns a prompt guard message before a run starts", () => {
-  const message = getPromptWorkspaceGuardMessage(
-    "Edit C:\\Users\\Example\\Desktop\\Other\\notes.txt",
-    workspaceRoot,
-  );
-
-  assert(message);
-  assert.match(message, /Run blocked/i);
-  assert.match(message, /Locked workspace:/i);
-});
-
-test("blocks directory-changing shell commands", () => {
-  assert.equal(containsDirectoryNavigationCommand("cd .."), true);
-  assert.equal(containsDirectoryNavigationCommand("Set-Location .."), true);
-  assert.equal(containsDirectoryNavigationCommand("pushd .."), true);
-
-  const message = getShellWorkspaceGuardMessage("cd ..", workspaceRoot);
-  assert(message);
-  assert.match(message, /Directory-changing commands/i);
-});
-
-test("blocks shell commands that reference outside absolute paths", () => {
-  const message = getShellWorkspaceGuardMessage(
-    "type C:\\Users\\Example\\Desktop\\Other\\notes.txt",
-    workspaceRoot,
-  );
-
-  assert(message);
-  assert.match(message, /Outside path references:/i);
-});
-
-test("blocks shell commands that reference escaping relative paths", () => {
-  const message = getShellWorkspaceGuardMessage("type ..\\outside.txt", workspaceRoot);
-
-  assert(message);
-  assert.match(message, /Outside path references:/i);
-});

package/src/core/workspaceRoot.test.ts

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { normalizeWorkspaceRoot, resolveWorkspaceRoot } from "./workspaceRoot.js";
-
-test("prefers CODEX_WORKSPACE_ROOT when provided", () => {
-  const originalWorkspace = process.env.CODEX_WORKSPACE_ROOT;
-  try {
-    process.env.CODEX_WORKSPACE_ROOT = "D:/project/";
-    assert.equal(resolveWorkspaceRoot(), normalizeWorkspaceRoot("D:/project/"));
-  } finally {
-    process.env.CODEX_WORKSPACE_ROOT = originalWorkspace;
-  }
-});
-
-test("falls back to process.cwd when no workspace override exists", () => {
-  const originalWorkspace = process.env.CODEX_WORKSPACE_ROOT;
-  try {
-    delete process.env.CODEX_WORKSPACE_ROOT;
-    assert.equal(resolveWorkspaceRoot(), normalizeWorkspaceRoot(process.cwd()));
-  } finally {
-    process.env.CODEX_WORKSPACE_ROOT = originalWorkspace;
-  }
-});

package/src/exec.test.ts

@@ -1,13 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-
-test("codexa exec entrypoint does not import interactive UI modules", () => {
-  const source = readFileSync(fileURLToPath(new URL("./exec.ts", import.meta.url)), "utf8");
-
-  assert.doesNotMatch(source, /from\s+["']\.\/index(?:\.js)?["']/);
-  assert.doesNotMatch(source, /from\s+["']\.\/app(?:\.js)?["']/);
-  assert.doesNotMatch(source, /from\s+["']ink["']/);
-  assert.doesNotMatch(source, /from\s+["']react["']/);
-});