@pensar/apex 0.0.70 → 0.0.71

package/build/index.js

@@ -135337,7 +135337,7 @@ import fs2 from "fs/promises";
 // package.json
 var package_default2 = {
   name: "@pensar/apex",
-  version: "0.0.70",
+  version: "0.0.71",
   description: "AI-powered penetration testing CLI tool with terminal UI",
   module: "src/tui/index.tsx",
   main: "build/index.js",
@@ -135352,6 +135352,7 @@ var package_default2 = {
   files: [
     "build",
     "bin",
+    "src/core/installation",
     "pensar.svg",
     "LICENSE"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pensar/apex",
-  "version": "0.0.70",
+  "version": "0.0.71",
   "description": "AI-powered penetration testing CLI tool with terminal UI",
   "module": "src/tui/index.tsx",
   "main": "build/index.js",
@@ -15,6 +15,7 @@
   "files": [
     "build",
     "bin",
+    "src/core/installation",
     "pensar.svg",
     "LICENSE"
   ],

package/src/core/installation/index.ts

@@ -0,0 +1,211 @@
+import { spawnSync } from "child_process";
+import packageJson from "../../../package.json";
+
+export type InstallMethod = "npm" | "homebrew" | "binary";
+
+export interface UpgradeResult {
+  success: boolean;
+  message: string;
+  fromVersion: string;
+  toVersion: string;
+}
+
+export async function resolveVersion(): Promise<string> {
+  if (process.env["APEX_VERSION"]) return process.env["APEX_VERSION"];
+  return getLatestVersion();
+}
+
+export function getCurrentVersion(): string {
+  return packageJson.version;
+}
+
+/**
+ * Returns true if `latest` is strictly greater than `current` by semver.
+ * Only compares major.minor.patch; pre-release suffixes are ignored.
+ */
+export function isNewerVersion(current: string, latest: string): boolean {
+  const parse = (v: string) => v.split(".").map((n) => parseInt(n, 10) || 0);
+  const c = parse(current);
+  const l = parse(latest);
+  for (let i = 0; i < Math.max(c.length, l.length); i++) {
+    const cv = c[i] ?? 0;
+    const lv = l[i] ?? 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
+  }
+  return false;
+}
+
+export async function getLatestVersion(): Promise<string> {
+  const res = await fetch("https://registry.npmjs.org/@pensar/apex/latest");
+  if (!res.ok)
+    throw new Error(`Failed to fetch latest version: ${res.statusText}`);
+  const data = (await res.json()) as Record<string, unknown>;
+  return String(data.version);
+}
+
+export function detectInstallMethod(): InstallMethod {
+  const execPath = process.execPath;
+  const argv1 = process.argv[1] ?? "";
+
+  if (
+    execPath.includes("homebrew") ||
+    execPath.includes("Cellar") ||
+    execPath.includes("linuxbrew") ||
+    argv1.includes("homebrew") ||
+    argv1.includes("Cellar")
+  ) {
+    return "homebrew";
+  }
+
+  if (
+    argv1.includes("node_modules") ||
+    argv1.includes(".npm") ||
+    argv1.includes("npx")
+  ) {
+    return "npm";
+  }
+
+  const npmCheck = spawnSync(
+    "npm",
+    ["list", "-g", "@pensar/apex", "--depth=0"],
+    {
+      encoding: "utf-8",
+      timeout: 10000,
+    },
+  );
+  if (npmCheck.status === 0 && npmCheck.stdout?.includes("@pensar/apex")) {
+    return "npm";
+  }
+
+  return "binary";
+}
+
+function getUpgradeCommand(method: InstallMethod): {
+  cmd: string;
+  args: string[];
+} {
+  switch (method) {
+    case "npm":
+      return { cmd: "npm", args: ["install", "-g", "@pensar/apex@latest"] };
+    case "homebrew":
+      return { cmd: "brew", args: ["upgrade", "pensarai/tap/apex"] };
+    case "binary":
+      return {
+        cmd: "bash",
+        args: ["-c", "curl -fsSL https://pensarai.com/install.sh | bash"],
+      };
+  }
+}
+
+export function getUpgradeCommandString(method: InstallMethod): string {
+  const { cmd, args } = getUpgradeCommand(method);
+  return `${cmd} ${args.join(" ")}`;
+}
+
+export interface CheckUpdateResult {
+  updateAvailable: boolean;
+  currentVersion: string;
+  latestVersion: string;
+}
+
+export async function checkForUpdate(): Promise<CheckUpdateResult> {
+  const currentVersion = getCurrentVersion();
+  let latestVersion: string;
+
+  try {
+    latestVersion = await getLatestVersion();
+  } catch {
+    return {
+      updateAvailable: false,
+      currentVersion,
+      latestVersion: currentVersion,
+    };
+  }
+
+  return {
+    updateAvailable: isNewerVersion(currentVersion, latestVersion),
+    currentVersion,
+    latestVersion,
+  };
+}
+
+export function runUpgrade(
+  method: InstallMethod,
+  options?: { interactive?: boolean },
+): UpgradeResult {
+  const currentVersion = getCurrentVersion();
+  const { cmd, args } = getUpgradeCommand(method);
+  const interactive = options?.interactive ?? false;
+
+  const result = spawnSync(cmd, args, {
+    encoding: "utf-8",
+    timeout: 120000,
+    stdio: interactive ? "inherit" : "pipe",
+  });
+
+  if (result.status !== 0) {
+    const stderr =
+      (typeof result.stderr === "string" ? result.stderr.trim() : "") ||
+      "Unknown error";
+    return {
+      success: false,
+      message: `Upgrade failed: ${stderr}`,
+      fromVersion: currentVersion,
+      toVersion: currentVersion,
+    };
+  }
+
+  return {
+    success: true,
+    message:
+      "Upgrade successful. Please restart pensar to use the new version.",
+    fromVersion: currentVersion,
+    toVersion: "latest",
+  };
+}
+
+export async function upgrade(options?: {
+  interactive?: boolean;
+}): Promise<UpgradeResult> {
+  const currentVersion = getCurrentVersion();
+  let latestVersion: string;
+
+  try {
+    latestVersion = await getLatestVersion();
+  } catch {
+    return {
+      success: false,
+      message:
+        "Failed to check for updates. Please check your internet connection.",
+      fromVersion: currentVersion,
+      toVersion: currentVersion,
+    };
+  }
+
+  if (!isNewerVersion(currentVersion, latestVersion)) {
+    return {
+      success: true,
+      message: `Already on the latest version (v${currentVersion}).`,
+      fromVersion: currentVersion,
+      toVersion: latestVersion,
+    };
+  }
+
+  const method = detectInstallMethod();
+  const result = runUpgrade(method, options);
+
+  if (result.success) {
+    return {
+      ...result,
+      toVersion: latestVersion,
+      message: `Upgraded from v${currentVersion} to v${latestVersion}. Please restart pensar.`,
+    };
+  }
+
+  return {
+    ...result,
+    toVersion: latestVersion,
+    message: `${result.message}\n\nYou can upgrade manually by running:\n  ${getUpgradeCommandString(method)}`,
+  };
+}

package/src/core/installation/installation.test.ts

@@ -0,0 +1,422 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  getCurrentVersion,
+  getLatestVersion,
+  resolveVersion,
+  isNewerVersion,
+  detectInstallMethod,
+  getUpgradeCommandString,
+  checkForUpdate,
+  upgrade,
+} from "./index";
+import packageJson from "../../../package.json";
+
+vi.mock("child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("child_process")>();
+  return { ...actual, spawnSync: vi.fn(actual.spawnSync) };
+});
+
+// ---------------------------------------------------------------------------
+// getCurrentVersion
+// ---------------------------------------------------------------------------
+
+describe("getCurrentVersion", () => {
+  it("returns the version from package.json", () => {
+    expect(getCurrentVersion()).toBe(packageJson.version);
+  });
+
+  it("returns a valid semver-like string", () => {
+    const version = getCurrentVersion();
+    expect(version).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveVersion
+// ---------------------------------------------------------------------------
+
+describe("resolveVersion", () => {
+  const originalEnv = process.env["APEX_VERSION"];
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env["APEX_VERSION"] = originalEnv;
+    } else {
+      delete process.env["APEX_VERSION"];
+    }
+    vi.restoreAllMocks();
+  });
+
+  it("returns APEX_VERSION env var when set", async () => {
+    process.env["APEX_VERSION"] = "1.2.3-custom";
+    const version = await resolveVersion();
+    expect(version).toBe("1.2.3-custom");
+  });
+
+  it("delegates to getLatestVersion when env var is not set", async () => {
+    delete process.env["APEX_VERSION"];
+    const mockFetch = vi
+      .spyOn(globalThis, "fetch")
+      .mockResolvedValue(
+        new Response(JSON.stringify({ version: "9.9.9" }), { status: 200 }),
+      );
+    const version = await resolveVersion();
+    expect(version).toBe("9.9.9");
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://registry.npmjs.org/@pensar/apex/latest",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getLatestVersion
+// ---------------------------------------------------------------------------
+
+describe("getLatestVersion", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("returns the latest version from npm registry", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "1.0.0" }), { status: 200 }),
+    );
+    const version = await getLatestVersion();
+    expect(version).toBe("1.0.0");
+  });
+
+  it("throws on non-ok response", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response("not found", { status: 404, statusText: "Not Found" }),
+    );
+    await expect(getLatestVersion()).rejects.toThrow("Not Found");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isNewerVersion
+// ---------------------------------------------------------------------------
+
+describe("isNewerVersion", () => {
+  it("returns true when latest has higher patch", () => {
+    expect(isNewerVersion("0.0.66", "0.0.67")).toBe(true);
+  });
+
+  it("returns true when latest has higher minor", () => {
+    expect(isNewerVersion("0.1.0", "0.2.0")).toBe(true);
+  });
+
+  it("returns true when latest has higher major", () => {
+    expect(isNewerVersion("1.0.0", "2.0.0")).toBe(true);
+  });
+
+  it("returns false when versions are equal", () => {
+    expect(isNewerVersion("0.0.67", "0.0.67")).toBe(false);
+  });
+
+  it("returns false when current is newer than latest", () => {
+    expect(isNewerVersion("0.0.67", "0.0.66")).toBe(false);
+  });
+
+  it("returns false when current major is higher", () => {
+    expect(isNewerVersion("2.0.0", "1.9.9")).toBe(false);
+  });
+
+  it("handles versions with different segment counts", () => {
+    expect(isNewerVersion("1.0", "1.0.1")).toBe(true);
+    expect(isNewerVersion("1.0.1", "1.0")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// detectInstallMethod
+// ---------------------------------------------------------------------------
+
+describe("detectInstallMethod", () => {
+  const origExecPath = process.execPath;
+  const origArgv = [...process.argv];
+
+  afterEach(() => {
+    Object.defineProperty(process, "execPath", {
+      value: origExecPath,
+      writable: true,
+    });
+    process.argv = [...origArgv];
+    vi.restoreAllMocks();
+  });
+
+  it("detects homebrew from execPath", () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/opt/homebrew/bin/bun",
+      writable: true,
+    });
+    expect(detectInstallMethod()).toBe("homebrew");
+  });
+
+  it("detects homebrew from Cellar in execPath", () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/opt/homebrew/Cellar/apex/0.1.0/bin/pensar",
+      writable: true,
+    });
+    expect(detectInstallMethod()).toBe("homebrew");
+  });
+
+  it("detects npm from node_modules in argv[1]", () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/usr/local/bin/node",
+      writable: true,
+    });
+    process.argv[1] = "/usr/local/lib/node_modules/@pensar/apex/bin/pensar.js";
+    expect(detectInstallMethod()).toBe("npm");
+  });
+
+  it("detects npm from npx in argv[1]", () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/usr/local/bin/node",
+      writable: true,
+    });
+    process.argv[1] = "/home/user/.npm/_npx/abc/node_modules/.bin/pensar";
+    expect(detectInstallMethod()).toBe("npm");
+  });
+
+  it("detects npm via spawnSync fallback when path heuristics miss", async () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/usr/local/bin/node",
+      writable: true,
+    });
+    process.argv[1] = "/usr/local/bin/pensar";
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: "└── @pensar/apex@0.1.0",
+      stderr: "",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    expect(detectInstallMethod()).toBe("npm");
+    expect(mockedSpawnSync).toHaveBeenCalledWith(
+      "npm",
+      ["list", "-g", "@pensar/apex", "--depth=0"],
+      expect.objectContaining({ encoding: "utf-8" }),
+    );
+  });
+
+  it("returns binary when all heuristics fail", async () => {
+    Object.defineProperty(process, "execPath", {
+      value: "/usr/local/bin/node",
+      writable: true,
+    });
+    process.argv[1] = "/usr/local/bin/pensar";
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 1,
+      stdout: "",
+      stderr: "",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    expect(detectInstallMethod()).toBe("binary");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getUpgradeCommandString
+// ---------------------------------------------------------------------------
+
+describe("getUpgradeCommandString", () => {
+  it("returns npm install command for npm method", () => {
+    expect(getUpgradeCommandString("npm")).toBe(
+      "npm install -g @pensar/apex@latest",
+    );
+  });
+
+  it("returns brew upgrade command for homebrew method", () => {
+    expect(getUpgradeCommandString("homebrew")).toBe(
+      "brew upgrade pensarai/tap/apex",
+    );
+  });
+
+  it("returns curl command for binary method", () => {
+    const cmd = getUpgradeCommandString("binary");
+    expect(cmd).toContain("curl");
+    expect(cmd).toContain("pensarai.com/install.sh");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// checkForUpdate
+// ---------------------------------------------------------------------------
+
+describe("checkForUpdate", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("reports no update when versions match", async () => {
+    const current = getCurrentVersion();
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: current }), { status: 200 }),
+    );
+
+    const result = await checkForUpdate();
+    expect(result.updateAvailable).toBe(false);
+    expect(result.currentVersion).toBe(current);
+    expect(result.latestVersion).toBe(current);
+  });
+
+  it("reports update available when latest is greater", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "99.99.99" }), { status: 200 }),
+    );
+
+    const result = await checkForUpdate();
+    expect(result.updateAvailable).toBe(true);
+    expect(result.currentVersion).toBe(getCurrentVersion());
+    expect(result.latestVersion).toBe("99.99.99");
+  });
+
+  it("reports no update when current is newer than latest", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "0.0.1" }), { status: 200 }),
+    );
+
+    const result = await checkForUpdate();
+    expect(result.updateAvailable).toBe(false);
+    expect(result.latestVersion).toBe("0.0.1");
+  });
+
+  it("returns no update on network failure", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
+
+    const result = await checkForUpdate();
+    expect(result.updateAvailable).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// upgrade (integration of version check + upgrade logic)
+// ---------------------------------------------------------------------------
+
+describe("upgrade", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("reports already up to date when versions match", async () => {
+    const current = getCurrentVersion();
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: current }), { status: 200 }),
+    );
+
+    const result = await upgrade();
+    expect(result.success).toBe(true);
+    expect(result.fromVersion).toBe(current);
+    expect(result.toVersion).toBe(current);
+    expect(result.message).toContain("Already on the latest version");
+  });
+
+  it("returns failure when version check fails", async () => {
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("network error"));
+
+    const result = await upgrade();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Failed to check for updates");
+  });
+
+  it("attempts upgrade when a newer version is available", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "99.99.99" }), { status: 200 }),
+    );
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: "upgraded successfully",
+      stderr: "",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    const result = await upgrade();
+    expect(result.success).toBe(true);
+    expect(result.fromVersion).toBe(getCurrentVersion());
+    expect(result.toVersion).toBe("99.99.99");
+    expect(result.message).toContain("Upgraded from");
+  });
+
+  it("uses stdio inherit when interactive is true", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "99.99.99" }), { status: 200 }),
+    );
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: "",
+      stderr: "",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    await upgrade({ interactive: true });
+
+    expect(mockedSpawnSync).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.any(Array),
+      expect.objectContaining({ stdio: "inherit" }),
+    );
+  });
+
+  it("uses stdio pipe when interactive is false", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "99.99.99" }), { status: 200 }),
+    );
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 0,
+      stdout: "",
+      stderr: "",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    await upgrade({ interactive: false });
+
+    expect(mockedSpawnSync).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.any(Array),
+      expect.objectContaining({ stdio: "pipe" }),
+    );
+  });
+
+  it("includes manual command on upgrade failure", async () => {
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify({ version: "99.99.99" }), { status: 200 }),
+    );
+
+    const { spawnSync } = await import("child_process");
+    const mockedSpawnSync = vi.mocked(spawnSync);
+    mockedSpawnSync.mockReturnValue({
+      status: 1,
+      stdout: "",
+      stderr: "permission denied",
+      pid: 0,
+      output: [],
+      signal: null,
+    });
+
+    const result = await upgrade();
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("permission denied");
+    expect(result.message).toContain("You can upgrade manually");
+  });
+});