@rbbtsn0w/adg 0.1.0-alpha.1

package/vendor/skills/src/remove.ts

@@ -0,0 +1,323 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { readdir, rm, lstat } from 'fs/promises';
+import { join } from 'path';
+import { agents, detectInstalledAgents } from './agents.ts';
+import { track } from './telemetry.ts';
+import { detectAgent } from './detect-agent.ts';
+import { removeSkillFromLock, getSkillFromLock } from './skill-lock.ts';
+import type { AgentType } from './types.ts';
+import {
+  getInstallPath,
+  getCanonicalPath,
+  getCanonicalSkillsDir,
+  sanitizeName,
+} from './installer.ts';
+
+export interface RemoveOptions {
+  global?: boolean;
+  agent?: string[];
+  yes?: boolean;
+  all?: boolean;
+}
+
+export async function removeCommand(skillNames: string[], options: RemoveOptions) {
+  // Auto-enable non-interactive mode when running inside an AI agent
+  const agentResult = await detectAgent();
+  if (agentResult.isAgent) {
+    options.yes = true;
+    p.log.info(
+      pc.bgCyan(pc.black(pc.bold(` ${agentResult.agent.name} `))) +
+        ' ' +
+        'Agent detected — removing non-interactively'
+    );
+  }
+
+  const isGlobal = options.global ?? false;
+  const cwd = process.cwd();
+
+  const spinner = p.spinner();
+
+  spinner.start('Scanning for installed skills...');
+  const skillNamesSet = new Set<string>();
+
+  const scanDir = async (dir: string) => {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skillNamesSet.add(entry.name);
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && (err as { code?: string }).code !== 'ENOENT') {
+        p.log.warn(`Could not scan directory ${dir}: ${err.message}`);
+      }
+    }
+  };
+
+  if (isGlobal) {
+    await scanDir(getCanonicalSkillsDir(true, cwd));
+    for (const agent of Object.values(agents)) {
+      if (agent.globalSkillsDir !== undefined) {
+        await scanDir(agent.globalSkillsDir);
+      }
+    }
+  } else {
+    await scanDir(getCanonicalSkillsDir(false, cwd));
+    for (const agent of Object.values(agents)) {
+      await scanDir(join(cwd, agent.skillsDir));
+    }
+  }
+
+  const installedSkills = Array.from(skillNamesSet).sort();
+  spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
+
+  if (installedSkills.length === 0) {
+    p.outro(pc.yellow('No skills found to remove.'));
+    return;
+  }
+
+  // Validate agent options BEFORE prompting for skill selection
+  if (options.agent && options.agent.length > 0) {
+    const validAgents = Object.keys(agents);
+    const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+
+    if (invalidAgents.length > 0) {
+      p.log.error(`Invalid agents: ${invalidAgents.join(', ')}`);
+      p.log.info(`Valid agents: ${validAgents.join(', ')}`);
+      process.exit(1);
+    }
+  }
+
+  let selectedSkills: string[] = [];
+
+  if (options.all) {
+    selectedSkills = installedSkills;
+  } else if (skillNames.length > 0) {
+    selectedSkills = installedSkills.filter((s) =>
+      skillNames.some((name) => name.toLowerCase() === s.toLowerCase())
+    );
+
+    if (selectedSkills.length === 0) {
+      p.log.error(`No matching skills found for: ${skillNames.join(', ')}`);
+      return;
+    }
+  } else {
+    const choices = installedSkills.map((s) => ({
+      value: s,
+      label: s,
+    }));
+
+    const selected = await p.multiselect({
+      message: `Select skills to remove ${pc.dim('(space to toggle)')}`,
+      options: choices,
+      required: true,
+    });
+
+    if (p.isCancel(selected)) {
+      p.cancel('Removal cancelled');
+      process.exit(0);
+    }
+
+    selectedSkills = selected as string[];
+  }
+
+  let targetAgents: AgentType[];
+  if (options.agent && options.agent.length > 0) {
+    targetAgents = options.agent as AgentType[];
+  } else {
+    // When removing, we should target all known agents to ensure
+    // ghost symlinks are cleaned up, even if the agent is not detected.
+    targetAgents = Object.keys(agents) as AgentType[];
+    spinner.stop(`Targeting ${targetAgents.length} potential agent(s)`);
+  }
+
+  if (!options.yes) {
+    console.log();
+    p.log.info('Skills to remove:');
+    for (const skill of selectedSkills) {
+      p.log.message(`  ${pc.red('•')} ${skill}`);
+    }
+    console.log();
+
+    const confirmed = await p.confirm({
+      message: `Are you sure you want to uninstall ${selectedSkills.length} skill(s)?`,
+    });
+
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel('Removal cancelled');
+      process.exit(0);
+    }
+  }
+
+  spinner.start('Removing skills...');
+
+  const results: {
+    skill: string;
+    success: boolean;
+    source?: string;
+    sourceType?: string;
+    error?: string;
+  }[] = [];
+
+  for (const skillName of selectedSkills) {
+    try {
+      const canonicalPath = getCanonicalPath(skillName, { global: isGlobal, cwd });
+
+      for (const agentKey of targetAgents) {
+        const agent = agents[agentKey];
+        const skillPath = getInstallPath(skillName, agentKey, { global: isGlobal, cwd });
+
+        // Determine potential paths to cleanup. For universal agents, getInstallPath
+        // now returns the canonical path, so we also need to check their 'native'
+        // directory to clean up any legacy symlinks.
+        const pathsToCleanup = new Set([skillPath]);
+        const sanitizedName = sanitizeName(skillName);
+        if (isGlobal && agent.globalSkillsDir) {
+          pathsToCleanup.add(join(agent.globalSkillsDir, sanitizedName));
+        } else {
+          pathsToCleanup.add(join(cwd, agent.skillsDir, sanitizedName));
+        }
+
+        for (const pathToCleanup of pathsToCleanup) {
+          // Skip if this is the canonical path - we'll handle that after checking all agents
+          if (pathToCleanup === canonicalPath) {
+            continue;
+          }
+
+          try {
+            const stats = await lstat(pathToCleanup).catch(() => null);
+            if (stats) {
+              await rm(pathToCleanup, { recursive: true, force: true });
+            }
+          } catch (err) {
+            p.log.warn(
+              `Could not remove skill from ${agent.displayName}: ${
+                err instanceof Error ? err.message : String(err)
+              }`
+            );
+          }
+        }
+      }
+
+      // Only remove the canonical path if no other installed agents are using it.
+      // This prevents breaking other agents when uninstalling from a specific agent (#287).
+      const installedAgents = await detectInstalledAgents();
+      const remainingAgents = installedAgents.filter((a) => !targetAgents.includes(a));
+
+      let isStillUsed = false;
+      for (const agentKey of remainingAgents) {
+        const path = getInstallPath(skillName, agentKey, { global: isGlobal, cwd });
+        const exists = await lstat(path).catch(() => null);
+        if (exists) {
+          isStillUsed = true;
+          break;
+        }
+      }
+
+      if (!isStillUsed) {
+        await rm(canonicalPath, { recursive: true, force: true });
+      }
+
+      const lockEntry = isGlobal ? await getSkillFromLock(skillName) : null;
+      const effectiveSource = lockEntry?.source || 'local';
+      const effectiveSourceType = lockEntry?.sourceType || 'local';
+
+      if (isGlobal) {
+        await removeSkillFromLock(skillName);
+      }
+
+      results.push({
+        skill: skillName,
+        success: true,
+        source: effectiveSource,
+        sourceType: effectiveSourceType,
+      });
+    } catch (err) {
+      results.push({
+        skill: skillName,
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+
+  spinner.stop('Removal process complete');
+
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+
+  // Track removal (grouped by source)
+  if (successful.length > 0) {
+    const bySource = new Map<string, { skills: string[]; sourceType?: string }>();
+
+    for (const r of successful) {
+      const source = r.source || 'local';
+      const existing = bySource.get(source) || { skills: [] };
+      existing.skills.push(r.skill);
+      existing.sourceType = r.sourceType;
+      bySource.set(source, existing);
+    }
+
+    for (const [source, data] of bySource) {
+      track({
+        event: 'remove',
+        source,
+        skills: data.skills.join(','),
+        agents: targetAgents.join(','),
+        ...(isGlobal && { global: '1' }),
+        sourceType: data.sourceType,
+      });
+    }
+  }
+
+  if (successful.length > 0) {
+    p.log.success(pc.green(`Successfully removed ${successful.length} skill(s)`));
+  }
+
+  if (failed.length > 0) {
+    p.log.error(pc.red(`Failed to remove ${failed.length} skill(s)`));
+    for (const r of failed) {
+      p.log.message(`  ${pc.red('✗')} ${r.skill}: ${r.error}`);
+    }
+  }
+
+  console.log();
+  p.outro(pc.green('Done!'));
+}
+
+/**
+ * Parse command line options for the remove command.
+ * Separates skill names from options flags.
+ */
+export function parseRemoveOptions(args: string[]): { skills: string[]; options: RemoveOptions } {
+  const options: RemoveOptions = {};
+  const skills: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '-g' || arg === '--global') {
+      options.global = true;
+    } else if (arg === '-y' || arg === '--yes') {
+      options.yes = true;
+    } else if (arg === '--all') {
+      options.all = true;
+    } else if (arg === '-a' || arg === '--agent') {
+      options.agent = options.agent || [];
+      i++;
+      let nextArg = args[i];
+      while (i < args.length && nextArg && !nextArg.startsWith('-')) {
+        options.agent.push(nextArg);
+        i++;
+        nextArg = args[i];
+      }
+      i--; // Back up one since the loop will increment
+    } else if (arg && !arg.startsWith('-')) {
+      skills.push(arg);
+    }
+  }
+
+  return { skills, options };
+}

package/vendor/skills/src/sanitize.ts

@@ -0,0 +1,65 @@
+/**
+ * Sanitize untrusted strings before terminal output.
+ *
+ * Strips ALL terminal escape sequences from a string, including:
+ *   - CSI sequences  (ESC [ ... final_byte)    — cursor movement, screen clear, SGR colors
+ *   - OSC sequences  (ESC ] ... BEL/ST)         — window title, hyperlinks
+ *   - Simple escapes (ESC followed by one char)  — e.g. ESC 7 (save cursor)
+ *   - C1 control codes (0x80–0x9F)
+ *   - Raw control characters (BEL, BS, etc.)     — except \t and \n which are safe
+ *
+ * This defends against CWE-150 (terminal escape injection) where
+ * untrusted data (e.g., skill name/description from SKILL.md frontmatter
+ * or remote APIs) could clear the screen, move the cursor, change the
+ * window title, or render attacker-controlled text that looks like
+ * legitimate CLI output.
+ */
+
+// CSI sequences: ESC[ followed by parameter bytes (0x30-0x3F), intermediate bytes (0x20-0x2F), and a final byte (0x40-0x7E)
+const CSI_RE = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+
+// OSC sequences: ESC] ... terminated by BEL (\x07) or ST (ESC\)
+const OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+
+// DCS, PM, APC sequences: ESC P|^|_ ... terminated by ST (ESC\)
+const DCS_PM_APC_RE = /\x1b[P^_][\s\S]*?(?:\x1b\\)/g;
+
+// Simple two-byte escape sequences: ESC followed by a single char in 0x20-0x7E range
+// Includes ESC 7 (DECSC), ESC 8 (DECRC), ESC c (RIS), ESC M (RI), etc.
+const SIMPLE_ESC_RE = /\x1b[\x20-\x7e]/g;
+
+// C1 control codes (0x80-0x9F) — used as 8-bit equivalents of ESC sequences
+const C1_RE = /[\x80-\x9f]/g;
+
+// Raw control characters except tab (\x09) and newline (\x0a)
+// Includes BEL (\x07), BS (\x08), CR (\x0d), and others
+const CONTROL_RE = /[\x00-\x06\x07\x08\x0b\x0c\x0d-\x1a\x1c-\x1f\x7f]/g;
+
+/**
+ * Strip all terminal escape sequences and dangerous control characters
+ * from a string.
+ *
+ * Safe for use on untrusted input before printing to the terminal.
+ */
+export function stripTerminalEscapes(str: string): string {
+  return str
+    .replace(OSC_RE, '') // OSC first (longest match)
+    .replace(DCS_PM_APC_RE, '') // DCS/PM/APC
+    .replace(CSI_RE, '') // CSI sequences
+    .replace(SIMPLE_ESC_RE, '') // Simple ESC+char
+    .replace(C1_RE, '') // C1 control codes
+    .replace(CONTROL_RE, ''); // Raw control chars (keep \t \n)
+}
+
+/**
+ * Sanitize a skill metadata string (name, description, etc.) for safe terminal display.
+ *
+ * In addition to stripping escape sequences, this also trims whitespace and
+ * collapses internal newlines into spaces (skill names/descriptions should
+ * be single-line when displayed).
+ */
+export function sanitizeMetadata(str: string): string {
+  return stripTerminalEscapes(str)
+    .replace(/[\r\n]+/g, ' ')
+    .trim();
+}

package/vendor/skills/src/self-cli.ts

@@ -0,0 +1,20 @@
+// ADG patch (new file): standalone helper for re-invoking the vendored CLI on
+// `cli.ts`. Kept dependency-free (no heavy transitive imports) so a test can
+// import it without pulling update.ts's graph (which currently includes the
+// detect-agent.ts ↔ @vercel/detect-agent API mismatch). Mirrors the rationale
+// for git-tree.ts. See vendor/skills/PROVENANCE.md.
+
+/**
+ * Args for re-invoking Node on the vendored `cli.ts`. `process.execArgv` is
+ * forwarded so the child inherits the parent's Node flags (e.g.
+ * --experimental-strip-types, required to run TypeScript directly on Node
+ * 22.6–23.5). `execArgv` is a parameter so the forwarding can be tested with a
+ * non-empty flag set.
+ */
+export function selfCliArgv(
+  cliEntry: string,
+  args: string[],
+  execArgv: string[] = process.execArgv
+): string[] {
+  return [...execArgv, cliEntry, ...args];
+}