superacli 1.1.5 → 1.1.7

package/__tests__/skills.test.js

@@ -1,9 +1,11 @@
 const {
   MCP_SERVERS_USAGE_SKILL_ID,
+  PLUGINS_AUTHORING_SKILL_ID,
   normalizeSkillId,
   buildCommandSkillMarkdown,
   buildTeachSkillMarkdown,
   buildPluginsUsageSkillMarkdown,
+  buildPluginsAuthoringSkillMarkdown,
   buildMcpServersUsageSkillMarkdown,
   listSkillsMetadata,
   handleSkillsCommand,
@@ -99,6 +101,14 @@ describe("skills", () => {
     expect(md).toContain("# Instruction")
   })
 
+  test("buildPluginsAuthoringSkillMarkdown returns markdown", () => {
+    const md = buildPluginsAuthoringSkillMarkdown({ showDag: true })
+    expect(md).toContain("skill_name: \"plugins_authoring_usage\"")
+    expect(md).toContain("plugins/<name>/")
+    expect(md).toContain("~/.supercli/plugins/local/<name>/")
+    expect(md).toContain("dag:")
+  })
+
   test("buildMcpServersUsageSkillMarkdown returns markdown", () => {
     const md = buildMcpServersUsageSkillMarkdown({ showDag: true })
     expect(md).toContain("skill_name: \"mcp_servers_usage\"")
@@ -120,6 +130,8 @@ describe("skills", () => {
     expect(item.description).toBe("desc")
     const mcpSkill = skills.find(s => s.name === MCP_SERVERS_USAGE_SKILL_ID)
     expect(mcpSkill).toBeTruthy()
+    const authoringSkill = skills.find(s => s.name === PLUGINS_AUTHORING_SKILL_ID)
+    expect(authoringSkill).toBeTruthy()
   })
 
   describe("handleSkillsCommand", () => {
@@ -236,6 +248,20 @@ describe("skills", () => {
       consoleSpy.mockRestore()
     })
 
+    test("get subcommand (plugins authoring usage)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "plugins.authoring.usage"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("skill_name: \"plugins_authoring_usage\""))
+      consoleSpy.mockRestore()
+    })
+
     test("get subcommand (mcp servers usage)", () => {
       const consoleSpy = jest.spyOn(console, "log").mockImplementation()
       const result = handleSkillsCommand({

package/__tests__/squirrelscan-plugin.test.js

@@ -0,0 +1,129 @@
+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 writeFakeDockerBinary(dir) {
+  const bin = path.join(dir, "docker")
+  const statePath = path.join(dir, "docker-state.json")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "const args = process.argv.slice(2);",
+    "const statePath = path.join(__dirname, 'docker-state.json');",
+    "const state = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, 'utf-8')) : { built: false, buildCount: 0 };",
+    "const save = () => fs.writeFileSync(statePath, JSON.stringify(state));",
+    "if (args.includes('--version')) { console.log('Docker version 26.1.0, build test'); process.exit(0); }",
+    "if (args[0] === 'image' && args[1] === 'inspect') { process.exit(state.built ? 0 : 1); }",
+    "if (args[0] === 'build') { state.built = true; state.buildCount += 1; save(); console.log('build ok'); process.exit(0); }",
+    "if (args[0] === 'run') { console.log(JSON.stringify({ ok: true, args })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return statePath
+}
+
+describe("squirrelscan plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-squirrelscan-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-squirrelscan-"))
+  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-squirrelscan-"))
+  const statePath = writeFakeDockerBinary(fakeDir)
+  const env = {
+    ...process.env,
+    PATH: `${fakeDir}:${process.env.PATH || ""}`,
+    SUPERCLI_HOME: tempHome,
+    HOME: fakeUserHome,
+  }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/squirrelscan --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove squirrelscan --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+    fs.rmSync(fakeUserHome, { recursive: true, force: true })
+  })
+
+  test("runs squirrel audit in docker with passthrough args", () => {
+    const r = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+    expect(r.ok).toBe(true)
+
+    const payload = JSON.parse(r.output)
+    expect(payload.command).toBe("squirrel.passthrough")
+
+    const dockerPayload = JSON.parse(payload.data.raw)
+    expect(dockerPayload.args[0]).toBe("run")
+    expect(dockerPayload.args).toContain("dcli-squirrelscan:0.0.38")
+    expect(dockerPayload.args).toContain("audit")
+    expect(dockerPayload.args).toContain("https://example.com")
+    expect(dockerPayload.args).toContain("-C")
+    expect(dockerPayload.args).toContain("quick")
+    expect(dockerPayload.args).toContain("dcli-squirrelscan-home:/root/.squirrel")
+  })
+
+  test("routes structured audit command to squirrel audit", () => {
+    const r = runNoServer("squirrel audit run --url https://example.com --coverage quick --json", { env })
+    expect(r.ok).toBe(true)
+
+    const payload = JSON.parse(r.output)
+    expect(payload.command).toBe("squirrel.audit.run")
+
+    const dockerPayload = JSON.parse(payload.data.raw)
+    expect(dockerPayload.args).toContain("audit")
+    expect(dockerPayload.args).toContain("https://example.com")
+    expect(dockerPayload.args).toContain("--coverage")
+    expect(dockerPayload.args).toContain("quick")
+  })
+
+  test("exposes learn content for agents", () => {
+    const r = runNoServer("plugins learn squirrelscan --json", { env })
+    expect(r.ok).toBe(true)
+    const payload = JSON.parse(r.output)
+    expect(payload.plugin).toBe("squirrelscan")
+    expect(payload.learn_markdown).toContain("SquirrelScan Quickstart")
+  })
+
+  test("registers squirrelscan skills provider in catalog", () => {
+    const r = runNoServer("skills list --catalog --provider squirrelscan --json", { env })
+    expect(r.ok).toBe(true)
+    const payload = JSON.parse(r.output)
+    expect(Array.isArray(payload.skills)).toBe(true)
+    expect(payload.skills.some(skill => skill.id === "squirrelscan:quickstart")).toBe(true)
+  })
+
+  test("builds image once and reuses on subsequent runs", () => {
+    const first = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+    const second = runNoServer("squirrel audit https://example.com -C quick --json", { env })
+
+    expect(first.ok).toBe(true)
+    expect(second.ok).toBe(true)
+
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8"))
+    expect(state.buildCount).toBe(1)
+  })
+})

package/__tests__/uipath-plugin.test.js

@@ -0,0 +1,104 @@
+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 writeFakeUipcliBinary(dir) {
+  const bin = path.join(dir, "uipcli")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('uipcli 25.10.3-test'); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'deploy') {",
+    "  const pathArg = args[2] || null;",
+    "  const appIdIndex = args.indexOf('--applicationId');",
+    "  const appId = appIdIndex >= 0 ? args[appIdIndex + 1] : null;",
+    "  console.log(JSON.stringify({ mode: 'deploy', path: pathArg, appId, args }));",
+    "  process.exit(0);",
+    "}",
+    "if (args[0] === 'orchestrator' && args[1] === 'folders' && args[2] === 'list') {",
+    "  console.log(JSON.stringify({ folders: [{ id: 1, name: 'Shared' }] }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("uipath plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-uipath-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-uipath-"))
+  writeFakeUipcliBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/uipath --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove uipath --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes wrapped deploy command and passthrough", () => {
+    const version = runNoServer("uipath cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("uipcli 25.10.3-test")
+
+    const deploy = runNoServer("uipath package deploy --path ./dist/app --application-id app-123 --organization org --tenant t1 --uri https://example.test --json", { env })
+    expect(deploy.ok).toBe(true)
+    const deployPayload = JSON.parse(JSON.parse(deploy.output).data.raw)
+    expect(deployPayload.mode).toBe("deploy")
+    expect(deployPayload.path).toBe("./dist/app")
+    expect(deployPayload.args).toContain("package")
+    expect(deployPayload.args).toContain("deploy")
+    expect(deployPayload.args).toContain("./dist/app")
+
+    const passthrough = runNoServer("uipath orchestrator folders list --json", { env })
+    expect(passthrough.ok).toBe(true)
+    expect(JSON.parse(passthrough.output).command).toBe("uipath.passthrough")
+  })
+
+  test("exposes learn content and healthy dependency checks", () => {
+    const learn = runNoServer("plugins learn uipath --json", { env })
+    expect(learn.ok).toBe(true)
+    const learnPayload = JSON.parse(learn.output)
+    expect(learnPayload.plugin).toBe("uipath")
+    expect(learnPayload.learn_markdown).toContain("uipath Quickstart")
+
+    const explore = runNoServer("plugins explore --name uipath --json", { env })
+    expect(explore.ok).toBe(true)
+    const plugin = JSON.parse(explore.output).plugins.find(p => p.name === "uipath")
+    expect(plugin).toBeDefined()
+    expect(plugin.has_learn).toBe(true)
+
+    const doctor = runNoServer("plugins doctor uipath --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "uipcli" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/uipathcli-plugin.test.js

@@ -0,0 +1,95 @@
+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 writeFakeUipcliBinary(dir) {
+  const bin = path.join(dir, "uipcli")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('uipcli 25.10.0-test'); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'pack') { console.log(JSON.stringify({ mode: 'pack', args })); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'analyze') { console.log(JSON.stringify({ mode: 'analyze', args })); process.exit(0); }",
+    "if (args[0] === 'package' && args[1] === 'deploy') { console.log(JSON.stringify({ mode: 'deploy', args })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("uipathcli plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-uipathcli-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-uipathcli-"))
+  writeFakeUipcliBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/uipathcli --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove uipathcli --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes version command", () => {
+    const r = runNoServer("uipath self version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.self.version")
+    expect(data.data.raw).toBe("uipcli 25.10.0-test")
+  })
+
+  test("routes project pack wrapper", () => {
+    const r = runNoServer("uipath project pack --project-path ./demo --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.project.pack")
+    const payload = JSON.parse(data.data.raw)
+    expect(payload.mode).toBe("pack")
+    expect(payload.args).toContain("--project-path")
+    expect(payload.args).toContain("./demo")
+  })
+
+  test("supports passthrough", () => {
+    const r = runNoServer("uipath package analyze --project-path ./sample --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("uipath.passthrough")
+    const payload = JSON.parse(data.data.raw)
+    expect(payload.args).toContain("package")
+    expect(payload.args).toContain("analyze")
+  })
+
+  test("doctor reports uipcli dependency as healthy", () => {
+    const r = runNoServer("plugins doctor uipathcli --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "uipcli" && c.ok === true)).toBe(true)
+  })
+})

package/cli/adapters/mcp.js

@@ -53,6 +53,8 @@ function mergeMcpConfig(cmdConfig, serverEntry) {
     server: cmdConfig.server,
     url: interpolateEnvPlaceholders(cmdConfig.url || (serverEntry && serverEntry.url)),
     command: cmdConfig.command || (serverEntry && serverEntry.command),
+    mcp_protocol: cmdConfig.mcp_protocol || (serverEntry && serverEntry.mcp_protocol),
+    mcp_wire: cmdConfig.mcp_wire || (serverEntry && serverEntry.mcp_wire),
     timeout_ms:
       cmdConfig.timeout_ms !== undefined
         ? cmdConfig.timeout_ms

package/cli/adapters/process.js

@@ -97,6 +97,44 @@ function flushStreamBuffer(buffer, onLine) {
   return pending
 }
 
+function normalizeErrorMatchers(cfg) {
+  return Array.isArray(cfg.errorMatchers) ? cfg.errorMatchers.filter(Boolean) : []
+}
+
+function applyErrorMatchers(message, errorText, parsedError, cfg) {
+  const haystack = [message, errorText]
+  if (parsedError && parsedError.error && parsedError.error.message) haystack.push(parsedError.error.message)
+  if (parsedError && parsedError.message) haystack.push(parsedError.message)
+  const source = haystack.filter(Boolean).join("\n")
+
+  for (const matcher of normalizeErrorMatchers(cfg)) {
+    if (!matcher || !matcher.match) continue
+    let regex = null
+    try {
+      regex = new RegExp(String(matcher.match), matcher.flags || "")
+    } catch {
+      continue
+    }
+    if (!regex.test(source)) continue
+    return {
+      message: matcher.message || message,
+      code: Number.isInteger(matcher.code) ? matcher.code : undefined,
+      type: matcher.type,
+      recoverable: typeof matcher.recoverable === "boolean" ? matcher.recoverable : undefined,
+      suggestions: Array.isArray(matcher.suggestions) ? matcher.suggestions : undefined
+    }
+  }
+
+  return null
+}
+
+function resolveCwd(cfg, cmd) {
+  if (cfg.cwd === "invoke_cwd") return process.cwd()
+  if (cfg.cwd === "plugin_dir") return cmd.plugin_dir || undefined
+  if (typeof cfg.cwd === "string" && cfg.cwd.trim()) return cfg.cwd
+  return cmd.plugin_dir || undefined
+}
+
 async function execute(cmd, flags, context = {}) {
   const cfg = cmd.adapterConfig || {}
   const binary = cfg.command
@@ -111,11 +149,11 @@ async function execute(cmd, flags, context = {}) {
   const timeoutMs = Number(cfg.timeout_ms) > 0 ? Number(cfg.timeout_ms) : 15000
   const flagsBeforePositionals = cfg.flagsBeforePositionals === true || binary === "docker"
   const passthroughInteractive = passthroughMode && flags.__passthroughInteractive === true
-  const defaultCwd = cmd.plugin_dir || undefined
-  const cwd = typeof cfg.cwd === "string" ? cfg.cwd : defaultCwd
+  const cwd = resolveCwd(cfg, cmd)
   const pluginEnv = {}
   if (cmd.plugin_dir) pluginEnv.SUPERCLI_PLUGIN_DIR = cmd.plugin_dir
   if (cmd.plugin_name) pluginEnv.SUPERCLI_PLUGIN_NAME = cmd.plugin_name
+  pluginEnv.SUPERCLI_INVOKE_CWD = process.cwd()
   const env = (cfg.env && typeof cfg.env === "object") ? { ...process.env, ...cfg.env, ...pluginEnv } : { ...process.env, ...pluginEnv }
   const streamMode = cfg.stream || null
   const onStreamEvent = typeof context.onStreamEvent === "function" ? context.onStreamEvent : null
@@ -234,6 +272,7 @@ async function execute(cmd, flags, context = {}) {
         const finalMsg = parsedError && parsedError.error && parsedError.error.message
           ? parsedError.error.message
           : (parsedError && parsedError.message ? parsedError.message : errorText || baseMsg)
+        const matchedError = applyErrorMatchers(finalMsg, errorText, parsedError, cfg)
 
         const errorObj = Object.assign(new Error(finalMsg), {
           code: (parsedError && parsedError.error && parsedError.error.code) || (parsedError && parsedError.code) || 105,
@@ -246,6 +285,14 @@ async function execute(cmd, flags, context = {}) {
             : (Array.isArray(parsedError && parsedError.suggestions) ? parsedError.suggestions : [])
         })
 
+        if (matchedError) {
+          if (matchedError.message) errorObj.message = matchedError.message
+          if (matchedError.code !== undefined) errorObj.code = matchedError.code
+          if (matchedError.type) errorObj.type = matchedError.type
+          if (matchedError.recoverable !== undefined) errorObj.recoverable = matchedError.recoverable
+          if (matchedError.suggestions) errorObj.suggestions = matchedError.suggestions
+        }
+
         reject(errorObj)
         return
       }