@golba98/codexa 1.0.1

package/src/core/attachments.test.ts

@@ -0,0 +1,155 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import path from "node:path";
+import { mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import {
+  isImageFile,
+  resolveAttachmentDestPath,
+  importExternalFile,
+  rewritePromptWithImportedPaths,
+} from "./attachments.js";
+
+// ─── isImageFile ─────────────────────────────────────────────────────────────
+
+test("isImageFile returns true for .png", () => {
+  assert.equal(isImageFile("screenshot.png"), true);
+});
+
+test("isImageFile returns true for .jpg", () => {
+  assert.equal(isImageFile("photo.jpg"), true);
+});
+
+test("isImageFile returns true for .jpeg", () => {
+  assert.equal(isImageFile("image.jpeg"), true);
+});
+
+test("isImageFile returns true for uppercase extension", () => {
+  assert.equal(isImageFile("PHOTO.JPG"), true);
+});
+
+test("isImageFile returns true for .webp", () => {
+  assert.equal(isImageFile("img.webp"), true);
+});
+
+test("isImageFile returns false for .txt", () => {
+  assert.equal(isImageFile("document.txt"), false);
+});
+
+test("isImageFile returns false for .ts", () => {
+  assert.equal(isImageFile("component.ts"), false);
+});
+
+test("isImageFile returns false for no extension", () => {
+  assert.equal(isImageFile("noext"), false);
+});
+
+// ─── resolveAttachmentDestPath ────────────────────────────────────────────────
+
+test("resolveAttachmentDestPath returns base filename when no collision", async () => {
+  const dir = path.join(tmpdir(), `codexa-attach-test-${Date.now()}`);
+  await mkdir(dir, { recursive: true });
+  try {
+    const dest = await resolveAttachmentDestPath("/some/path/file.png", dir);
+    assert.equal(path.basename(dest), "file.png");
+    assert.equal(path.dirname(dest), dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("resolveAttachmentDestPath appends -1 on collision", async () => {
+  const dir = path.join(tmpdir(), `codexa-attach-test-${Date.now()}`);
+  await mkdir(dir, { recursive: true });
+  try {
+    // Create a file that would collide
+    await writeFile(path.join(dir, "file.png"), "existing");
+    const dest = await resolveAttachmentDestPath("/some/path/file.png", dir);
+    assert.equal(path.basename(dest), "file-1.png");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("resolveAttachmentDestPath appends -2 on double collision", async () => {
+  const dir = path.join(tmpdir(), `codexa-attach-test-${Date.now()}`);
+  await mkdir(dir, { recursive: true });
+  try {
+    await writeFile(path.join(dir, "file.png"), "existing");
+    await writeFile(path.join(dir, "file-1.png"), "existing-1");
+    const dest = await resolveAttachmentDestPath("/some/path/file.png", dir);
+    assert.equal(path.basename(dest), "file-2.png");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+// ─── importExternalFile ───────────────────────────────────────────────────────
+
+test("importExternalFile creates attachments dir if missing and copies file", async () => {
+  const baseDir = path.join(tmpdir(), `codexa-import-test-${Date.now()}`);
+  const srcDir = path.join(baseDir, "src");
+  const destDir = path.join(baseDir, "attachments");
+  await mkdir(srcDir, { recursive: true });
+  const srcPath = path.join(srcDir, "test.png");
+  await writeFile(srcPath, "image-content");
+  try {
+    const destPath = await importExternalFile(srcPath, destDir);
+    assert.equal(path.basename(destPath), "test.png");
+    // Verify the file was copied
+    const { readFile } = await import("node:fs/promises");
+    const content = await readFile(destPath, "utf8");
+    assert.equal(content, "image-content");
+  } finally {
+    await rm(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ─── rewritePromptWithImportedPaths ──────────────────────────────────────────
+
+test("rewritePromptWithImportedPaths rewrites quoted path with spaces", () => {
+  const prompt = '"C:\\Users\\jorda\\OneDrive\\Screenshots\\Screenshot 2026.png" what is this?';
+  const result = rewritePromptWithImportedPaths(prompt, [{
+    rawPath: "C:\\Users\\jorda\\OneDrive\\Screenshots\\Screenshot 2026.png",
+    workspaceRelativePath: ".codexa/attachments/Screenshot 2026.png",
+  }]);
+  assert.equal(result, '".codexa/attachments/Screenshot 2026.png" what is this?');
+});
+
+test("rewritePromptWithImportedPaths rewrites unquoted path without spaces", () => {
+  const prompt = "Look at C:\\Users\\jorda\\file.png please";
+  const result = rewritePromptWithImportedPaths(prompt, [{
+    rawPath: "C:\\Users\\jorda\\file.png",
+    workspaceRelativePath: ".codexa/attachments/file.png",
+  }]);
+  assert.equal(result, "Look at .codexa/attachments/file.png please");
+});
+
+test("rewritePromptWithImportedPaths leaves non-matched text unchanged", () => {
+  const prompt = "hello world, no paths here";
+  const result = rewritePromptWithImportedPaths(prompt, [{
+    rawPath: "C:\\some\\other\\path.png",
+    workspaceRelativePath: ".codexa/attachments/path.png",
+  }]);
+  assert.equal(result, "hello world, no paths here");
+});
+
+test("rewritePromptWithImportedPaths does not double-quote already-quoted replacement path with spaces", () => {
+  const prompt = '"C:\\Users\\file with spaces.png" describe';
+  const result = rewritePromptWithImportedPaths(prompt, [{
+    rawPath: "C:\\Users\\file with spaces.png",
+    workspaceRelativePath: ".codexa/attachments/file with spaces.png",
+  }]);
+  // workspaceRelativePath has spaces → re-quoted; original was quoted → double-quoted match replaced
+  assert.equal(result, '".codexa/attachments/file with spaces.png" describe');
+});
+
+test("rewritePromptWithImportedPaths handles multiple replacements", () => {
+  // Paths without spaces get no quotes; the enclosing quotes from the original are consumed
+  const prompt = '"C:\\path\\a.png" and "C:\\path\\b.png" compare them';
+  const result = rewritePromptWithImportedPaths(prompt, [
+    { rawPath: "C:\\path\\a.png", workspaceRelativePath: ".codexa/attachments/a.png" },
+    { rawPath: "C:\\path\\b.png", workspaceRelativePath: ".codexa/attachments/b.png" },
+  ]);
+  assert.equal(result, ".codexa/attachments/a.png and .codexa/attachments/b.png compare them");
+});

package/src/core/attachments.ts

@@ -0,0 +1,71 @@
+import { access, copyFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+
+export const IMAGE_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".tif",
+  ".svg",
+]);
+
+export function isImageFile(filePath: string): boolean {
+  return IMAGE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function resolveAttachmentDestPath(
+  srcPath: string,
+  attachmentsDir: string,
+): Promise<string> {
+  const ext = path.extname(srcPath);
+  const base = path.basename(srcPath, ext);
+  let dest = path.join(attachmentsDir, `${base}${ext}`);
+  let counter = 1;
+  while (await fileExists(dest)) {
+    dest = path.join(attachmentsDir, `${base}-${counter}${ext}`);
+    counter++;
+  }
+  return dest;
+}
+
+export async function importExternalFile(
+  srcPath: string,
+  attachmentsDir: string,
+): Promise<string> {
+  await mkdir(attachmentsDir, { recursive: true });
+  const destPath = await resolveAttachmentDestPath(srcPath, attachmentsDir);
+  await copyFile(srcPath, destPath);
+  return destPath;
+}
+
+export function rewritePromptWithImportedPaths(
+  prompt: string,
+  replacements: Array<{ rawPath: string; workspaceRelativePath: string }>,
+): string {
+  let result = prompt;
+  for (const { rawPath, workspaceRelativePath } of replacements) {
+    const needsQuotes = /\s/.test(workspaceRelativePath);
+    const quotedReplacement = needsQuotes
+      ? `"${workspaceRelativePath}"`
+      : workspaceRelativePath;
+    // Replace quoted forms first so the unquoted pass doesn't double-replace
+    result = result.split(`"${rawPath}"`).join(quotedReplacement);
+    result = result.split(`'${rawPath}'`).join(quotedReplacement);
+    // Replace any remaining unquoted occurrences
+    result = result.split(rawPath).join(quotedReplacement);
+  }
+  return result;
+}

package/src/core/auth/codexAuth.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  getRunGateDecision,
+  getAuthStateLabel,
+  inferAuthStateFromProbe,
+  isLikelyAuthFailure,
+} from "./codexAuth.js";
+
+test("infers authenticated from successful probe exit", () => {
+  const state = inferAuthStateFromProbe(0, "", "");
+  assert.equal(state, "authenticated");
+});
+
+test("infers unauthenticated from signed-out probe output", () => {
+  const state = inferAuthStateFromProbe(
+    1,
+    "No active session. Please login.",
+    "",
+  );
+  assert.equal(state, "unauthenticated");
+});
+
+test("infers unknown from ambiguous probe output", () => {
+  const state = inferAuthStateFromProbe(
+    2,
+    "Usage: codex login status [OPTIONS]",
+    "unexpected argument '--json'",
+  );
+  assert.equal(state, "unknown");
+});
+
+test("blocks runs when unauthenticated", () => {
+  const decision = getRunGateDecision("unauthenticated");
+  assert.equal(decision.allowRun, false);
+  assert.match(decision.blockMessage ?? "", /codex login/i);
+});
+
+test("warns but allows runs when auth state is unknown", () => {
+  const decision = getRunGateDecision("unknown");
+  assert.equal(decision.allowRun, true);
+  assert.match(decision.warningMessage ?? "", /unknown/i);
+});
+
+test("allows unchecked initial auth state without a warning", () => {
+  const decision = getRunGateDecision("unknown", { warnOnUnknown: false });
+  assert.equal(decision.allowRun, true);
+  assert.equal(decision.warningMessage, undefined);
+});
+
+test("allows runs when authenticated", () => {
+  const decision = getRunGateDecision("authenticated");
+  assert.equal(decision.allowRun, true);
+  assert.equal(decision.warningMessage, undefined);
+});
+
+test("detects runtime auth failure messages", () => {
+  const detected = isLikelyAuthFailure("Unauthorized (401): token expired. Run codex login.");
+  assert.equal(detected, true);
+});
+
+test("getAuthStateLabel returns Checking for checking state", () => {
+  assert.equal(getAuthStateLabel("checking"), "Checking");
+});
+
+test("getAuthStateLabel returns Unknown for unknown state", () => {
+  assert.equal(getAuthStateLabel("unknown"), "Unknown");
+});

package/src/core/auth/codexAuth.ts

@@ -0,0 +1,359 @@
+import { spawn } from "child_process";
+import { formatCodexLaunchError, resolveCodexExecutable, spawnCodexProcess } from "../executables/codexExecutable.js";
+
+export type CodexAuthState = "checking" | "authenticated" | "unauthenticated" | "unknown";
+
+export interface CodexAuthProbeResult {
+  state: CodexAuthState;
+  checkedAt: number;
+  rawSummary: string;
+  recommendedAction: string;
+}
+
+interface CommandResult {
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+  error?: NodeJS.ErrnoException;
+}
+
+const JSON_STATUS_FLAGS = ["authenticated", "is_authenticated", "logged_in", "signed_in"] as const;
+
+const UNAUTHENTICATED_PATTERNS = [
+  "not logged in",
+  "not signed in",
+  "no active session",
+  "login required",
+  "sign in required",
+  "unauthenticated",
+  "authentication required",
+  "run `codex login`",
+  "run codex login",
+  "please login",
+  "please log in",
+  "session expired",
+  "token expired",
+] as const;
+
+const AUTH_FAILURE_PATTERNS = [
+  ...UNAUTHENTICATED_PATTERNS,
+  "unauthorized",
+  "forbidden",
+  "invalid token",
+  "invalid grant",
+  "access denied",
+  "401",
+  "403",
+] as const;
+
+export function getAuthStateLabel(state: CodexAuthState): string {
+  switch (state) {
+    case "authenticated":
+      return "Authenticated";
+    case "unauthenticated":
+      return "Signed out";
+    case "checking":
+      return "Checking";
+    default:
+      return "Unknown";
+  }
+}
+
+export function getLoginGuidance(): string {
+  return [
+    "Sign in to the Codexa neural network to continue.",
+    "Run this in your terminal:",
+    "  codex login",
+    "",
+    "If you were previously using API-key auth and want ChatGPT subscription auth:",
+    "  codex logout",
+    "  codex",
+  ].join("\n");
+}
+
+export function getLogoutGuidance(): string {
+  return [
+    "You are managing your Codexa sign-out state.",
+    "Run this in your terminal:",
+    "  codex logout",
+    "",
+    "After logging out, use /auth status in this UI to refresh state.",
+  ].join("\n");
+}
+
+export function getAuthStatusMessage(result: CodexAuthProbeResult): string {
+  if (result.state === "authenticated") {
+    return [
+      "Codexa authentication looks healthy.",
+      "State: Authenticated",
+      `Summary: ${result.rawSummary}`,
+    ].join("\n");
+  }
+
+  if (result.state === "unauthenticated") {
+    return [
+      "Codexa is currently signed out.",
+      "State: Signed out",
+      `Summary: ${result.rawSummary}`,
+      "Recovery:",
+      "  codex login",
+    ].join("\n");
+  }
+
+  if (result.state === "checking") {
+    return "Authentication check is currently running.";
+  }
+
+  return [
+    "Codexa auth state is unknown. This can happen on unsupported neural versions.",
+    `Summary: ${result.rawSummary}`,
+    `Recommended action: ${result.recommendedAction}`,
+  ].join("\n");
+}
+
+export interface RunGateDecision {
+  allowRun: boolean;
+  blockMessage?: string;
+  warningMessage?: string;
+}
+
+export interface RunGateDecisionOptions {
+  warnOnUnknown?: boolean;
+}
+
+export function getRunGateDecision(
+  authState: CodexAuthState,
+  options: RunGateDecisionOptions = {},
+): RunGateDecision {
+  if (authState === "unauthenticated") {
+    return {
+      allowRun: false,
+      blockMessage: [
+        "Run blocked: Codexa is signed out.",
+        "Sign in first with your ChatGPT subscription:",
+        "  codex login",
+      ].join("\n"),
+    };
+  }
+
+  if (authState === "unknown" || authState === "checking") {
+    if (options.warnOnUnknown === false) {
+      return { allowRun: true };
+    }
+
+    return {
+      allowRun: true,
+      warningMessage:
+        "Auth state is unknown. Run is allowed, but if this fails, use `codex login` and try again.",
+    };
+  }
+
+  return { allowRun: true };
+}
+
+export function inferAuthStateFromProbe(
+  exitCode: number | null,
+  stdout: string,
+  stderr: string,
+): CodexAuthState {
+  if (exitCode === 0) return "authenticated";
+
+  const jsonState = inferAuthStateFromJson(stdout);
+  if (jsonState) return jsonState;
+
+  const output = `${stdout}\n${stderr}`.toLowerCase();
+
+  if (UNAUTHENTICATED_PATTERNS.some((pattern) => output.includes(pattern))) {
+    return "unauthenticated";
+  }
+
+  return "unknown";
+}
+
+export function isLikelyAuthFailure(message: string): boolean {
+  const lower = message.toLowerCase();
+  return AUTH_FAILURE_PATTERNS.some((pattern) => lower.includes(pattern));
+}
+
+export async function probeCodexAuthStatus(): Promise<CodexAuthProbeResult> {
+  const attempts: string[][] = [
+    ["login", "status", "--json"],
+    ["login", "status"],
+  ];
+
+  const summaries: string[] = [];
+
+  for (let index = 0; index < attempts.length; index += 1) {
+    const args = attempts[index]!;
+    const result = await runCodexCommand(args);
+    const summary = summarizeAttempt(args, result);
+    summaries.push(summary);
+
+    if (result.error) {
+      if (isCodexUnavailableError(result.error)) {
+        return {
+          state: "unknown",
+          checkedAt: Date.now(),
+          rawSummary: summary,
+          recommendedAction:
+            "Set CODEX_EXECUTABLE to a working Codex command/path, restart Codexa, then run /auth status again.",
+        };
+      }
+
+      continue;
+    }
+
+    const inferred = inferAuthStateFromProbe(result.exitCode, result.stdout, result.stderr);
+
+    if (inferred === "authenticated" || inferred === "unauthenticated") {
+      return {
+        state: inferred,
+        checkedAt: Date.now(),
+        rawSummary: summary,
+        recommendedAction: inferred === "authenticated" ? "None" : "Run `codex login` and retry.",
+      };
+    }
+  }
+
+  return {
+    state: "unknown",
+    checkedAt: Date.now(),
+    rawSummary: summaries.join(" | "),
+    recommendedAction: "If runs fail, sign in with `codex login`, then retry `/auth status`.",
+  };
+}
+
+function inferAuthStateFromJson(raw: string): CodexAuthState | null {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+
+  try {
+    const payload = JSON.parse(trimmed) as Record<string, unknown>;
+
+    for (const key of JSON_STATUS_FLAGS) {
+      const value = payload[key];
+      if (typeof value === "boolean") {
+        return value ? "authenticated" : "unauthenticated";
+      }
+    }
+
+    const status = payload.status;
+    if (typeof status === "string") {
+      const lower = status.toLowerCase();
+      if (lower.includes("auth")) return "authenticated";
+      if (lower.includes("unauth")) return "unauthenticated";
+      if (lower.includes("signed_out")) return "unauthenticated";
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function runCodexCommand(args: string[], timeoutMs = 6000): Promise<CommandResult> {
+  return new Promise<CommandResult>((resolve) => {
+    let done = false;
+    let proc: ReturnType<typeof spawn> | null = null;
+
+    let stdout = "";
+    let stderr = "";
+
+    const finish = (result: CommandResult) => {
+      if (done) return;
+      done = true;
+      resolve(result);
+    };
+
+    const startWithExecutable = async () => {
+      let executable: string;
+      try {
+        executable = await resolveCodexExecutable();
+      } catch (error) {
+        const errno = error as NodeJS.ErrnoException;
+        finish({
+          exitCode: null,
+          stdout,
+          stderr: formatCodexLaunchError(errno),
+          timedOut: false,
+          error: errno,
+        });
+        return;
+      }
+
+      if (done) return;
+      try {
+        proc = spawnCodexProcess(executable, args, { stdio: ["ignore", "pipe", "pipe"] });
+      } catch (error) {
+        const errno = error as NodeJS.ErrnoException;
+        clearTimeout(timer);
+        finish({
+          exitCode: null,
+          stdout,
+          stderr: formatCodexLaunchError(errno),
+          timedOut: false,
+          error: errno,
+        });
+        return;
+      }
+
+      proc.stdout?.on("data", (chunk: Buffer) => {
+        stdout += chunk.toString();
+      });
+
+      proc.stderr?.on("data", (chunk: Buffer) => {
+        stderr += chunk.toString();
+      });
+
+      proc.on("error", (error) => {
+        clearTimeout(timer);
+        const errno = error as NodeJS.ErrnoException;
+        finish({
+          exitCode: null,
+          stdout,
+          stderr: formatCodexLaunchError(errno),
+          timedOut: false,
+          error: errno,
+        });
+      });
+
+      proc.on("close", (exitCode) => {
+        clearTimeout(timer);
+        finish({
+          exitCode,
+          stdout,
+          stderr,
+          timedOut: false,
+        });
+      });
+    };
+
+    const timer = setTimeout(() => {
+      proc?.kill();
+      finish({
+        exitCode: null,
+        stdout,
+        stderr,
+        timedOut: true,
+      });
+    }, timeoutMs);
+
+    void startWithExecutable();
+  });
+}
+
+function summarizeAttempt(args: string[], result: CommandResult): string {
+  const status =
+    result.error?.code ??
+    (result.timedOut ? "timeout" : `exit:${result.exitCode ?? "null"}`);
+
+  const combined = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join(" | ");
+  const output = combined.length > 140 ? `${combined.slice(0, 137)}...` : combined || "no output";
+
+  return `[${args.join(" ")}] ${status} - ${output}`;
+}
+
+function isCodexUnavailableError(error: NodeJS.ErrnoException): boolean {
+  return error.code === "ENOENT" || error.code === "EACCES" || error.code === "EPERM";
+}