agentskillsdk 0.5.3 → 0.6.1

package/src/index.js

@@ -1,30 +1,102 @@
-import { Command } from 'commander';
+import { Command, CommanderError, Option } from 'commander';
 import { createRequire } from 'node:module';
 import { addCommand } from './commands/add.js';
 import { listCommand } from './commands/list.js';
+import { EXIT, UsageError } from './lib/errors.js';
+import { t } from './lib/messages/index.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
-const program = new Command();
+function normalizeOptions(options) {
+  if (options.nonInteractive) options.yes = true;
+  if (options.all) {
+    options.agent = options.agent && options.agent.length ? options.agent : ['*'];
+  }
+  return options;
+}
 
-program
-  .name('agentskillsdk')
-  .description('installer agent-skills fra agentskills.dk')
-  .version(pkg.version);
+const ADD_EXAMPLES = `
+Examples:
+  $ agentskillsdk add genkit-ai/skills --skill developing-genkit-js -y
+  $ agentskillsdk add obra/superpowers@brainstorming -a claude-code -y --json
+  $ CLAUDECODE=1 npx agentskillsdk add my-skill        # agent mode auto-detected
 
-program
-  .command('add')
-  .description('installer en skill i dit projekt')
-  .argument('<skill-name>', 'navn på skill (eller owner/repo for GitHub)')
-  .option('--skill <path>', 'sti i repo, f.eks. skills/twitter')
-  .option('-g, --global', 'installer globalt i ~/.claude/skills/')
-  .option('-p, --project', 'installer i projekt .claude/skills/ (standard)')
-  .action(addCommand);
+Output:
+  stdout  JSON payload (--json), or quiet status line (--quiet)
+  stderr  banner, spinners, errors, human-readable output
 
-program
-  .command('list')
-  .description('vis alle tilgængelige skills')
-  .action(listCommand);
+Exit codes:
+  0  success
+  1  generic error
+  2  invalid usage
+  3  ambiguous target (multiple agents detected without --agent)
+  4  no matching skills
+  5  network / registry unreachable
+  6  filesystem error
+  7  no agent detected
+  130  user cancelled
 
-program.parse();
+Environment:
+  AI_AGENT, CLAUDECODE, CURSOR_AGENT, CODEX_*, COPILOT_*, OPENCODE_CLIENT, ...
+    Any of these flip the CLI into agent mode (non-interactive, English, JSON-safe).
+  AGENTSKILLSDK_LANG=en|da
+    UI language. Same as --lang.
+`;
+
+export function buildProgram() {
+  const program = new Command();
+
+  program
+    .name('agentskillsdk')
+    .description(t('cli.description'))
+    .version(pkg.version)
+    .exitOverride((err) => {
+      if (err.exitCode === 0) throw err;
+      const wrapped = new UsageError(err.message);
+      wrapped.silent = true;
+      throw wrapped;
+    });
+
+  program
+    .command('add')
+    .description(t('cli.add.description'))
+    .argument('<skill-name>', t('cli.add.arg'))
+    .option('--skill <path>', t('cli.add.skill_option'))
+    .option('-g, --global', t('cli.add.global_option'))
+    .option('-p, --project', t('cli.add.project_option'))
+    .option('-y, --yes', t('cli.add.yes_option'))
+    .option('--non-interactive', t('cli.add.non_interactive_option'))
+    .option('-a, --agent <slugs...>', t('cli.add.agent_option'))
+    .option('--all', t('cli.add.all_option'))
+    .option('--json', t('cli.add.json_option'))
+    .option('--quiet', t('cli.add.quiet_option'))
+    .option('--lang <code>', t('cli.add.lang_option'))
+    .option('--dry-run', t('cli.add.dry_run_option'))
+    .option('--force', t('cli.add.force_option'))
+    .addHelpText('after', ADD_EXAMPLES)
+    .action((skillName, options) => addCommand(skillName, normalizeOptions(options)));
+
+  program
+    .command('list')
+    .description(t('cli.list.description'))
+    .option('--json', t('cli.add.json_option'))
+    .option('--quiet', t('cli.add.quiet_option'))
+    .option('--lang <code>', t('cli.add.lang_option'))
+    .action((options) => listCommand(normalizeOptions(options)));
+
+  return program;
+}
+
+export async function run(argv = process.argv) {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    if (err instanceof CommanderError && err.exitCode === 0) {
+      return EXIT.OK;
+    }
+    throw err;
+  }
+  return EXIT.OK;
+}

