@meshxdata/fops 0.0.1

package/src/agent/llm.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("execa", () => ({
+  execa: vi.fn(),
+  execaSync: vi.fn(),
+}));
+
+vi.mock("../auth/index.js", () => ({
+  resolveAnthropicApiKey: vi.fn(() => null),
+  resolveOpenAiApiKey: vi.fn(() => null),
+  readClaudeCodeKeychain: vi.fn(() => null),
+}));
+
+vi.mock("../ui/index.js", () => ({
+  renderSpinner: vi.fn(() => ({ stop: vi.fn() })),
+}));
+
+const { execa, execaSync } = await import("execa");
+const { readClaudeCodeKeychain } = await import("../auth/index.js");
+const { hasClaudeCode, hasClaudeCodeAuth, runViaClaudeCode, streamViaClaudeCode } = await import("./llm.js");
+
+describe("llm", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("hasClaudeCode", () => {
+    it("returns true when claude is on PATH", () => {
+      execaSync.mockReturnValue({ stdout: "/usr/local/bin/claude" });
+      expect(hasClaudeCode()).toBe(true);
+    });
+
+    it("returns false when claude is not found", () => {
+      execaSync.mockImplementation(() => { throw new Error("not found"); });
+      expect(hasClaudeCode()).toBe(false);
+    });
+
+    it("calls which claude", () => {
+      execaSync.mockReturnValue({ stdout: "" });
+      hasClaudeCode();
+      expect(execaSync).toHaveBeenCalledWith("which", ["claude"]);
+    });
+  });
+
+  describe("hasClaudeCodeAuth", () => {
+    it("returns true when keychain has accessToken", () => {
+      readClaudeCodeKeychain.mockReturnValue({ accessToken: "sk-ant-oat01-xxx" });
+      expect(hasClaudeCodeAuth()).toBe(true);
+    });
+
+    it("returns false when keychain returns null", () => {
+      readClaudeCodeKeychain.mockReturnValue(null);
+      expect(hasClaudeCodeAuth()).toBe(false);
+    });
+
+    it("returns false when accessToken is missing", () => {
+      readClaudeCodeKeychain.mockReturnValue({ refreshToken: "rt-xxx" });
+      expect(hasClaudeCodeAuth()).toBe(false);
+    });
+
+    it("returns false when accessToken is empty", () => {
+      readClaudeCodeKeychain.mockReturnValue({ accessToken: "" });
+      expect(hasClaudeCodeAuth()).toBe(false);
+    });
+
+    it("returns false when keychain returns empty object", () => {
+      readClaudeCodeKeychain.mockReturnValue({});
+      expect(hasClaudeCodeAuth()).toBe(false);
+    });
+  });
+
+  describe("runViaClaudeCode", () => {
+    it("calls claude CLI with prompt and system prompt", async () => {
+      execa.mockResolvedValue({ stdout: "response text" });
+      const result = await runViaClaudeCode("my prompt", "system prompt");
+      expect(result).toBe("response text");
+      expect(execa).toHaveBeenCalledWith(
+        "claude",
+        ["-p", "--no-session-persistence", "--append-system-prompt", "system prompt"],
+        expect.objectContaining({ input: "my prompt", encoding: "utf8" })
+      );
+    });
+
+    it("omits system prompt flag when not provided", async () => {
+      execa.mockResolvedValue({ stdout: "response" });
+      await runViaClaudeCode("prompt", null);
+      const args = execa.mock.calls[0][1];
+      expect(args).not.toContain("--append-system-prompt");
+    });
+
+    it("returns empty string when stdout is empty", async () => {
+      execa.mockResolvedValue({ stdout: "" });
+      const result = await runViaClaudeCode("prompt", "sys");
+      expect(result).toBe("");
+    });
+
+    it("returns empty string when stdout is null", async () => {
+      execa.mockResolvedValue({ stdout: null });
+      const result = await runViaClaudeCode("prompt", "sys");
+      expect(result).toBe("");
+    });
+  });
+
+  describe("streamViaClaudeCode", () => {
+    it("accumulates chunks and returns full text", async () => {
+      const { EventEmitter } = await import("node:events");
+      const mockStdout = new EventEmitter();
+      const mockProc = Promise.resolve();
+      mockProc.stdout = mockStdout;
+
+      execa.mockReturnValue(mockProc);
+
+      const chunks = [];
+      const resultPromise = streamViaClaudeCode("prompt", "sys", (chunk) => chunks.push(chunk));
+
+      mockStdout.emit("data", Buffer.from("hello "));
+      mockStdout.emit("data", Buffer.from("world"));
+
+      const result = await resultPromise;
+      expect(result).toBe("hello world");
+      expect(chunks).toEqual(["hello ", "world"]);
+    });
+
+    it("works without onChunk callback", async () => {
+      const { EventEmitter } = await import("node:events");
+      const mockStdout = new EventEmitter();
+      const mockProc = Promise.resolve();
+      mockProc.stdout = mockStdout;
+
+      execa.mockReturnValue(mockProc);
+
+      const resultPromise = streamViaClaudeCode("prompt", "sys");
+      mockStdout.emit("data", Buffer.from("data"));
+
+      const result = await resultPromise;
+      expect(result).toBe("data");
+    });
+  });
+});

