@golba98/codexa 1.0.2 → 1.0.4

package/src/core/process/CommandRunner.test.ts

@@ -1,105 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import test from "node:test";
-import { runCommand, runShellCommand, summarizeCommandResult, type CommandResult } from "./CommandRunner.js";
-
-function makeResult(overrides: Partial<CommandResult> = {}): CommandResult {
-  return {
-    status: "completed",
-    exitCode: 0,
-    signal: null,
-    stdout: "",
-    stderr: "",
-    startedAt: 1,
-    endedAt: 2,
-    durationMs: 1,
-    userMessage: "Command completed.",
-    ...overrides,
-  };
-}
-
-test("summarizes ripgrep file listings without flooding the UI", () => {
-  const result = makeResult({
-    stdout: "src/app.tsx\nsrc/ui/BottomComposer.tsx\n",
-  });
-
-  assert.equal(summarizeCommandResult("rg --files", result), "Found 2 files.");
-});
-
-test("keeps a concise fallback summary for generic successful commands", () => {
-  const result = makeResult({
-    stdout: "alpha\nbeta\ngamma\n",
-  });
-
-  assert.equal(summarizeCommandResult("node script.js", result), "Produced 3 lines of output.");
-});
-
-test("preserves the failure message for unsuccessful commands", () => {
-  const result = makeResult({
-    status: "failed",
-    exitCode: 1,
-    userMessage: "git exited with code 1.",
-    stderr: "fatal: not a git repository",
-  });
-
-  assert.equal(summarizeCommandResult("git status", result), "git exited with code 1.");
-});
-
-test("runCommand executes a direct executable with argument array", async () => {
-  const runner = runCommand({
-    executable: process.execPath,
-    args: ["-e", "console.log(process.argv[1])", "direct-ok"],
-    cwd: process.cwd(),
-  });
-
-  const result = await runner.result;
-  assert.equal(result.status, "completed");
-  assert.equal(result.exitCode, 0);
-  assert.equal(result.stdout.trim(), "direct-ok");
-});
-
-test("runCommand rejects obvious executable injection", () => {
-  assert.throws(
-    () => runCommand({
-      executable: "node & echo injected",
-      args: ["--version"],
-      cwd: process.cwd(),
-    }),
-    /single executable name|shell metacharacters/i,
-  );
-});
-
-test("runShellCommand is the explicit shell execution path", async () => {
-  const runner = runShellCommand("echo shell-ok", { cwd: process.cwd() });
-  const result = await runner.result;
-
-  assert.equal(result.status, "completed");
-  assert.equal(result.exitCode, 0);
-  assert.match(result.stdout, /shell-ok/);
-});
-
-test("command runner reports lifecycle boundaries for terminal title reassertion", () => {
-  const source = readFileSync(fileURLToPath(new URL("./CommandRunner.ts", import.meta.url)), "utf8");
-  const beforeSpawnIndex = source.indexOf('handlers.onProcessLifecycle?.("before-spawn")');
-  const spawnIndex = source.indexOf("child = spawn(");
-  const spawnedIndex = source.indexOf('handlers.onProcessLifecycle?.("spawned")', spawnIndex);
-  const errorIndex = source.indexOf('child.once("error"', spawnIndex);
-  const lifecycleErrorIndex = source.indexOf('handlers.onProcessLifecycle?.("error")', errorIndex);
-  const closeIndex = source.indexOf('child.once("close"', spawnIndex);
-  const exitIndex = source.indexOf('handlers.onProcessLifecycle?.("exit")', closeIndex);
-  const cancelIndex = source.indexOf("cancel: () =>");
-  const lifecycleCancelIndex = source.indexOf('handlers.onProcessLifecycle?.("cancel")', cancelIndex);
-
-  assert.ok(beforeSpawnIndex >= 0 && beforeSpawnIndex < spawnIndex);
-  assert.ok(spawnedIndex > spawnIndex);
-  assert.ok(lifecycleErrorIndex > errorIndex);
-  assert.ok(exitIndex > closeIndex);
-  assert.ok(lifecycleCancelIndex > cancelIndex);
-});
-
-test("generic command runner does not expose shell mode", () => {
-  const source = readFileSync(fileURLToPath(new URL("./CommandRunner.ts", import.meta.url)), "utf8");
-  assert.equal(source.includes("shell?: boolean"), false);
-  assert.equal(source.includes("spec.shell"), false);
-});

package/src/core/projectInstructions.test.ts

