@alavida/agentpack 0.1.4 → 0.1.6

package/src/commands/auth.js

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import { login } from '../application/auth/login.js';
+import { logout } from '../application/auth/logout.js';
+import { output } from '../utils/output.js';
+import { getAuthStatus } from '../application/auth/get-auth-status.js';
+
+export function authCommand() {
+  const cmd = new Command('auth')
+    .description('Configure and inspect package registry authentication');
+
+  cmd.addHelpText('after', `
+Defaults:
+  Scope: @alavida-ai
+  Registry: https://npm.pkg.github.com
+  Token: GitHub personal access token with package read access
+`);
+
+  cmd
+    .command('login')
+    .description('Configure GitHub Packages authentication for this machine')
+    .option('--scope <scope>', 'Override the package scope to configure')
+    .option('--registry <url>', 'Override the package registry URL')
+    .option('--verify-package <packageName>', 'Override the package used for live verification')
+    .action(async (opts, command) => {
+      const globalOpts = command.optsWithGlobals();
+      const result = await login({
+        scope: opts.scope || null,
+        registry: opts.registry || null,
+        verificationPackage: opts.verifyPackage || null,
+      });
+
+      if (globalOpts.json) {
+        output.json(result);
+        return;
+      }
+
+      output.write(`Configured auth for ${result.scope}`);
+      output.write(`Registry: ${result.registry}`);
+      output.write(`Storage: ${result.storage.mode}`);
+    });
+
+  cmd
+    .command('status')
+    .description('Show authentication status for the configured package registry')
+    .option('--verify', 'Check whether the stored credential works against the configured registry')
+    .action(async (opts, command) => {
+      const globalOpts = command.optsWithGlobals();
+      const result = await getAuthStatus({ verify: opts.verify });
+
+      if (globalOpts.json) {
+        output.json(result);
+        return;
+      }
+
+      output.write(`Provider: ${result.provider}`);
+      output.write(`Configured: ${result.configured}`);
+      output.write(`Storage: ${result.storage.mode}`);
+      output.write(`Verification: ${result.verification.status}`);
+    });
+
+  cmd
+    .command('logout')
+    .description('Remove configured package registry authentication')
+    .action((opts, command) => {
+      const globalOpts = command.optsWithGlobals();
+      const result = logout();
+
+      if (globalOpts.json) {
+        output.json(result);
+        return;
+      }
+
+      output.write(`Removed Credentials: ${result.removedCredentials}`);
+      output.write(`Removed npm Keys: ${result.removedNpmKeys}`);
+    });
+
+  return cmd;
+}

package/src/commands/skills.js

@@ -136,6 +136,8 @@ export function skillsCommand() {
       output.write(`Outdated Skills: ${result.outdatedCount}`);
       output.write(`Deprecated Skills: ${result.deprecatedCount}`);
       output.write(`Incomplete Skills: ${result.incompleteCount}`);
+      output.write(`Runtime Drifted Skills: ${result.runtimeDriftCount}`);
+      output.write(`Orphaned Materializations: ${result.orphanedMaterializationCount}`);
       output.write(`Registry Configured: ${result.registry.configured}`);
 
       if (result.outdated.length > 0) {
@@ -170,6 +172,28 @@ export function skillsCommand() {
           }
         }
       }
+
+      if (result.runtimeDrift.length > 0) {
+        output.write('');
+        output.write('Runtime Drift:');
+        for (const install of result.runtimeDrift) {
+          output.write(`- ${install.packageName}`);
+          for (const issue of install.issues) {
+            output.write(`  issue: ${issue.code}`);
+            output.write(`  target: ${issue.target}`);
+            if (issue.runtimeName) output.write(`  runtime: ${issue.runtimeName}`);
+          }
+        }
+      }
+
+      if (result.orphanedMaterializations.length > 0) {
+        output.write('');
+        output.write('Orphaned Materializations:');
+        for (const entry of result.orphanedMaterializations) {
+          output.write(`- ${entry.target}`);
+          output.write(`  issue: ${entry.code}`);
+        }
+      }
     });
 
   cmd
