straylight-ai 0.1.0

package/dist/mcp-register.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClaudeAvailable = isClaudeAvailable;
+exports.registerMCP = registerMCP;
+exports.manualRegistrationInstructions = manualRegistrationInstructions;
+const child_process_1 = require("child_process");
+/** Name to use when registering the MCP server */
+const MCP_SERVER_NAME = "straylight-ai";
+/**
+ * Check whether the Claude Code CLI is available on PATH.
+ */
+function isClaudeAvailable() {
+    try {
+        (0, child_process_1.execSync)("claude --version", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Register the Straylight-AI MCP server with Claude Code.
+ *
+ * Runs:
+ *   claude mcp add straylight-ai --transport stdio -- npx straylight-ai mcp
+ *
+ * @returns true on success, false if claude is unavailable or the command fails.
+ */
+async function registerMCP() {
+    if (!isClaudeAvailable()) {
+        return false;
+    }
+    const result = (0, child_process_1.spawnSync)("claude", [
+        "mcp",
+        "add",
+        MCP_SERVER_NAME,
+        "--transport",
+        "stdio",
+        "--",
+        "npx",
+        "straylight-ai",
+        "mcp",
+    ], { stdio: "pipe" });
+    return result.status === 0;
+}
+/**
+ * Build the manual registration instructions string for users who do not have
+ * Claude Code installed.
+ */
+function manualRegistrationInstructions() {
+    return [
+        "To register the MCP server manually, run:",
+        "",
+        "  claude mcp add straylight-ai --transport stdio -- npx straylight-ai mcp",
+        "",
+        "Or add it directly to your Claude Code settings.",
+    ].join("\n");
+}
+//# sourceMappingURL=mcp-register.js.map

package/dist/mcp-register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-register.js","sourceRoot":"","sources":["../src/mcp-register.ts"],"names":[],"mappings":";;AAQA,8CAOC;AAUD,kCAsBC;AAMD,wEAQC;AA7DD,iDAAoD;AAEpD,kDAAkD;AAClD,MAAM,eAAe,GAAG,eAAe,CAAC;AAExC;;GAEG;AACH,SAAgB,iBAAiB;IAC/B,IAAI,CAAC;QACH,IAAA,wBAAQ,EAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,WAAW;IAC/B,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,MAAM,GAAG,IAAA,yBAAS,EACtB,QAAQ,EACR;QACE,KAAK;QACL,KAAK;QACL,eAAe;QACf,aAAa;QACb,OAAO;QACP,IAAI;QACJ,KAAK;QACL,eAAe;QACf,KAAK;KACN,EACD,EAAE,KAAK,EAAE,MAAM,EAAE,CAClB,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED;;;GAGG;AACH,SAAgB,8BAA8B;IAC5C,OAAO;QACL,2CAA2C;QAC3C,EAAE;QACF,2EAA2E;QAC3E,EAAE;QACF,kDAAkD;KACnD,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/open.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Open the given URL in the system's default browser.
+ * Best-effort: failure is silent to avoid blocking the setup flow.
+ */
+export declare function openBrowser(url: string): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../src/open.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB5D"}

package/dist/open.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = openBrowser;
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+/**
+ * Open the given URL in the system's default browser.
+ * Best-effort: failure is silent to avoid blocking the setup flow.
+ */
+async function openBrowser(url) {
+    const platform = os.platform();
+    let command;
+    if (platform === "darwin") {
+        command = "open";
+    }
+    else if (platform === "win32") {
+        command = "start";
+    }
+    else {
+        command = "xdg-open";
+    }
+    return new Promise((resolve) => {
+        try {
+            const child = (0, child_process_1.spawn)(command, [url], {
+                stdio: "ignore",
+                detached: true,
+            });
+            child.unref();
+        }
+        catch {
+            // Best-effort: ignore errors opening the browser
+        }
+        // Resolve immediately; we don't wait for the browser to finish
+        resolve();
+    });
+}
+//# sourceMappingURL=open.js.map

package/dist/open.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.js","sourceRoot":"","sources":["../src/open.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,kCAyBC;AAhCD,iDAAsC;AACtC,uCAAyB;AAEzB;;;GAGG;AACI,KAAK,UAAU,WAAW,CAAC,GAAW;IAC3C,MAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;IAC/B,IAAI,OAAe,CAAC;IAEpB,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;SAAM,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QAChC,OAAO,GAAG,OAAO,CAAC;IACpB,CAAC;SAAM,CAAC;QACN,OAAO,GAAG,UAAU,CAAC;IACvB,CAAC;IAED,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;QACnC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,IAAA,qBAAK,EAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE;gBAClC,KAAK,EAAE,QAAQ;gBACf,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QAAC,MAAM,CAAC;YACP,iDAAiD;QACnD,CAAC;QACD,+DAA+D;QAC/D,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "straylight-ai",
+  "version": "0.1.0",
+  "description": "Zero-knowledge credential proxy for AI agents",
+  "bin": {
+    "straylight-ai": "bin/cli.js",
+    "straylight-mcp": "bin/mcp-shim.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/"
+  ],
+  "keywords": [
+    "mcp",
+    "ai",
+    "credentials",
+    "proxy",
+    "claude"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^3.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/__tests__/commands.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock all external dependencies
+vi.mock("child_process", () => ({
+  execSync: vi.fn(),
+  spawnSync: vi.fn(),
+  spawn: vi.fn(),
+}));
+
+vi.mock("../docker.js", () => ({
+  detectRuntime: vi.fn(),
+  getContainerStatus: vi.fn(),
+  isContainerRunning: vi.fn(),
+  buildRunCommand: vi.fn(),
+  buildStartCommand: vi.fn(),
+  buildStopCommand: vi.fn(),
+}));
+
+vi.mock("../health.js", () => ({
+  waitForHealth: vi.fn(),
+  checkHealth: vi.fn(),
+}));
+
+vi.mock("../mcp-register.js", () => ({
+  registerMCP: vi.fn(),
+  isClaudeAvailable: vi.fn(),
+  manualRegistrationInstructions: vi.fn().mockReturnValue("Manual instructions"),
+}));
+
+// Mock open (browser opening)
+vi.mock("../open.js", () => ({
+  openBrowser: vi.fn(),
+}));
+
+import { execSync } from "child_process";
+import {
+  detectRuntime,
+  getContainerStatus,
+  isContainerRunning,
+  buildRunCommand,
+  buildStartCommand,
+  buildStopCommand,
+} from "../docker.js";
+import { waitForHealth, checkHealth } from "../health.js";
+import { registerMCP, isClaudeAvailable } from "../mcp-register.js";
+import { openBrowser } from "../open.js";
+
+import { runSetup } from "../commands/setup.js";
+import { runStart } from "../commands/start.js";
+import { runStop } from "../commands/stop.js";
+import { runStatus } from "../commands/status.js";
+
+const mockDetectRuntime = vi.mocked(detectRuntime);
+const mockGetContainerStatus = vi.mocked(getContainerStatus);
+const mockIsContainerRunning = vi.mocked(isContainerRunning);
+const mockBuildRunCommand = vi.mocked(buildRunCommand);
+const mockBuildStartCommand = vi.mocked(buildStartCommand);
+const mockBuildStopCommand = vi.mocked(buildStopCommand);
+const mockWaitForHealth = vi.mocked(waitForHealth);
+const mockCheckHealth = vi.mocked(checkHealth);
+const mockRegisterMCP = vi.mocked(registerMCP);
+const mockIsClaudeAvailable = vi.mocked(isClaudeAvailable);
+const mockOpenBrowser = vi.mocked(openBrowser);
+const mockExecSync = vi.mocked(execSync);
+
+const HEALTH_URL = "http://localhost:9470/api/v1/health";
+const HEALTH_RESPONSE = { status: "ok", version: "0.1.0" };
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  // Default: docker available, claude not available
+  mockDetectRuntime.mockReturnValue("docker");
+  mockBuildRunCommand.mockReturnValue(
+    "docker run -d --name straylight-ai -p 9470:9470 ghcr.io/aj-geddes/straylight-ai:latest"
+  );
+  mockBuildStartCommand.mockReturnValue("docker start straylight-ai");
+  mockBuildStopCommand.mockReturnValue("docker stop straylight-ai");
+  mockWaitForHealth.mockResolvedValue(HEALTH_RESPONSE);
+  mockCheckHealth.mockResolvedValue(HEALTH_RESPONSE);
+  mockRegisterMCP.mockResolvedValue(false);
+  mockIsClaudeAvailable.mockReturnValue(false);
+  mockOpenBrowser.mockResolvedValue(undefined);
+  mockExecSync.mockReturnValue(Buffer.from(""));
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("runSetup", () => {
+  it("errors when no container runtime is found", async () => {
+    mockDetectRuntime.mockReturnValue(null);
+    await expect(runSetup()).rejects.toThrow(/docker|podman/i);
+  });
+
+  it("creates and starts container when not found", async () => {
+    mockGetContainerStatus.mockResolvedValue("not_found");
+
+    await runSetup();
+
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("docker run"),
+      expect.any(Object)
+    );
+    expect(mockWaitForHealth).toHaveBeenCalledWith(HEALTH_URL, 30_000);
+  });
+
+  it("starts stopped container without re-creating it", async () => {
+    mockGetContainerStatus.mockResolvedValue("stopped");
+
+    await runSetup();
+
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("docker start"),
+      expect.any(Object)
+    );
+    // Should NOT call docker run
+    const calls = mockExecSync.mock.calls.map((c) => c[0] as string);
+    expect(calls.some((c) => c.includes("docker run"))).toBe(false);
+  });
+
+  it("skips container creation when already running", async () => {
+    mockGetContainerStatus.mockResolvedValue("running");
+
+    await runSetup();
+
+    // Should not call docker run or docker start
+    const calls = mockExecSync.mock.calls.map((c) => c[0] as string);
+    expect(calls.some((c) => c.includes("docker run"))).toBe(false);
+    expect(calls.some((c) => c.includes("docker start"))).toBe(false);
+    // Should still check health
+    expect(mockWaitForHealth).toHaveBeenCalled();
+  });
+
+  it("registers MCP when claude is available", async () => {
+    mockGetContainerStatus.mockResolvedValue("not_found");
+    mockRegisterMCP.mockResolvedValue(true);
+
+    await runSetup();
+
+    expect(mockRegisterMCP).toHaveBeenCalled();
+  });
+
+  it("opens browser after health check passes", async () => {
+    mockGetContainerStatus.mockResolvedValue("not_found");
+
+    await runSetup();
+
+    expect(mockOpenBrowser).toHaveBeenCalledWith("http://localhost:9470");
+  });
+
+  it("is idempotent: running twice does not create duplicate containers", async () => {
+    // First call: not found -> create
+    mockGetContainerStatus.mockResolvedValueOnce("not_found");
+    await runSetup();
+    const firstCallCount = mockExecSync.mock.calls.filter((c) =>
+      (c[0] as string).includes("docker run")
+    ).length;
+
+    vi.resetAllMocks();
+    mockDetectRuntime.mockReturnValue("docker");
+    mockBuildRunCommand.mockReturnValue(
+      "docker run -d --name straylight-ai -p 9470:9470 ghcr.io/aj-geddes/straylight-ai:latest"
+    );
+    mockBuildStartCommand.mockReturnValue("docker start straylight-ai");
+    mockWaitForHealth.mockResolvedValue(HEALTH_RESPONSE);
+    mockRegisterMCP.mockResolvedValue(false);
+    mockOpenBrowser.mockResolvedValue(undefined);
+    mockExecSync.mockReturnValue(Buffer.from(""));
+
+    // Second call: already running -> skip create
+    mockGetContainerStatus.mockResolvedValueOnce("running");
+    await runSetup();
+    const secondCallCount = mockExecSync.mock.calls.filter((c) =>
+      (c[0] as string).includes("docker run")
+    ).length;
+
+    expect(firstCallCount).toBe(1);
+    expect(secondCallCount).toBe(0);
+  });
+});
+
+describe("runStart", () => {
+  it("errors when no container runtime is found", async () => {
+    mockDetectRuntime.mockReturnValue(null);
+    await expect(runStart()).rejects.toThrow(/docker|podman/i);
+  });
+
+  it("starts stopped container", async () => {
+    mockGetContainerStatus.mockResolvedValue("stopped");
+
+    await runStart();
+
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("docker start"),
+      expect.any(Object)
+    );
+    expect(mockWaitForHealth).toHaveBeenCalledWith(HEALTH_URL, 30_000);
+  });
+
+  it("does not restart already-running container", async () => {
+    mockGetContainerStatus.mockResolvedValue("running");
+
+    await runStart();
+
+    expect(mockExecSync).not.toHaveBeenCalled();
+  });
+
+  it("errors when container does not exist", async () => {
+    mockGetContainerStatus.mockResolvedValue("not_found");
+    await expect(runStart()).rejects.toThrow(/not found|setup/i);
+  });
+});
+
+describe("runStop", () => {
+  it("errors when no container runtime is found", async () => {
+    mockDetectRuntime.mockReturnValue(null);
+    await expect(runStop()).rejects.toThrow(/docker|podman/i);
+  });
+
+  it("stops running container", async () => {
+    mockIsContainerRunning.mockResolvedValue(true);
+
+    await runStop();
+
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining("docker stop"),
+      expect.any(Object)
+    );
+  });
+
+  it("skips stop when container is not running", async () => {
+    mockIsContainerRunning.mockResolvedValue(false);
+
+    await runStop();
+
+    expect(mockExecSync).not.toHaveBeenCalled();
+  });
+});
+
+describe("runStatus", () => {
+  it("errors when no container runtime is found", async () => {
+    mockDetectRuntime.mockReturnValue(null);
+    await expect(runStatus()).rejects.toThrow(/docker|podman/i);
+  });
+
+  it("returns status with health info when container is running", async () => {
+    mockGetContainerStatus.mockResolvedValue("running");
+
+    const result = await runStatus();
+
+    expect(result.containerStatus).toBe("running");
+    expect(mockCheckHealth).toHaveBeenCalledWith(HEALTH_URL);
+  });
+
+  it("returns status without health check when container is stopped", async () => {
+    mockGetContainerStatus.mockResolvedValue("stopped");
+
+    const result = await runStatus();
+
+    expect(result.containerStatus).toBe("stopped");
+    expect(mockCheckHealth).not.toHaveBeenCalled();
+  });
+
+  it("returns not_found status when container does not exist", async () => {
+    mockGetContainerStatus.mockResolvedValue("not_found");
+
+    const result = await runStatus();
+
+    expect(result.containerStatus).toBe("not_found");
+  });
+});

