@astrofoundry/pi-astro 0.5.0 → 0.6.0

package/extensions/astro-agents/spawn.test.ts

@@ -0,0 +1,218 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("node:child_process", () => ({
+    spawn: vi.fn(),
+}));
+
+function makeFakeProc(): {
+    proc: EventEmitter & { stdout: EventEmitter; stderr: EventEmitter; kill: ReturnType<typeof vi.fn> };
+    close: (code: number) => void;
+    error: (err: Error) => void;
+    emit: (w: "stdout" | "stderr", chunk: string) => void;
+} {
+    const proc = Object.assign(new EventEmitter(), {
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        kill: vi.fn(),
+    });
+    return {
+        proc,
+        close: (code) => proc.emit("close", code),
+        error: (err) => proc.emit("error", err),
+        emit: (w, chunk) => proc[w].emit("data", Buffer.from(chunk, "utf-8")),
+    };
+}
+
+describe("runAgent (spawn.ts)", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("spawns pi with --mode json -p --no-session and captures agent_end", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "sys" },
+            task: "do thing",
+            cwd: "/tmp",
+        });
+
+        // Emit an agent_end with a single assistant message
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "agent_end",
+                messages: [{ role: "assistant", content: [{ type: "text", text: "result" }] }],
+            }) + "\n",
+        );
+        fake.close(0);
+
+        const res = await promise;
+        expect(res.exitCode).toBe(0);
+        expect(res.text).toBe("result");
+
+        const args = vi.mocked(spawn).mock.calls[0][1] as string[];
+        expect(args).toContain("--mode");
+        expect(args).toContain("json");
+        expect(args).toContain("-p");
+        expect(args).toContain("--no-session");
+    });
+
+    it("includes --tools when agent has tools", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: {
+                name: "a",
+                description: "x",
+                source: "bundle",
+                filePath: "/tmp/a.md",
+                systemPrompt: "",
+                tools: ["read", "bash"],
+            },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.close(0);
+        await promise;
+        const args = vi.mocked(spawn).mock.calls[0][1] as string[];
+        expect(args).toContain("--tools");
+        expect(args).toContain("read,bash");
+    });
+
+    it("includes --no-skills + --skill paths when skills declared", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: {
+                name: "a",
+                description: "x",
+                source: "bundle",
+                filePath: "/tmp/a.md",
+                systemPrompt: "",
+                skills: ["playwright-cli"],
+            },
+            task: "t",
+            cwd: "/tmp",
+            skillPaths: ["/pkg/skills/playwright-cli"],
+        });
+        fake.close(0);
+        await promise;
+        const args = vi.mocked(spawn).mock.calls[0][1] as string[];
+        expect(args).toContain("--no-skills");
+        expect(args).toContain("--skill");
+        expect(args).toContain("/pkg/skills/playwright-cli");
+    });
+
+    it("appends --append-system-prompt when agent has a systemPrompt", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "body" },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.close(0);
+        await promise;
+        const args = vi.mocked(spawn).mock.calls[0][1] as string[];
+        expect(args).toContain("--append-system-prompt");
+    });
+
+    it("returns empty text when agent_end has no assistant messages", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.emit("stdout", JSON.stringify({ type: "agent_end", messages: [] }) + "\n");
+        fake.close(0);
+        const res = await promise;
+        expect(res.text).toBe("");
+    });
+
+    it("ignores non-JSON stdout lines gracefully", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.emit("stdout", "garbage not json\n");
+        fake.close(0);
+        const res = await promise;
+        expect(res.exitCode).toBe(0);
+    });
+
+    it("captures stderr into the result", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.emit("stderr", "oops");
+        fake.close(1);
+        const res = await promise;
+        expect(res.stderr).toContain("oops");
+        expect(res.exitCode).toBe(1);
+    });
+
+    it("resolves with exitCode 1 on spawn error", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+        });
+        fake.error(new Error("spawn failed"));
+        const res = await promise;
+        expect(res.exitCode).toBe(1);
+        expect(res.stderr).toContain("spawn failed");
+    });
+
+    it("kills process on abort signal", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+        const ac = new AbortController();
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            signal: ac.signal,
+        });
+        ac.abort();
+        expect(fake.proc.kill).toHaveBeenCalledWith("SIGTERM");
+        fake.close(0);
+        await promise;
+    });
+});

