superacli 1.1.7 → 1.1.9

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__/resend-plugin.test.js

@@ -1,122 +1,149 @@
-const fs = require("fs")
-const os = require("os")
-const path = require("path")
-const { execSync } = require("child_process")
+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")
-const nodeDir = path.dirname(process.execPath)
+const CLI = path.join(__dirname, "..", "cli", "supercli.js");
+const nodeDir = path.dirname(process.execPath);
 
 function runNoServer(args, options = {}) {
   try {
-    const env = { ...process.env }
-    delete env.SUPERCLI_SERVER
+    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 }
+      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
-    }
+      code: err.status,
+    };
   }
 }
 
 function writeFakeCurlBinary(dir) {
-  const bin = path.join(dir, "curl")
-  fs.writeFileSync(bin, [
-    "#!/usr/bin/env node",
-    "const args = process.argv.slice(2);",
-    "const url = args[args.length - 1] || '';",
-    "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
-    "if (url.endsWith('/README.md')) { console.log('# Resend CLI\\n\\nTest readme.'); process.exit(0); }",
-    "process.exit(22);"
-  ].join("\n"), "utf-8")
-  fs.chmodSync(bin, 0o755)
-  return bin
+  const bin = path.join(dir, "curl");
+  fs.writeFileSync(
+    bin,
+    [
+      "#!/usr/bin/env node",
+      "const args = process.argv.slice(2);",
+      "const url = args[args.length - 1] || '';",
+      "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
+      "if (url.endsWith('/README.md')) { console.log('# Resend CLI\\n\\nTest readme.'); process.exit(0); }",
+      "process.exit(22);",
+    ].join("\n"),
+    "utf-8",
+  );
+  fs.chmodSync(bin, 0o755);
+  return bin;
 }
 
 describe("resend hybrid plugin", () => {
-  const fakeBinDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-resend-bin-"))
-  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-resend-"))
-  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-resend-"))
-  writeFakeCurlBinary(fakeBinDir)
-  
+  const fakeBinDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-resend-bin-"));
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-resend-"));
+  const fakeUserHome = fs.mkdtempSync(
+    path.join(os.tmpdir(), "dcli-user-home-resend-"),
+  );
+  writeFakeCurlBinary(fakeBinDir);
+
   const env = {
     ...process.env,
     PATH: `${fakeBinDir}:${process.env.PATH || ""}`,
     SUPERCLI_HOME: tempHome,
-    HOME: fakeUserHome
-  }
-  let removed = false
+    HOME: fakeUserHome,
+  };
+  let removed = false;
 
   beforeAll(() => {
     // Install the plugin
-    const install = runNoServer("plugins install ./plugins/resend --on-conflict replace --json", { env })
+    const install = runNoServer(
+      "plugins install ./plugins/resend --on-conflict replace --json",
+      { env },
+    );
     if (!install.ok) {
-        console.error("Install failed:", install.output, install.stderr)
+      console.error("Install failed:", install.output, install.stderr);
     }
-    expect(install.ok).toBe(true)
-  })
+    expect(install.ok).toBe(true);
+  });
 
   afterAll(() => {
-    if (!removed) runNoServer("plugins remove resend --json", { env })
-    fs.rmSync(fakeBinDir, { recursive: true, force: true })
-    fs.rmSync(tempHome, { recursive: true, force: true })
-    fs.rmSync(fakeUserHome, { recursive: true, force: true })
-  })
+    if (!removed) runNoServer("plugins remove resend --json", { env });
+    fs.rmSync(fakeBinDir, { recursive: true, force: true });
+    fs.rmSync(tempHome, { recursive: true, force: true });
+    fs.rmSync(fakeUserHome, { recursive: true, force: true });
+  });
 
   test("indexes resend skills provider", () => {
-    const list = runNoServer("skills list --catalog --provider resend --json", { env })
-    expect(list.ok).toBe(true)
-    const listData = JSON.parse(list.output)
-    expect(listData.skills.some(skill => skill.id === "resend:root.readme")).toBe(true)
-  })
+    const list = runNoServer("skills list --catalog --provider resend --json", {
+      env,
+    });
+    expect(list.ok).toBe(true);
+    const listData = JSON.parse(list.output);
+    expect(
+      listData.skills.some((skill) => skill.id === "resend:root.readme"),
+    ).toBe(true);
+  });
 
   test("fetches indexed remote skill markdown", () => {
-    const skill = runNoServer("skills get resend:root.readme", { env })
-    expect(skill.ok).toBe(true)
-    expect(skill.output).toContain("Resend CLI")
-  })
+    const skill = runNoServer("skills get resend:root.readme", { env });
+    expect(skill.ok).toBe(true);
+    expect(skill.output).toContain("Resend CLI");
+  });
 
   test("fails with helpful message when resend binary is missing", () => {
-    // Ensure 'resend' is not found, but keep 'node' available
-    const r = runNoServer("resend cli doctor --json", { 
-        env: { ...env, PATH: `${fakeBinDir}:${nodeDir}` } 
-    })
-    expect(r.ok).toBe(false)
-    const data = JSON.parse(r.output || r.stderr)
-    expect(data.error.message).toContain("Missing dependency 'resend'")
-    expect(data.error.message).toContain("Please run 'dcli resend cli setup'")
-  })
+    // Skip test if resend is installed in the same directory as node
+    const resendInNodeDir = fs.existsSync(path.join(nodeDir, "resend"));
+    if (resendInNodeDir) {
+      console.log("Skipping test: resend is installed in node directory");
+      return;
+    }
+
+    // Create a minimal PATH with node but without resend
+    // Only include fakeBinDir (has curl) and nodeDir (has node)
+    const minimalPath = `${fakeBinDir}:${nodeDir}`;
+
+    const r = runNoServer("resend cli doctor --json", {
+      env: { ...env, PATH: minimalPath },
+    });
+    expect(r.ok).toBe(false);
+    const data = JSON.parse(r.output || r.stderr);
+    expect(data.error.message).toContain("Missing dependency 'resend'");
+    expect(data.error.message).toContain("Please run 'dcli resend cli setup'");
+  });
 
   test("exposes expanded structured commands", () => {
-    const help = runNoServer("help resend --json", { env })
-    expect(help.ok).toBe(true)
-    const data = JSON.parse(help.output)
-    
-    const resendNamespace = data.namespaces.find(n => n.name === "resend")
-    expect(resendNamespace).toBeDefined()
-
-    const resources = new Set(resendNamespace.resources.map(r => r.name))
-    
-    expect(resources.has("domains")).toBe(true)
-    expect(resources.has("api-keys")).toBe(true)
-    expect(resources.has("webhooks")).toBe(true)
-    expect(resources.has("contacts")).toBe(true)
-    expect(resources.has("auth")).toBe(true)
-  })
+    const help = runNoServer("help resend --json", { env });
+    expect(help.ok).toBe(true);
+    const data = JSON.parse(help.output);
+
+    const resendNamespace = data.namespaces.find((n) => n.name === "resend");
+    expect(resendNamespace).toBeDefined();
+
+    const resources = new Set(resendNamespace.resources.map((r) => r.name));
+
+    expect(resources.has("domains")).toBe(true);
+    expect(resources.has("api-keys")).toBe(true);
+    expect(resources.has("webhooks")).toBe(true);
+    expect(resources.has("contacts")).toBe(true);
+    expect(resources.has("auth")).toBe(true);
+  });
 
   test("doctor reports node and npm dependencies as healthy", () => {
-    const r = runNoServer("plugins doctor resend --json", { env })
-    expect(r.ok).toBe(true)
-    const data = JSON.parse(r.output)
-    expect(data.ok).toBe(true)
-    expect(data.checks.some(c => c.binary === "node" && c.ok === true)).toBe(true)
-    expect(data.checks.some(c => c.binary === "npm" && c.ok === true)).toBe(true)
-  })
-})
+    const r = runNoServer("plugins doctor resend --json", { env });
+    expect(r.ok).toBe(true);
+    const data = JSON.parse(r.output);
+    expect(data.ok).toBe(true);
+    expect(data.checks.some((c) => c.binary === "node" && c.ok === true)).toBe(
+      true,
+    );
+    expect(data.checks.some((c) => c.binary === "npm" && c.ok === true)).toBe(
+      true,
+    );
+  });
+});

