@agent-nexus/csreg 0.1.0

package/src/commands/pull.ts

@@ -0,0 +1,276 @@
+import { Command } from 'commander';
+import { resolve, join, dirname } from 'node:path';
+import { mkdirSync, writeFileSync, existsSync, readFileSync, renameSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { confirm } from '@inquirer/prompts';
+import { ApiClient } from '../api-client.js';
+import { extract } from '../lib/archive.js';
+import { findClaudeSkillsDir } from '../lib/discovery.js';
+import { spinner, success, info, warn } from '../lib/output.js';
+import { handleError, CliError } from '../lib/errors.js';
+
+interface DownloadResponse {
+  downloadUrl: string;
+  archiveSha256: string;
+  archiveSizeBytes: number;
+  version: string;
+}
+
+interface SkillLockEntry {
+  ref: string;
+  version?: string;
+}
+
+interface SkillsConfig {
+  skills: SkillLockEntry[];
+}
+
+function parseSkillRef(ref: string): { scope: string; name: string; version?: string } {
+  // Strip leading @ (e.g., @nexus/newsletter → nexus/newsletter)
+  const cleaned = ref.startsWith('@') ? ref.slice(1) : ref;
+
+  // Check for version suffix: nexus/newsletter@1.0.0
+  const atIndex = cleaned.lastIndexOf('@');
+  let scopeAndName: string;
+  let version: string | undefined;
+
+  if (atIndex > 0) {
+    scopeAndName = cleaned.slice(0, atIndex);
+    version = cleaned.slice(atIndex + 1);
+  } else {
+    scopeAndName = cleaned;
+  }
+
+  const slashIndex = scopeAndName.indexOf('/');
+  if (slashIndex < 0) {
+    throw new CliError(`Invalid skill reference: ${ref}`, [
+      'Use the format: @scope/name or @scope/name@version',
+    ]);
+  }
+
+  return {
+    scope: scopeAndName.slice(0, slashIndex),
+    name: scopeAndName.slice(slashIndex + 1),
+    version,
+  };
+}
+
+/**
+ * Read the skills config file (.claude/skills.json).
+ */
+function readSkillsConfig(): SkillsConfig | null {
+  // Look for .claude/skills.json by walking up
+  let dir = resolve('.');
+  while (dir !== dirname(dir)) {
+    const configPath = join(dir, '.claude', 'skills.json');
+    if (existsSync(configPath)) {
+      try {
+        const raw = readFileSync(configPath, 'utf-8');
+        return JSON.parse(raw) as SkillsConfig;
+      } catch {
+        throw new CliError('Failed to parse .claude/skills.json', [
+          'Check that the file is valid JSON.',
+        ]);
+      }
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Pull a single skill to a target directory.
+ */
+async function pullSkill(
+  scope: string,
+  name: string,
+  version: string | undefined,
+  targetDir: string,
+): Promise<{ version: string }> {
+  const spin = spinner(`Fetching ${scope}/${name}${version ? `@${version}` : ''}...`);
+
+  const client = new ApiClient();
+  const query: Record<string, string> = {};
+  if (version) {
+    query.version = version;
+  }
+
+  const downloadInfo = await client.get<DownloadResponse>(
+    `/api/v1/skills/${scope}/${name}/download`,
+    { query },
+  );
+  spin.succeed(`Found ${scope}/${name}@${downloadInfo.version}`);
+
+  // Download the archive
+  spin.start('Downloading archive...');
+  const response = await fetch(downloadInfo.downloadUrl);
+  if (!response.ok) {
+    spin.fail('Download failed.');
+    throw new CliError(`Download failed with status ${response.status}.`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  const archiveData = Buffer.from(arrayBuffer);
+
+  // Verify SHA-256
+  const actualSha = createHash('sha256').update(archiveData).digest('hex');
+  if (actualSha !== downloadInfo.archiveSha256) {
+    spin.fail('Integrity check failed.');
+    throw new CliError(
+      `SHA-256 mismatch: expected ${downloadInfo.archiveSha256}, got ${actualSha}`,
+      ['The archive may be corrupted. Try again.'],
+    );
+  }
+  spin.succeed('Downloaded and verified.');
+
+  // Ensure target directory exists
+  mkdirSync(targetDir, { recursive: true });
+
+  // Write temp file and extract to a temp location, then move
+  spin.start('Installing...');
+  const tempDir = join(dirname(targetDir), `.csreg-tmp-${Date.now()}`);
+  mkdirSync(tempDir, { recursive: true });
+  const tempArchive = join(tempDir, `${name}.tar.gz`);
+  writeFileSync(tempArchive, archiveData);
+
+  try {
+    await extract(tempArchive, tempDir, downloadInfo.archiveSha256);
+
+    // The archive extracts to tempDir/<name>/ — move contents to targetDir
+    const extractedDir = join(tempDir, name);
+    const finalDir = join(targetDir, name);
+
+    // Remove existing skill directory if it exists (update)
+    if (existsSync(finalDir)) {
+      // Remove recursively
+      const { rmSync } = await import('node:fs');
+      rmSync(finalDir, { recursive: true });
+    }
+
+    renameSync(extractedDir, finalDir);
+    spin.succeed(`Installed to ${finalDir}`);
+
+    return { version: downloadInfo.version };
+  } finally {
+    // Clean up temp dir
+    try {
+      const { rmSync } = await import('node:fs');
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}
+
+export const pullCommand = new Command('pull')
+  .description('Download and install a skill')
+  .argument('[ref]', 'Skill reference (@scope/name[@version])')
+  .option('--all', 'Pull all skills listed in .claude/skills.json')
+  .option('--path <dir>', 'Custom install directory (overrides auto-detection)')
+  .action(async (ref: string | undefined, opts: { all?: boolean; path?: string }) => {
+    try {
+      // --- Mode: pull --all from skills.json ---
+      if (opts.all) {
+        const config = readSkillsConfig();
+        if (!config) {
+          throw new CliError('No .claude/skills.json found.', [
+            'Create .claude/skills.json with a "skills" array.',
+            'Example:\n  {\n    "skills": [\n      { "ref": "@nexus/newsletter" },\n      { "ref": "@nexus/code-review", "version": "1.2.0" }\n    ]\n  }',
+          ]);
+        }
+
+        if (!config.skills || config.skills.length === 0) {
+          info('No skills listed in .claude/skills.json. Nothing to pull.');
+          return;
+        }
+
+        // Determine target
+        const skillsDir = opts.path ? resolve(opts.path) : findClaudeSkillsDir();
+        if (!skillsDir) {
+          throw new CliError('Cannot find .claude/ directory.', [
+            'Run this from a project with a .claude/ directory, or use --path.',
+          ]);
+        }
+
+        console.log(`Installing ${config.skills.length} skill(s) to ${skillsDir}/\n`);
+
+        let installed = 0;
+        for (const entry of config.skills) {
+          try {
+            const { scope, name, version } = parseSkillRef(entry.ref);
+            const ver = entry.version || version;
+            await pullSkill(scope, name, ver, skillsDir);
+            installed++;
+            console.log('');
+          } catch (err) {
+            warn(`Failed to pull ${entry.ref}: ${err instanceof Error ? err.message : String(err)}`);
+            console.log('');
+          }
+        }
+
+        console.log('');
+        success(`Installed ${installed}/${config.skills.length} skill(s).`);
+        return;
+      }
+
+      // --- Mode: pull single skill ---
+      if (!ref) {
+        throw new CliError('Missing skill reference.', [
+          'Usage: csreg pull @scope/name[@version]',
+          'Or use: csreg pull --all  (to pull from .claude/skills.json)',
+        ]);
+      }
+
+      const { scope, name, version } = parseSkillRef(ref);
+
+      // Determine install target
+      let targetDir: string;
+
+      if (opts.path) {
+        targetDir = resolve(opts.path);
+      } else {
+        const detected = findClaudeSkillsDir();
+
+        if (detected) {
+          targetDir = detected;
+          const finalPath = join(detected, name);
+          const ok = await confirm({
+            message: `Install to ${finalPath}?`,
+            default: true,
+          });
+          if (!ok) {
+            const { input } = await import('@inquirer/prompts');
+            const custom = await input({
+              message: 'Custom install path:',
+              default: join('.', '.claude', 'skills'),
+            });
+            targetDir = resolve(custom);
+          }
+        } else {
+          // No .claude/ found — default to .claude/skills/ in cwd
+          targetDir = join(resolve('.'), '.claude', 'skills');
+          info(`No .claude/ directory found. Will create ${targetDir}/`);
+          const ok = await confirm({
+            message: `Install to ${join(targetDir, name)}?`,
+            default: true,
+          });
+          if (!ok) {
+            const { input } = await import('@inquirer/prompts');
+            const custom = await input({
+              message: 'Custom install path:',
+              default: targetDir,
+            });
+            targetDir = resolve(custom);
+          }
+        }
+      }
+
+      const result = await pullSkill(scope, name, version, targetDir);
+
+      console.log('');
+      success(`Pulled ${scope}/${name}@${result.version}`);
+      info(`Skill is ready at ${join(targetDir, name)}/SKILL.md`);
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/push.ts

@@ -0,0 +1,228 @@
+import { Command } from 'commander';
+import { resolve, join, basename } from 'node:path';
+import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { runValidation } from './validate.js';
+import { pack as archivePack } from '../lib/archive.js';
+import { parseManifest } from '../lib/manifest.js';
+import { findClaudeSkillsDir, discoverSkillDirs } from '../lib/discovery.js';
+import { ApiClient } from '../api-client.js';
+import { spinner, success, warn } from '../lib/output.js';
+import { handleError, CliError } from '../lib/errors.js';
+import { getAuthToken } from '../config.js';
+
+interface PrepareResponse {
+  versionId: string;
+  uploadUrl: string;
+}
+
+function collectFileTree(dir: string, prefix = ''): Array<{ path: string; size: number; sha256: string }> {
+  const files: Array<{ path: string; size: number; sha256: string }> = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const fullPath = join(dir, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      files.push(...collectFileTree(fullPath, relativePath));
+    } else {
+      const stat = statSync(fullPath);
+      const content = readFileSync(fullPath);
+      const sha256 = createHash('sha256').update(content).digest('hex');
+      files.push({ path: relativePath, size: stat.size, sha256 });
+    }
+  }
+  return files;
+}
+
+/**
+ * Push a single skill directory to the registry.
+ * Returns the published version string, or throws on failure.
+ */
+async function pushSingle(resolved: string): Promise<string> {
+  // Step 1: Validate
+  const spin = spinner('Validating skill...');
+  const validation = runValidation(resolved);
+  if (!validation.valid) {
+    spin.fail('Validation failed.');
+    for (const e of validation.errors) {
+      console.error('  ' + e);
+    }
+    throw new CliError('Fix validation errors before pushing.');
+  }
+  spin.succeed('Validation passed.');
+
+  // Step 2: Parse manifest from SKILL.md frontmatter
+  const manifest = parseManifest(resolved);
+
+  if (!manifest.version) {
+    throw new CliError('Missing "version" in SKILL.md frontmatter.', [
+      'Add a version field: version: "1.0.0"',
+    ]);
+  }
+  if (!manifest.scope) {
+    throw new CliError('Missing "scope" in SKILL.md frontmatter.', [
+      'Add a scope field: scope: my-team',
+    ]);
+  }
+
+  // Step 3: Pack
+  spin.start('Packing skill...');
+  const archive = await archivePack(resolved);
+  spin.succeed(`Packed (${(archive.size / 1024).toFixed(1)}KB).`);
+
+  // Step 4: Ensure skill exists in registry (auto-create on first push)
+  const client = new ApiClient();
+  spin.start('Checking registry...');
+  try {
+    await client.get(`/api/v1/skills/${manifest.scope}/${manifest.name}`);
+    spin.succeed('Skill found in registry.');
+  } catch {
+    spin.start(`Creating skill ${manifest.scope}/${manifest.name}...`);
+    await client.post('/api/v1/skills', {
+      body: {
+        scope: manifest.scope,
+        slug: manifest.name,
+        displayName: manifest.name,
+        description: manifest.description || '',
+        tags: manifest.tags || [],
+      },
+    });
+    spin.succeed(`Created skill ${manifest.scope}/${manifest.name}.`);
+  }
+
+  // Step 5: Prepare version
+  spin.start('Preparing version...');
+  const fileTree = collectFileTree(resolved);
+
+  const prepared = await client.post<PrepareResponse>(
+    `/api/v1/skills/${manifest.scope}/${manifest.name}/versions`,
+    {
+      body: {
+        version: manifest.version,
+        fileTree,
+        archiveSha256: archive.sha256,
+        archiveSize: archive.size,
+        entryPoint: 'SKILL.md',
+        manifestJson: {
+          name: manifest.name,
+          description: manifest.description,
+          version: manifest.version,
+          scope: manifest.scope,
+          'allowed-tools': manifest['allowed-tools'],
+          'argument-hint': manifest['argument-hint'],
+          'disable-model-invocation': manifest['disable-model-invocation'],
+          'user-invocable': manifest['user-invocable'],
+          tags: manifest.tags,
+        },
+      },
+    },
+  );
+  spin.succeed('Version prepared.');
+
+  // Step 6: Upload to presigned URL
+  spin.start('Uploading archive...');
+  const archiveData = readFileSync(archive.path);
+  const uploadResponse = await fetch(prepared.uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': 'application/gzip',
+      'Content-Length': String(archive.size),
+    },
+    body: archiveData,
+  });
+
+  if (!uploadResponse.ok) {
+    spin.fail('Upload failed.');
+    throw new CliError(`Upload failed with status ${uploadResponse.status}.`, [
+      'Try again. If the problem persists, contact support.',
+    ]);
+  }
+  spin.succeed('Archive uploaded.');
+
+  // Step 7: Finalize
+  spin.start('Finalizing version...');
+  await client.post(
+    `/api/v1/skills/${manifest.scope}/${manifest.name}/versions/${manifest.version}/finalize`,
+    {
+      body: { status: 'published' },
+    },
+  );
+  spin.succeed('Version finalized.');
+
+  return `${manifest.scope}/${manifest.name}@${manifest.version}`;
+}
+
+export const pushCommand = new Command('push')
+  .description('Publish a skill to the registry')
+  .argument('[dir]', 'Skill directory', '.')
+  .option('--all', 'Push all skills in .claude/skills/')
+  .action(async (dir: string, opts: { all?: boolean }) => {
+    try {
+      if (!getAuthToken()) {
+        throw new CliError('Not logged in.', ['Run `csreg login` to authenticate.']);
+      }
+
+      // --- Mode: push --all ---
+      if (opts.all) {
+        const skillsDir = findClaudeSkillsDir();
+        if (!skillsDir) {
+          throw new CliError('Cannot find .claude/skills/ directory.', [
+            'Run this from a project with a .claude/ directory.',
+          ]);
+        }
+
+        const skillDirs = discoverSkillDirs(skillsDir);
+        if (skillDirs.length === 0) {
+          throw new CliError(`No skills found in ${skillsDir}/`, [
+            'Skills must be directories containing a SKILL.md file.',
+          ]);
+        }
+
+        console.log(`Pushing ${skillDirs.length} skill(s) from ${skillsDir}/\n`);
+
+        let published = 0;
+        let failed = 0;
+
+        for (const skillDir of skillDirs) {
+          const name = basename(skillDir);
+          console.log(`\n--- ${name} ---\n`);
+
+          try {
+            const ref = await pushSingle(skillDir);
+            success(`Published ${ref}`);
+            published++;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warn(`Failed to push ${name}: ${msg}`);
+            failed++;
+          }
+        }
+
+        console.log(`\n${'─'.repeat(40)}\n`);
+        if (failed === 0) {
+          success(`All ${published} skill(s) published.`);
+        } else {
+          success(`Published ${published}/${published + failed} skill(s).`);
+          if (failed > 0) {
+            warn(`${failed} skill(s) failed. Check the errors above.`);
+          }
+        }
+        return;
+      }
+
+      // --- Mode: push single ---
+      const resolved = resolve(dir);
+      if (!existsSync(resolved)) {
+        throw new CliError(`Directory not found: ${resolved}`);
+      }
+
+      const ref = await pushSingle(resolved);
+      console.log('');
+      success(`Published ${ref}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/search.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api-client.js';
+import { formatTable, info } from '../lib/output.js';
+import { handleError } from '../lib/errors.js';
+
+interface SearchResult {
+  scope: string;
+  name: string;
+  description?: string;
+  totalDownloads: number;
+  latestVersion: string;
+}
+
+interface SearchResponse {
+  skills: SearchResult[];
+  total: number;
+}
+
+export const searchCommand = new Command('search')
+  .description('Search for skills in the registry')
+  .argument('<query>', 'Search query')
+  .option('-t, --type <type>', 'Filter by skill type')
+  .option('-l, --limit <limit>', 'Max results', '20')
+  .action(async (query: string, opts: { type?: string; limit: string }) => {
+    try {
+      const client = new ApiClient();
+      const queryParams: Record<string, string> = {
+        q: query,
+        limit: opts.limit,
+      };
+      if (opts.type) {
+        queryParams.type = opts.type;
+      }
+
+      const data = await client.get<SearchResponse>('/api/v1/skills', {
+        query: queryParams,
+      });
+
+      if (data.skills.length === 0) {
+        info(`No skills found for "${query}".`);
+        return;
+      }
+
+      const rows = data.skills.map(s => [
+        `${s.scope}/${s.name}`,
+        s.description?.slice(0, 50) ?? '',
+        String(s.totalDownloads),
+        s.latestVersion,
+      ]);
+
+      console.log('');
+      console.log(formatTable(['Skill', 'Description', 'Downloads', 'Version'], rows));
+      console.log('');
+      info(`Showing ${data.skills.length} of ${data.total} results.`);
+    } catch (err) {
+      handleError(err);
+    }
+  });