@@ -1,50 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import { loadProjectInstructions } from "./projectInstructions.js";
-
-function withTempWorkspace(run: (workspaceRoot: string) => void) {
-  const workspaceRoot = mkdtempSync(join(tmpdir(), "codexa-instructions-"));
-  try {
-    run(workspaceRoot);
-  } finally {
-    rmSync(workspaceRoot, { recursive: true, force: true });
-  }
-}
-
-test("loads AGENTS.md from the workspace root first", () => {
-  withTempWorkspace((workspaceRoot) => {
-    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
-    writeFileSync(join(workspaceRoot, "AGENTS.md"), "root instructions\n", "utf8");
-    writeFileSync(join(workspaceRoot, ".codex", "AGENTS.md"), "nested instructions\n", "utf8");
-
-    const result = loadProjectInstructions(workspaceRoot);
-
-    assert.equal(result.status, "loaded");
-    if (result.status !== "loaded") return;
-    assert.equal(result.instructions.content, "root instructions");
-    assert.match(result.instructions.path, /AGENTS\.md$/);
-  });
-});
-
-test("falls back to .codex/AGENTS.md", () => {
-  withTempWorkspace((workspaceRoot) => {
-    mkdirSync(join(workspaceRoot, ".codex"), { recursive: true });
-    writeFileSync(join(workspaceRoot, ".codex", "AGENTS.md"), "project instructions\n", "utf8");
-
-    const result = loadProjectInstructions(workspaceRoot);
-
-    assert.equal(result.status, "loaded");
-    if (result.status !== "loaded") return;
-    assert.equal(result.instructions.content, "project instructions");
-    assert.match(result.instructions.path, /\.codex[\\/]AGENTS\.md$/);
-  });
-});
-
-test("treats missing instruction files as non-fatal", () => {
-  withTempWorkspace((workspaceRoot) => {
-    assert.deepEqual(loadProjectInstructions(workspaceRoot), { status: "missing" });
-  });
-});

package/src/core/providerLauncher/launcher.test.ts