package/extensions/claude-globals/index.test.ts

@@ -0,0 +1,77 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+type Handler = (event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>;
+
+interface CapturedPi {
+    on: (event: string, handler: Handler) => void;
+    handlers: Record<string, Handler>;
+}
+
+function makePi(): CapturedPi {
+    const handlers: Record<string, Handler> = {};
+    return {
+        handlers,
+        on: (event, handler) => {
+            handlers[event] = handler;
+        },
+    };
+}
+
+describe("claude-globals extension", () => {
+    let fakeHome: string;
+    const homeEnv = process.env.HOME;
+
+    beforeEach(() => {
+        fakeHome = mkdtempSync(join(tmpdir(), "claude-glob-"));
+        process.env.HOME = fakeHome;
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        rmSync(fakeHome, { recursive: true, force: true });
+        process.env.HOME = homeEnv;
+    });
+
+    it("appends ~/.claude/CLAUDE.md content inside a wrapper tag", async () => {
+        const claudeDir = join(fakeHome, ".claude");
+        const { mkdirSync } = await import("node:fs");
+        mkdirSync(claudeDir, { recursive: true });
+        writeFileSync(join(claudeDir, "CLAUDE.md"), "RULE ONE\nRULE TWO", "utf-8");
+
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+
+        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
+        expect(result).toBeDefined();
+        expect(result?.systemPrompt).toContain("SYS");
+        expect(result?.systemPrompt).toContain("<claude-global-rules");
+        expect(result?.systemPrompt).toContain("RULE ONE");
+        expect(result?.systemPrompt).toContain("RULE TWO");
+        expect(result?.systemPrompt).toContain("</claude-global-rules>");
+    });
+
+    it("returns undefined when ~/.claude/CLAUDE.md does not exist", async () => {
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
+        expect(result).toBeUndefined();
+    });
+
+    it("returns undefined when ~/.claude/CLAUDE.md is empty / whitespace", async () => {
+        const claudeDir = join(fakeHome, ".claude");
+        const { mkdirSync } = await import("node:fs");
+        mkdirSync(claudeDir, { recursive: true });
+        writeFileSync(join(claudeDir, "CLAUDE.md"), "   \n\n  ", "utf-8");
+
+        const mod = await import("./index.ts");
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
+        expect(result).toBeUndefined();
+    });
+});

package/extensions/gemini-image/credentials.test.ts

@@ -0,0 +1,130 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("credentials", () => {
+    let fakeHome: string;
+    const originalHome = process.env.HOME;
+    const originalGemini = process.env.GEMINI_API_KEY;
+
+    beforeEach(() => {
+        fakeHome = mkdtempSync(join(tmpdir(), "gem-cred-"));
+        process.env.HOME = fakeHome;
+        delete process.env.GEMINI_API_KEY;
+        vi.resetModules();
+    });
+
+    afterEach(() => {
+        rmSync(fakeHome, { recursive: true, force: true });
+        process.env.HOME = originalHome;
+        if (originalGemini === undefined) delete process.env.GEMINI_API_KEY;
+        else process.env.GEMINI_API_KEY = originalGemini;
+    });
+
+    it("resolves env var first when set", async () => {
+        process.env.GEMINI_API_KEY = "from-env";
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBe("from-env");
+    });
+
+    it("returns undefined when neither env nor file set", async () => {
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBeUndefined();
+    });
+
+    it("reads auth.json google.key when env is absent", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(
+            join(dir, "auth.json"),
+            JSON.stringify({ google: { type: "api_key", key: "from-file" } }),
+            "utf-8",
+        );
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBe("from-file");
+    });
+
+    it("returns undefined when auth.json google entry is malformed", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "auth.json"), JSON.stringify({ google: "not-an-object" }), "utf-8");
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBeUndefined();
+    });
+
+    it("returns undefined when auth.json is corrupt JSON", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "auth.json"), "{not-json", "utf-8");
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBeUndefined();
+    });
+
+    it("persistApiKey creates auth.json with google entry", async () => {
+        const { persistApiKey } = await import("./credentials.ts");
+        persistApiKey("new-key");
+        const data = JSON.parse(readFileSync(join(fakeHome, ".pi", "agent", "auth.json"), "utf-8"));
+        expect(data.google).toEqual({ type: "api_key", key: "new-key" });
+    });
+
+    it("persistApiKey merges with existing entries", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(
+            join(dir, "auth.json"),
+            JSON.stringify({ anthropic: { type: "api_key", key: "ant-k" } }),
+            "utf-8",
+        );
+        const { persistApiKey } = await import("./credentials.ts");
+        persistApiKey("new-google-key");
+        const data = JSON.parse(readFileSync(join(dir, "auth.json"), "utf-8"));
+        expect(data.anthropic).toEqual({ type: "api_key", key: "ant-k" });
+        expect(data.google).toEqual({ type: "api_key", key: "new-google-key" });
+    });
+
+    it("persistApiKey overwrites an existing google entry", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(
+            join(dir, "auth.json"),
+            JSON.stringify({ google: { type: "api_key", key: "old" } }),
+            "utf-8",
+        );
+        const { persistApiKey } = await import("./credentials.ts");
+        persistApiKey("replacement");
+        const data = JSON.parse(readFileSync(join(dir, "auth.json"), "utf-8"));
+        expect(data.google.key).toBe("replacement");
+    });
+
+    it("env var with whitespace is trimmed", async () => {
+        process.env.GEMINI_API_KEY = "   spaced   ";
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBe("spaced");
+    });
+
+    it("empty string env var is treated as unset", async () => {
+        process.env.GEMINI_API_KEY = "   ";
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBeUndefined();
+    });
+
+    it("auth file exists but lacks google entry -> undefined", async () => {
+        const dir = join(fakeHome, ".pi", "agent");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(
+            join(dir, "auth.json"),
+            JSON.stringify({ anthropic: { type: "api_key", key: "x" } }),
+            "utf-8",
+        );
+        const { resolveExistingApiKey } = await import("./credentials.ts");
+        expect(resolveExistingApiKey()).toBeUndefined();
+    });
+
+    it("persistApiKey creates parent dirs implicitly if needed", async () => {
+        expect(existsSync(join(fakeHome, ".pi", "agent"))).toBe(false);
+        const { persistApiKey } = await import("./credentials.ts");
+        persistApiKey("x");
+        expect(existsSync(join(fakeHome, ".pi", "agent", "auth.json"))).toBe(true);
+    });
+});

