cli4ai 0.9.2 → 1.0.1

package/src/core/registry.ts

@@ -0,0 +1,165 @@
+/**
+ * Package Registry
+ *
+ * Fetches and caches package metadata from cli4ai.com registry.
+ * Provides integrity hashes for verification.
+ */
+
+import { createHash } from 'crypto';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const REGISTRY_URL = 'https://cli4ai.com/registry/packages.json';
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+interface RegistryPackage {
+  name: string;
+  version: string;
+  description: string;
+  integrity: string;
+  readme: string;
+  commands: Record<string, { description: string; args?: Array<{ name: string; required: boolean }> }>;
+  dependencies: Record<string, string>;
+  env: Record<string, { required: boolean; description: string }>;
+  category: string;
+  keywords: string[];
+  author: string;
+  license: string;
+  runtime: string;
+  mcp: boolean;
+  repository: string;
+  homepage: string;
+  npm: string;
+  updatedAt: string;
+}
+
+interface Registry {
+  version: number;
+  generatedAt: string;
+  packages: RegistryPackage[];
+}
+
+// In-memory cache
+let cachedRegistry: Registry | null = null;
+let cacheTimestamp = 0;
+
+/**
+ * Fetch registry from cli4ai.com
+ */
+export async function fetchRegistry(): Promise<Registry | null> {
+  // Return cached if fresh
+  if (cachedRegistry && Date.now() - cacheTimestamp < CACHE_TTL) {
+    return cachedRegistry;
+  }
+
+  try {
+    const response = await fetch(REGISTRY_URL, {
+      headers: { 'Accept': 'application/json' },
+      signal: AbortSignal.timeout(10000), // 10 second timeout
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const registry = await response.json() as Registry;
+    cachedRegistry = registry;
+    cacheTimestamp = Date.now();
+    return registry;
+  } catch {
+    // Return cached even if stale, or null if no cache
+    return cachedRegistry;
+  }
+}
+
+/**
+ * Get package info from registry
+ */
+export async function getRegistryPackage(name: string): Promise<RegistryPackage | null> {
+  const registry = await fetchRegistry();
+  if (!registry) return null;
+
+  return registry.packages.find(p => p.name === name) || null;
+}
+
+/**
+ * Get integrity hash for a package from registry
+ */
+export async function getRegistryIntegrity(name: string): Promise<string | null> {
+  const pkg = await getRegistryPackage(name);
+  return pkg?.integrity || null;
+}
+
+/**
+ * Get all package names from registry
+ */
+export async function getRegistryPackageNames(): Promise<string[]> {
+  const registry = await fetchRegistry();
+  if (!registry) return [];
+  return registry.packages.map(p => p.name);
+}
+
+/**
+ * Compute SHA-512 integrity hash for a directory
+ * Same algorithm as used by generate-registry.ts
+ */
+export function computeDirectoryIntegrity(dirPath: string): string {
+  const hash = createHash('sha512');
+
+  function processDir(dir: string) {
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) =>
+      a.name.localeCompare(b.name)
+    );
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+
+      // Skip node_modules and hidden files
+      if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        processDir(fullPath);
+      } else if (entry.isFile()) {
+        // Include relative path in hash for structure integrity
+        const relativePath = fullPath.slice(dirPath.length + 1);
+        hash.update(relativePath);
+        hash.update(readFileSync(fullPath));
+      }
+    }
+  }
+
+  processDir(dirPath);
+  return `sha512-${hash.digest('base64')}`;
+}
+
+/**
+ * Verify package integrity against registry
+ */
+export async function verifyPackageIntegrity(
+  packageName: string,
+  packagePath: string
+): Promise<{ valid: boolean; expected: string | null; actual: string }> {
+  const expected = await getRegistryIntegrity(packageName);
+  const actual = computeDirectoryIntegrity(packagePath);
+
+  if (!expected) {
+    // Package not in registry, can't verify
+    return { valid: true, expected: null, actual };
+  }
+
+  return {
+    valid: expected === actual,
+    expected,
+    actual,
+  };
+}
+
+/**
+ * Clear the registry cache
+ */
+export function clearRegistryCache(): void {
+  cachedRegistry = null;
+  cacheTimestamp = 0;
+}

package/src/commands/init.test.ts

