superacli 1.1.6 → 1.1.8

package/__tests__/adapter-schema.test.js

@@ -1,121 +1,286 @@
-const { validateAdapterConfig } = require("../cli/adapter-schema")
+const { validateAdapterConfig } = require("../cli/adapter-schema");
 
 describe("adapter-schema", () => {
   test("accepts valid process adapter", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "process",
-      adapterConfig: { command: "br", baseArgs: ["list"], timeout_ms: 5000 }
-    })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "br", baseArgs: ["list"], timeout_ms: 5000 },
+      }),
+    ).not.toThrow();
+  });
 
   test("ignores unknown adapters", () => {
-    expect(() => validateAdapterConfig({ adapter: "custom" })).not.toThrow()
-  })
+    expect(() => validateAdapterConfig({ adapter: "custom" })).not.toThrow();
+  });
 
   test("rejects non-object adapterConfig", () => {
-    expect(() => validateAdapterConfig({ adapter: "http", adapterConfig: "string" })).toThrow(/requires adapterConfig object/)
-  })
+    expect(() =>
+      validateAdapterConfig({ adapter: "http", adapterConfig: "string" }),
+    ).toThrow(/requires adapterConfig object/);
+  });
 
   test("rejects invalid common types", () => {
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", parseJson: "yes" } })).toThrow(/must be boolean/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", cwd: 123 } })).toThrow(/must be string/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", safetyLevel: true } })).toThrow(/must be string/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", parseJson: "yes" },
+      }),
+    ).toThrow(/must be boolean/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", cwd: 123 },
+      }),
+    ).toThrow(/must be string/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", safetyLevel: true },
+      }),
+    ).toThrow(/must be string/);
+  });
 
   test("timeout_ms validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", timeout_ms: "none" } })).toThrow(/positive number/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", timeout_ms: -1 } })).toThrow(/positive number/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", timeout_ms: 20000 } })).toThrow(/cannot exceed 15000ms/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", timeout_ms: "none" },
+      }),
+    ).toThrow(/positive number/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", timeout_ms: -1 },
+      }),
+    ).toThrow(/positive number/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", timeout_ms: 200000 },
+      }),
+    ).toThrow(/cannot exceed 180000ms/);
+  });
 
   test("http adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "http", adapterConfig: { url: 123 } })).toThrow(/requires adapterConfig.url/)
-    expect(() => validateAdapterConfig({ adapter: "http", adapterConfig: { url: "u", method: 1 } })).toThrow(/method must be string/)
-    expect(() => validateAdapterConfig({ adapter: "http", adapterConfig: { url: "u" } })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({ adapter: "http", adapterConfig: { url: 123 } }),
+    ).toThrow(/requires adapterConfig.url/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "http",
+        adapterConfig: { url: "u", method: 1 },
+      }),
+    ).toThrow(/method must be string/);
+    expect(() =>
+      validateAdapterConfig({ adapter: "http", adapterConfig: { url: "u" } }),
+    ).not.toThrow();
+  });
 
   test("openapi adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "openapi", adapterConfig: { spec: 1 } })).toThrow(/requires adapterConfig.spec/)
-    expect(() => validateAdapterConfig({ adapter: "openapi", adapterConfig: { spec: "s", operationId: 1 } })).toThrow(/requires adapterConfig.operationId/)
-    expect(() => validateAdapterConfig({ adapter: "openapi", adapterConfig: { spec: "s", operationId: "o" } })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({ adapter: "openapi", adapterConfig: { spec: 1 } }),
+    ).toThrow(/requires adapterConfig.spec/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "openapi",
+        adapterConfig: { spec: "s", operationId: 1 },
+      }),
+    ).toThrow(/requires adapterConfig.operationId/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "openapi",
+        adapterConfig: { spec: "s", operationId: "o" },
+      }),
+    ).not.toThrow();
+  });
 
   test("mcp adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: 1 } })).toThrow(/requires adapterConfig.tool/)
-    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t" } })).toThrow(/requires one source/)
-    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s" } })).not.toThrow()
-    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s", timeout_ms: 180000 } })).not.toThrow()
-    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s", timeout_ms: 180001 } })).toThrow(/cannot exceed 180000ms/)
-  })
+    expect(() =>
+      validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: 1 } }),
+    ).toThrow(/requires adapterConfig.tool/);
+    expect(() =>
+      validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t" } }),
+    ).toThrow(/requires one source/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "mcp",
+        adapterConfig: { tool: "t", server: "s" },
+      }),
+    ).not.toThrow();
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "mcp",
+        adapterConfig: { tool: "t", server: "s", timeout_ms: 180000 },
+      }),
+    ).not.toThrow();
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "mcp",
+        adapterConfig: { tool: "t", server: "s", timeout_ms: 180001 },
+      }),
+    ).toThrow(/cannot exceed 180000ms/);
+  });
 
   test("process adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: 1 } })).toThrow(/requires adapterConfig.command/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", baseArgs: "none" } })).toThrow(/must be an array/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", positionalArgs: "none" } })).toThrow(/must be an array/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", passthrough: "yes" } })).toThrow(/must be boolean/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", flagsBeforePositionals: "yes" } })).toThrow(/must be boolean/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", missingDependencyHelp: 1 } })).toThrow(/must be string/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", env: [] } })).toThrow(/must be object/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", stream: true } })).toThrow(/must be string/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", stream: "sse" } })).toThrow(/must be 'jsonl'/)
-    expect(() => validateAdapterConfig({ adapter: "process", adapterConfig: { command: "a", stream: "jsonl" } })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: 1 },
+      }),
+    ).toThrow(/requires adapterConfig.command/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", baseArgs: "none" },
+      }),
+    ).toThrow(/must be an array/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", positionalArgs: "none" },
+      }),
+    ).toThrow(/must be an array/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", passthrough: "yes" },
+      }),
+    ).toThrow(/must be boolean/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", flagsBeforePositionals: "yes" },
+      }),
+    ).toThrow(/must be boolean/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", missingDependencyHelp: 1 },
+      }),
+    ).toThrow(/must be string/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", env: [] },
+      }),
+    ).toThrow(/must be object/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", stream: true },
+      }),
+    ).toThrow(/must be string/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", stream: "sse" },
+      }),
+    ).toThrow(/must be 'jsonl'/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "a", stream: "jsonl" },
+      }),
+    ).not.toThrow();
+  });
 
   test("builtin adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "builtin", adapterConfig: { builtin: 1 } })).toThrow(/requires adapterConfig.builtin/)
-    expect(() => validateAdapterConfig({ adapter: "builtin", adapterConfig: { builtin: "b" } })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "builtin",
+        adapterConfig: { builtin: 1 },
+      }),
+    ).toThrow(/requires adapterConfig.builtin/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "builtin",
+        adapterConfig: { builtin: "b" },
+      }),
+    ).not.toThrow();
+  });
 
   test("shell adapter validation", () => {
-    expect(() => validateAdapterConfig({ adapter: "shell", adapterConfig: { script: 1, unsafe: true } })).toThrow(/requires adapterConfig.script/)
-    expect(() => validateAdapterConfig({ adapter: "shell", adapterConfig: { script: "s", unsafe: true, shell: 1 } })).toThrow(/shell must be string/)
-    expect(() => validateAdapterConfig({ adapter: "shell", adapterConfig: { script: "s", unsafe: true, env: "none" } })).toThrow(/must be object/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "shell",
+        adapterConfig: { script: 1, unsafe: true },
+      }),
+    ).toThrow(/requires adapterConfig.script/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "shell",
+        adapterConfig: { script: "s", unsafe: true, shell: 1 },
+      }),
+    ).toThrow(/shell must be string/);
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "shell",
+        adapterConfig: { script: "s", unsafe: true, env: "none" },
+      }),
+    ).toThrow(/must be object/);
+  });
 
   test("rejects interactive config", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "http",
-      adapterConfig: { url: "https://example.com", non_interactive: false }
-    })).toThrow(/Interactive command execution is not supported/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "http",
+        adapterConfig: { url: "https://example.com", non_interactive: false },
+      }),
+    ).toThrow(/Interactive command execution is not supported/);
+  });
 
   test("requires unsafe true for shell adapter", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "shell",
-      adapterConfig: { script: "echo hi" }
-    })).toThrow(/unsafe=true/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "shell",
+        adapterConfig: { script: "echo hi" },
+      }),
+    ).toThrow(/unsafe=true/);
+  });
 
   test("accepts shell adapter with unsafe true", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "shell",
-      adapterConfig: { script: "echo '{\"ok\":true}'", unsafe: true, timeout_ms: 1000 }
-    })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "shell",
+        adapterConfig: {
+          script: "echo '{\"ok\":true}'",
+          unsafe: true,
+          timeout_ms: 1000,
+        },
+      }),
+    ).not.toThrow();
+  });
 
   test("accepts process safety metadata", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "process",
-      adapterConfig: {
-        command: "docker",
-        safetyLevel: "guarded",
-        interactiveFlags: ["-i", "--interactive"],
-        requiresInteractive: false
-      }
-    })).not.toThrow()
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: {
+          command: "docker",
+          safetyLevel: "guarded",
+          interactiveFlags: ["-i", "--interactive"],
+          requiresInteractive: false,
+        },
+      }),
+    ).not.toThrow();
+  });
 
   test("rejects non-array interactiveFlags", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "process",
-      adapterConfig: { command: "docker", interactiveFlags: "--tty" }
-    })).toThrow(/interactiveFlags must be an array/)
-  })
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "docker", interactiveFlags: "--tty" },
+      }),
+    ).toThrow(/interactiveFlags must be an array/);
+  });
 
   test("rejects non-string interactiveFlags values", () => {
-    expect(() => validateAdapterConfig({
-      adapter: "process",
-      adapterConfig: { command: "docker", interactiveFlags: ["--tty", 42] }
-    })).toThrow(/interactiveFlags values must be strings/)
-  })
-})
+    expect(() =>
+      validateAdapterConfig({
+        adapter: "process",
+        adapterConfig: { command: "docker", interactiveFlags: ["--tty", 42] },
+      }),
+    ).toThrow(/interactiveFlags values must be strings/);
+  });
+});