@@ -459,6 +483,9 @@ export function skillsCommand() {
         output.write(`  direct: ${install.direct}`);
         output.write(`  version: ${install.packageVersion}`);
         output.write(`  source: ${install.sourcePackagePath}`);
+        if (install.skills?.length > 0) {
+          output.write(`  skills: ${install.skills.map((skill) => skill.name).join(', ')}`);
+        }
         for (const materialization of install.materializations) {
           output.write(`  materialized: ${materialization.target} (${materialization.mode})`);
         }

package/src/domain/auth/registry-resolution.js

@@ -0,0 +1,55 @@
+function getScopedRegistry(config, scope) {
+  return config?.[`${scope}:registry`] || null;
+}
+
+function getRegistryHostKey(registry) {
+  if (!registry) return null;
+  try {
+    const url = new URL(registry);
+    return `//${url.host}/:_authToken`;
+  } catch {
+    return null;
+  }
+}
+
+function getAuthToken(config, registry) {
+  const hostKey = getRegistryHostKey(registry);
+  return hostKey ? (config?.[hostKey] || null) : null;
+}
+
+export function resolveRegistryConfig({
+  scope,
+  defaults = {},
+  userNpmrc = {},
+  repoNpmrc = {},
+} = {}) {
+  const repoRegistry = getScopedRegistry(repoNpmrc, scope);
+  if (repoRegistry) {
+    return {
+      scope,
+      registry: repoRegistry,
+      authToken: getAuthToken(repoNpmrc, repoRegistry),
+      verificationPackage: defaults.verificationPackage || null,
+      source: 'repo',
+    };
+  }
+
+  const userRegistry = getScopedRegistry(userNpmrc, scope);
+  if (userRegistry) {
+    return {
+      scope,
+      registry: userRegistry,
+      authToken: getAuthToken(userNpmrc, userRegistry),
+      verificationPackage: defaults.verificationPackage || null,
+      source: 'user',
+    };
+  }
+
+  return {
+    scope,
+    registry: defaults.registry || null,
+    authToken: null,
+    verificationPackage: defaults.verificationPackage || null,
+    source: 'default',
+  };
+}

package/src/domain/skills/skill-model.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { dirname, join, relative } from 'node:path';
 import { NotFoundError, ValidationError } from '../../utils/errors.js';
 
 function parseScalar(value) {
@@ -171,6 +171,7 @@ export function readPackageMetadata(packageDir) {
       files: null,
       repository: null,
       publishConfigRegistry: null,
+      exportedSkills: null,
     };
   }
 
@@ -183,5 +184,61 @@ export function readPackageMetadata(packageDir) {
     files: Array.isArray(pkg.files) ? pkg.files : null,
     repository: pkg.repository || null,
     publishConfigRegistry: pkg.publishConfig?.registry || null,
+    exportedSkills: pkg.agentpack?.skills || null,
   };
 }
+
+export function buildCanonicalSkillRequirement(packageName, skillName) {
+  if (!packageName || !skillName) return null;
+  return `${packageName}:${skillName}`;
+}
+
+export function readInstalledSkillExports(packageDir) {
+  const packageMetadata = readPackageMetadata(packageDir);
+  const exports = [];
+
+  if (packageMetadata.exportedSkills && typeof packageMetadata.exportedSkills === 'object') {
+    for (const [declaredName, entry] of Object.entries(packageMetadata.exportedSkills)) {
+      const relativeSkillFile = typeof entry === 'string' ? entry : entry?.path;
+      if (!relativeSkillFile) continue;
+
+      const skillFile = join(packageDir, relativeSkillFile);
+      if (!existsSync(skillFile)) continue;
+
+      const metadata = parseSkillFrontmatterFile(skillFile);
+      exports.push({
+        declaredName,
+        name: metadata.name,
+        description: metadata.description,
+        requires: metadata.requires,
+        status: metadata.status,
+        replacement: metadata.replacement,
+        message: metadata.message,
+        skillDir: dirname(skillFile),
+        skillFile,
+        relativeSkillFile,
+      });
+    }
+  }
+
+  if (exports.length > 0) {
+    return exports.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  const rootSkillFile = join(packageDir, 'SKILL.md');
+  if (!existsSync(rootSkillFile)) return [];
+
+  const metadata = parseSkillFrontmatterFile(rootSkillFile);
+  return [{
+    declaredName: metadata.name,
+    name: metadata.name,
+    description: metadata.description,
+    requires: metadata.requires,
+    status: metadata.status,
+    replacement: metadata.replacement,
+    message: metadata.message,
+    skillDir: packageDir,
+    skillFile: rootSkillFile,
+    relativeSkillFile: 'SKILL.md',
+  }];
+}

package/src/infrastructure/fs/user-config-repository.js

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const DEFAULT_CONFIG = {
+  version: 1,
+  provider: 'github-packages',
+  scope: '@alavida-ai',
+  registry: 'https://npm.pkg.github.com',
+  verificationPackage: '@alavida-ai/agentpack-auth-probe',
+  managedNpmKeys: [],
+};
+
+function resolveConfigDir(env = process.env) {
+  const xdgConfigHome = env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) return join(xdgConfigHome, 'agentpack');
+  return join(env.HOME || homedir(), '.config', 'agentpack');
+}
+
+export function getUserConfigPath({ env = process.env } = {}) {
+  return join(resolveConfigDir(env), 'config.json');
+}
+
+export function readUserConfig({ env = process.env } = {}) {
+  const configPath = getUserConfigPath({ env });
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+
+  return {
+    ...DEFAULT_CONFIG,
+    ...JSON.parse(readFileSync(configPath, 'utf-8')),
+  };
+}
+
+export function writeUserConfig(config, { env = process.env } = {}) {
+  const configPath = getUserConfigPath({ env });
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}

