@alavida/agentpack 0.1.4 → 0.1.6

package/src/infrastructure/runtime/materialize-skills.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, unlinkSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { writeInstallState } from '../fs/install-state-repository.js';
 
@@ -7,7 +7,17 @@ function ensureDir(pathValue) {
 }
 
 export function removePathIfExists(pathValue) {
-  rmSync(pathValue, { recursive: true, force: true });
+  try {
+    const stat = lstatSync(pathValue);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      unlinkSync(pathValue);
+      return;
+    }
+    rmSync(pathValue, { recursive: true, force: true });
+  } catch (error) {
+    if (error?.code === 'ENOENT') return;
+    throw error;
+  }
 }
 
 export function ensureSkillLink(repoRoot, baseDir, skillName, skillDir, normalizeDisplayPath) {
@@ -25,9 +35,13 @@ export function removeSkillLinks(repoRoot, name, normalizeDisplayPath) {
     join(repoRoot, '.claude', 'skills', name),
     join(repoRoot, '.agents', 'skills', name),
   ]) {
-    if (!existsSync(pathValue)) continue;
-    removePathIfExists(pathValue);
-    removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    try {
+      removePathIfExists(pathValue);
+      removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    } catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw error;
+    }
   }
   return removed;
 }
@@ -50,9 +64,13 @@ export function removeSkillLinksByPaths(repoRoot, paths, normalizeDisplayPath) {
     const pathValue = resolve(repoRoot, relativePath);
     const inAllowedRoot = allowedRoots.some((root) => pathValue === root || pathValue.startsWith(`${root}/`));
     if (!inAllowedRoot) continue;
-    if (!existsSync(pathValue)) continue;
-    removePathIfExists(pathValue);
-    removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    try {
+      removePathIfExists(pathValue);
+      removed.push(normalizeDisplayPath(repoRoot, pathValue));
+    } catch (error) {
+      if (error?.code === 'ENOENT') continue;
+      throw error;
+    }
   }
   return [...new Set(removed)];
 }
@@ -63,31 +81,62 @@ function ensureSymlink(targetPath, linkPath) {
   symlinkSync(targetPath, linkPath, 'dir');
 }
 