package/src/lib/api.js

@@ -1,24 +1,27 @@
+import { NetworkError } from './errors.js';
+import { t } from './messages/index.js';
+
 const API_BASE = 'https://agentskills.dk/api/cli';
 
-export async function fetchSkills() {
+async function fetchJson(url) {
   let res;
   try {
-    res = await fetch(`${API_BASE}/skills`);
+    res = await fetch(url);
   } catch {
-    throw new Error('Could not reach agentskills.dk. Check your internet connection.');
+    throw new NetworkError(t('api.error.unreachable'));
   }
-  if (!res.ok) throw new Error(`Failed to fetch skills: ${res.status}`);
+  return res;
+}
+
+export async function fetchSkills() {
+  const res = await fetchJson(`${API_BASE}/skills`);
+  if (!res.ok) throw new NetworkError(t('api.error.fetch_skills', { status: res.status }));
   return res.json();
 }
 
 export async function fetchSkill(name) {
-  let res;
-  try {
-    res = await fetch(`${API_BASE}/skills/${encodeURIComponent(name)}`);
-  } catch {
-    throw new Error('Could not reach agentskills.dk. Check your internet connection.');
-  }
+  const res = await fetchJson(`${API_BASE}/skills/${encodeURIComponent(name)}`);
   if (res.status === 404) return null;
-  if (!res.ok) throw new Error(`Failed to fetch skill: ${res.status}`);
+  if (!res.ok) throw new NetworkError(t('api.error.fetch_skill', { status: res.status }));
   return res.json();
 }

package/src/lib/detect-agent.js

@@ -2,19 +2,26 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-function makeAgent(name, folder, { globalFolder, detectFolder, universal } = {}) {
+// `slug` is the canonical kebab-case identifier used by:
+//   - the `-a/--agent <slug>` CLI flag
+//   - env-var → agent mapping in detect-runtime.js
+//   - JSON output payloads
+// Slugs are frozen once shipped. Renames go through `legacySlugAliases` in
+// the resolver, not by editing this list.
+function makeAgent(name, folder, slug, { globalFolder, detectFolder, path } = {}) {
   const gFolder = globalFolder || folder;
   const dFolder = detectFolder || folder;
+  const defaultPath = (skill, { cwd, scope }) => {
+    if (scope === 'global') return join(homedir(), gFolder, 'skills', skill);
+    return join(cwd, folder, 'skills', skill);
+  };
   return {
     name,
+    slug,
     folder,
     globalFolder: gFolder,
     detectFolder: dFolder,
-    universal: !!universal,
-    path: (skill, { cwd, scope }) => {
-      if (scope === 'global') return join(homedir(), gFolder, 'skills', skill);
-      return join(cwd, folder, 'skills', skill);
-    },
+    path: path || defaultPath,
     displayPath: (skill, scope) => {
       if (scope === 'global') return `~/${gFolder}/skills/${skill}/`;
       return `${folder}/skills/${skill}/`;
@@ -22,47 +29,41 @@ function makeAgent(name, folder, { globalFolder, detectFolder, universal } = {})
   };
 }
 
+// GitHub Copilot note: `folder` is `.github` and the default `path()` then
+// resolves to `.github/skills/<skill>/`, which is the convention the
+// community has settled on. `detectFolder` of `.github/skills` matches that
+// install location for auto-detect.
 export const AGENTS = [
-  makeAgent('Amp', '.agents', { detectFolder: '.config/amp', universal: true }),
-  makeAgent('Cline', '.cline'),
-  makeAgent('Claude Code', '.claude'),
-  makeAgent('CodeBuddy', '.codebuddy'),
-  makeAgent('Codex CLI', '.agents', { globalFolder: '.codex', detectFolder: '.codex', universal: true }),
-  makeAgent('Command Code', '.commandcode'),
-  makeAgent('Continue', '.continue'),
-  makeAgent('Crush', '.crush'),
-  makeAgent('Cursor', '.agents', { globalFolder: '.cursor', detectFolder: '.cursor', universal: true }),
-  makeAgent('Droid', '.factory'),
-  makeAgent('Gemini CLI', '.agents', { detectFolder: '.gemini', universal: true }),
-  makeAgent('GitHub Copilot', '.agents', { detectFolder: '.github/skills', globalFolder: '.github', universal: true }),
-  makeAgent('Goose', '.goose'),
-  makeAgent('Kilo Code', '.kilocode'),
-  makeAgent('Kimi CLI', '.agents', { detectFolder: '.kimi', universal: true }),
-  makeAgent('Kiro CLI', '.kiro'),
-  makeAgent('MCPJam', '.mcpjam'),
-  makeAgent('Mux', '.mux'),
-  makeAgent('Neovate', '.neovate'),
-  makeAgent('OpenClaw', '.openclaw'),
-  makeAgent('OpenCode', '.agents', { globalFolder: '.opencode', detectFolder: '.opencode', universal: true }),
-  makeAgent('OpenHands', '.openhands'),
-  makeAgent('Pi', '.pi'),
-  makeAgent('Qoder', '.qoder'),
-  makeAgent('Qwen Code', '.qwen'),
-  makeAgent('Replit', '.agents', { detectFolder: '.replit', universal: true }),
-  makeAgent('Roo Code', '.roo'),
-  makeAgent('Trae', '.trae'),
-  makeAgent('Windsurf', '.windsurf'),
-  makeAgent('Zencoder', '.zencoder'),
+  makeAgent('Cline', '.cline', 'cline'),
+  makeAgent('Claude Code', '.claude', 'claude-code'),
+  makeAgent('CodeBuddy', '.codebuddy', 'codebuddy'),
+  makeAgent('Codex CLI', '.agents', 'codex', { globalFolder: '.codex' }),
+  makeAgent('Command Code', '.commandcode', 'commandcode'),
+  makeAgent('Continue', '.continue', 'continue'),
+  makeAgent('Crush', '.crush', 'crush'),
+  makeAgent('Cursor', '.cursor', 'cursor'),
+  makeAgent('Droid', '.factory', 'droid'),
+  makeAgent('GitHub Copilot', '.github', 'copilot', { detectFolder: '.github/skills' }),
+  makeAgent('Goose', '.goose', 'goose'),
+  makeAgent('Kilo Code', '.kilocode', 'kilo-code'),
+  makeAgent('Kiro CLI', '.kiro', 'kiro'),
+  makeAgent('MCPJam', '.mcpjam', 'mcpjam'),
+  makeAgent('Mux', '.mux', 'mux'),
+  makeAgent('Neovate', '.neovate', 'neovate'),
+  makeAgent('OpenClaw', '.openclaw', 'openclaw'),
+  makeAgent('OpenCode', '.opencode', 'opencode'),
+  makeAgent('OpenHands', '.openhands', 'openhands'),
+  makeAgent('Pi', '.pi', 'pi'),
+  makeAgent('Qoder', '.qoder', 'qoder'),
+  makeAgent('Qwen Code', '.qwen', 'qwen'),
+  makeAgent('Roo Code', '.roo', 'roo'),
+  makeAgent('Trae', '.trae', 'trae'),
+  makeAgent('Windsurf', '.windsurf', 'windsurf'),
+  makeAgent('Zencoder', '.zencoder', 'zencoder'),
 ];
 
+export const AGENT_BY_SLUG = Object.fromEntries(AGENTS.map(a => [a.slug, a]));
+
 export function detectAgents(cwd) {
   return AGENTS.filter(agent => existsSync(join(cwd, agent.detectFolder)));
 }
-
-export function getUniversalAgents(agentList) {
-  return agentList.filter(a => a.universal);
-}
-
-export function getNonUniversalAgents(agentList) {
-  return agentList.filter(a => !a.universal);
-}

package/src/lib/detect-runtime.js

@@ -0,0 +1,63 @@
+import { existsSync } from 'node:fs';
+import { AGENT_BY_SLUG } from './detect-agent.js';
+
+// Env-var matrix for agent detection. Order matters: the first truthy match wins.
+// Mirrors @vercel/detect-agent; re-sync quarterly. `slug` is null when the
+// agent is known to be running but we don't have an install target for it
+// (e.g. Gemini, Replit, Devin); the caller still sees isAgent=true and the
+// install will fail noisily on the missing -a flag.
+const ENV_MATRIX = [
+  { env: 'CLAUDECODE', slug: 'claude-code' },
+  { env: 'CLAUDE_CODE', slug: 'claude-code' },
+  { env: 'CURSOR_TRACE_ID', slug: 'cursor' },
+  { env: 'CURSOR_AGENT', slug: 'cursor' },
+  { env: 'GEMINI_CLI', slug: null },
+  { env: 'CODEX_SANDBOX', slug: 'codex' },
+  { env: 'CODEX_CI', slug: 'codex' },
+  { env: 'CODEX_THREAD_ID', slug: 'codex' },
+  { env: 'ANTIGRAVITY_AGENT', slug: null },
+  { env: 'AUGMENT_AGENT', slug: null },
+  { env: 'OPENCODE_CLIENT', slug: 'opencode' },
+  { env: 'REPL_ID', slug: null },
+  { env: 'COPILOT_MODEL', slug: 'copilot' },
+  { env: 'COPILOT_ALLOW_ALL', slug: 'copilot' },
+  { env: 'COPILOT_GITHUB_TOKEN', slug: 'copilot' },
+];
+
+const DEVIN_MARKER = '/opt/.devin';
+
+export function detectRuntime(env = process.env) {
+  // AI_AGENT is the explicit "I'm an agent" signal. If its value happens to
+  // be a known slug, use it as the agent target. If not (e.g. Conductor sets
+  // it to a versioned string), still mark isAgent=true but fall through to
+  // the implicit env matrix so we can recover a slug from CLAUDECODE etc.
+  let aiAgentSlug = null;
+  if (env.AI_AGENT) {
+    aiAgentSlug = AGENT_BY_SLUG[env.AI_AGENT] ? env.AI_AGENT : null;
+    if (aiAgentSlug) {
+      return { isAgent: true, agentSlug: aiAgentSlug, source: 'AI_AGENT' };
+    }
+  }
+
+  for (const { env: name, slug } of ENV_MATRIX) {
+    if (env[name]) {
+      return {
+        isAgent: true,
+        agentSlug: slug && AGENT_BY_SLUG[slug] ? slug : null,
+        source: name,
+      };
+    }
+  }
+
+  if (env.AI_AGENT) {
+    // AI_AGENT was set but didn't match a known slug and no implicit env
+    // var picked it up. Still flag as agent — the caller has to pass -a.
+    return { isAgent: true, agentSlug: null, source: 'AI_AGENT' };
+  }
+
+  if (existsSync(DEVIN_MARKER)) {
+    return { isAgent: true, agentSlug: null, source: DEVIN_MARKER };
+  }
+
+  return { isAgent: false, agentSlug: null, source: null };
+}

package/src/lib/download.js

@@ -1,11 +1,39 @@
 import { pipeline } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
-import { createWriteStream, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname, resolve, sep } from 'node:path';
 import tar from 'tar-stream';
+import { NetworkError, FsError, NoMatchError } from './errors.js';
+import { matchSkillDir } from './resolve-github-path.js';
+import { t } from './messages/index.js';
 
-export async function downloadSkill(skill, destDir) {
-  const url = `https://api.github.com/repos/${skill.githubOwner}/${skill.githubRepo}/tarball/${skill.defaultBranch}`;
+const PER_ENTRY_SIZE_CAP = 25 * 1024 * 1024; // 25 MB
+
+function stripFirstSegment(p) {
+  const parts = p.split('/');
+  parts.shift();
+  return parts.join('/');
+}
+
+function isSkillMd(name) {
+  return /(^|\/)SKILL\.md$/i.test(name);
+}
+
+// Downloads a GitHub tarball, resolves which skill directory inside it to
+// install, and writes the matching files to `destDir`. Path resolution is
+// done entirely from the tarball contents — no GitHub API calls — so this
+// works under anonymous-IP rate limits (the resolver previously hit 403 in
+// shared cloud sandboxes).
+//
+// Returns { resolvedPath, skillDirs } so the caller can log "resolved A → B".
+export async function downloadSkill(skill, destDir, opts = {}) {
+  // Backward-compat: when callers don't pass an opts object, fall back to the
+  // legacy `skill.githubPath` field. Production code in add.js passes opts
+  // explicitly; this fallback exists for unit tests that pre-date the change.
+  const requestedPath = opts.requestedPath ?? skill.githubPath;
+  const owner = opts.owner ?? skill.githubOwner;
+  const base = `https://api.github.com/repos/${skill.githubOwner}/${skill.githubRepo}/tarball`;
+  const url = skill.ref ? `${base}/${skill.ref}` : base;
 
   let res;
   try {
@@ -17,65 +45,154 @@ export async function downloadSkill(skill, destDir) {
       redirect: 'follow',
     });
   } catch {
-    throw new Error('kunne ikke downloade skill-filer. tjek din internetforbindelse.');
+    throw new NetworkError(t('download.error.network'));
   }
-
-  if (!res.ok) throw new Error(`GitHub download fejlede: ${res.status}`);
+  if (!res.ok) throw new NetworkError(t('download.error.github', { status: res.status }));
 
   const extract = tar.extract();
-  const skillPath = skill.githubPath;
-  const filePromises = [];
+  const entries = new Map(); // relativePath -> Buffer
+  let aborted = null;
+
+  extract.on('error', () => {});
 
   extract.on('entry', (header, stream, next) => {
-    // Tarball entries: "{owner}-{repo}-{sha}/skills/real-estate-crm/SKILL.md"
-    // Strip the first path segment (the repo prefix)
-    const parts = header.name.split('/');
-    parts.shift();
-    const relativePath = parts.join('/');
+    if (aborted) {
+      stream.on('end', next);
+      stream.resume();
+      return;
+    }
 
-    let fileRelative;
-    if (skillPath === '') {
-      if (header.type === 'file' && relativePath) {
-        fileRelative = relativePath;
+    // Reject symlink/link entries outright (same posture as before).
+    if (header.type === 'symlink' || header.type === 'link') {
+      aborted = new FsError(t('download.error.unsupported_entry', { type: header.type, name: header.name }));
+      stream.on('end', () => next());
+      stream.resume();
+      return;
+    }
+
+    if (header.type !== 'file') {
+      stream.on('end', next);
+      stream.resume();
+      return;
+    }
+
+    const relativePath = stripFirstSegment(header.name);
+    if (!relativePath) {
+      stream.on('end', next);
+      stream.resume();
+      return;
+    }
+
+    const chunks = [];
+    let size = 0;
+    stream.on('data', (c) => {
+      size += c.length;
+      if (size > PER_ENTRY_SIZE_CAP && !aborted) {
+        aborted = new FsError(t('download.error.entry_too_large', {
+          name: header.name,
+          cap: PER_ENTRY_SIZE_CAP,
+        }));
       }
+      if (!aborted) chunks.push(c);
+    });
+    stream.on('end', () => {
+      if (!aborted) entries.set(relativePath, Buffer.concat(chunks));
+      next();
+    });
+    stream.on('error', (err) => {
+      if (!aborted) aborted = err instanceof FsError ? err : new FsError(err.message);
+    });
+  });
+
+  try {
+    await pipeline(res.body, createGunzip(), extract);
+  } catch (err) {
+    if (aborted) throw aborted;
+    throw err;
+  }
+  if (aborted) throw aborted;
+
+  // Discover skill directories from the buffered tarball.
+  const skillDirs = [...new Set(
+    [...entries.keys()]
+      .filter(isSkillMd)
+      .map(p => p.replace(/\/?SKILL\.md$/i, '')),
+  )];
+
+  // Choose which prefix to install.
+  let prefix;
+  if (requestedPath) {
+    if (skillDirs.includes(requestedPath)) {
+      prefix = requestedPath;
     } else {
-      const marker = skillPath + '/';
-      const idx = relativePath.indexOf(marker);
-      if (header.type === 'file' && idx !== -1) {
-        fileRelative = relativePath.slice(idx + marker.length);
-      }
+      prefix = matchSkillDir(requestedPath, owner || skill.githubOwner, skillDirs);
     }
+    if (prefix === null || prefix === undefined) {
+      throw new NoMatchError(t('resolve.error.skill_not_in_repo', {
+        skill: requestedPath,
+        owner: skill.githubOwner,
+        repo: skill.githubRepo,
+        candidates: skillDirs.length > 0
+          ? skillDirs.map(d => `  - ${d || '<root>'}`).join('\n')
+          : '  (no SKILL.md files found in this repo)',
+      }));
+    }
+  } else {
+    if (skillDirs.length === 0) {
+      throw new NoMatchError(t('resolve.error.no_skills', {
+        owner: skill.githubOwner,
+        repo: skill.githubRepo,
+      }));
+    }
+    if (skillDirs.length > 1) {
+      throw new NoMatchError(t('resolve.error.multiple_skills', {
+        owner: skill.githubOwner,
+        repo: skill.githubRepo,
+        candidates: skillDirs.map(d => `  - ${d || '<root>'}`).join('\n'),
+      }));
+    }
+    prefix = skillDirs[0];
+  }
 
-    if (fileRelative) {
-      const destPath = join(destDir, fileRelative);
-
-      mkdirSync(dirname(destPath), { recursive: true });
+  // Write files under the resolved prefix.
+  const destDirResolved = resolve(destDir);
+  let filesWritten = 0;
 
-      const writePromise = new Promise((resolve, reject) => {
-        stream.pipe(createWriteStream(destPath))
-          .on('finish', resolve)
-          .on('error', reject);
-      });
-      filePromises.push(writePromise);
+  for (const [relativePath, buf] of entries) {
+    let fileRelative;
+    if (prefix === '') {
+      fileRelative = relativePath;
+    } else if (relativePath === prefix) {
+      // Edge case: a file literally at the prefix path. Shouldn't happen for
+      // a SKILL.md dir but keep it safe.
+      fileRelative = relativePath.split('/').pop();
+    } else if (relativePath.startsWith(prefix + '/')) {
+      fileRelative = relativePath.slice(prefix.length + 1);
     } else {
-      stream.resume();
+      continue;
     }
-    next();
-  });
+    if (!fileRelative) continue;
 
-  await pipeline(
-    res.body,
-    createGunzip(),
-    extract,
-  );
+    const destPath = join(destDir, fileRelative);
+    const destPathResolved = resolve(destPath);
 
-  await Promise.all(filePromises);
+    // Zip-slip guard: destination must stay within destDir.
+    if (destPathResolved !== destDirResolved && !destPathResolved.startsWith(destDirResolved + sep)) {
+      throw new FsError(t('download.error.traversal', { name: relativePath }));
+    }
 
-  if (filePromises.length === 0) {
-    throw new Error(
-      skillPath
-        ? `ingen filer fundet for "${skillPath}" i repository.`
-        : 'ingen filer fundet i repository.'
-    );
+    mkdirSync(dirname(destPathResolved), { recursive: true });
+    writeFileSync(destPathResolved, buf);
+    filesWritten++;
   }
+
+  if (filesWritten === 0) {
+    throw new NoMatchError(t('download.error.no_files_matched', {
+      path: prefix || '<root>',
+      owner: skill.githubOwner,
+      repo: skill.githubRepo,
+    }));
+  }
+
+  return { resolvedPath: prefix, skillDirs };
 }

package/src/lib/errors.js

@@ -0,0 +1,58 @@
+export const EXIT = {
+  OK: 0,
+  GENERIC: 1,
+  USAGE: 2,
+  AMBIGUOUS: 3,
+  NO_MATCH: 4,
+  NETWORK: 5,
+  FS: 6,
+  NO_AGENT: 7,
+  CANCELED: 130,
+};
+
+class CliError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+  }
+}
+
+export class UsageError extends CliError {
+  constructor(message) { super(message, EXIT.USAGE); }
+}
+
+export class AmbiguousError extends CliError {
+  constructor(message, { candidates } = {}) {
+    super(message, EXIT.AMBIGUOUS);
+    this.candidates = candidates;
+  }
+}
+
+export class NoMatchError extends CliError {
+  constructor(message) { super(message, EXIT.NO_MATCH); }
+}
+
+export class NetworkError extends CliError {
+  constructor(message) { super(message, EXIT.NETWORK); }
+}
+
+export class FsError extends CliError {
+  constructor(message) { super(message, EXIT.FS); }
+}
+
+export class NoAgentError extends CliError {
+  constructor(message, { candidates } = {}) {
+    super(message, EXIT.NO_AGENT);
+    this.candidates = candidates;
+  }
+}
+
+export class CanceledError extends CliError {
+  constructor(message) { super(message, EXIT.CANCELED); }
+}
+
+export function exitCodeFor(err) {
+  if (err && typeof err.code === 'number') return err.code;
+  return EXIT.GENERIC;
+}