package/src/infrastructure/fs/user-credentials-repository.js

@@ -0,0 +1,30 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function resolveConfigDir(env = process.env) {
+  const xdgConfigHome = env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) return join(xdgConfigHome, 'agentpack');
+  return join(env.HOME || homedir(), '.config', 'agentpack');
+}
+
+export function getUserCredentialsPath({ env = process.env } = {}) {
+  return join(resolveConfigDir(env), 'credentials.json');
+}
+
+export function readUserCredentials({ env = process.env } = {}) {
+  const credentialsPath = getUserCredentialsPath({ env });
+  if (!existsSync(credentialsPath)) return null;
+  return JSON.parse(readFileSync(credentialsPath, 'utf-8'));
+}
+
+export function writeUserCredentials(credentials, { env = process.env } = {}) {
+  const credentialsPath = getUserCredentialsPath({ env });
+  mkdirSync(dirname(credentialsPath), { recursive: true });
+  writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2) + '\n', { mode: 0o600 });
+  chmodSync(credentialsPath, 0o600);
+}
+
+export function deleteUserCredentials({ env = process.env } = {}) {
+  rmSync(getUserCredentialsPath({ env }), { force: true });
+}

package/src/infrastructure/fs/user-npmrc-repository.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function parseNpmrc(content) {
+  const config = {};
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+    const eqIndex = line.indexOf('=');
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    const value = line.slice(eqIndex + 1).trim();
+    config[key] = value;
+  }
+  return config;
+}
+
+export function getUserNpmrcPath({ env = process.env } = {}) {
+  return join(env.HOME || homedir(), '.npmrc');
+}
+
+export function readUserNpmrc({ env = process.env } = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  if (!existsSync(npmrcPath)) return {};
+  return parseNpmrc(readFileSync(npmrcPath, 'utf-8'));
+}
+
+function upsertLine(lines, key, value) {
+  const prefix = `${key}=`;
+  const nextLine = `${key}=${value}`;
+  const index = lines.findIndex((line) => line.trim().startsWith(prefix));
+  if (index === -1) {
+    lines.push(nextLine);
+    return;
+  }
+  lines[index] = nextLine;
+}
+
+function removeLine(lines, key) {
+  const prefix = `${key}=`;
+  return lines.filter((line) => !line.trim().startsWith(prefix));
+}
+
+export function writeManagedNpmrcEntries({
+  entries,
+  env = process.env,
+} = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  const lines = existsSync(npmrcPath)
+    ? readFileSync(npmrcPath, 'utf-8').split('\n').filter((line, index, all) => !(index === all.length - 1 && line === ''))
+    : [];
+
+  for (const [key, value] of Object.entries(entries)) {
+    upsertLine(lines, key, value);
+  }
+
+  writeFileSync(npmrcPath, `${lines.join('\n')}\n`);
+}
+
+export function removeManagedNpmrcEntries({
+  keys,
+  env = process.env,
+} = {}) {
+  const npmrcPath = getUserNpmrcPath({ env });
+  if (!existsSync(npmrcPath)) return;
+
+  let lines = readFileSync(npmrcPath, 'utf-8').split('\n').filter((line, index, all) => !(index === all.length - 1 && line === ''));
+  for (const key of keys) {
+    lines = removeLine(lines, key);
+  }
+
+  writeFileSync(npmrcPath, `${lines.join('\n')}\n`);
+}