@@ -1,211 +0,0 @@
-/**
- * Integration tests for init command
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { initCommand } from './init.js';
-
-describe('init command', () => {
-  let tempDir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-init-test-'));
-    originalCwd = process.cwd();
-    process.chdir(tempDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('with name argument (creates subdirectory)', () => {
-    test('creates cli4ai.json in subdirectory', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'cli4ai.json'))).toBe(true);
-    });
-
-    test('creates run.ts entry file in subdirectory', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'run.ts'))).toBe(true);
-    });
-
-    test('creates README.md and package.json', async () => {
-      await initCommand('test-tool', {});
-
-      expect(existsSync(join(tempDir, 'test-tool', 'README.md'))).toBe(true);
-      expect(existsSync(join(tempDir, 'test-tool', 'package.json'))).toBe(true);
-    });
-
-    test('creates the subdirectory', async () => {
-      await initCommand('new-project', {});
-
-      expect(existsSync(join(tempDir, 'new-project'))).toBe(true);
-    });
-  });
-
-  describe('without name argument (uses current directory)', () => {
-    test('creates cli4ai.json in current directory', async () => {
-      await initCommand(undefined, {});
-
-      expect(existsSync(join(tempDir, 'cli4ai.json'))).toBe(true);
-    });
-
-    test('creates run.ts entry file', async () => {
-      await initCommand(undefined, {});
-
-      expect(existsSync(join(tempDir, 'run.ts'))).toBe(true);
-    });
-
-    test('uses directory name as package name', async () => {
-      await initCommand(undefined, {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'cli4ai.json'), 'utf-8'));
-      // Name is normalized from the temp dir name
-      expect(manifest.name).toBeDefined();
-      expect(typeof manifest.name).toBe('string');
-    });
-  });
-
-  describe('manifest content', () => {
-    test('manifest has correct name', async () => {
-      await initCommand('my-cool-tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'my-cool-tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.name).toBe('my-cool-tool');
-    });
-
-    test('manifest has default version', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.version).toBe('1.0.0');
-    });
-
-    test('manifest has default runtime node', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('node');
-    });
-
-    test('manifest has entry pointing to run.ts', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-    });
-
-    test('manifest has hello command defined', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.commands?.hello).toBeDefined();
-      expect(manifest.commands?.hello?.description).toBe('Say hello');
-    });
-
-    test('manifest includes dependencies', async () => {
-      await initCommand('tool', {});
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.dependencies).toBeDefined();
-      expect(manifest.dependencies['@cli4ai/lib']).toBeDefined();
-      expect(manifest.dependencies['commander']).toBeDefined();
-    });
-  });
-
-  describe('entry file content', () => {
-    test('run.ts starts with tsx shebang', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content.startsWith('#!/usr/bin/env npx tsx')).toBe(true);
-    });
-
-    test('run.ts has hello command', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content).toContain('hello');
-    });
-
-    test('run.ts uses cli4ai SDK helpers', async () => {
-      await initCommand('tool', {});
-
-      const content = readFileSync(join(tempDir, 'tool', 'run.ts'), 'utf-8');
-      expect(content).toContain("@cli4ai/lib");
-      expect(content).toContain('output(');
-    });
-  });
-
-  describe('runtime option', () => {
-    test('respects runtime option', async () => {
-      await initCommand('tool', { runtime: 'bun' });
-
-      const manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.runtime).toBe('bun');
-    });
-
-    test('both runtimes use run.ts with tsx', async () => {
-      // Node runtime (default)
-      await initCommand('tool', { runtime: 'node' });
-      let manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
-
-      // Bun runtime
-      rmSync(join(tempDir, 'tool'), { recursive: true, force: true });
-      await initCommand('tool', { runtime: 'bun' });
-      manifest = JSON.parse(readFileSync(join(tempDir, 'tool', 'cli4ai.json'), 'utf-8'));
-      expect(manifest.entry).toBe('run.ts');
-      expect(existsSync(join(tempDir, 'tool', 'run.ts'))).toBe(true);
-    });
-  });
-
-  describe('test scaffolding', () => {
-    test('creates vitest.config.ts', async () => {
-      await initCommand('tool', {});
-      expect(existsSync(join(tempDir, 'tool', 'vitest.config.ts'))).toBe(true);
-    });
-
-    test('creates run.test.ts with vitest imports', async () => {
-      await initCommand('tool', {});
-      const content = readFileSync(join(tempDir, 'tool', 'run.test.ts'), 'utf-8');
-      expect(content).toContain("from 'vitest'");
-      expect(content).toContain('describe(');
-    });
-
-    test('package.json has vitest dev dependency', async () => {
-      await initCommand('tool', {});
-      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
-      expect(pkg.devDependencies).toBeDefined();
-      expect(pkg.devDependencies['vitest']).toBeDefined();
-      expect(pkg.devDependencies['tsx']).toBeDefined();
-    });
-
-    test('package.json has test script', async () => {
-      await initCommand('tool', {});
-      const pkg = JSON.parse(readFileSync(join(tempDir, 'tool', 'package.json'), 'utf-8'));
-      expect(pkg.scripts?.test).toBe('vitest run');
-    });
-  });
-
-  describe('tsconfig.json', () => {
-    test('creates tsconfig.json', async () => {
-      await initCommand('tool', {});
-      expect(existsSync(join(tempDir, 'tool', 'tsconfig.json'))).toBe(true);
-    });
-
-    test('tsconfig uses NodeNext module resolution', async () => {
-      await initCommand('tool', {});
-      const tsconfig = JSON.parse(readFileSync(join(tempDir, 'tool', 'tsconfig.json'), 'utf-8'));
-      expect(tsconfig.compilerOptions.moduleResolution).toBe('NodeNext');
-    });
-  });
-});

package/src/core/config.test.ts

@@ -1,188 +0,0 @@
-/**
- * Tests for config.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import {
-  ensureLocalDir,
-  getGlobalPackages,
-  getLocalPackages,
-  findPackage,
-  LOCAL_DIR,
-  LOCAL_PACKAGES_DIR,
-  DEFAULT_CONFIG
-} from './config.js';
-
-describe('config', () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-config-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  describe('DEFAULT_CONFIG', () => {
-    test('has expected defaults', () => {
-      expect(DEFAULT_CONFIG.registry).toBe('https://registry.cli4ai.com');
-      expect(DEFAULT_CONFIG.localRegistries).toEqual([]);
-      expect(DEFAULT_CONFIG.defaultRuntime).toBe('node');
-      expect(DEFAULT_CONFIG.mcp.transport).toBe('stdio');
-      expect(DEFAULT_CONFIG.telemetry).toBe(false);
-    });
-  });
-
-  describe('ensureLocalDir', () => {
-    test('creates .cli4ai directory', () => {
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_DIR))).toBe(true);
-    });
-
-    test('creates packages subdirectory', () => {
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_PACKAGES_DIR))).toBe(true);
-    });
-
-    test('is idempotent', () => {
-      ensureLocalDir(tempDir);
-      ensureLocalDir(tempDir);
-
-      expect(existsSync(join(tempDir, LOCAL_PACKAGES_DIR))).toBe(true);
-    });
-  });
-
-  describe('getLocalPackages', () => {
-    test('returns empty array when no packages dir', () => {
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns empty array when packages dir empty', () => {
-      ensureLocalDir(tempDir);
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns installed packages', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a mock package
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'test-tool');
-      mkdirSync(pkgDir);
-      writeFileSync(
-        join(pkgDir, 'cli4ai.json'),
-        JSON.stringify({
-          name: 'test-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const packages = getLocalPackages(tempDir);
-
-      expect(packages).toHaveLength(1);
-      expect(packages[0].name).toBe('test-tool');
-      expect(packages[0].version).toBe('1.0.0');
-    });
-
-    test('ignores directories without manifest', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a directory without cli4ai.json
-      const invalidDir = join(tempDir, LOCAL_PACKAGES_DIR, 'invalid');
-      mkdirSync(invalidDir);
-      writeFileSync(join(invalidDir, 'readme.txt'), 'not a package');
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('ignores files in packages dir', () => {
-      ensureLocalDir(tempDir);
-
-      // Create a file instead of directory
-      writeFileSync(
-        join(tempDir, LOCAL_PACKAGES_DIR, 'somefile.txt'),
-        'not a package'
-      );
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('handles invalid JSON gracefully', () => {
-      ensureLocalDir(tempDir);
-
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'bad-json');
-      mkdirSync(pkgDir);
-      writeFileSync(join(pkgDir, 'cli4ai.json'), 'invalid json');
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toEqual([]);
-    });
-
-    test('returns multiple packages', () => {
-      ensureLocalDir(tempDir);
-
-      // Create multiple packages
-      for (const name of ['pkg-a', 'pkg-b', 'pkg-c']) {
-        const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, name);
-        mkdirSync(pkgDir);
-        writeFileSync(
-          join(pkgDir, 'cli4ai.json'),
-          JSON.stringify({
-            name,
-            version: '1.0.0',
-            entry: 'run.ts'
-          })
-        );
-      }
-
-      const packages = getLocalPackages(tempDir);
-      expect(packages).toHaveLength(3);
-      expect(packages.map(p => p.name).sort()).toEqual(['pkg-a', 'pkg-b', 'pkg-c']);
-    });
-  });
-
-  describe('findPackage', () => {
-    test('finds local package', () => {
-      ensureLocalDir(tempDir);
-
-      const pkgDir = join(tempDir, LOCAL_PACKAGES_DIR, 'local-tool');
-      mkdirSync(pkgDir);
-      writeFileSync(
-        join(pkgDir, 'cli4ai.json'),
-        JSON.stringify({
-          name: 'local-tool',
-          version: '1.0.0',
-          entry: 'run.ts'
-        })
-      );
-
-      const pkg = findPackage('local-tool', tempDir);
-
-      expect(pkg).not.toBeNull();
-      expect(pkg?.name).toBe('local-tool');
-    });
-
-    test('returns null when package not found', () => {
-      const pkg = findPackage('nonexistent', tempDir);
-      expect(pkg).toBeNull();
-    });
-
-    test('searches without project dir', () => {
-      // Should not throw, just search global
-      const pkg = findPackage('test');
-      // May or may not find depending on global state
-      expect(pkg === null || typeof pkg === 'object').toBe(true);
-    });
-  });
-});