superacli 1.1.26 → 1.1.28

package/plugins/acp/skills/quickstart/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: acp
+description: Use this skill when the user wants to interact with AI coding agents via the Agent Communication Protocol (ACP), list available ACP servers, start a coding agent, or inspect the ACP registry.
+---
+
+# acp Plugin
+
+Agent Communication Protocol (ACP) CLI — standardizes communication between editors and AI coding agents. 35+ registered agents.
+
+## Commands
+
+### Registry
+- `acp registry list` — List all 35+ ACP agents from registry (JSON)
+- `acp registry info` — Get info about a specific ACP agent (requires piping curl output to jq)
+
+### Servers (Launch ACP Agents)
+- `acp server claude` — Start Claude Agent ACP (npx @agentclientprotocol/claude-agent-acp)
+- `acp server gemini` — Start Gemini CLI ACP (npx @google/gemini-cli --acp)
+- `acp server copilot` — Start GitHub Copilot ACP (npx @github/copilot --acp)
+- `acp server cursor` — Start Cursor ACP (binary: cursor-agent acp)
+- `acp server opencode` — Start OpenCode ACP (binary: opencode acp)
+- `acp server codex` — Start Codex CLI ACP (npx @zed-industries/codex-acp)
+- `acp server cline` — Start Cline ACP (npx cline --acp)
+- `acp server kilo` — Start Kilo ACP (npx @kilocode/cli acp)
+- `acp server goose` — Start Goose ACP (binary: goose acp)
+- `acp server qwen` — Start Qwen Code ACP (npx @qwen-code/qwen-code --acp)
+- `acp server mistral` — Start Mistral Vibe ACP (binary: vibe-acp)
+- `acp server kimi` — Start Kimi CLI ACP (binary: kimi acp)
+- `acp server deepagents` — Start DeepAgents ACP (npx deepagents-acp)
+- `acp server dimcode` — Start DimCode ACP (npx dimcode acp)
+- `acp server auggie` — Start Auggie CLI ACP (npx @augmentcode/auggie --acp)
+- `acp server dirac` — Start Dirac ACP (npx dirac-cli --acp)
+- `acp server junie` — Start Junie ACP (binary: junie --acp=true)
+- `acp server nova` — Start Nova ACP (npx @compass-ai/nova acp)
+- `acp server factory` — Start Factory Droid ACP (npx droid exec --output-format acp-daemon)
+- `acp server qoder` — Start Qoder CLI ACP (npx @qoder-ai/qodercli --acp)
+- `acp server agoragentic` — Start Agoragentic ACP (npx agoragentic-mcp --acp)
+- `acp server glm` — Start GLM Agent ACP (npx glm-acp-agent)
+- `acp server autohand` — Start Autohand Code ACP (npx @autohandai/autohand-acp)
+- `acp server codebuddy` — Start Codebuddy Code ACP (npx @tencent-ai/codebuddy-code --acp)
+- `acp server pi` — Start pi ACP (npx pi-acp)
+- `acp server fast` — Start fast-agent ACP (uvx fast-agent-acp -x)
+- `acp server minion` — Start Minion Code ACP (uvx minion-code acp)
+- `acp server start` — Start any ACP agent by npx package name
+
+## Usage Examples
+- "List all ACP coding agents"
+- "Start Claude Code ACP agent"
+- "Launch Gemini CLI via ACP"
+- "Start Cline as an ACP server"
+- "Find info about an ACP agent in the registry"
+
+## Installation
+
+```bash
+# npx is included with Node.js
+# Install Node.js from nodejs.org
+```
+
+## Registry Access
+
+```bash
+# List all ACP agents
+acp registry list
+
+# Get info about an agent (pipe through jq)
+acp registry list | jq '.agents[] | select(.id=="claude-acp")'
+
+# Pretty-print all agent names
+acp registry list | jq '.agents[].name'
+```
+
+## Launching ACP Servers
+
+Start a Claude ACP server (requires ANTHROPIC_API_KEY):
+
+```bash
+acp server claude
+```
+
+Start Gemini CLI ACP (requires GEMINI_API_KEY):
+
+```bash
+acp server gemini
+```
+
+Start any ACP server via npx:
+
+```bash
+acp server start @agentclientprotocol/claude-agent-acp
+```
+
+## All 35 Registered ACP Agents
+
+| ID | Name | Type |
+|----|------|------|
+| claude-acp | Claude Agent | npx |
+| gemini | Gemini CLI | npx |
+| github-copilot-cli | GitHub Copilot | npx |
+| cursor | Cursor | binary |
+| opencode | OpenCode | binary |
+| codex-acp | Codex CLI | npx/binary |
+| cline | Cline | npx |
+| kilo | Kilo | npx/binary |
+| goose | goose | binary |
+| qwen-code | Qwen Code | npx |
+| mistral-vibe | Mistral Vibe | binary |
+| kimi | Kimi CLI | binary |
+| deepagents | DeepAgents | npx |
+| dimcode | DimCode | npx |
+| auggie | Auggie CLI | npx |
+| dirac | Dirac | npx |
+| junie | Junie | binary |
+| nova | Nova | npx |
+| factory-droid | Factory Droid | npx |
+| qoder | Qoder CLI | npx |
+| agoragentic-acp | Agoragentic | npx |
+| glm-acp-agent | GLM Agent | npx |
+| autohand | Autohand Code | npx |
+| codebuddy-code | Codebuddy Code | npx |
+| pi-acp | pi ACP | npx |
+| fast-agent | fast-agent | uvx |
+| minion-code | Minion Code | uvx |
+| amp-acp | Amp | binary |
+| corust-agent | Corust Agent | binary |
+| crow-cli | crow-cli | binary |
+| poolside | Poolside | binary |
+| sigit | siGit Code | npx/binary |
+| stakpak | Stakpak | binary |
+| vtcode | VT Code | binary |
+| cortex-code | Cortex Code | binary |
+
+## Notes
+- ACP agents communicate over stdio via JSON-RPC
+- Most agents require API keys (set as env vars)
+- npx agents auto-install on first run
+- Binary agents need manual download from their releases page
+- The ACP registry is at cdn.agentclientprotocol.com
+
+## Tested ACP Agents (18/35 handshake OK)
+
+### Full prompt response (tested via OpenRouter free models)
+| Agent | Handshake | Prompt Response | Notes |
+|-------|-----------|----------------|-------|
+| opencode | ✅ | ✅ "Hello" via mimo-v2-flash | Full ACP lifecycle works |
+| claude-acp | ✅ | ✅ "Hello! How can I help?" via mimo | 18k tokens |
+| qoder | ✅ | ✅ "Hello! How can I help?" via mimo | Works with model override |
+| dirac | ✅ | ✅ "Hello! I'm Dirac, ready to help" | Uses own model, no key needed |
+| agoragentic | ✅ | ✅ Tool bridge (tools/list, tools/call) | Not a chat agent |
+| auggie | ✅ | ✅ Workspace index prompt | Needs workspace config |
+
+### Handshake OK, prompt auth-gated
+| Agent | Handshake | Needs |
+|-------|-----------|-------|
+| cline | ✅ | ANTHROPIC_API_KEY |
+| goose | ✅ | GOOGLE_API_KEY / ANTHROPIC_API_KEY |
+| kimi | ✅ | KIMI_API_KEY |
+| dimcode | ✅ | OPENAI_API_KEY |
+| glm-acp-agent | ✅ | Z_AI_API_KEY |
+| deepagents | ✅ | API key |
+| pi-acp | ✅ | API key |
+| nova | ✅ | API key |
+| fast-agent | ✅ | API key |
+| qwen-code | ✅ | API key |
+| autohand | ✅ | API key |
+| codebuddy-code | ✅ | API key |
+
+### Free model support via OpenRouter
+Configure opencode with `xiaomi/mimo-v2-flash` or `openrouter/free` via `--model` flag:
+
+```bash
+acp-cli session:create opencode --model xiaomi/mimo-v2-flash --prompt "Hello"
+acp-cli session:create claude-acp --model xiaomi/mimo-v2-flash --prompt "Hello"
+```
+
+## Adding OpenRouter for Free Model Access
+
+Some ACP agents support overriding the LLM model via the ACP `session/set_config_option` protocol method. To use free models via OpenRouter:
+
+### 1. Get an OpenRouter API key
+Get a key from https://openrouter.ai/keys (free tier available with rate limits).
+
+### 2. Add provider to opencode config
+Edit `~/.config/opencode/opencode.json` and add under the `"provider"` key:
+
+```json
+"openrouter": {
+  "npm": "@ai-sdk/openai-compatible",
+  "name": "OpenRouter.ai (free models)",
+  "options": {
+    "baseURL": "https://openrouter.ai/api/v1",
+    "apiKey": "sk-or-v1-YOUR_KEY_HERE"
+  },
+  "models": {
+    "free": { "name": "openrouter/free" },
+    "mimo-v2-flash": { "name": "xiaomi/mimo-v2-flash" },
+    "gemini-flash": { "name": "google/gemini-2.0-flash-exp" }
+  }
+}
+```
+
+### 3. Use with acp-cli
+```bash
+# Override model via ACP protocol
+acp-cli session:create opencode --model xiaomi/mimo-v2-flash --prompt "Say hi"
+
+# Works with agents that support config overrides
+acp-cli session:create claude-acp --model xiaomi/mimo-v2-flash --prompt "Hello"
+```
+
+### How it works
+The `--model` flag sends `session/set_config_option` with `{configId: "model", value: "provider/model-name", type: true}` after session creation. The agent then routes prompts through that provider's model.
+
+### Which agents support model override
+- **opencode** ✅ (tested: `xiaomi/mimo-v2-flash` → responded "Hello" with 15k tokens)
+- **claude-acp** ✅ (tested: `xiaomi/mimo-v2-flash` → responded with greeting, 18k tokens)
+- **qoder** ✅ (tested: `xiaomi/mimo-v2-flash` → responded with greeting)
+- **dirac** ⚡ Works out of the box with its own model (no override needed)
+- Others: depends on whether the agent implements `session/set_config_option`
+
+