+function inferPackageRuntimeNamespace(packageName) {
+  return packageName?.split('/').pop() || null;
+}
+
+function buildRuntimeName(packageName, exportedSkills, entry) {
+  if (exportedSkills.length <= 1) return entry.name;
+
+  const namespace = inferPackageRuntimeNamespace(packageName);
+  if (!namespace) return entry.name;
+  if (entry.name === namespace) return namespace;
+  return `${namespace}:${entry.name}`;
+}
+
 export function buildInstallRecord(repoRoot, packageDir, directTargetMap, {
-  parseSkillFrontmatterFile,
   readPackageMetadata,
+  readInstalledSkillExports,
   normalizeRelativePath,
 } = {}) {
   const packageMetadata = readPackageMetadata(packageDir);
   if (!packageMetadata.packageName) return null;
-
-  const skillMetadata = parseSkillFrontmatterFile(join(packageDir, 'SKILL.md'));
-  const skillDirName = skillMetadata.name;
+  const exportedSkills = readInstalledSkillExports(packageDir);
+  if (exportedSkills.length === 0) return null;
   const materializations = [];
+  const skills = [];
 
-  const claudeTargetAbs = join(repoRoot, '.claude', 'skills', skillDirName);
-  ensureSymlink(packageDir, claudeTargetAbs);
-  materializations.push({
-    target: normalizeRelativePath(relative(repoRoot, claudeTargetAbs)),
-    mode: 'symlink',
-  });
+  for (const entry of exportedSkills) {
+    const runtimeName = buildRuntimeName(packageMetadata.packageName, exportedSkills, entry);
+    const skillMaterializations = [];
 
-  const agentsTargetAbs = join(repoRoot, '.agents', 'skills', skillDirName);
-  ensureSymlink(packageDir, agentsTargetAbs);
-  materializations.push({
-    target: normalizeRelativePath(relative(repoRoot, agentsTargetAbs)),
-    mode: 'symlink',
-  });
+    const claudeTargetAbs = join(repoRoot, '.claude', 'skills', runtimeName);
+    ensureSymlink(entry.skillDir, claudeTargetAbs);
+    skillMaterializations.push({
+      target: normalizeRelativePath(relative(repoRoot, claudeTargetAbs)),
+      mode: 'symlink',
+    });
+
+    const agentsTargetAbs = join(repoRoot, '.agents', 'skills', runtimeName);
+    ensureSymlink(entry.skillDir, agentsTargetAbs);
+    skillMaterializations.push({
+      target: normalizeRelativePath(relative(repoRoot, agentsTargetAbs)),
+      mode: 'symlink',
+    });
+
+    materializations.push(...skillMaterializations);
+    skills.push({
+      name: entry.name,
+      runtime_name: runtimeName,
+      source_skill_path: normalizeRelativePath(relative(repoRoot, entry.skillDir)),
+      source_skill_file: normalizeRelativePath(relative(repoRoot, entry.skillFile)),
+      requires: entry.requires,
+      status: entry.status,
+      replacement: entry.replacement,
+      message: entry.message,
+      materializations: skillMaterializations,
+    });
+  }
 
   return {
     packageName: packageMetadata.packageName,
@@ -95,26 +144,23 @@ export function buildInstallRecord(repoRoot, packageDir, directTargetMap, {
     requestedTarget: directTargetMap.get(packageMetadata.packageName) || null,
     packageVersion: packageMetadata.packageVersion,
     sourcePackagePath: normalizeRelativePath(relative(repoRoot, packageDir)),
+    skills,
     materializations,
   };
 }
 
 export function rebuildInstallState(repoRoot, directTargetMap, {
-  listInstalledPackageDirs,
-  parseSkillFrontmatterFile,
+  packageDirs = [],
   readPackageMetadata,
+  readInstalledSkillExports,
   normalizeRelativePath,
 } = {}) {
-  const packageDirs = listInstalledPackageDirs(join(repoRoot, 'node_modules'));
   const installs = {};
 
   for (const packageDir of packageDirs) {
-    const skillFile = join(packageDir, 'SKILL.md');
-    if (!existsSync(skillFile)) continue;
-
     const record = buildInstallRecord(repoRoot, packageDir, directTargetMap, {
-      parseSkillFrontmatterFile,
       readPackageMetadata,
+      readInstalledSkillExports,
       normalizeRelativePath,
     });
     if (!record) continue;
@@ -124,6 +170,7 @@ export function rebuildInstallState(repoRoot, directTargetMap, {
       requested_target: record.requestedTarget,
       package_version: record.packageVersion,
       source_package_path: record.sourcePackagePath,
+      skills: record.skills,
       materializations: record.materializations,
     };
   }

package/src/infrastructure/runtime/open-browser.js

@@ -1,6 +1,12 @@
+import { writeFileSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 
 export function openBrowser(url) {
+  if (process.env.AGENTPACK_BROWSER_CAPTURE_PATH) {
+    writeFileSync(process.env.AGENTPACK_BROWSER_CAPTURE_PATH, `${url}\n`);
+    return;
+  }
+
   if (process.env.AGENTPACK_DISABLE_BROWSER === '1') return;
 
   const command = process.platform === 'darwin'

package/src/lib/skills.js

@@ -19,11 +19,14 @@ import {
   removeSkillLinksByNames,
 } from '../infrastructure/runtime/materialize-skills.js';
 import {
+  buildCanonicalSkillRequirement,
   normalizeDisplayPath,
   normalizeRepoPath,
   parseSkillFrontmatterFile,
+  readInstalledSkillExports,
   readPackageMetadata,
 } from '../domain/skills/skill-model.js';
+import { inspectMaterializedSkills } from '../infrastructure/runtime/inspect-materialized-skills.js';
 import {
   buildStateRecordForPackageDir,
   compareRecordedSources,
@@ -31,6 +34,10 @@ import {
   readBuildState,
   writeBuildState,
 } from '../domain/skills/skill-provenance.js';
+import { readUserConfig } from '../infrastructure/fs/user-config-repository.js';
+import { readUserCredentials } from '../infrastructure/fs/user-credentials-repository.js';
+import { getUserNpmrcPath, readUserNpmrc } from '../infrastructure/fs/user-npmrc-repository.js';
+import { resolveRegistryConfig } from '../domain/auth/registry-resolution.js';
 import { startSkillDevWorkbench } from '../application/skills/start-skill-dev-workbench.js';
 import { AgentpackError, EXIT_CODES, NetworkError, NotFoundError, ValidationError } from '../utils/errors.js';
 
@@ -638,24 +645,75 @@ function readRepoNpmRegistryConfig(repoRoot, scope = null) {
     : {};
   const scopes = scope ? [scope] : MANAGED_PACKAGE_SCOPES;
   const matchedScope = scopes.find((candidate) => config[`${candidate}:registry`]) || scope || scopes[0] || null;
+  const registry = matchedScope ? (config[`${matchedScope}:registry`] || null) : null;
+  const authKey = registry ? `//${new URL(registry).host}/:_authToken` : null;
 
   return {
     npmrcPath: existsSync(npmrcPath) ? npmrcPath : null,
     scope: matchedScope,
-    registry: matchedScope ? (config[`${matchedScope}:registry`] || null) : null,
-    authToken: config['//npm.pkg.github.com/:_authToken'] || null,
+    registry,
+    authToken: authKey ? (config[authKey] || null) : null,
     alwaysAuth: String(config['always-auth'] || '').toLowerCase() === 'true',
   };
 }
 
+function readEffectiveRegistryConfig(repoRoot, scope = null, env = process.env) {
+  const userConfig = readUserConfig({ env });
+  const userNpmrc = readUserNpmrc({ env });
+  const repoConfig = readRepoNpmRegistryConfig(repoRoot, scope);
+  const userScope = MANAGED_PACKAGE_SCOPES.find((candidate) => userNpmrc[`${candidate}:registry`]) || null;
+  const resolvedScope = scope
+    || (repoConfig.registry ? repoConfig.scope : null)
+    || userScope
+    || userConfig.scope
+    || repoConfig.scope
+    || MANAGED_PACKAGE_SCOPES[0]
+    || null;
+  const resolved = resolveRegistryConfig({
+    scope: resolvedScope,
+    defaults: {
+      registry: userConfig.registry,
+      verificationPackage: userConfig.verificationPackage,
+    },
+    userNpmrc,
+    repoNpmrc: repoConfig.registry ? {
+      [`${repoConfig.scope}:registry`]: repoConfig.registry,
+      ...(repoConfig.authToken ? { [`//${new URL(repoConfig.registry).host}/:_authToken`]: repoConfig.authToken } : {}),
+    } : {},
+  });
+
+  let npmrcPath = null;
+  if (resolved.source === 'repo') {
+    npmrcPath = repoConfig.npmrcPath;
+  } else if (resolved.source === 'user') {
+    npmrcPath = getUserNpmrcPath({ env });
+  }
+
+  const alwaysAuth = resolved.source === 'repo'
+    ? repoConfig.alwaysAuth
+    : String(userNpmrc['always-auth'] || '').toLowerCase() === 'true';
+
+  return {
+    scope: resolved.scope,
+    npmrcPath,
+    registry: resolved.registry,
+    authToken: resolved.authToken,
+    alwaysAuth,
+    source: resolved.source,
+    configured: resolved.source !== 'default' && Boolean(resolved.registry),
+  };
+}
+
 export function inspectRegistryConfig({
   cwd = process.cwd(),
   scope = null,
+  env = process.env,
 } = {}) {
   const repoRoot = findRepoRoot(cwd);
-  const { npmrcPath, scope: resolvedScope, registry, authToken, alwaysAuth } = readRepoNpmRegistryConfig(
+  const { npmrcPath, scope: resolvedScope, registry, authToken, alwaysAuth, source, configured } = readEffectiveRegistryConfig(
     repoRoot,
-    scope
+    scope,
+    env
   );
 
   let auth = {
@@ -688,10 +746,11 @@ export function inspectRegistryConfig({
     scope: resolvedScope,
     repoRoot,
     npmrcPath: npmrcPath ? normalizeDisplayPath(repoRoot, npmrcPath) : null,
-    configured: Boolean(registry),
-    registry,
+    configured,
+    registry: configured ? registry : null,
     auth,
     alwaysAuth,
+    source,
   };
 }
 
@@ -704,6 +763,22 @@ function resolveRegistryAuthToken(rawValue) {
   return rawValue;
 }
 
+function buildNpmRegistryEnv(repoRoot, env = process.env) {
+  const effective = readEffectiveRegistryConfig(repoRoot, null, env);
+  const authToken = effective.authToken || null;
+  const envMatch = authToken?.match(/^\$\{([^}]+)\}$/) || null;
+  if (!envMatch) return env;
+  if (env[envMatch[1]]) return env;
+
+  const credentials = readUserCredentials({ env });
+  if (!credentials?.token) return env;
+
+  return {
+    ...env,
+    [envMatch[1]]: credentials.token,
+  };
+}
+
 async function fetchRegistryLatestVersion(packageName, {
   registry,
   authToken,
@@ -1265,6 +1340,36 @@ function listInstalledPackageDirs(nodeModulesDir) {
   return packageDirs;
 }
 
+function findInstalledPackageDir(nodeModulesDir, packageName) {
+  if (!packageName) return null;
+  const packageDir = join(nodeModulesDir, ...packageName.split('/'));
+  return existsSync(packageDir) ? packageDir : null;
+}
+
+function resolveInstalledPackageClosure(repoRoot, directTargetMap) {
+  const nodeModulesDir = join(repoRoot, 'node_modules');
+  const queue = [...directTargetMap.keys()];
+  const seen = new Set();
+  const packageDirs = [];
+
+  while (queue.length > 0) {
+    const packageName = queue.shift();
+    if (seen.has(packageName)) continue;
+    seen.add(packageName);
+
+    const packageDir = findInstalledPackageDir(nodeModulesDir, packageName);
+    if (!packageDir) continue;
+
+    packageDirs.push(packageDir);
+    const packageMetadata = readPackageMetadata(packageDir);
+    for (const dependencyName of Object.keys(packageMetadata.dependencies || {})) {
+      queue.push(dependencyName);
+    }
+  }
+
+  return packageDirs.sort();
+}
+
 function collectLocalInstallTargets(initialTarget) {
   const resolvedTarget = resolve(initialTarget);
   const queue = [resolvedTarget];
@@ -1342,14 +1447,16 @@ export function installSkills(targets, { cwd = process.cwd() } = {}) {
 
   execFileSync('npm', ['install', '--no-save', ...uniqueInstallTargets], {
     cwd: repoRoot,
+    env: buildNpmRegistryEnv(repoRoot, process.env),
     encoding: 'utf-8',
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
+  const resolvedPackageDirs = resolveInstalledPackageClosure(repoRoot, directTargetMap);
   return rebuildInstallState(repoRoot, directTargetMap, {
-    listInstalledPackageDirs,
-    parseSkillFrontmatterFile,
+    packageDirs: resolvedPackageDirs,
     readPackageMetadata,
+    readInstalledSkillExports,
     normalizeRelativePath,
   });
 }
@@ -1360,11 +1467,14 @@ export function inspectSkillsEnv({ cwd = process.cwd() } = {}) {
   const installs = Object.entries(state.installs || {})
     .sort(([a], [b]) => a.localeCompare(b))
     .map(([packageName, install]) => ({
-      ...readInstalledSkillLifecycle(repoRoot, install.source_package_path),
+      ...(install.skills?.length > 0
+        ? readInstalledSkillLifecycleFromRecord(install)
+        : readInstalledSkillLifecycle(repoRoot, install.source_package_path)),
       packageName,
       direct: install.direct,
       packageVersion: install.package_version,
       sourcePackagePath: install.source_package_path,
+      skills: install.skills || [],
       materializations: install.materializations || [],
     }));
 
@@ -1403,10 +1513,66 @@ function readInstalledSkillLifecycle(repoRoot, sourcePackagePath) {
   };
 }
 
+function readInstalledSkillLifecycleFromRecord(install) {
+  const primarySkill = (install.skills || []).find((entry) => entry.runtime_name === entry.name)
+    || (install.skills || [])[0]
+    || null;
+
+  if (!primarySkill) {
+    return {
+      requires: [],
+      status: null,
+      replacement: null,
+      message: null,
+    };
+  }
+
+  return {
+    requires: primarySkill.requires || [],
+    status: primarySkill.status || null,
+    replacement: primarySkill.replacement || null,
+    message: primarySkill.message || null,
+  };
+}
+
 function buildInstallCommand(packageName) {
   return `agentpack skills install ${packageName}`;
 }
 
+function buildInstalledRequirementSet(installs) {
+  const installed = new Set();
+
+  for (const install of installs) {
+    if (install.packageName) installed.add(install.packageName);
+    for (const skill of install.skills || []) {
+      const requirement = buildCanonicalSkillRequirement(install.packageName, skill.name);
+      if (requirement) installed.add(requirement);
+    }
+  }
+
+  return installed;
+}
+
+function buildInstalledRequirementRecords(installs) {
+  return installs.map((install) => {
+    const requires = new Set();
+
+    for (const skill of install.skills || []) {
+      for (const requirement of skill.requires || []) {
+        requires.add(requirement);
+      }
+    }
+
+    return {
+      packageName: install.packageName,
+      name: null,
+      skillFile: install.sourcePackagePath ? `${install.sourcePackagePath}/SKILL.md` : null,
+      direct: install.direct,
+      requires: [...requires].sort((a, b) => a.localeCompare(b)),
+    };
+  });
+}
+
 function listLocalWorkbenchSkillRecords(repoRoot) {
   const records = [];
 
@@ -1492,14 +1658,8 @@ export function inspectMissingSkillDependencies({
 } = {}) {
   const repoRoot = findRepoRoot(cwd);
   const env = inspectSkillsEnv({ cwd });
-  const installed = new Set(env.installs.map((install) => install.packageName));
-  const installedRecords = env.installs.map((install) => ({
-    packageName: install.packageName,
-    name: null,
-    skillFile: install.sourcePackagePath ? `${install.sourcePackagePath}/SKILL.md` : null,
-    direct: install.direct,
-    requires: install.requires,
-  }));
+  const installed = buildInstalledRequirementSet(env.installs);
+  const installedRecords = buildInstalledRequirementRecords(env.installs);
   const localWorkbenchRecords = listLocalWorkbenchSkillRecords(repoRoot);
 
   let records = [...installedRecords, ...localWorkbenchRecords];
@@ -1600,9 +1760,11 @@ export async function listOutdatedSkills({
 
 export async function inspectSkillsStatus({ cwd = process.cwd() } = {}) {
   const env = inspectSkillsEnv({ cwd });
+  const state = readInstallState(env.repoRoot);
   const registry = inspectRegistryConfig({ cwd });
   const outdatedResult = await listOutdatedSkills({ cwd });
   const missingResult = inspectMissingSkillDependencies({ cwd });
+  const runtimeInspection = inspectMaterializedSkills(env.repoRoot, state);
 
   const installedCount = env.installs.length;
   const directCount = env.installs.filter((install) => install.direct).length;
@@ -1619,13 +1781,23 @@ export async function inspectSkillsStatus({ cwd = process.cwd() } = {}) {
   const deprecatedCount = deprecated.length;
   const incomplete = missingResult.skills;
   const incompleteCount = missingResult.count;
+  const runtimeDrift = runtimeInspection.runtimeDrift;
+  const runtimeDriftCount = runtimeInspection.runtimeDriftCount;
+  const orphanedMaterializations = runtimeInspection.orphanedMaterializations;
+  const orphanedMaterializationCount = runtimeInspection.orphanedMaterializationCount;
 
   let health = 'healthy';
   if (!registry.configured) {
     health = installedCount > 0 || outdatedCount > 0 ? 'attention-needed' : 'needs-config';
-  } else if (outdatedCount > 0 || deprecatedCount > 0 || incompleteCount > 0) {
+  } else if (
+    outdatedCount > 0
+    || deprecatedCount > 0
+    || incompleteCount > 0
+    || runtimeDriftCount > 0
+    || orphanedMaterializationCount > 0
+  ) {
     health = 'attention-needed';
-  } else if (incompleteCount > 0) {
+  } else if (incompleteCount > 0 || runtimeDriftCount > 0 || orphanedMaterializationCount > 0) {
     health = 'attention-needed';
   }
 
@@ -1637,10 +1809,14 @@ export async function inspectSkillsStatus({ cwd = process.cwd() } = {}) {
     outdatedCount,
     deprecatedCount,
     incompleteCount,
+    runtimeDriftCount,
+    orphanedMaterializationCount,
     registry,
     outdated: outdatedResult.skills,
     deprecated,
     incomplete,
+    runtimeDrift,
+    orphanedMaterializations,
     installs: env.installs,
     health,
   };
@@ -1662,15 +1838,17 @@ export function uninstallSkills(target, { cwd = process.cwd() } = {}) {
   if (nextInstallTargets.length > 0) {
     execFileSync('npm', ['install', '--no-save', ...nextInstallTargets], {
       cwd: repoRoot,
+      env: buildNpmRegistryEnv(repoRoot, process.env),
       encoding: 'utf-8',
       stdio: ['pipe', 'pipe', 'pipe'],
     });
   }
 
+  const resolvedPackageDirs = resolveInstalledPackageClosure(repoRoot, nextDirectTargetMap);
   const nextState = rebuildInstallState(repoRoot, nextDirectTargetMap, {
-    listInstalledPackageDirs,
-    parseSkillFrontmatterFile,
+    packageDirs: resolvedPackageDirs,
     readPackageMetadata,
+    readInstalledSkillExports,
     normalizeRelativePath,
   });
   const remainingTargets = new Set(