package/extensions/gemini-image/credentials.ts

@@ -0,0 +1,53 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const AUTH_FILE = join(homedir(), ".pi", "agent", "auth.json");
+const PROVIDER_KEY = "google";
+
+interface AuthEntry {
+    type: "api_key";
+    key: string;
+}
+
+type AuthFile = Record<string, AuthEntry | unknown>;
+
+function readAuthFile(): AuthFile {
+    if (!existsSync(AUTH_FILE)) return {};
+    try {
+        const raw = readFileSync(AUTH_FILE, "utf-8");
+        const parsed = JSON.parse(raw) as unknown;
+        return typeof parsed === "object" && parsed !== null ? (parsed as AuthFile) : {};
+    } catch {
+        return {};
+    }
+}
+
+function writeAuthFile(data: AuthFile): void {
+    mkdirSync(dirname(AUTH_FILE), { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    try {
+        chmodSync(AUTH_FILE, 0o600);
+    } catch {
+        // non-fatal: filesystem may not support chmod (e.g. some Windows envs)
+    }
+}
+
+export function resolveExistingApiKey(): string | undefined {
+    const fromEnv = process.env.GEMINI_API_KEY?.trim();
+    if (fromEnv) return fromEnv;
+
+    const authFile = readAuthFile();
+    const entry = authFile[PROVIDER_KEY];
+    if (entry && typeof entry === "object" && "type" in entry && entry.type === "api_key") {
+        const { key } = entry as AuthEntry;
+        if (typeof key === "string" && key.trim().length > 0) return key.trim();
+    }
+    return undefined;
+}
+
+export function persistApiKey(key: string): void {
+    const authFile = readAuthFile();
+    authFile[PROVIDER_KEY] = { type: "api_key", key };
+    writeAuthFile(authFile);
+}