package/src/infrastructure/runtime/inspect-materialized-skills.js

@@ -0,0 +1,153 @@
+import { lstatSync, readlinkSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { readDevSession } from '../fs/dev-session-repository.js';
+
+function readPathType(pathValue) {
+  try {
+    const stat = lstatSync(pathValue);
+    return {
+      exists: true,
+      isSymlink: stat.isSymbolicLink(),
+      type: stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other',
+    };
+  } catch {
+    return {
+      exists: false,
+      isSymlink: false,
+      type: null,
+    };
+  }
+}
+
+export function inspectRecordedMaterialization(repoRoot, {
+  target,
+  expectedSourcePath,
+  packageName,
+  runtimeName = null,
+} = {}) {
+  const absTarget = resolve(repoRoot, target);
+  const expectedTarget = resolve(repoRoot, expectedSourcePath);
+  const pathState = readPathType(absTarget);
+
+  if (!pathState.exists) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'missing_path',
+    };
+  }
+
+  if (!pathState.isSymlink) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'wrong_type',
+      actualType: pathState.type,
+    };
+  }
+
+  const rawLinkTarget = readlinkSync(absTarget);
+  const actualTarget = resolve(join(absTarget, '..'), rawLinkTarget);
+  if (actualTarget !== expectedTarget) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'wrong_target',
+      actualTarget,
+    };
+  }
+
+  const resolvedState = readPathType(actualTarget);
+  if (!resolvedState.exists) {
+    return {
+      packageName,
+      runtimeName,
+      target,
+      expectedSourcePath,
+      code: 'dangling_target',
+      actualTarget,
+    };
+  }
+
+  return null;
+}
+
+export function inspectMaterializedSkills(repoRoot, state) {
+  const runtimeDrift = [];
+  const ownedTargets = new Set();
+  const devSession = readDevSession(repoRoot);
+
+  if (devSession?.status === 'active') {
+    for (const target of devSession.links || []) {
+      ownedTargets.add(target);
+    }
+  }
+
+  for (const [packageName, install] of Object.entries(state.installs || {})) {
+    const issues = [];
+
+    for (const skill of install.skills || []) {
+      for (const materialization of skill.materializations || []) {
+        ownedTargets.add(materialization.target);
+        const issue = inspectRecordedMaterialization(repoRoot, {
+          target: materialization.target,
+          expectedSourcePath: skill.source_skill_path,
+          packageName,
+          runtimeName: skill.runtime_name,
+        });
+        if (issue) issues.push(issue);
+      }
+    }
+
+    if (issues.length > 0) {
+      runtimeDrift.push({
+        packageName,
+        issues,
+      });
+    }
+  }
+
+  const orphanedMaterializations = [];
+  for (const root of [
+    join(repoRoot, '.claude', 'skills'),
+    join(repoRoot, '.agents', 'skills'),
+  ]) {
+    let entries = [];
+    try {
+      entries = readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const relativeTarget = root.startsWith(join(repoRoot, '.claude'))
+        ? `.claude/skills/${entry.name}`
+        : `.agents/skills/${entry.name}`;
+      if (ownedTargets.has(relativeTarget)) continue;
+
+      const absPath = join(root, entry.name);
+      const pathState = readPathType(absPath);
+      orphanedMaterializations.push({
+        target: relativeTarget,
+        code: 'orphaned_materialization',
+        actualType: pathState.isSymlink ? 'symlink' : pathState.type,
+      });
+    }
+  }
+
+  runtimeDrift.sort((a, b) => a.packageName.localeCompare(b.packageName));
+  orphanedMaterializations.sort((a, b) => a.target.localeCompare(b.target));
+
+  return {
+    runtimeDriftCount: runtimeDrift.length,
+    runtimeDrift,
+    orphanedMaterializationCount: orphanedMaterializations.length,
+    orphanedMaterializations,
+  };
+}