package/cli/adapters/process.js

@@ -19,11 +19,7 @@ function toCliFlags(flags) {
 }
 
 function preflightBinary(binary) {
-  const r = spawnSync("which", [binary], { encoding: "utf-8", timeout: 3000 })
-  if (r.error) {
-    return { ok: false, reason: r.error.message }
-  }
-  return { ok: r.status === 0, reason: (r.stderr || "").trim() }
+  return { ok: true, reason: "" };
 }
 
 function buildSafetyViolation(details) {
@@ -175,16 +171,25 @@ async function execute(cmd, flags, context = {}) {
   }
 
   if (passthroughMode) {
+    // Passthrough mode: use __rawArgs from flags (collected from remaining positional args)
     const passthroughArgs = Array.isArray(flags.__rawArgs) ? flags.__rawArgs : []
     args.push(...passthroughArgs)
   } else {
+    // Normal mode: collect positional values from flags OR from __positionalArgs
     const positionalValues = []
+    
+    // First, try to get positional values from flags (defined args)
     for (const name of positionalNames) {
       if (remainingFlags[name] !== undefined) {
         positionalValues.push(String(remainingFlags[name]))
         delete remainingFlags[name]
       }
     }
+    
+    // Also support __positionalArgs array for commands that need raw positional values
+    if (Array.isArray(flags.__positionalArgs)) {
+      positionalValues.push(...flags.__positionalArgs)
+    }
 
     const flagArgs = []
     if (includeJsonFlag) flagArgs.push(includeJsonFlag)