@checkstack/backend 0.8.2 → 0.9.0

package/src/services/plugin-installer.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-
-// 1. Mock child_process and fs BEFORE importing the target module
-const mockExec = mock((_cmd: string, cb: any) => {
-  cb(null, { stdout: "mocked" }, { stderr: "" });
-});
-
-const mockExistsSync = mock(() => true);
-const mockMkdirSync = mock();
-const mockReadFileSync = mock(() => JSON.stringify({ name: "mock-plugin" }));
-
-mock.module("node:util", () => ({
-  promisify: (fn: any) => {
-    return async (...args: any[]) => {
-      // Return a promise that resolves with what our mock would return
-      // We can just call mockExec and return its "result"
-      return new Promise((resolve) => {
-        fn(...args, (err: any, stdout: any, stderr: any) =>
-          resolve({ stdout, stderr })
-        );
-      });
-    };
-  },
-}));
-
-mock.module("node:child_process", () => ({
-  exec: mockExec,
-}));
-
-mock.module("node:fs", () => {
-  const exports = {
-    existsSync: mockExistsSync,
-    mkdirSync: mockMkdirSync,
-    readFileSync: mockReadFileSync,
-  };
-  return {
-    ...exports,
-    default: exports,
-  };
-});
-
-// 2. Now import the module under test
-import { PluginLocalInstaller } from "./plugin-installer";
-import fs from "node:fs";
-import path from "node:path";
-
-describe("PluginLocalInstaller", () => {
-  const runtimeDir = "/tmp/runtime_plugins";
-  let installer: PluginLocalInstaller;
-  let customExec: any;
-
-  beforeEach(() => {
-    customExec = mock(() => Promise.resolve({ stdout: "mocked", stderr: "" }));
-    installer = new PluginLocalInstaller(runtimeDir, customExec);
-    mockExistsSync.mockClear();
-    mockExistsSync.mockReturnValue(true);
-  });
-
-  it("should install a package using bun", async () => {
-    const result = await installer.install("my-plugin");
-
-    expect(customExec).toHaveBeenCalled();
-    const command = customExec.mock.calls[0][0];
-    expect(command).toContain("bun install my-plugin");
-    expect(command).toContain(`--cwd ${path.resolve(runtimeDir)}`);
-    expect(command).toContain("--no-save");
-
-    expect(result.name).toBe("mock-plugin");
-  });
-
-  it("should handle scoped packages correctly", async () => {
-    const result = await installer.install("@scope/plugin");
-
-    expect(customExec).toHaveBeenCalled();
-    const command = customExec.mock.calls[0][0];
-    expect(command).toContain("bun install @scope/plugin");
-
-    expect(result.name).toBe("mock-plugin");
-  });
-
-  it("should throw error if package.json is missing after install", async () => {
-    // The constructor was already called in beforeEach.
-    // The next call to existsSync will be inside the install method for the pkgJsonPath.
-    mockExistsSync.mockReturnValueOnce(false);
-
-    await expect(installer.install("failing-plugin")).rejects.toThrow(
-      "not found"
-    );
-  });
-});

package/src/services/plugin-installer.ts

@@ -1,70 +0,0 @@
-import { PluginInstaller } from "@checkstack/backend-api";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import path from "node:path";
-import fs from "node:fs";
-
-export class PluginLocalInstaller implements PluginInstaller {
-  private runtimeDir: string;
-  private execAsync: (
-    command: string
-  ) => Promise<{ stdout: string; stderr: string }>;
-
-  constructor(
-    runtimeDir: string,
-    customExec?: (
-      command: string
-    ) => Promise<{ stdout: string; stderr: string }>
-  ) {
-    this.runtimeDir = path.resolve(runtimeDir);
-    this.execAsync = customExec || promisify(exec);
-    if (!fs.existsSync(this.runtimeDir)) {
-      fs.mkdirSync(this.runtimeDir, { recursive: true });
-    }
-  }
-
-  async install(packageName: string): Promise<{ name: string; path: string }> {
-    try {
-      console.log(
-        `🔌 Installing plugin: ${packageName} into ${this.runtimeDir}`
-      );
-
-      // Use bun install with --no-save to avoid creating/modifying lockfiles
-      // in the runtime directory. This keeps plugins isolated from the main app.
-      await this.execAsync(
-        `bun install ${packageName} --cwd ${this.runtimeDir} --no-save`
-      );
-
-      // Extract the actual package name (packageName could be a URL or @org/name@version)
-      // For now, we assume it's a simple package name for the path lookup,
-      // or we can parse it better.
-      // A safer way is to check the recently changed folders in node_modules?
-      // Or just assume the input packageName (stripped of @version) matches the folder.
-      let folderName = packageName;
-      if (packageName.includes("@") && !packageName.startsWith("@")) {
-        folderName = packageName.split("@")[0];
-      } else if (packageName.startsWith("@") && packageName.includes("@", 1)) {
-        folderName = "@" + packageName.split("@")[1];
-      }
-
-      const pkgPath = path.join(this.runtimeDir, "node_modules", folderName);
-      const pkgJsonPath = path.join(pkgPath, "package.json");
-
-      if (!fs.existsSync(pkgJsonPath)) {
-        throw new Error(
-          `Package folder ${folderName} not found at ${pkgPath} after installation`
-        );
-      }
-
-      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
-
-      return {
-        name: pkgJson.name,
-        path: pkgPath,
-      };
-    } catch (error) {
-      console.error(`❌ Failed to install plugin ${packageName}:`, error);
-      throw error;
-    }
-  }
-}