package/src/__tests__/docker.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock child_process before importing the module under test
+vi.mock("child_process", () => ({
+  execSync: vi.fn(),
+  spawn: vi.fn(),
+}));
+
+import { execSync } from "child_process";
+import {
+  detectRuntime,
+  getContainerStatus,
+  isContainerRunning,
+  buildRunCommand,
+  buildStartCommand,
+  buildStopCommand,
+} from "../docker.js";
+
+const mockExecSync = vi.mocked(execSync);
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("detectRuntime", () => {
+  it("returns docker when docker is available", () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes("docker")) return Buffer.from("Docker version 24.0");
+      throw new Error("not found");
+    });
+    expect(detectRuntime()).toBe("docker");
+  });
+
+  it("returns podman when only podman is available", () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes("docker")) throw new Error("not found");
+      if (cmdStr.includes("podman")) return Buffer.from("podman version 4.0");
+      throw new Error("not found");
+    });
+    expect(detectRuntime()).toBe("podman");
+  });
+
+  it("returns null when neither docker nor podman is available", () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error("command not found");
+    });
+    expect(detectRuntime()).toBeNull();
+  });
+});
+
+describe("getContainerStatus", () => {
+  it("returns running when container is running", async () => {
+    mockExecSync.mockReturnValue(Buffer.from("running\n"));
+    const status = await getContainerStatus("docker");
+    expect(status).toBe("running");
+  });
+
+  it("returns stopped when container is exited", async () => {
+    mockExecSync.mockReturnValue(Buffer.from("exited\n"));
+    const status = await getContainerStatus("docker");
+    expect(status).toBe("stopped");
+  });
+
+  it("returns not_found when container does not exist", async () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error("No such container");
+    });
+    const status = await getContainerStatus("docker");
+    expect(status).toBe("not_found");
+  });
+});
+
+describe("isContainerRunning", () => {
+  it("returns true when container status is running", async () => {
+    mockExecSync.mockReturnValue(Buffer.from("running\n"));
+    expect(await isContainerRunning("docker")).toBe(true);
+  });
+
+  it("returns false when container status is stopped", async () => {
+    mockExecSync.mockReturnValue(Buffer.from("exited\n"));
+    expect(await isContainerRunning("docker")).toBe(false);
+  });
+
+  it("returns false when container does not exist", async () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error("No such container");
+    });
+    expect(await isContainerRunning("docker")).toBe(false);
+  });
+});
+
+describe("buildRunCommand", () => {
+  it("builds a valid docker run command with required flags", () => {
+    const cmd = buildRunCommand("docker");
+    expect(cmd).toContain("docker run");
+    expect(cmd).toContain("-d");
+    expect(cmd).toContain("--name straylight-ai");
+    expect(cmd).toContain("-p 9470:9470");
+    expect(cmd).toContain("/data");
+    expect(cmd).toContain("--restart unless-stopped");
+    expect(cmd).toContain("ghcr.io/aj-geddes/straylight-ai:latest");
+  });
+
+  it("builds a valid podman run command", () => {
+    const cmd = buildRunCommand("podman");
+    expect(cmd).toContain("podman run");
+    expect(cmd).toContain("--name straylight-ai");
+  });
+});
+
+describe("buildStartCommand", () => {
+  it("builds a docker start command", () => {
+    const cmd = buildStartCommand("docker");
+    expect(cmd).toBe("docker start straylight-ai");
+  });
+
+  it("builds a podman start command", () => {
+    const cmd = buildStartCommand("podman");
+    expect(cmd).toBe("podman start straylight-ai");
+  });
+});
+
+describe("buildStopCommand", () => {
+  it("builds a docker stop command", () => {
+    const cmd = buildStopCommand("docker");
+    expect(cmd).toBe("docker stop straylight-ai");
+  });
+
+  it("builds a podman stop command", () => {
+    const cmd = buildStopCommand("podman");
+    expect(cmd).toBe("podman stop straylight-ai");
+  });
+});