@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.5

package/src/lib/setup/discover.js

@@ -0,0 +1,116 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+
+async function which(bin) {
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    const { stdout } = await execFileAsync(cmd, [bin], { timeout: 5000 });
+    const path = String(stdout || '').trim().split(/\r?\n/)[0];
+    return path || null;
+  } catch {
+    return null;
+  }
+}
+
+async function versionOf(bin, args = ['--version']) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { timeout: 8000 });
+    const text = `${stdout || ''}${stderr || ''}`.trim().split(/\n/)[0];
+    return text.slice(0, 120) || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Discover host environment for setup planning.
+ */
+export async function discoverEnvironment(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const arch = options.arch || os.arch();
+  const hostname = os.hostname().replace(/\.local$/i, '');
+
+  const nodeVersion = process.versions.node;
+  const brew = platform === 'darwin' || platform === 'linux' ? await which('brew') : null;
+  const git = await which('git');
+  const docker = await which('docker');
+  const gcloud = await which('gcloud');
+  const wrangler = await which('wrangler');
+  const magick = (await which('magick')) || (await which('convert'));
+  const potrace = await which('potrace');
+  const ffmpeg = await which('ffmpeg');
+  const svgo = await which('svgo');
+
+  let wranglerVersion = null;
+  if (wrangler) wranglerVersion = await versionOf(wrangler, ['--version']);
+  else {
+    try {
+      wranglerVersion = require('wrangler/package.json').version;
+    } catch {
+      wranglerVersion = null;
+    }
+  }
+
+  const hostLabel =
+    platform === 'darwin' ? 'Mac'
+      : platform === 'win32' ? 'PC'
+        : 'host';
+
+  return {
+    schema_version: 'agentsam-setup-environment-v1',
+    hostname,
+    host_label: hostLabel,
+    platform,
+    arch,
+    os_release: os.release(),
+    node: nodeVersion,
+    tools: {
+      brew: brew ? { path: brew, version: await versionOf('brew', ['--version']) } : null,
+      git: git ? { path: git, version: await versionOf('git', ['--version']) } : null,
+      docker: docker ? { path: docker, version: await versionOf('docker', ['--version']) } : null,
+      gcloud: gcloud ? { path: gcloud, version: await versionOf('gcloud', ['--version']) } : null,
+      wrangler: wrangler || wranglerVersion
+        ? { path: wrangler, version: wranglerVersion }
+        : null,
+      magick: magick ? { path: magick, version: await versionOf(magick, ['--version']) } : null,
+      potrace: potrace ? { path: potrace, version: await versionOf('potrace', ['-v']) } : null,
+      ffmpeg: ffmpeg ? { path: ffmpeg, version: await versionOf('ffmpeg', ['-version']) } : null,
+      svgo: svgo ? { path: svgo, version: await versionOf('svgo', ['--version']) } : null,
+    },
+    env_flags: {
+      AGENTSAM_API_KEY: Boolean(String(env.AGENTSAM_API_KEY || '').trim()),
+      GOOGLE_CLIENT_ID: Boolean(String(env.GOOGLE_CLIENT_ID || '').trim()),
+      GOOGLE_DESKTOP_CLIENT_ID: Boolean(String(env.GOOGLE_DESKTOP_CLIENT_ID || '').trim()),
+    },
+  };
+}
+
+export function renderEnvironment(env) {
+  const lines = [
+    '',
+    '  Environment',
+    `    ${env.host_label} · ${env.hostname}`,
+    `    ${env.platform} ${env.arch} · Node ${env.node}`,
+  ];
+  const rows = [
+    ['Homebrew', env.tools.brew],
+    ['Git', env.tools.git],
+    ['Docker', env.tools.docker],
+    ['Google Cloud CLI', env.tools.gcloud],
+    ['Wrangler', env.tools.wrangler],
+    ['ImageMagick', env.tools.magick],
+    ['Potrace', env.tools.potrace],
+    ['ffmpeg', env.tools.ffmpeg],
+  ];
+  for (const [label, tool] of rows) {
+    lines.push(`    ${tool ? '✓' : '○'} ${label}${tool?.version ? ` · ${String(tool.version).slice(0, 40)}` : ''}`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}

package/src/lib/setup/execute.js

@@ -0,0 +1,205 @@
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { SETUP_RECEIPT_SCHEMA } from './contract.js';
+import { getCapabilityRecipe } from './recipes.js';
+
+const execFileAsync = promisify(execFile);
+
+function homeDir(options = {}) {
+  return path.resolve(options.home || options.env?.HOME || os.homedir());
+}
+
+export function setupReceiptsDir(options = {}) {
+  return path.join(homeDir(options), '.agentsam', 'receipts');
+}
+
+function runStreaming(command, args, { cwd, env, write } = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: env || process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (buf) => {
+      const text = String(buf);
+      stdout += text;
+      write?.(text);
+    });
+    child.stderr.on('data', (buf) => {
+      const text = String(buf);
+      stderr += text;
+      write?.(text);
+    });
+    child.on('error', (error) => {
+      resolve({ ok: false, code: 1, stdout, stderr: error.message });
+    });
+    child.on('close', (code) => {
+      resolve({ ok: code === 0, code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+
+/**
+ * Execute approved install plan steps via native providers.
+ */
+export async function executeSetupPlan(plan, options = {}) {
+  const write = options.write || ((s) => process.stdout.write(s));
+  const env = options.env || process.env;
+  const results = [];
+
+  for (const step of plan.would_install || []) {
+    write(`\n  Installing ${step.capability} via ${step.provider}\n`);
+    let result;
+    if (step.provider === 'homebrew') {
+      if (!plan.platform || (plan.platform !== 'darwin' && plan.platform !== 'linux')) {
+        result = { ok: false, error: 'homebrew_unsupported_platform' };
+      } else {
+        const pkgs = step.packages || [];
+        // Support ["--cask", "gcloud-cli"] style.
+        result = await runStreaming('brew', ['install', ...pkgs], { env, write });
+      }
+    } else if (step.provider === 'npm') {
+      const pkgs = step.packages || [];
+      result = await runStreaming('npm', ['install', '-g', ...pkgs], { env, write });
+    } else if (step.provider === 'winget') {
+      const pkgs = step.packages || [];
+      result = await runStreaming('winget', ['install', '-e', '--id', ...pkgs], { env, write });
+    } else if (step.provider === 'manual') {
+      write('  Manual install required:\n');
+      for (const cmd of step.commands || []) write(`    ${cmd}\n`);
+      for (const note of step.notes || []) write(`    ${note}\n`);
+      result = { ok: false, error: 'manual_required', notes: step.notes || [] };
+    } else {
+      result = { ok: false, error: `unsupported_provider:${step.provider}` };
+    }
+
+    const recipe = getCapabilityRecipe(step.capability);
+    let verified = null;
+    if (result.ok && recipe?.verify) {
+      verified = await recipe.verify({ env });
+      write(verified.ok
+        ? `  ✓ verified ${step.capability}${verified.version ? ` · ${verified.version}` : ''}\n`
+        : `  ✕ verify failed for ${step.capability}\n`);
+    }
+
+    results.push({
+      capability: step.capability,
+      provider: step.provider,
+      packages: step.packages || null,
+      ok: Boolean(result.ok) && (verified ? verified.ok : true),
+      code: result.code ?? null,
+      error: result.error || null,
+      verified,
+    });
+  }
+
+  const receipt = {
+    schema_version: SETUP_RECEIPT_SCHEMA,
+    generated_at: new Date().toISOString(),
+    hostname: plan.hostname,
+    platform: plan.platform,
+    results,
+    ok: results.every((r) => r.ok) || results.length === 0,
+  };
+
+  const dir = setupReceiptsDir(options);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = path.join(dir, `setup-${stamp}.json`);
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`, { mode: 0o600 });
+  receipt.path = file;
+  return receipt;
+}
+
+/**
+ * Read-only Google Cloud permission inventory (for setup google.cloud / doctor).
+ */
+export async function collectGooglePermissionInventory(options = {}) {
+  const env = options.env || process.env;
+  const out = {
+    schema_version: 'agentsam-gcp-permission-inventory-v1',
+    generated_at: new Date().toISOString(),
+    auth_list: null,
+    config: null,
+    user_token_scopes: null,
+    projects: null,
+    billing_accounts: null,
+    iam_roles_for_active_user: null,
+    errors: [],
+  };
+
+  try {
+    const { stdout } = await execFileAsync('gcloud', ['auth', 'list', '--format=json'], { env, timeout: 20000 });
+    out.auth_list = JSON.parse(stdout || '[]');
+  } catch (error) {
+    out.errors.push(`auth_list: ${error.message}`);
+  }
+
+  try {
+    const { stdout } = await execFileAsync(
+      'gcloud',
+      ['config', 'list', '--format=json'],
+      { env, timeout: 15000 },
+    );
+    out.config = JSON.parse(stdout || '{}');
+  } catch (error) {
+    out.errors.push(`config: ${error.message}`);
+  }
+
+  try {
+    const { stdout: token } = await execFileAsync('gcloud', ['auth', 'print-access-token'], { env, timeout: 15000 });
+    const t = String(token || '').trim();
+    if (t) {
+      const info = await fetch(`https://oauth2.googleapis.com/tokeninfo?access_token=${encodeURIComponent(t)}`);
+      out.user_token_scopes = await info.json();
+    }
+  } catch (error) {
+    out.errors.push(`tokeninfo: ${error.message}`);
+  }
+
+  try {
+    const { stdout } = await execFileAsync('gcloud', ['projects', 'list', '--format=json'], { env, timeout: 45000 });
+    out.projects = JSON.parse(stdout || '[]');
+  } catch (error) {
+    out.errors.push(`projects: ${error.message}`);
+  }
+
+  try {
+    const { stdout } = await execFileAsync('gcloud', ['billing', 'accounts', 'list', '--format=json'], { env, timeout: 30000 });
+    out.billing_accounts = JSON.parse(stdout || '[]');
+  } catch (error) {
+    out.errors.push(`billing: ${error.message}`);
+  }
+
+  const project = out.config?.core?.project;
+  const account = out.config?.core?.account;
+  if (project && account && !String(account).includes('.gserviceaccount.com')) {
+    try {
+      const { stdout } = await execFileAsync(
+        'gcloud',
+        [
+          'projects', 'get-iam-policy', project,
+          '--flatten=bindings[].members',
+          `--filter=bindings.members:user:${account}`,
+          '--format=json',
+        ],
+        { env, timeout: 45000 },
+      );
+      const rows = JSON.parse(stdout || '[]');
+      out.iam_roles_for_active_user = {
+        project,
+        account,
+        roles: [...new Set((rows || []).map((r) => r.bindings?.role).filter(Boolean))],
+      };
+    } catch (error) {
+      out.errors.push(`iam: ${error.message}`);
+    }
+  }
+
+  return out;
+}

package/src/lib/setup/planner.js

@@ -0,0 +1,134 @@
+import { SETUP_PLAN_SCHEMA } from './contract.js';
+import { getCapabilityRecipe, listCapabilityRecipes } from './recipes.js';
+
+function platformKey(platform) {
+  if (platform === 'darwin') return 'darwin';
+  if (platform === 'win32') return 'win32';
+  return 'linux';
+}
+
+/**
+ * Build an install plan for requested capability IDs (or all known recipes).
+ */
+export async function buildSetupPlan(options = {}) {
+  const environment = options.environment;
+  if (!environment) throw new Error('environment_required');
+  const requested = Array.isArray(options.capabilityIds) && options.capabilityIds.length
+    ? options.capabilityIds
+    : listCapabilityRecipes().map((r) => r.id);
+
+  const capabilities = [];
+  const wouldInstall = [];
+  const providers = new Set();
+  const mutations = new Set();
+  let blocked = false;
+
+  for (const id of requested) {
+    const recipe = getCapabilityRecipe(id);
+    if (!recipe) {
+      capabilities.push({ id, ok: false, error: 'unknown_capability' });
+      continue;
+    }
+    const detection = await recipe.detect({ environment });
+    const plan = recipe.installPlans[platformKey(environment.platform)] || null;
+    const entry = {
+      id: recipe.id,
+      displayName: recipe.displayName,
+      description: recipe.description,
+      risk: recipe.risk,
+      requiresApproval: recipe.requiresApproval !== false,
+      capabilityProvided: recipe.capabilityProvided || [],
+      detected: detection,
+      installPlan: plan,
+      mutations: recipe.mutations || [],
+      uninstallHint: recipe.uninstallHint?.() || null,
+    };
+    capabilities.push(entry);
+    if (detection.ok) continue;
+    if (!plan) {
+      blocked = true;
+      entry.error = 'no_install_plan_for_platform';
+      continue;
+    }
+    providers.add(plan.provider);
+    for (const m of entry.mutations) mutations.add(m);
+    if (plan.packages?.length) {
+      wouldInstall.push({
+        capability: recipe.id,
+        provider: plan.provider,
+        packages: plan.packages,
+        notes: plan.notes || [],
+      });
+    } else if (plan.commands?.length) {
+      wouldInstall.push({
+        capability: recipe.id,
+        provider: plan.provider,
+        commands: plan.commands,
+        notes: plan.notes || [],
+      });
+    }
+  }
+
+  return {
+    schema_version: SETUP_PLAN_SCHEMA,
+    ok: !blocked,
+    hostname: environment.hostname,
+    host_label: environment.host_label,
+    platform: environment.platform,
+    capabilities,
+    would_install: wouldInstall,
+    providers: [...providers],
+    mutations: [...mutations],
+    trust_notes: [
+      'Agent Sam will not silently trust third-party package taps/repos.',
+      'No shell profiles, project files, or provider credentials are modified unless a recipe explicitly lists them and you approve.',
+    ],
+  };
+}
+
+export function renderSetupPlan(plan) {
+  const lines = [
+    '',
+    '  Agent Sam Setup',
+    '  ────────────────────────────────────────',
+    '',
+    `  Host  ${plan.host_label} · ${plan.hostname} · ${plan.platform}`,
+    '',
+    '  Capabilities',
+  ];
+  for (const cap of plan.capabilities) {
+    const mark = cap.detected?.ok ? '✓' : '○';
+    const ver = cap.detected?.version ? ` · ${String(cap.detected.version).slice(0, 36)}` : '';
+    lines.push(`    ${mark} ${cap.displayName || cap.id}${ver}`);
+    if (!cap.detected?.ok && cap.detected?.detail) {
+      lines.push(`      ${cap.detected.detail}`);
+    }
+  }
+  lines.push('');
+  if (!plan.would_install.length) {
+    lines.push('  Suggested installation');
+    lines.push('    Nothing missing from the requested set.');
+    lines.push('');
+    return lines.join('\n');
+  }
+  lines.push('  Suggested installation');
+  lines.push(`    Would install ${plan.would_install.length} capability package group(s):`);
+  for (const row of plan.would_install) {
+    const pkgs = (row.packages || row.commands || []).join(' ');
+    lines.push(`      ${row.provider.padEnd(12)} ${pkgs}`);
+  }
+  lines.push('');
+  lines.push('  Would use');
+  for (const p of plan.providers) lines.push(`    ${p}`);
+  lines.push('');
+  lines.push('  Would modify');
+  if (!plan.mutations.length) {
+    lines.push('    no project files / shell profiles / credentials (package install only)');
+  } else {
+    for (const m of plan.mutations) lines.push(`    • ${m}`);
+  }
+  lines.push('');
+  for (const note of plan.trust_notes || []) lines.push(`  Note  ${note}`);
+  lines.push('');
+  return lines.join('\n');
+}

package/src/lib/setup/recipes.js

@@ -0,0 +1,235 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createRequire } from 'node:module';
+
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+
+async function which(bin) {
+  try {
+    const { stdout } = await execFileAsync(process.platform === 'win32' ? 'where' : 'which', [bin], { timeout: 5000 });
+    return String(stdout || '').trim().split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+async function versionOf(bin, args) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { timeout: 8000 });
+    return `${stdout || ''}${stderr || ''}`.trim().split(/\n/)[0].slice(0, 80);
+  } catch {
+    return null;
+  }
+}
+
+/** @type {import('./contract.js').InstallableCapability} */
+export const imageRasterTransformCapability = {
+  id: 'image.raster.transform',
+  displayName: 'Raster image transforms',
+  description: 'Resize/convert PNG/JPEG/WebP/AVIF via Sharp (preferred) or ImageMagick (optional)',
+  risk: 'low',
+  requiresApproval: false,
+  capabilityProvided: ['image.raster.transform', 'image.raster.inspect'],
+  supportedPlatforms: ['darwin', 'linux', 'win32'],
+  dependencies: ['sharp'],
+  mutations: ['may npm-install sharp in the AgentSam package; optional ImageMagick via OS package manager'],
+  installPlans: {
+    darwin: {
+      provider: 'npm',
+      packages: ['sharp'],
+      notes: [
+        'Sharp is the portable default (declared dependency of @inneranimalmedia/agentsam-sdk-brand).',
+        'Optional enrichment: Homebrew imagemagick for ICNS / exotic formats.',
+        'Brand packs: agentsam brand promote → pack → preview → optional publish',
+        '  agentsam brand pack --brand acme --asset app-icon --source ./master.png --preset app-icon --out ./acme.zip',
+        '  agentsam brand preview --from ./acme.zip',
+      ],
+    },
+    linux: {
+      provider: 'npm',
+      packages: ['sharp'],
+      notes: ['Optional: apt/dnf/pacman imagemagick for extended tooling'],
+    },
+    win32: {
+      provider: 'npm',
+      packages: ['sharp'],
+      notes: ['Optional: winget install ImageMagick.ImageMagick'],
+    },
+  },
+  async detect() {
+    let sharpOk = false;
+    try {
+      require.resolve('sharp');
+      sharpOk = true;
+    } catch {
+      sharpOk = false;
+    }
+    const magick = (await which('magick')) || (await which('convert'));
+    const ok = sharpOk || Boolean(magick);
+    return {
+      ok,
+      detail: sharpOk
+        ? 'Sharp available'
+        : magick
+          ? 'ImageMagick available (Sharp preferred)'
+          : 'missing Sharp and ImageMagick',
+      version: sharpOk ? 'sharp' : magick ? await versionOf(magick, ['--version']) : null,
+      backends: { sharp: sharpOk, imagemagick: Boolean(magick) },
+    };
+  },
+  async verify() {
+    return this.detect();
+  },
+  uninstallHint() {
+    return 'Remove optional ImageMagick via your package manager; Sharp uninstalls with the npm package.';
+  },
+};
+
+/** @type {import('./contract.js').InstallableCapability} */
+export const imageVectorizeCapability = {
+  id: 'image.vectorize',
+  displayName: 'Vector image tooling',
+  description: 'Potrace (+ optional ImageMagick/SVGO) for raster→SVG workflows',
+  risk: 'low',
+  requiresApproval: true,
+  capabilityProvided: ['image.vectorize', 'image.optimize'],
+  supportedPlatforms: ['darwin', 'linux', 'win32'],
+  dependencies: ['potrace'],
+  mutations: ['installs OS packages via detected package manager — no shell profile edits'],
+  installPlans: {
+    darwin: {
+      provider: 'homebrew',
+      packages: ['potrace'],
+      notes: ['Optional: brew install imagemagick; npm i -g svgo'],
+    },
+    linux: {
+      provider: 'apt',
+      packages: ['potrace'],
+      notes: [
+        'Debian/Ubuntu: apt',
+        'Fedora: dnf install potrace',
+        'Arch: pacman -S potrace',
+      ],
+    },
+    win32: {
+      provider: 'winget',
+      packages: [],
+      notes: ['Install Potrace from https://potrace.sourceforge.net/ or chocolatey if available'],
+    },
+  },
+  async detect() {
+    const potrace = await which('potrace');
+    const magick = (await which('magick')) || (await which('convert'));
+    const ok = Boolean(potrace);
+    return {
+      ok,
+      detail: ok ? 'Potrace available' : 'missing potrace',
+      version: potrace ? await versionOf(potrace, ['-v']) : null,
+      backends: { potrace: Boolean(potrace), imagemagick: Boolean(magick) },
+    };
+  },
+  async verify() {
+    return this.detect();
+  },
+  uninstallHint() {
+    return 'Remove potrace with your platform package manager (brew/apt/dnf/winget) — AgentSam will not invent a command.';
+  },
+};
+
+/** @type {import('./contract.js').InstallableCapability} */
+export const googleCloudCapability = {
+  id: 'google.cloud',
+  displayName: 'Google Cloud connection',
+  description: 'gcloud CLI + Agent Sam Desktop/Web OAuth + connection preference',
+  risk: 'medium',
+  requiresApproval: true,
+  capabilityProvided: ['google.cloud.auth', 'google.cloud.doctor'],
+  supportedPlatforms: ['darwin', 'linux', 'win32'],
+  dependencies: ['gcloud'],
+  mutations: [
+    'may open browser for OAuth',
+    'writes ~/.agentsam/connections/google-cloud.json',
+    'may store google-cloud token in OS keychain / vault',
+  ],
+  installPlans: {
+    darwin: {
+      provider: 'homebrew',
+      packages: ['--cask', 'google-cloud-sdk'],
+      notes: [
+        'After gcloud: agentsam gcloud auth login',
+        'Then: agentsam google-cloud connection set --identity EMAIL --project PROJECT',
+        'Inspect: agentsam setup google.cloud --inventory',
+        'Doctor: agentsam google-cloud doctor --json',
+      ],
+    },
+    linux: {
+      provider: 'manual',
+      commands: ['# install Google Cloud SDK: https://cloud.google.com/sdk/docs/install'],
+      notes: ['Then agentsam gcloud auth login'],
+    },
+    win32: {
+      provider: 'winget',
+      packages: ['Google.CloudSDK'],
+      notes: ['Then agentsam gcloud auth login'],
+    },
+  },
+  async detect() {
+    const gcloud = await which('gcloud');
+    if (!gcloud) return { ok: false, detail: 'gcloud not on PATH' };
+    const version = await versionOf('gcloud', ['--version']);
+    return { ok: true, detail: 'gcloud available', version };
+  },
+  async verify() {
+    return this.detect();
+  },
+  uninstallHint() {
+    return 'brew uninstall --cask gcloud-cli   # or remove Google Cloud SDK';
+  },
+};
+
+/** @type {import('./contract.js').InstallableCapability} */
+export const cloudflareWranglerCapability = {
+  id: 'cloudflare.wrangler',
+  displayName: 'Cloudflare Wrangler',
+  description: 'Wrangler CLI for Workers / D1 / deploy',
+  risk: 'low',
+  requiresApproval: true,
+  capabilityProvided: ['cloudflare.wrangler'],
+  supportedPlatforms: ['darwin', 'linux', 'win32'],
+  dependencies: ['wrangler'],
+  mutations: ['npm/global or project-local install'],
+  installPlans: {
+    darwin: { provider: 'npm', packages: ['wrangler@latest'], notes: ['Prefer repo-local npx wrangler'] },
+    linux: { provider: 'npm', packages: ['wrangler@latest'] },
+    win32: { provider: 'npm', packages: ['wrangler@latest'] },
+  },
+  async detect() {
+    const wrangler = await which('wrangler');
+    if (wrangler) {
+      return { ok: true, detail: 'wrangler on PATH', version: await versionOf('wrangler', ['--version']) };
+    }
+    return { ok: false, detail: 'wrangler not on PATH (npx wrangler may still work in this repo)' };
+  },
+  async verify() {
+    return this.detect();
+  },
+  uninstallHint() {
+    return 'npm uninstall -g wrangler';
+  },
+};
+
+export const CAPABILITY_RECIPES = Object.freeze({
+  [imageRasterTransformCapability.id]: imageRasterTransformCapability,
+  [imageVectorizeCapability.id]: imageVectorizeCapability,
+  [googleCloudCapability.id]: googleCloudCapability,
+  [cloudflareWranglerCapability.id]: cloudflareWranglerCapability,
+});
+
+export function listCapabilityRecipes() {
+  return Object.values(CAPABILITY_RECIPES);
+}
+
+export function getCapabilityRecipe(id) {
+  return CAPABILITY_RECIPES[String(id || '').trim()] || null;
+}