package/src/auth/index.js

@@ -0,0 +1,4 @@
+export { resolveAnthropicApiKey, resolveOpenAiApiKey, readJsonKey } from "./resolve.js";
+export { readClaudeCodeKeychain } from "./keychain.js";
+export { authHelp, offerClaudeLogin, runLogin } from "./login.js";
+export { runOAuthLogin } from "./oauth.js";

package/src/auth/keychain.js

@@ -0,0 +1,58 @@
+import os from "node:os";
+import { execaSync } from "execa";
+
+const KEYCHAIN_SERVICE = "Claude Code-credentials";
+
+/**
+ * Try to read Claude Code's OAuth token from macOS Keychain.
+ * Returns { accessToken, refreshToken } or null.
+ */
+export function readClaudeCodeKeychain() {
+  if (process.platform !== "darwin") return null;
+  try {
+    const { stdout } = execaSync("security", [
+      "find-generic-password",
+      "-s", KEYCHAIN_SERVICE,
+      "-w"
+    ], { encoding: "utf8" });
+    const data = JSON.parse(stdout.trim());
+    if (data?.claudeAiOauth?.accessToken) {
+      return {
+        accessToken: data.claudeAiOauth.accessToken,
+        refreshToken: data.claudeAiOauth.refreshToken || null,
+      };
+    }
+  } catch {
+    // Not found or not on macOS
+  }
+  return null;
+}
+
+/**
+ * Save OAuth token to macOS Keychain (same format as Claude Code).
+ */
+export function saveClaudeCodeKeychain(accessToken, refreshToken = null) {
+  if (process.platform !== "darwin") return false;
+  try {
+    const data = JSON.stringify({
+      claudeAiOauth: {
+        accessToken,
+        ...(refreshToken && { refreshToken }),
+      }
+    });
+    // Delete existing entry first (ignore errors)
+    try {
+      execaSync("security", ["delete-generic-password", "-s", KEYCHAIN_SERVICE]);
+    } catch {}
+    // Add new entry
+    execaSync("security", [
+      "add-generic-password",
+      "-s", KEYCHAIN_SERVICE,
+      "-a", os.userInfo().username,
+      "-w", data,
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/auth/keychain.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("execa", () => ({
+  execaSync: vi.fn(),
+}));
+
+const { execaSync } = await import("execa");
+const { readClaudeCodeKeychain, saveClaudeCodeKeychain } = await import("./keychain.js");
+
+describe("auth/keychain", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("readClaudeCodeKeychain", () => {
+    it("returns null on non-darwin platforms", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "linux" });
+      expect(readClaudeCodeKeychain()).toBe(null);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns null on win32", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "win32" });
+      expect(readClaudeCodeKeychain()).toBe(null);
+      expect(execaSync).not.toHaveBeenCalled();
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns tokens on darwin when keychain has data", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({
+        stdout: JSON.stringify({
+          claudeAiOauth: {
+            accessToken: "sk-ant-oat01-test",
+            refreshToken: "rt-test",
+          },
+        }),
+      });
+      const result = readClaudeCodeKeychain();
+      expect(result).toEqual({
+        accessToken: "sk-ant-oat01-test",
+        refreshToken: "rt-test",
+      });
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns null refreshToken when not in keychain data", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({
+        stdout: JSON.stringify({
+          claudeAiOauth: {
+            accessToken: "sk-ant-oat01-test",
+          },
+        }),
+      });
+      const result = readClaudeCodeKeychain();
+      expect(result).toEqual({
+        accessToken: "sk-ant-oat01-test",
+        refreshToken: null,
+      });
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns null on darwin when keychain throws", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockImplementation(() => { throw new Error("not found"); });
+      expect(readClaudeCodeKeychain()).toBe(null);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns null when keychain data has no claudeAiOauth", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({ stdout: JSON.stringify({ other: "data" }) });
+      expect(readClaudeCodeKeychain()).toBe(null);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns null when stdout is not valid JSON", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({ stdout: "not json" });
+      expect(readClaudeCodeKeychain()).toBe(null);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("calls security find-generic-password on darwin", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({ stdout: "{}" });
+      readClaudeCodeKeychain();
+      expect(execaSync).toHaveBeenCalledWith(
+        "security",
+        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        { encoding: "utf8" }
+      );
+      Object.defineProperty(process, "platform", { value: original });
+    });
+  });
+
+  describe("saveClaudeCodeKeychain", () => {
+    it("returns false on non-darwin platforms", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "linux" });
+      expect(saveClaudeCodeKeychain("token")).toBe(false);
+      expect(execaSync).not.toHaveBeenCalled();
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("calls security commands on darwin", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({});
+      const result = saveClaudeCodeKeychain("access-token", "refresh-token");
+      expect(result).toBe(true);
+      expect(execaSync).toHaveBeenCalledWith(
+        "security",
+        expect.arrayContaining(["delete-generic-password"])
+      );
+      expect(execaSync).toHaveBeenCalledWith(
+        "security",
+        expect.arrayContaining(["add-generic-password"])
+      );
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("succeeds even when delete fails (no existing entry)", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      let callCount = 0;
+      execaSync.mockImplementation((_cmd, args) => {
+        if (args.includes("delete-generic-password")) {
+          throw new Error("item not found");
+        }
+        return {};
+      });
+      const result = saveClaudeCodeKeychain("access-token");
+      expect(result).toBe(true);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("returns false when add-generic-password fails", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockImplementation((_cmd, args) => {
+        if (args.includes("add-generic-password")) {
+          throw new Error("keychain locked");
+        }
+        return {};
+      });
+      const result = saveClaudeCodeKeychain("token");
+      expect(result).toBe(false);
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("saves without refreshToken when not provided", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({});
+      saveClaudeCodeKeychain("access-only");
+      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
+      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
+      expect(data.claudeAiOauth.accessToken).toBe("access-only");
+      expect(data.claudeAiOauth.refreshToken).toBeUndefined();
+      Object.defineProperty(process, "platform", { value: original });
+    });
+
+    it("includes refreshToken when provided", () => {
+      const original = process.platform;
+      Object.defineProperty(process, "platform", { value: "darwin" });
+      execaSync.mockReturnValue({});
+      saveClaudeCodeKeychain("access", "refresh");
+      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
+      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
+      expect(data.claudeAiOauth.accessToken).toBe("access");
+      expect(data.claudeAiOauth.refreshToken).toBe("refresh");
+      Object.defineProperty(process, "platform", { value: original });
+    });
+  });
+});