package/plugins/acp-cli/acp-cli.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const { readFileSync, existsSync, writeFileSync } = require('fs');
+const { resolve } = require('path');
+
+const [,, cmd, ...args] = process.argv;
+const ACP_REGISTRY = 'https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json';
+
+function usage() {
+  console.log(`acp-cli — Agent Communication Protocol CLI
+
+USAGE
+  acp-cli <command> [options]
+
+COMMANDS
+  registry                    List all ACP agents from registry
+  registry:info <agent-id>    Show details for a specific ACP agent
+
+  session:create <agent-id>   Create a new session with an ACP agent
+    --cwd <dir>               Working directory (default: .)
+    --prompt <text>           Prompt to send after session creation
+    --model <model>           Override model (e.g. gemini/gemini-2.0-flash)
+    --mode <mode>             Set session mode (e.g. code, ask, architect)
+
+  server:start <agent>        Launch an ACP server and show capabilities
+    --cwd <dir>               Working directory
+
+  help                        Show this help
+
+EXAMPLES
+  acp-cli registry
+  acp-cli registry:info claude-acp
+  acp-cli session:create opencode --prompt "Hello" --model nvidia-minimax/zai-org/GLM-5.1-FP8
+  acp-cli server:start @google/gemini-cli
+`);
+}
+
+function jsonRpc(id, method, params) {
+  return JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+}
+
+async function readJson(stream) {
+  let buf = '';
+  for await (const chunk of stream) {
+    buf += chunk.toString();
+    const lines = buf.split('\n');
+    for (let i = 0; i < lines.length - 1; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      try { return { line: JSON.parse(line), rest: lines.slice(i + 1).join('\n') }; }
+      catch { continue; }
+    }
+    buf = lines[lines.length - 1];
+  }
+  return null;
+}
+
+async function fetchAgentInfo(agentId) {
+  const http = require('http');
+  const https = require('https');
+  return new Promise((resolve, reject) => {
+    https.get(ACP_REGISTRY, res => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        const registry = JSON.parse(data);
+        const agent = registry.agents.find(a => a.id === agentId);
+        resolve(agent || null);
+      });
+    }).on('error', reject);
+  });
+}
+
+async function cmdRegistry() {
+  const https = require('https');
+  https.get(ACP_REGISTRY, res => {
+    let data = '';
+    res.on('data', c => data += c);
+    res.on('end', () => {
+      const registry = JSON.parse(data);
+      console.log(JSON.stringify(registry.agents.map(a => ({
+        id: a.id,
+        name: a.name,
+        version: a.version,
+        description: a.description,
+        type: a.distribution.binary ? 'binary' : a.distribution.npx ? 'npx' : a.distribution.uvx ? 'uvx' : 'other'
+      })), null, 2));
+    });
+  });
+}
+
+async function cmdRegistryInfo(agentId) {
+  const agent = await fetchAgentInfo(agentId);
+  if (!agent) { console.log(`Agent "${agentId}" not found`); process.exit(1); }
+  console.log(JSON.stringify(agent, null, 2));
+}
+
+function startAgentProcess(packageName, cwd) {
+  const { execSync } = require('child_process');
+  let isNpx = true;
+  let acpArgs = ['--acp'];
+
+  // Check if packageName is a known binary in PATH
+  try {
+    execSync(`which ${packageName}`, { stdio: 'ignore' });
+    isNpx = false;
+  } catch { isNpx = true; }
+
+  // If it's a local path, use it directly
+  if (existsSync(packageName)) { isNpx = false; }
+
+  // Detect ACP invocation style per agent
+  const knownAgents = {
+    'opencode': { cmd: 'opencode', args: ['acp'] },
+    'cursor-agent': { cmd: 'cursor-agent', args: ['acp'] },
+    'goose': { cmd: 'goose', args: ['acp'] },
+    'kimi': { cmd: 'kimi', args: ['acp'] },
+    'kilo': { cmd: 'npx', args: ['@kilocode/cli', 'acp'] },
+    'vibe-acp': { cmd: 'vibe-acp', args: [] },
+    'junie': { cmd: 'junie', args: ['--acp=true'] },
+    'stakpak': { cmd: 'stakpak', args: ['acp'] },
+  };
+
+  const binName = isNpx ? packageName : packageName.split('/').pop();
+  if (knownAgents[binName]) {
+    const agent = knownAgents[binName];
+    const cmd = isNpx && agent.cmd === 'npx' ? 'npx' : agent.cmd;
+    const cmdArgs = isNpx && agent.cmd === 'npx' ? [packageName, ...agent.args] : [...agent.args];
+    const proc = spawn(cmd, cmdArgs, {
+      cwd: resolve(cwd || '.'),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env }
+    });
+    proc.on('error', err => { console.error('Failed to start agent:', err.message); process.exit(1); });
+    return proc;
+  }
+
+  // Default: npx <package> --acp
+  const cmd = isNpx ? 'npx' : packageName;
+  const cmdArgs = isNpx ? [packageName] : [];
+  const proc = spawn(cmd, [...cmdArgs, ...acpArgs], {
+    cwd: resolve(cwd || '.'),
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env }
+  });
+  proc.on('error', err => { console.error('Failed to start agent:', err.message); process.exit(1); });
+  return proc;
+}
+
+async function cmdServerStart() {
+  const pkg = args[0];
+  if (!pkg) { console.error('Usage: acp-cli server:start <npx-package> [--cwd <dir>]'); process.exit(1); }
+  const cwdIdx = args.indexOf('--cwd');
+  const cwd = cwdIdx >= 0 ? args[cwdIdx + 1] : '.';
+
+  console.error(`Starting ACP server: ${pkg}`);
+  const proc = startAgentProcess(pkg, cwd);
+
+  // Forward stderr
+  proc.stderr.on('data', d => process.stderr.write(d));
+
+  // Initialize
+  proc.stdin.write(jsonRpc(1, 'initialize', {
+    protocolVersion: 1,
+    clientCapabilities: {
+      fs: { readTextFile: true, writeTextFile: true },
+      terminal: true,
+      auth: { terminal: true }
+    },
+    clientInfo: { name: 'acp-cli', version: '0.1.0' }
+  }));
+
+  // Create session
+  let buf = '';
+  proc.stdout.on('data', d => {
+    buf += d.toString();
+    const lines = buf.split('\n');
+    buf = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id === 1 && msg.result) {
+          console.log('AGENT:', msg.result.agentInfo.name, msg.result.agentInfo.version);
+          console.log('CAPABILITIES:', JSON.stringify(msg.result.agentCapabilities, null, 2));
+        } else if (msg.method === 'session/update' && msg.params?.update?.sessionUpdate === 'agent_message_chunk') {
+          process.stdout.write(msg.params.update.content.text || '');
+        } else if (msg.result) {
+          console.log(JSON.stringify(msg.result, null, 2));
+        }
+      } catch {}
+    }
+  });
+
+  proc.on('exit', code => { process.exit(code || 0); });
+}
+
+async function cmdSessionCreate() {
+  const agentId = args[0];
+  if (!agentId) { console.error('Usage: acp-cli session:create <agent> [--prompt <text>] [--model <m>] [--mode <m>] [--cwd <d>]'); process.exit(1); }
+
+  const flags = { prompt: null, model: null, mode: null, cwd: '.' };
+  ['prompt', 'model', 'mode', 'cwd'].forEach(k => {
+    const i = args.indexOf('--' + k);
+    if (i >= 0) flags[k] = args[i + 1];
+  });
+
+  let rid = 0;
+  function rpc(method, params) { return jsonRpc(++rid, method, params); }
+  let sessionId = null;
+
+  console.error(`Connecting to ACP agent: ${agentId}`);
+  const proc = startAgentProcess(agentId, flags.cwd);
+  let buf = '';
+  let configSent = false;
+
+  proc.stderr.on('data', d => process.stderr.write(d));
+
+  // Initialize
+  proc.stdin.write(rpc('initialize', {
+    protocolVersion: 1,
+    clientCapabilities: {
+      fs: { readTextFile: true, writeTextFile: true },
+      terminal: true,
+      auth: { terminal: true }
+    },
+    clientInfo: { name: 'acp-cli', version: '0.1.0' }
+  }));
+
+  // Read responses
+  proc.stdout.on('data', async data => {
+    buf += data.toString();
+    const lines = buf.split('\n');
+    buf = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+
+        // Handle initialize response - create session
+        if (msg.id === 1 && msg.result) {
+          proc.stdin.write(rpc('session/new', {
+            cwd: resolve(flags.cwd),
+            mcpServers: [],
+            title: 'acp-cli session'
+          }));
+        }
+        // Handle session create response
+        else if (msg.id === 2 && msg.result) {
+          sessionId = msg.result.sessionId;
+          console.log(JSON.stringify({ sessionId, ...msg.result }, null, 2));
+
+          // Set model via ACP protocol if specified
+          if (flags.model) {
+            configSent = true;
+            proc.stdin.write(rpc('session/set_config_option', {
+              sessionId,
+              configId: 'model',
+              value: flags.model,
+              type: true
+            }));
+          }
+          // Set mode via ACP protocol if specified
+          if (flags.mode) {
+            configSent = true;
+            proc.stdin.write(rpc('session/set_mode', {
+              sessionId,
+              modeId: flags.mode
+            }));
+          }
+          // Send prompt if no config options (or after config in next handler)
+          if (!configSent && flags.prompt) {
+            proc.stdin.write(rpc('session/prompt', {
+              sessionId,
+              prompt: [{ type: 'text', text: flags.prompt }]
+            }));
+          }
+        }
+        // Handle config responses, then send prompt
+        else if ((msg.id === 3 || msg.id === 4) && sessionId && flags.prompt) {
+          // Config option response received, now send prompt
+          proc.stdin.write(rpc('session/prompt', {
+            sessionId,
+            prompt: [{ type: 'text', text: flags.prompt }]
+          }));
+        }
+        // Handle prompt response
+        else if (msg.result?.stopReason) {
+          console.log('\n[stopReason:', msg.result.stopReason, '| tokens:', msg.result.usage?.totalTokens, ']');
+        }
+        // Handle notifications (session/update)
+        else if (msg.method) {
+          // Standard ACP delta format
+          if (msg.params?.delta?.content?.text) {
+            process.stdout.write(msg.params.delta.content.text);
+          } else if (typeof msg.params?.delta === 'string') {
+            process.stdout.write(msg.params.delta);
+          }
+          // OpenCode format
+          if (msg.params?.update?.sessionUpdate === 'agent_message_chunk' && msg.params?.update?.content?.text) {
+            process.stdout.write(msg.params.update.content.text);
+          }
+        }
+      } catch { /* partial JSON */ }
+    }
+  });
+
+  proc.on('exit', code => { process.exit(code || 0); });
+
+  setTimeout(() => {
+    console.error('\nACP session timed out after 60s');
+    proc.kill();
+    process.exit(0);
+  }, 60000);
+}
+
+async function main() {
+  switch (cmd) {
+    case 'registry':
+      return cmdRegistry();
+    case 'registry:info':
+      return cmdRegistryInfo(args[0]);
+    case 'server:start':
+      return cmdServerStart();
+    case 'session:create':
+      return cmdSessionCreate();
+    case 'help':
+    case undefined:
+    case null:
+      return usage();
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      usage();
+      process.exit(1);
+  }
+}
+
+main().catch(err => { console.error(err); process.exit(1); });