@@ -1,238 +0,0 @@
-import assert from "node:assert/strict";
-import { EventEmitter } from "events";
-import test from "node:test";
-import { buildProviderLaunchSpec, launchProviderCli } from "./launcher.js";
-import type { ProviderConfig } from "./types.js";
-
-function makeProvider(overrides: Partial<ProviderConfig> = {}): ProviderConfig {
-  return {
-    id: "openai",
-    displayName: "OpenAI",
-    currentModel: "gpt-5.4",
-    backendType: "codex-cli-auth",
-    routeMode: "in-codexa",
-    enabled: true,
-    statusLabel: "Enabled",
-    launchCommand: { executable: "codex", args: [] },
-    isDefault: true,
-    isActiveRoute: true,
-    routeUnavailableReason: null,
-    ...overrides,
-  };
-}
-
-test("builds launch specs for enabled providers", () => {
-  const spec = buildProviderLaunchSpec(makeProvider({
-    launchCommand: { executable: "claude", args: ["--resume"] },
-  }), "C:\\Workspace");
-
-  assert.equal("status" in spec, false);
-  if ("status" in spec) return;
-  assert.equal(spec.executable, "claude");
-  assert.deepEqual(spec.args, ["--resume"]);
-  assert.equal(spec.cwd, "C:\\Workspace");
-});
-
-test("disabled providers fail before spawning", () => {
-  const result = buildProviderLaunchSpec(makeProvider({
-    id: "local",
-    displayName: "Local",
-    backendType: "local-openai-compatible",
-    enabled: false,
-    statusLabel: "Disabled",
-    launchCommand: null,
-    isDefault: false,
-  }), "C:\\Workspace");
-
-  assert.equal("status" in result, true);
-  assert.equal("status" in result ? result.status : "", "disabled");
-  assert.match("status" in result ? result.message : "", /Configure a command/i);
-});
-
-test("unsafe configured launch commands fail before spawning", () => {
-  const result = buildProviderLaunchSpec(makeProvider({
-    launchCommand: { executable: "codex & calc", args: [] },
-  }), "C:\\Workspace");
-
-  assert.equal("status" in result, true);
-  assert.equal("status" in result ? result.status : "", "spawn-error");
-  assert.match("status" in result ? result.message : "", /unsafe launch command/i);
-});
-
-test("missing command spawn errors become friendly launch results", async () => {
-  const child = new EventEmitter();
-  const spawnImpl = (() => {
-    queueMicrotask(() => {
-      const error = new Error("not found") as NodeJS.ErrnoException;
-      error.code = "ENOENT";
-      child.emit("error", error);
-    });
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace",
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "missing-command");
-  assert.match(result.message, /codex.*PATH/i);
-});
-
-test("missing command preflight fails before suspending raw mode", async () => {
-  const rawModes: boolean[] = [];
-  let didSpawn = false;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace",
-    stdin: {
-      isRaw: true,
-      setRawMode(enabled) {
-        rawModes.push(enabled);
-      },
-    },
-    commandExists: () => false,
-    spawnImpl: (() => {
-      didSpawn = true;
-      return new EventEmitter();
-    }) as unknown as typeof import("child_process").spawn,
-  });
-
-  assert.equal(result.status, "missing-command");
-  assert.equal(didSpawn, false);
-  assert.deepEqual(rawModes, []);
-});
-
-test("launch restores raw mode after child exits", async () => {
-  const child = new EventEmitter();
-  const rawModes: boolean[] = [];
-  const spawnImpl = (() => {
-    queueMicrotask(() => child.emit("close", 0, null));
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace",
-    stdin: {
-      isRaw: true,
-      setRawMode(enabled) {
-        rawModes.push(enabled);
-      },
-    },
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "completed");
-  assert.deepEqual(rawModes, [false, true]);
-});
-
-test("launch passes the workspace root as the child cwd", async () => {
-  const child = new EventEmitter();
-  let observedCwd = "";
-  let observedShell: boolean | undefined = undefined;
-  const spawnImpl = ((_executable: string, _args: string[], options: { cwd?: string; shell?: boolean }) => {
-    observedCwd = options.cwd ?? "";
-    observedShell = options.shell;
-    queueMicrotask(() => child.emit("close", 0, null));
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace\\Project",
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "completed");
-  assert.equal(observedCwd, "C:\\Workspace\\Project");
-  assert.equal(observedShell, false);
-});
-
-test("launch wraps Windows batch commands without enabling shell mode", async () => {
-  if (process.platform !== "win32") return;
-
-  const child = new EventEmitter();
-  let observedExecutable = "";
-  let observedArgs: string[] = [];
-  let observedShell: boolean | undefined = undefined;
-  const spawnImpl = ((executable: string, args: string[], options: { shell?: boolean }) => {
-    observedExecutable = executable;
-    observedArgs = args;
-    observedShell = options.shell;
-    queueMicrotask(() => child.emit("close", 0, null));
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider({
-    launchCommand: { executable: "codex.cmd", args: ["--resume"] },
-  }), {
-    cwd: "C:\\Workspace",
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "completed");
-  assert.equal(observedExecutable, "cmd.exe");
-  assert.deepEqual(observedArgs, ["/d", "/s", "/c", "call", "codex.cmd", "--resume"]);
-  assert.equal(observedShell, false);
-});
-
-test("launch runs suspend and resume hooks around raw mode changes", async () => {
-  const child = new EventEmitter();
-  const events: string[] = [];
-  const spawnImpl = (() => {
-    events.push("spawn");
-    queueMicrotask(() => child.emit("close", 0, null));
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace",
-    stdin: {
-      isRaw: true,
-      setRawMode(enabled) {
-        events.push(enabled ? "raw-on" : "raw-off");
-      },
-    },
-    beforeLaunch: () => events.push("before"),
-    afterLaunch: () => events.push("after"),
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "completed");
-  assert.deepEqual(events, ["before", "raw-off", "spawn", "raw-on", "after"]);
-});
-
-test("launch restores terminal state after child spawn error", async () => {
-  const child = new EventEmitter();
-  const events: string[] = [];
-  const spawnImpl = (() => {
-    events.push("spawn");
-    queueMicrotask(() => {
-      const error = new Error("blocked") as NodeJS.ErrnoException;
-      error.code = "EPERM";
-      child.emit("error", error);
-    });
-    return child;
-  }) as unknown as typeof import("child_process").spawn;
-
-  const result = await launchProviderCli(makeProvider(), {
-    cwd: "C:\\Workspace",
-    stdin: {
-      isRaw: true,
-      setRawMode(enabled) {
-        events.push(enabled ? "raw-on" : "raw-off");
-      },
-    },
-    beforeLaunch: () => events.push("before"),
-    afterLaunch: () => events.push("after"),
-    commandExists: () => true,
-    spawnImpl,
-  });
-
-  assert.equal(result.status, "spawn-error");
-  assert.deepEqual(events, ["before", "raw-off", "spawn", "raw-on", "after"]);
-});