@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/commands/packs.mjs

@@ -0,0 +1,741 @@
+import {
+  cpSync,
+  existsSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { assertAuraProjectRoot } from '../authored-project.mjs';
+import {
+  PROJECT_PACKS_MANIFEST_PATH,
+  PROJECT_PACKS_SCHEMA,
+  createPackCatalogReport,
+  expandPackSelection,
+  findPackOrBundleEntry,
+  normalizeProjectPackManifest,
+  resolvePackInstallSpec,
+} from '../packs/catalog.mjs';
+
+export const PACKS_USAGE = 'aura packs <list|show|add|vendor> [options]';
+const PACK_DEFINITION_PATH = 'aurajs-pack.json';
+
+function raiseCliError(errorHandler, message) {
+  if (typeof errorHandler === 'function') {
+    errorHandler(message);
+    return;
+  }
+  throw new Error(message);
+}
+
+function handlePackCommandError(errorHandler, err) {
+  raiseCliError(errorHandler, err instanceof Error ? err.message : String(err));
+}
+
+function readJsonFile(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function writeJsonFile(path, payload) {
+  writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+function readProjectPackageJson(projectRoot) {
+  const packageJsonPath = resolve(projectRoot, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    throw new Error('Missing package.json in the current AuraJS project.');
+  }
+  return {
+    path: packageJsonPath,
+    payload: readJsonFile(packageJsonPath),
+  };
+}
+
+function readProjectPackManifest(projectRoot) {
+  const manifestPath = resolve(projectRoot, PROJECT_PACKS_MANIFEST_PATH);
+  if (!existsSync(manifestPath)) {
+    return {
+      path: manifestPath,
+      payload: normalizeProjectPackManifest(null),
+      existed: false,
+    };
+  }
+  return {
+    path: manifestPath,
+    payload: normalizeProjectPackManifest(readJsonFile(manifestPath)),
+    existed: true,
+  };
+}
+
+function parseListArgs(args) {
+  let json = false;
+  for (const arg of args) {
+    if (arg === '--json') {
+      json = true;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      throw new Error(`Unknown option for packs list: ${arg}`);
+    }
+    throw new Error(`Unexpected extra argument "${arg}". Usage: aura packs list [--json]`);
+  }
+  return { json };
+}
+
+function parseShowArgs(args) {
+  let id = null;
+  let json = false;
+  for (const arg of args) {
+    if (arg === '--json') {
+      json = true;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      throw new Error(`Unknown option for packs show: ${arg}`);
+    }
+    if (id !== null) {
+      throw new Error(`Unexpected extra argument "${arg}". Usage: aura packs show <id> [--json]`);
+    }
+    id = arg;
+  }
+  if (!id) {
+    throw new Error('Missing pack or bundle id. Usage: aura packs show <id> [--json]');
+  }
+  return { id, json };
+}
+
+function parsePackSourceArgs(args, mode) {
+  const parsed = {
+    id: null,
+    json: false,
+    install: false,
+    force: false,
+    source: mode === 'vendor' ? 'auto' : 'package',
+    ref: null,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--json') {
+      parsed.json = true;
+      continue;
+    }
+    if (arg === '--install') {
+      parsed.install = true;
+      continue;
+    }
+    if (arg === '--force') {
+      parsed.force = true;
+      continue;
+    }
+    if (arg === '--workspace') {
+      parsed.source = 'workspace';
+      continue;
+    }
+    if (arg === '--github') {
+      parsed.source = 'github';
+      continue;
+    }
+    if (arg === '--installed') {
+      parsed.source = 'installed';
+      continue;
+    }
+    if (arg === '--source') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`Missing value for --source. Usage: aura packs ${mode} <id> [options]`);
+      }
+      parsed.source = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--source=')) {
+      parsed.source = arg.slice('--source='.length);
+      continue;
+    }
+    if (arg === '--ref') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error(`Missing value for --ref. Usage: aura packs ${mode} <id> [options]`);
+      }
+      parsed.ref = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--ref=')) {
+      parsed.ref = arg.slice('--ref='.length);
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      throw new Error(`Unknown option for packs ${mode}: ${arg}`);
+    }
+    if (parsed.id !== null) {
+      throw new Error(`Unexpected extra argument "${arg}". Usage: aura packs ${mode} <id> [options]`);
+    }
+    parsed.id = arg;
+  }
+
+  if (!parsed.id) {
+    throw new Error(`Missing pack or bundle id. Usage: aura packs ${mode} <id> [options]`);
+  }
+
+  const validSources = mode === 'vendor'
+    ? new Set(['auto', 'workspace', 'installed', 'github'])
+    : new Set(['package', 'workspace']);
+  if (!validSources.has(parsed.source)) {
+    throw new Error(`Unsupported --source "${parsed.source}" for packs ${mode}. Expected one of: ${[...validSources].join(', ')}.`);
+  }
+  if (mode !== 'vendor' && parsed.ref) {
+    throw new Error('--ref is only supported for packs vendor.');
+  }
+  if (mode !== 'vendor' && parsed.force) {
+    throw new Error('--force is only supported for packs vendor.');
+  }
+  if (mode === 'vendor' && parsed.install) {
+    throw new Error('--install is not supported for packs vendor.');
+  }
+
+  return parsed;
+}
+
+function resolveInstalledPackRoot(projectRoot, packageName) {
+  const packageSegments = String(packageName || '').split('/');
+  return resolve(projectRoot, 'node_modules', ...packageSegments);
+}
+
+function readPackDefinition(rootPath) {
+  const definitionPath = resolve(rootPath, PACK_DEFINITION_PATH);
+  if (!existsSync(definitionPath)) {
+    throw new Error(`Missing ${PACK_DEFINITION_PATH} in pack root ${rootPath}.`);
+  }
+  const definition = readJsonFile(definitionPath);
+  if (typeof definition?.id !== 'string' || definition.id.trim().length === 0) {
+    throw new Error(`Invalid ${PACK_DEFINITION_PATH} in ${rootPath}: missing pack id.`);
+  }
+  return definition;
+}
+
+function ensureDirectory(path) {
+  mkdirSync(path, { recursive: true });
+}
+
+function normalizeVendorTargets(definition) {
+  return Array.isArray(definition?.vendorTargets)
+    ? definition.vendorTargets
+      .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+      .map((entry) => ({
+        source: typeof entry.source === 'string' ? entry.source : null,
+        target: typeof entry.target === 'string' ? entry.target : null,
+      }))
+      .filter((entry) => entry.source && entry.target)
+    : [];
+}
+
+function updateProjectPackManifest(manifest, selection, resolvedPacks) {
+  const next = normalizeProjectPackManifest(manifest);
+  const selectedKeys = new Set(next.selected.map((entry) => `${entry.kind}:${entry.id}`));
+  const packIds = new Set(next.packs.map((entry) => entry.id));
+  const bundleIds = new Set(next.bundles.map((entry) => entry.id));
+
+  if (!selectedKeys.has(`${selection.requested.kind}:${selection.requested.id}`)) {
+    next.selected.push({
+      id: selection.requested.id,
+      kind: selection.requested.kind,
+      sourceMode: selection.requested.sourceMode || 'package',
+    });
+  }
+
+  for (const entry of resolvedPacks) {
+    if (packIds.has(entry.id)) {
+      const target = next.packs.find((item) => item.id === entry.id);
+      target.packageName = entry.packageName;
+      target.spec = entry.spec;
+      target.installMode = entry.installMode;
+      target.sourceMode = entry.sourceMode;
+      target.vendoredPaths = [...(entry.vendoredPaths || [])];
+      continue;
+    }
+    next.packs.push({
+      id: entry.id,
+      kind: entry.kind,
+      packageName: entry.packageName,
+      spec: entry.spec,
+      installMode: entry.installMode,
+      sourceMode: entry.sourceMode,
+      vendoredPaths: [...(entry.vendoredPaths || [])],
+    });
+    packIds.add(entry.id);
+  }
+
+  for (const bundle of selection.bundles) {
+    if (bundleIds.has(bundle.id)) {
+      continue;
+    }
+    next.bundles.push({
+      id: bundle.id,
+      packageName: bundle.packageName,
+      memberPackIds: [...bundle.memberPackIds],
+    });
+    bundleIds.add(bundle.id);
+  }
+
+  return {
+    schema: PROJECT_PACKS_SCHEMA,
+    selected: next.selected,
+    packs: next.packs,
+    bundles: next.bundles,
+  };
+}
+
+function cmdList(parsed) {
+  const report = createPackCatalogReport();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  console.log('');
+  console.log('  AuraJS Packs');
+  console.log('');
+  for (const entry of report.packs) {
+    console.log(`  ${entry.id}`);
+    console.log(`    kind: ${entry.kind}`);
+    console.log(`    package: ${entry.packageName}`);
+    console.log(`    summary: ${entry.description}`);
+  }
+  console.log('');
+  console.log('  AuraJS Bundles');
+  console.log('');
+  for (const entry of report.bundles) {
+    console.log(`  ${entry.id}`);
+    console.log(`    package: ${entry.packageName}`);
+    console.log(`    members: ${entry.memberPackIds.join(', ')}`);
+    console.log(`    summary: ${entry.description}`);
+  }
+  console.log('');
+}
+
+function cmdShow(parsed) {
+  const entry = findPackOrBundleEntry(parsed.id);
+  if (!entry) {
+    throw new Error(`Unknown pack or bundle "${parsed.id}". Run "aura packs list" for available ids.`);
+  }
+
+  const payload = {
+    schema: 'aurajs.pack-entry.v1',
+    id: entry.id,
+    kind: entry.kind,
+    title: entry.title,
+    description: entry.description,
+    packageName: entry.packageName,
+    versionRange: entry.versionRange,
+    workspaceAvailable: entry.workspaceAvailable,
+    github: entry.github ? { ...entry.github } : null,
+    recommendedFor: Array.isArray(entry.recommendedFor) ? [...entry.recommendedFor] : [],
+    surfaces: Array.isArray(entry.surfaces) ? [...entry.surfaces] : [],
+    memberPackIds: Array.isArray(entry.memberPackIds) ? [...entry.memberPackIds] : [],
+  };
+
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log('');
+  console.log(`  ${payload.title}`);
+  console.log('');
+  console.log(`  id: ${payload.id}`);
+  console.log(`  kind: ${payload.kind}`);
+  console.log(`  package: ${payload.packageName}`);
+  console.log(`  version: ${payload.versionRange}`);
+  console.log(`  summary: ${payload.description}`);
+  if (payload.github?.repository) {
+    console.log(`  github: ${payload.github.repository}#${payload.github.ref || 'main'}`);
+  }
+  if (payload.memberPackIds.length > 0) {
+    console.log(`  members: ${payload.memberPackIds.join(', ')}`);
+  }
+  console.log('');
+}
+
+function cmdAdd(parsed) {
+  const projectRoot = process.cwd();
+  assertAuraProjectRoot(projectRoot);
+  const selection = expandPackSelection(parsed.id);
+  if (!selection) {
+    throw new Error(`Unknown pack or bundle "${parsed.id}". Run "aura packs list" for available ids.`);
+  }
+
+  const packageJson = readProjectPackageJson(projectRoot);
+  const manifest = readProjectPackManifest(projectRoot);
+  const dependencies = packageJson.payload.dependencies && typeof packageJson.payload.dependencies === 'object'
+    ? { ...packageJson.payload.dependencies }
+    : {};
+
+  const resolvedPacks = selection.packs.map((entry) => {
+    const resolution = resolvePackInstallSpec(entry, {
+      projectRoot,
+      workspace: parsed.source === 'workspace',
+    });
+    dependencies[entry.packageName] = resolution.spec;
+    return {
+      id: entry.id,
+      kind: entry.kind,
+      title: entry.title,
+      packageName: entry.packageName,
+      spec: resolution.spec,
+      installMode: resolution.mode,
+      sourceMode: resolution.mode,
+      vendoredPaths: [],
+    };
+  });
+
+  packageJson.payload.dependencies = Object.fromEntries(
+    Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)),
+  );
+  writeJsonFile(packageJson.path, packageJson.payload);
+
+  const nextManifest = updateProjectPackManifest(
+    manifest.payload,
+    {
+      ...selection,
+      requested: {
+        ...selection.requested,
+        sourceMode: parsed.source,
+      },
+    },
+    resolvedPacks,
+  );
+  writeJsonFile(manifest.path, nextManifest);
+
+  let install = null;
+  if (parsed.install) {
+    install = spawnSync('npm', ['install'], {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+  }
+
+  const report = {
+    schema: 'aurajs.packs-add.v1',
+    ok: install ? install.status === 0 : true,
+    reasonCode: install
+      ? (install.status === 0 ? 'project_packs_added_and_installed' : 'project_packs_added_install_failed')
+      : 'project_packs_added',
+    requestedId: selection.requested.id,
+    requestedKind: selection.requested.kind,
+    dependenciesAdded: resolvedPacks.map((entry) => ({
+      id: entry.id,
+      packageName: entry.packageName,
+      spec: entry.spec,
+      installMode: entry.installMode,
+      sourceMode: entry.sourceMode,
+    })),
+    bundles: selection.bundles.map((entry) => ({
+      id: entry.id,
+      packageName: entry.packageName,
+      memberPackIds: [...entry.memberPackIds],
+    })),
+    manifestPath: PROJECT_PACKS_MANIFEST_PATH,
+    installRequested: parsed.install,
+    installStatus: install ? install.status : null,
+    installStdout: install?.stdout || '',
+    installStderr: install?.stderr || '',
+  };
+
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  console.log('');
+  console.log('  Added optional pack selection');
+  console.log('');
+  console.log(`  Requested: ${selection.requested.id}`);
+  console.log(`  Packages: ${resolvedPacks.map((entry) => entry.id).join(', ')}`);
+  console.log(`  Manifest: ${PROJECT_PACKS_MANIFEST_PATH}`);
+  if (parsed.install) {
+    console.log(`  Install status: ${install?.status === 0 ? 'ok' : 'failed'}`);
+  } else {
+    console.log('  Next step: npm install');
+  }
+  console.log('');
+}
+
+function resolveVendorSourceMode(entry, projectRoot, requestedSource) {
+  if (requestedSource === 'workspace') {
+    return 'workspace';
+  }
+  if (requestedSource === 'installed') {
+    return 'installed';
+  }
+  if (requestedSource === 'github') {
+    return 'github';
+  }
+  if (entry.workspaceAvailable) {
+    return 'workspace';
+  }
+  if (existsSync(resolveInstalledPackRoot(projectRoot, entry.packageName))) {
+    return 'installed';
+  }
+  return 'github';
+}
+
+async function resolveVendorPackRoot(entry, projectRoot, requestedSource, ref) {
+  const sourceMode = resolveVendorSourceMode(entry, projectRoot, requestedSource);
+  if (sourceMode === 'workspace') {
+    if (!entry.workspaceAvailable) {
+      throw new Error(`Pack "${entry.id}" is not available in the current AuraJS workspace.`);
+    }
+    return {
+      sourceMode,
+      rootPath: entry.workspacePath,
+      ref: null,
+      archiveUrl: null,
+      cleanup() {},
+    };
+  }
+
+  if (sourceMode === 'installed') {
+    const rootPath = resolveInstalledPackRoot(projectRoot, entry.packageName);
+    if (!existsSync(rootPath)) {
+      throw new Error(`Pack "${entry.id}" is not installed in node_modules. Run "aura packs add ${entry.id} --install" first or use --source workspace/github.`);
+    }
+    return {
+      sourceMode,
+      rootPath,
+      ref: null,
+      archiveUrl: null,
+      cleanup() {},
+    };
+  }
+
+  if (!entry.github?.repository || !entry.github?.packPath) {
+    throw new Error(`Pack "${entry.id}" does not declare a GitHub source.`);
+  }
+
+  const tempRoot = mkdtempSync(join(tmpdir(), 'aurajs-pack-github-'));
+  const archivePath = join(tempRoot, 'pack.tar.gz');
+  const extractRoot = join(tempRoot, 'extract');
+  ensureDirectory(extractRoot);
+  const resolvedRef = ref || entry.github.ref || 'main';
+  const archiveUrl = `https://codeload.github.com/${entry.github.repository}/tar.gz/${resolvedRef}`;
+
+  const response = await fetch(archiveUrl);
+  if (!response.ok) {
+    rmSync(tempRoot, { recursive: true, force: true });
+    throw new Error(`Unable to download pack archive for "${entry.id}" from ${archiveUrl} (${response.status} ${response.statusText}).`);
+  }
+
+  writeFileSync(archivePath, Buffer.from(await response.arrayBuffer()));
+  const extract = spawnSync('tar', ['-xzf', archivePath, '-C', extractRoot], {
+    encoding: 'utf8',
+  });
+  if (extract.status !== 0) {
+    rmSync(tempRoot, { recursive: true, force: true });
+    throw new Error(`Unable to extract GitHub archive for "${entry.id}": ${extract.stderr || extract.stdout}`.trim());
+  }
+
+  const extractedRoot = readdirSync(extractRoot, { withFileTypes: true }).find((entryDir) => entryDir.isDirectory());
+  if (!extractedRoot) {
+    rmSync(tempRoot, { recursive: true, force: true });
+    throw new Error(`GitHub archive for "${entry.id}" did not contain an extracted root directory.`);
+  }
+
+  const rootPath = resolve(extractRoot, extractedRoot.name, entry.github.packPath);
+  if (!existsSync(rootPath)) {
+    rmSync(tempRoot, { recursive: true, force: true });
+    throw new Error(`GitHub archive for "${entry.id}" is missing pack path "${entry.github.packPath}".`);
+  }
+
+  return {
+    sourceMode,
+    rootPath,
+    ref: resolvedRef,
+    archiveUrl,
+    cleanup() {
+      rmSync(tempRoot, { recursive: true, force: true });
+    },
+  };
+}
+
+function copyVendorTarget({ projectRoot, sourceRoot, sourceRelativePath, targetRelativePath, force }) {
+  const absoluteSourcePath = resolve(sourceRoot, sourceRelativePath);
+  if (!existsSync(absoluteSourcePath)) {
+    throw new Error(`Missing pack vendor source "${sourceRelativePath}" inside ${sourceRoot}.`);
+  }
+
+  const absoluteTargetPath = resolve(projectRoot, targetRelativePath);
+  const alreadyExists = existsSync(absoluteTargetPath);
+  if (alreadyExists && !force) {
+    return {
+      created: [],
+      overwritten: [],
+      skipped: [targetRelativePath],
+    };
+  }
+
+  ensureDirectory(resolve(absoluteTargetPath, '..'));
+  const sourceStats = statSync(absoluteSourcePath);
+  if (sourceStats.isDirectory()) {
+    cpSync(absoluteSourcePath, absoluteTargetPath, {
+      recursive: true,
+      force: true,
+    });
+  } else {
+    ensureDirectory(resolve(absoluteTargetPath, '..'));
+    cpSync(absoluteSourcePath, absoluteTargetPath, { force: true });
+  }
+
+  return alreadyExists
+    ? { created: [], overwritten: [targetRelativePath], skipped: [] }
+    : { created: [targetRelativePath], overwritten: [], skipped: [] };
+}
+
+async function cmdVendor(parsed) {
+  const projectRoot = process.cwd();
+  assertAuraProjectRoot(projectRoot);
+  const selection = expandPackSelection(parsed.id);
+  if (!selection) {
+    throw new Error(`Unknown pack or bundle "${parsed.id}". Run "aura packs list" for available ids.`);
+  }
+
+  const manifest = readProjectPackManifest(projectRoot);
+  const vendoredPacks = [];
+  const created = [];
+  const overwritten = [];
+  const skipped = [];
+  const fetchedArchives = [];
+
+  for (const entry of selection.packs) {
+    const resolved = await resolveVendorPackRoot(entry, projectRoot, parsed.source, parsed.ref);
+    try {
+      const definition = readPackDefinition(resolved.rootPath);
+      const vendorTargets = normalizeVendorTargets(definition);
+      if (vendorTargets.length === 0) {
+        throw new Error(`Pack "${entry.id}" does not define any vendorTargets in ${PACK_DEFINITION_PATH}.`);
+      }
+
+      const vendoredPaths = [];
+      for (const target of vendorTargets) {
+        const result = copyVendorTarget({
+          projectRoot,
+          sourceRoot: resolved.rootPath,
+          sourceRelativePath: target.source,
+          targetRelativePath: target.target,
+          force: parsed.force,
+        });
+        created.push(...result.created);
+        overwritten.push(...result.overwritten);
+        skipped.push(...result.skipped);
+        if (result.created.length > 0 || result.overwritten.length > 0) {
+          vendoredPaths.push(target.target);
+        }
+      }
+
+      vendoredPacks.push({
+        id: entry.id,
+        kind: entry.kind,
+        title: entry.title,
+        packageName: entry.packageName,
+        spec: null,
+        installMode: 'package',
+        sourceMode: resolved.sourceMode === 'installed' ? 'package' : resolved.sourceMode,
+        vendoredPaths,
+      });
+      if (resolved.archiveUrl) {
+        fetchedArchives.push({
+          id: entry.id,
+          archiveUrl: resolved.archiveUrl,
+          ref: resolved.ref,
+        });
+      }
+    } finally {
+      resolved.cleanup();
+    }
+  }
+
+  const nextManifest = updateProjectPackManifest(
+    manifest.payload,
+    {
+      ...selection,
+      requested: {
+        ...selection.requested,
+        sourceMode: parsed.source === 'auto' ? vendoredPacks[0]?.sourceMode || 'workspace' : parsed.source,
+      },
+    },
+    vendoredPacks,
+  );
+  writeJsonFile(manifest.path, nextManifest);
+
+  const report = {
+    schema: 'aurajs.packs-vendor.v1',
+    ok: true,
+    reasonCode: overwritten.length > 0 ? 'project_packs_resynced' : 'project_packs_vendored',
+    requestedId: selection.requested.id,
+    requestedKind: selection.requested.kind,
+    source: parsed.source,
+    created,
+    overwritten,
+    skipped,
+    vendoredPacks: vendoredPacks.map((entry) => ({
+      id: entry.id,
+      sourceMode: entry.sourceMode,
+      vendoredPaths: [...entry.vendoredPaths],
+    })),
+    fetchedArchives,
+    manifestPath: PROJECT_PACKS_MANIFEST_PATH,
+  };
+
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  console.log('');
+  console.log('  Vendored optional pack payload');
+  console.log('');
+  console.log(`  Requested: ${selection.requested.id}`);
+  console.log(`  Source: ${parsed.source}`);
+  console.log(`  Created: ${created.length}`);
+  console.log(`  Overwritten: ${overwritten.length}`);
+  console.log(`  Skipped: ${skipped.length}`);
+  console.log('');
+}
+
+export async function cmdPacks(args, { error } = {}) {
+  try {
+    const subcommand = args[0] || 'list';
+    const rest = args.slice(1);
+
+    if (subcommand === 'list') {
+      cmdList(parseListArgs(rest));
+      return;
+    }
+    if (subcommand === 'show') {
+      cmdShow(parseShowArgs(rest));
+      return;
+    }
+    if (subcommand === 'add') {
+      cmdAdd(parsePackSourceArgs(rest, 'add'));
+      return;
+    }
+    if (subcommand === 'vendor') {
+      await cmdVendor(parsePackSourceArgs(rest, 'vendor'));
+      return;
+    }
+
+    raiseCliError(error, `Unsupported packs subcommand "${subcommand}". Usage: ${PACKS_USAGE}`);
+  } catch (err) {
+    handlePackCommandError(error, err);
+  }
+}
+