@nimblebrain/mpak 0.1.0 → 0.2.0

package/src/utils/config-manager.ts

@@ -1,272 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-
-/**
- * Current config schema version
- */
-export const CONFIG_VERSION = '1.0.0';
-
-/**
- * Per-package user configuration (stores user_config values)
- */
-export interface PackageConfig {
-  [key: string]: string;
-}
-
-/**
- * Configuration structure (v1.0.0)
- */
-export interface MpakConfig {
-  version: string;
-  lastUpdated: string;
-  registryUrl?: string;
-  packages?: Record<string, PackageConfig>;
-}
-
-/**
- * Error thrown when config file is corrupted or invalid
- */
-export class ConfigCorruptedError extends Error {
-  constructor(
-    message: string,
-    public readonly configPath: string,
-    public readonly cause?: Error
-  ) {
-    super(message);
-    this.name = 'ConfigCorruptedError';
-  }
-}
-
-/**
- * Validates that a parsed object conforms to the MpakConfig schema
- */
-function validateConfig(data: unknown, configPath: string): MpakConfig {
-  if (typeof data !== 'object' || data === null) {
-    throw new ConfigCorruptedError(
-      'Config file must be a JSON object',
-      configPath
-    );
-  }
-
-  const obj = data as Record<string, unknown>;
-
-  // Required fields
-  if (typeof obj.version !== 'string') {
-    throw new ConfigCorruptedError(
-      'Config missing required field: version (string)',
-      configPath
-    );
-  }
-
-  if (typeof obj.lastUpdated !== 'string') {
-    throw new ConfigCorruptedError(
-      'Config missing required field: lastUpdated (string)',
-      configPath
-    );
-  }
-
-  // Optional fields with type validation
-  if (obj.registryUrl !== undefined && typeof obj.registryUrl !== 'string') {
-    throw new ConfigCorruptedError(
-      'Config field registryUrl must be a string',
-      configPath
-    );
-  }
-
-  if (obj.packages !== undefined) {
-    if (typeof obj.packages !== 'object' || obj.packages === null) {
-      throw new ConfigCorruptedError(
-        'Config field packages must be an object',
-        configPath
-      );
-    }
-
-    // Validate each package config
-    for (const [pkgName, pkgConfig] of Object.entries(
-      obj.packages as Record<string, unknown>
-    )) {
-      if (typeof pkgConfig !== 'object' || pkgConfig === null) {
-        throw new ConfigCorruptedError(
-          `Config packages.${pkgName} must be an object`,
-          configPath
-        );
-      }
-
-      for (const [key, value] of Object.entries(
-        pkgConfig as Record<string, unknown>
-      )) {
-        if (typeof value !== 'string') {
-          throw new ConfigCorruptedError(
-            `Config packages.${pkgName}.${key} must be a string`,
-            configPath
-          );
-        }
-      }
-    }
-  }
-
-  // Check for unknown fields (additionalProperties: false in schema)
-  const knownFields = new Set(['version', 'lastUpdated', 'registryUrl', 'packages']);
-  for (const key of Object.keys(obj)) {
-    if (!knownFields.has(key)) {
-      throw new ConfigCorruptedError(
-        `Config contains unknown field: ${key}`,
-        configPath
-      );
-    }
-  }
-
-  return data as MpakConfig;
-}
-
-/**
- * Configuration manager for CLI settings in ~/.mpak/config.json
- */
-export class ConfigManager {
-  private configDir: string;
-  private configFile: string;
-  private config: MpakConfig | null = null;
-
-  constructor() {
-    this.configDir = join(homedir(), '.mpak');
-    this.configFile = join(this.configDir, 'config.json');
-    this.ensureConfigDir();
-  }
-
-  private ensureConfigDir(): void {
-    if (!existsSync(this.configDir)) {
-      mkdirSync(this.configDir, { recursive: true, mode: 0o700 });
-    }
-  }
-
-  loadConfig(): MpakConfig {
-    if (this.config) {
-      return this.config;
-    }
-
-    if (!existsSync(this.configFile)) {
-      this.config = {
-        version: CONFIG_VERSION,
-        lastUpdated: new Date().toISOString(),
-      };
-      this.saveConfig();
-      return this.config;
-    }
-
-    let configJson: string;
-    try {
-      configJson = readFileSync(this.configFile, 'utf8');
-    } catch (err) {
-      throw new ConfigCorruptedError(
-        `Failed to read config file: ${err instanceof Error ? err.message : String(err)}`,
-        this.configFile,
-        err instanceof Error ? err : undefined
-      );
-    }
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(configJson);
-    } catch (err) {
-      throw new ConfigCorruptedError(
-        `Config file contains invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
-        this.configFile,
-        err instanceof Error ? err : undefined
-      );
-    }
-
-    // Validate structure against schema
-    this.config = validateConfig(parsed, this.configFile);
-    return this.config;
-  }
-
-  private saveConfig(): void {
-    if (!this.config) {
-      return;
-    }
-    this.config.lastUpdated = new Date().toISOString();
-    const configJson = JSON.stringify(this.config, null, 2);
-    writeFileSync(this.configFile, configJson, { mode: 0o600 });
-  }
-
-  setRegistryUrl(url: string): void {
-    const config = this.loadConfig();
-    config.registryUrl = url;
-    this.saveConfig();
-  }
-
-  getRegistryUrl(): string {
-    const config = this.loadConfig();
-    return config.registryUrl || process.env.MPAK_REGISTRY_URL || 'https://api.mpak.dev';
-  }
-
-  /**
-   * Get all stored config values for a package
-   */
-  getPackageConfig(packageName: string): PackageConfig | undefined {
-    const config = this.loadConfig();
-    return config.packages?.[packageName];
-  }
-
-  /**
-   * Get a specific config value for a package
-   */
-  getPackageConfigValue(packageName: string, key: string): string | undefined {
-    const packageConfig = this.getPackageConfig(packageName);
-    return packageConfig?.[key];
-  }
-
-  /**
-   * Set a config value for a package
-   */
-  setPackageConfigValue(packageName: string, key: string, value: string): void {
-    const config = this.loadConfig();
-    if (!config.packages) {
-      config.packages = {};
-    }
-    if (!config.packages[packageName]) {
-      config.packages[packageName] = {};
-    }
-    config.packages[packageName][key] = value;
-    this.saveConfig();
-  }
-
-  /**
-   * Clear all config values for a package
-   */
-  clearPackageConfig(packageName: string): boolean {
-    const config = this.loadConfig();
-    if (config.packages?.[packageName]) {
-      delete config.packages[packageName];
-      this.saveConfig();
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Clear a specific config value for a package
-   */
-  clearPackageConfigValue(packageName: string, key: string): boolean {
-    const config = this.loadConfig();
-    if (config.packages?.[packageName]?.[key] !== undefined) {
-      delete config.packages[packageName][key];
-      // Clean up empty package entries
-      if (Object.keys(config.packages[packageName]).length === 0) {
-        delete config.packages[packageName];
-      }
-      this.saveConfig();
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * List all packages with stored config
-   */
-  listPackagesWithConfig(): string[] {
-    const config = this.loadConfig();
-    return Object.keys(config.packages || {});
-  }
-}

package/src/utils/errors.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CLIError } from './errors.js';
-
-describe('CLIError', () => {
-  it('should create error with message', () => {
-    const error = new CLIError('Test error');
-    expect(error.message).toBe('Test error');
-    expect(error.name).toBe('CLIError');
-  });
-
-  it('should have default exit code of 1', () => {
-    const error = new CLIError('Test error');
-    expect(error.exitCode).toBe(1);
-  });
-
-  it('should allow custom exit code', () => {
-    const error = new CLIError('Test error', 2);
-    expect(error.exitCode).toBe(2);
-  });
-
-  it('should be instance of Error', () => {
-    const error = new CLIError('Test error');
-    expect(error).toBeInstanceOf(Error);
-  });
-});

package/src/utils/errors.ts

@@ -1,33 +0,0 @@
-/**
- * Custom error class for CLI errors
- */
-export class CLIError extends Error {
-  public readonly exitCode: number;
-
-  constructor(
-    message: string,
-    exitCode: number = 1
-  ) {
-    super(message);
-    this.name = 'CLIError';
-    this.exitCode = exitCode;
-  }
-}
-
-/**
- * Handles errors gracefully and exits with appropriate code
- */
-export function handleError(error: unknown): never {
-  if (error instanceof CLIError) {
-    console.error(`Error: ${error.message}`);
-    process.exit(error.exitCode);
-  }
-
-  if (error instanceof Error) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-
-  console.error('An unexpected error occurred');
-  process.exit(1);
-}

package/src/utils/version.test.ts

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getVersion } from './version.js';
-
-describe('getVersion', () => {
-  it('should return a valid version string', () => {
-    const version = getVersion();
-    expect(version).toBeTruthy();
-    expect(typeof version).toBe('string');
-  });
-
-  it('should match semver format or be "unknown"', () => {
-    const version = getVersion();
-    const semverRegex = /^\d+\.\d+\.\d+/;
-    expect(version === 'unknown' || semverRegex.test(version)).toBe(true);
-  });
-});

package/src/utils/version.ts

@@ -1,18 +0,0 @@
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-/**
- * Gets the current version from package.json
- */
-export function getVersion(): string {
-  try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const packageJsonPath = join(__dirname, '../../package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    return packageJson.version;
-  } catch (_error) {
-    return 'unknown';
-  }
-}

package/test/integration/registry-client.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, afterAll } from 'vitest';
-import { RegistryClient } from '../../src/lib/api/registry-client.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * Integration tests for the mpak registry client
- *
- * These tests hit the live api.mpak.dev registry using the @nimblebraininc/echo
- * bundle as a known fixture. They verify the full flow from search to download.
- *
- * Run with: npm run test:integration
- */
-describe('RegistryClient Integration', () => {
-  const client = new RegistryClient();
-  const testBundle = '@nimblebraininc/echo';
-  const downloadedFiles: string[] = [];
-
-  afterAll(() => {
-    // Clean up any downloaded files
-    for (const file of downloadedFiles) {
-      if (fs.existsSync(file)) {
-        fs.unlinkSync(file);
-      }
-    }
-  });
-
-  describe('searchBundles', () => {
-    it('should find echo bundle when searching for "echo"', async () => {
-      const result = await client.searchBundles('echo');
-
-      expect(result.bundles).toBeDefined();
-      expect(result.bundles.length).toBeGreaterThan(0);
-
-      const echoBundle = result.bundles.find(b => b.name === testBundle);
-      expect(echoBundle).toBeDefined();
-      expect(echoBundle?.description).toContain('Echo');
-    });
-
-    it('should return empty results for nonsense query', async () => {
-      const result = await client.searchBundles('xyznonexistent12345');
-
-      expect(result.bundles).toBeDefined();
-      expect(result.bundles.length).toBe(0);
-    });
-
-    it('should respect limit parameter', async () => {
-      const result = await client.searchBundles('', { limit: 1 });
-
-      expect(result.bundles.length).toBeLessThanOrEqual(1);
-    });
-  });
-
-  describe('getBundle', () => {
-    it('should return bundle details for @nimblebraininc/echo', async () => {
-      const bundle = await client.getBundle(testBundle);
-
-      expect(bundle.name).toBe(testBundle);
-      expect(bundle.description).toBeDefined();
-      expect(bundle.server_type).toBe('python');
-      expect(bundle.author).toBeDefined();
-      expect(bundle.latest_version).toBeDefined();
-    });
-
-    it('should include provenance information', async () => {
-      const bundle = await client.getBundle(testBundle);
-
-      expect(bundle.provenance).toBeDefined();
-      expect(bundle.provenance?.provider).toBe('github_oidc');
-      expect(bundle.provenance?.repository).toContain('mcp-echo');
-    });
-
-    it('should throw error for non-existent bundle', async () => {
-      await expect(
-        client.getBundle('@nonexistent/bundle-xyz')
-      ).rejects.toThrow('Bundle not found');
-    });
-
-    it('should throw error for unscoped package name', async () => {
-      await expect(
-        client.getBundle('unscoped-name')
-      ).rejects.toThrow('Package name must be scoped');
-    });
-  });
-
-  describe('getVersions', () => {
-    it('should return version list with platforms', async () => {
-      const result = await client.getVersions(testBundle);
-
-      expect(result.versions).toBeDefined();
-      expect(result.versions.length).toBeGreaterThan(0);
-
-      const latestVersion = result.versions[0];
-      expect(latestVersion.version).toBeDefined();
-      expect(latestVersion.platforms).toBeDefined();
-      expect(latestVersion.platforms.length).toBeGreaterThan(0);
-    });
-
-    it('should include linux platforms for echo bundle', async () => {
-      const result = await client.getVersions(testBundle);
-
-      const latestVersion = result.versions[0];
-      const platforms = latestVersion.platforms.map(p => `${p.os}-${p.arch}`);
-
-      expect(platforms).toContain('linux-x64');
-      expect(platforms).toContain('linux-arm64');
-    });
-  });
-
-  describe('getDownloadInfo', () => {
-    it('should return download URL for latest version', async () => {
-      const info = await client.getDownloadInfo(testBundle, undefined, {
-        os: 'linux',
-        arch: 'x64',
-      });
-
-      expect(info.url).toBeDefined();
-      expect(info.url).toMatch(/^https?:\/\//);
-      expect(info.bundle.version).toBeDefined();
-      expect(info.bundle.platform).toBeDefined();
-      expect(info.bundle.size).toBeGreaterThan(0);
-      expect(info.bundle.sha256).toBeDefined();
-    });
-
-    it('should return correct artifact for requested platform', async () => {
-      const info = await client.getDownloadInfo(testBundle, undefined, {
-        os: 'linux',
-        arch: 'arm64',
-      });
-
-      expect(info.bundle.platform.os).toBe('linux');
-      expect(info.bundle.platform.arch).toBe('arm64');
-    });
-
-    it('should return download info for specific version', async () => {
-      const versions = await client.getVersions(testBundle);
-      const specificVersion = versions.versions[0].version;
-
-      const info = await client.getDownloadInfo(testBundle, specificVersion, {
-        os: 'linux',
-        arch: 'x64',
-      });
-
-      expect(info.bundle.version).toBe(specificVersion);
-    });
-  });
-
-  describe('downloadBundle', () => {
-    it('should download bundle file successfully', async () => {
-      const info = await client.getDownloadInfo(testBundle, undefined, {
-        os: 'linux',
-        arch: 'x64',
-      });
-
-      const outputPath = path.join(
-        process.cwd(),
-        `test-download-${Date.now()}.mcpb`
-      );
-      downloadedFiles.push(outputPath);
-
-      await client.downloadBundle(info.url, outputPath);
-
-      expect(fs.existsSync(outputPath)).toBe(true);
-
-      const stats = fs.statSync(outputPath);
-      expect(stats.size).toBe(info.bundle.size);
-    }, 60000); // 60s timeout for download
-  });
-
-  describe('detectPlatform', () => {
-    it('should return valid platform object', () => {
-      const platform = RegistryClient.detectPlatform();
-
-      expect(platform.os).toBeDefined();
-      expect(platform.arch).toBeDefined();
-      expect(['darwin', 'linux', 'win32', 'any']).toContain(platform.os);
-      expect(['x64', 'arm64', 'any']).toContain(platform.arch);
-    });
-  });
-});

package/tsconfig.check.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "noEmit": true
-  },
-  "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ES2022",
-    "lib": ["ES2022"],
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['src/**/*.test.ts', 'test/**/*.test.ts'],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: ['dist', 'node_modules', '**/*.test.ts', '**/*.config.ts', 'test'],
-    },
-  },
-});