package/__tests__/azd-plugin.test.js

@@ -0,0 +1,109 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeAzdBinary(dir) {
+  const bin = path.join(dir, "azd")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log('azd version 1.17.0-test'); process.exit(0); }",
+    "if (args[0] === 'auth' && args[1] === 'login' && args.includes('--check-status')) {",
+    "  console.log('Logged in as test-user');",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'deploy' && args[1] === '--all') {",
+    "  const envIndex = args.indexOf('--environment');",
+    "  const environment = envIndex >= 0 ? args[envIndex + 1] : null;",
+    "  console.log(JSON.stringify({ mode: 'deploy-all', environment, args }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'env' && args[1] === 'list') {",
+    "  console.log(JSON.stringify({ environments: ['dev', 'prod'] }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("azd plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-azd-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-azd-"))
+  writeFakeAzdBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/azd --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove azd --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes wrapped commands and passthrough", () => {
+    const version = runNoServer("azd cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("azd version 1.17.0-test")
+
+    const status = runNoServer("azd auth status --json", { env })
+    expect(status.ok).toBe(true)
+    expect(JSON.parse(status.output).data.raw).toContain("Logged in")
+
+    const deploy = runNoServer("azd deploy all --environment dev --json", { env })
+    expect(deploy.ok).toBe(true)
+    const deployPayload = JSON.parse(JSON.parse(deploy.output).data.raw)
+    expect(deployPayload.mode).toBe("deploy-all")
+    expect(deployPayload.environment).toBe("dev")
+    expect(deployPayload.args).toContain("--no-prompt")
+
+    const passthrough = runNoServer("azd env list --json", { env })
+    expect(passthrough.ok).toBe(true)
+    expect(JSON.parse(passthrough.output).command).toBe("azd.passthrough")
+  })
+
+  test("exposes learn content and healthy dependency checks", () => {
+    const learn = runNoServer("plugins learn azd --json", { env })
+    expect(learn.ok).toBe(true)
+    const learnPayload = JSON.parse(learn.output)
+    expect(learnPayload.plugin).toBe("azd")
+    expect(learnPayload.learn_markdown).toContain("azd Quickstart")
+
+    const explore = runNoServer("plugins explore --name azd --json", { env })
+    expect(explore.ok).toBe(true)
+    const plugin = JSON.parse(explore.output).plugins.find(p => p.name === "azd")
+    expect(plugin).toBeDefined()
+    expect(plugin.has_learn).toBe(true)
+
+    const doctor = runNoServer("plugins doctor azd --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "azd" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/config.test.js

@@ -17,7 +17,7 @@ const {
   upsertCommand,
   removeCommandsByNamespace
 } = require("../cli/config")
-const { getInstalledPluginCommands, listInstalledPlugins } = require("../cli/plugins-store")
+const { getEffectivePluginCommands, listInstalledPlugins, readServerPluginsLock } = require("../cli/plugins-store")
 
 global.fetch = jest.fn()
 
@@ -29,8 +29,9 @@ describe("config", () => {
   beforeEach(() => {
     jest.clearAllMocks()
     os.homedir.mockReturnValue(mockHomedir)
-    getInstalledPluginCommands.mockReturnValue([])
+    getEffectivePluginCommands.mockReturnValue([])
     listInstalledPlugins.mockReturnValue([])
+    readServerPluginsLock.mockReturnValue({ installed: {} })
     jest.spyOn(Date, "now").mockReturnValue(1000000)
   })
 
@@ -52,7 +53,7 @@ describe("config", () => {
         version: "2",
         commands: [{ id: "base" }]
       }))
-      getInstalledPluginCommands.mockReturnValue([{ id: "plugin" }])
+      getEffectivePluginCommands.mockReturnValue([{ id: "plugin" }])
 
       const config = await loadConfig()
       expect(config.version).toBe("2")

package/__tests__/discover.test.js

@@ -0,0 +1,59 @@
+const { tokenizeIntent, discoverPluginsByIntent } = require("../cli/discover")
+const { listRegistryPlugins } = require("../cli/plugins-registry")
+const { listInstalledPlugins, getPluginInstallGuidance } = require("../cli/plugins-manager")
+
+jest.mock("../cli/plugins-registry")
+jest.mock("../cli/plugins-manager")
+
+describe("discover", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("tokenizeIntent strips stopwords and expands synonyms", () => {
+    const tokens = tokenizeIntent("Please send mail with gmail")
+    expect(tokens).toEqual(expect.arrayContaining(["email", "gmail", "mail"]))
+    expect(tokens).not.toContain("please")
+    expect(tokens).not.toContain("with")
+  })
+
+  test("discoverPluginsByIntent ranks plugins deterministically", () => {
+    listRegistryPlugins.mockReturnValue([
+      {
+        name: "resend",
+        description: "Resend email API",
+        tags: ["email", "api"],
+        has_learn: true,
+        source: { type: "bundled" },
+      },
+      {
+        name: "browser-use",
+        description: "Browser automation over MCP",
+        tags: ["browser", "mcp"],
+        has_learn: true,
+        source: { type: "bundled" },
+      },
+    ])
+    listInstalledPlugins.mockReturnValue([{ name: "resend" }])
+    getPluginInstallGuidance.mockReturnValue({
+      install_steps: ["supercli plugins install resend", "supercli resend cli setup"],
+    })
+
+    const out = discoverPluginsByIntent("send email", { limit: 5 })
+    expect(out.no_llm).toBe(true)
+    expect(out.plugins[0].name).toBe("resend")
+    expect(out.plugins[0].installed).toBe(true)
+    expect(out.plugins[0].matched_tokens).toContain("email")
+    expect(out.plugins[0].next_steps).toEqual(expect.arrayContaining(["supercli plugins learn resend --json"]))
+  })
+
+  test("discoverPluginsByIntent validates empty intent", () => {
+    expect(() => discoverPluginsByIntent("   ")).toThrow(/Missing --intent text/)
+  })
+
+  test("discoverPluginsByIntent validates limit", () => {
+    listRegistryPlugins.mockReturnValue([])
+    listInstalledPlugins.mockReturnValue([])
+    expect(() => discoverPluginsByIntent("email", { limit: 0 })).toThrow(/Invalid --limit/)
+  })
+})