package/plugins/acp-cli/install-guidance.json

@@ -0,0 +1,12 @@
+{
+  "plugin": "acp-cli",
+  "binary": "acp-cli.js",
+  "check": "which node",
+  "install_steps": [
+    "Install Node.js from nodejs.org",
+    "acp-cli.js is bundled with the plugin",
+    "Verify: node plugins/acp-cli/acp-cli.js help",
+    "supercli plugins install ./plugins/acp-cli --on-conflict replace --json"
+  ],
+  "note": "ACP agents require API keys as env vars (e.g., ANTHROPIC_API_KEY, GEMINI_API_KEY, GITHUB_TOKEN). The acp-cli uses JSON-RPC over stdio — no network daemon needed."
+}

package/plugins/acp-cli/meta.json

@@ -0,0 +1,5 @@
+{
+  "description": "acp-cli — consume ACP coding agents directly from the CLI. Send prompts, create sessions, stream completions from 35+ ACP agents (Claude, Gemini, Cursor, Copilot, Cline, Goose, Codex, Kilo, Junie, Qwen, Mistral, Kimi, OpenCode). Implements the Agent Communication Protocol JSON-RPC client over stdio.",
+  "tags": ["acp", "agent", "protocol", "ai", "coding-agent", "llm", "cli", "nodejs"],
+  "has_learn": true
+}