@nimblebrain/mpak 0.0.2 → 0.2.0

package/src/commands/packages/run.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { homedir } from 'os';
-import { join } from 'path';
-import { parsePackageSpec, getCacheDir, resolveArgs, substituteUserConfig, substituteEnvVars } from './run.js';
-
-describe('parsePackageSpec', () => {
-  describe('scoped packages', () => {
-    it('parses @scope/name without version', () => {
-      expect(parsePackageSpec('@scope/name')).toEqual({
-        name: '@scope/name',
-      });
-    });
-
-    it('parses @scope/name@1.0.0', () => {
-      expect(parsePackageSpec('@scope/name@1.0.0')).toEqual({
-        name: '@scope/name',
-        version: '1.0.0',
-      });
-    });
-
-    it('parses prerelease versions @scope/name@1.0.0-beta.1', () => {
-      expect(parsePackageSpec('@scope/name@1.0.0-beta.1')).toEqual({
-        name: '@scope/name',
-        version: '1.0.0-beta.1',
-      });
-    });
-
-    it('parses version with build metadata @scope/name@1.0.0+build.123', () => {
-      expect(parsePackageSpec('@scope/name@1.0.0+build.123')).toEqual({
-        name: '@scope/name',
-        version: '1.0.0+build.123',
-      });
-    });
-  });
-
-  describe('edge cases', () => {
-    it('handles package name with multiple slashes @org/sub/name', () => {
-      // This is technically invalid per npm spec, but we should handle gracefully
-      const result = parsePackageSpec('@org/sub/name');
-      expect(result.name).toBe('@org/sub/name');
-    });
-
-    it('handles unscoped package name', () => {
-      expect(parsePackageSpec('simple-name')).toEqual({
-        name: 'simple-name',
-      });
-    });
-
-    it('treats unscoped@version as invalid (mpak requires scoped packages)', () => {
-      // mpak only supports scoped packages (@scope/name)
-      // An unscoped name with @ is treated as the full name, not name@version
-      expect(parsePackageSpec('unscoped@1.0.0')).toEqual({
-        name: 'unscoped@1.0.0',
-      });
-    });
-
-    it('handles empty string', () => {
-      expect(parsePackageSpec('')).toEqual({ name: '' });
-    });
-
-    it('handles @ only', () => {
-      expect(parsePackageSpec('@')).toEqual({ name: '@' });
-    });
-  });
-});
-
-describe('getCacheDir', () => {
-  const expectedBase = join(homedir(), '.mpak', 'cache');
-
-  it('converts @scope/name to scope-name', () => {
-    expect(getCacheDir('@nimblebraininc/echo')).toBe(
-      join(expectedBase, 'nimblebraininc-echo')
-    );
-  });
-
-  it('handles simple scoped names', () => {
-    expect(getCacheDir('@foo/bar')).toBe(join(expectedBase, 'foo-bar'));
-  });
-
-  it('handles unscoped names', () => {
-    expect(getCacheDir('simple')).toBe(join(expectedBase, 'simple'));
-  });
-});
-
-describe('resolveArgs', () => {
-  const cacheDir = '/Users/test/.mpak/cache/scope-name';
-
-  it('resolves ${__dirname} placeholder', () => {
-    expect(resolveArgs(['${__dirname}/dist/index.js'], cacheDir)).toEqual([
-      `${cacheDir}/dist/index.js`,
-    ]);
-  });
-
-  it('resolves multiple ${__dirname} in single arg', () => {
-    expect(
-      resolveArgs(['--config=${__dirname}/config.json'], cacheDir)
-    ).toEqual([`--config=${cacheDir}/config.json`]);
-  });
-
-  it('resolves ${__dirname} in multiple args', () => {
-    expect(
-      resolveArgs(
-        ['${__dirname}/index.js', '--config', '${__dirname}/config.json'],
-        cacheDir
-      )
-    ).toEqual([
-      `${cacheDir}/index.js`,
-      '--config',
-      `${cacheDir}/config.json`,
-    ]);
-  });
-
-  it('leaves args without placeholders unchanged', () => {
-    expect(resolveArgs(['-m', 'mcp_echo.server'], cacheDir)).toEqual([
-      '-m',
-      'mcp_echo.server',
-    ]);
-  });
-
-  it('handles empty args array', () => {
-    expect(resolveArgs([], cacheDir)).toEqual([]);
-  });
-
-  it('handles Windows-style paths in cacheDir', () => {
-    const winPath = 'C:\\Users\\test\\.mpak\\cache\\scope-name';
-    expect(resolveArgs(['${__dirname}\\dist\\index.js'], winPath)).toEqual([
-      `${winPath}\\dist\\index.js`,
-    ]);
-  });
-});
-
-describe('substituteUserConfig', () => {
-  it('substitutes single user_config variable', () => {
-    expect(
-      substituteUserConfig('${user_config.api_key}', { api_key: 'secret123' })
-    ).toBe('secret123');
-  });
-
-  it('substitutes multiple user_config variables', () => {
-    expect(
-      substituteUserConfig('key=${user_config.key}&secret=${user_config.secret}', {
-        key: 'mykey',
-        secret: 'mysecret',
-      })
-    ).toBe('key=mykey&secret=mysecret');
-  });
-
-  it('leaves unmatched variables unchanged', () => {
-    expect(
-      substituteUserConfig('${user_config.missing}', { other: 'value' })
-    ).toBe('${user_config.missing}');
-  });
-
-  it('handles mixed matched and unmatched variables', () => {
-    expect(
-      substituteUserConfig('${user_config.found}-${user_config.missing}', {
-        found: 'yes',
-      })
-    ).toBe('yes-${user_config.missing}');
-  });
-
-  it('handles empty config values', () => {
-    expect(
-      substituteUserConfig('${user_config.empty}', { empty: '' })
-    ).toBe('');
-  });
-
-  it('handles values with special characters', () => {
-    expect(
-      substituteUserConfig('${user_config.key}', { key: 'abc$def{ghi}' })
-    ).toBe('abc$def{ghi}');
-  });
-
-  it('leaves non-user_config placeholders unchanged', () => {
-    expect(
-      substituteUserConfig('${__dirname}/path', { dirname: '/cache' })
-    ).toBe('${__dirname}/path');
-  });
-});
-
-describe('substituteEnvVars', () => {
-  it('substitutes user_config in all env vars', () => {
-    const env = {
-      API_KEY: '${user_config.api_key}',
-      DEBUG: 'true',
-      TOKEN: '${user_config.token}',
-    };
-    const values = { api_key: 'key123', token: 'tok456' };
-
-    expect(substituteEnvVars(env, values)).toEqual({
-      API_KEY: 'key123',
-      DEBUG: 'true',
-      TOKEN: 'tok456',
-    });
-  });
-
-  it('handles undefined env', () => {
-    expect(substituteEnvVars(undefined, { key: 'value' })).toEqual({});
-  });
-
-  it('handles empty env', () => {
-    expect(substituteEnvVars({}, { key: 'value' })).toEqual({});
-  });
-
-  it('preserves env vars without placeholders', () => {
-    const env = { PATH: '/usr/bin', HOME: '/home/user' };
-    expect(substituteEnvVars(env, {})).toEqual(env);
-  });
-
-  it('leaves unsubstituted placeholders as-is', () => {
-    const env = {
-      API_KEY: '${user_config.api_key}',
-      DEBUG: 'true',
-    };
-    // api_key not provided, so placeholder remains
-    // (process.env will override this at merge time)
-    expect(substituteEnvVars(env, {})).toEqual({
-      API_KEY: '${user_config.api_key}',
-      DEBUG: 'true',
-    });
-  });
-});

package/src/commands/packages/run.ts

@@ -1,451 +0,0 @@
-import { spawn, spawnSync } from 'child_process';
-import { createInterface } from 'readline';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
-import { homedir } from 'os';
-import { join, dirname } from 'path';
-import { RegistryClient } from '../../lib/api/registry-client.js';
-import { ConfigManager } from '../../utils/config-manager.js';
-
-export interface RunOptions {
-  update?: boolean;
-}
-
-interface McpConfig {
-  command: string;
-  args: string[];
-  env?: Record<string, string>;
-}
-
-/**
- * User configuration field definition (MCPB v0.3 spec)
- */
-interface UserConfigField {
-  type: 'string' | 'number' | 'boolean';
-  title?: string;
-  description?: string;
-  sensitive?: boolean;
-  required?: boolean;
-  default?: string | number | boolean;
-}
-
-interface McpbManifest {
-  manifest_version: string;
-  name: string;
-  version: string;
-  description: string;
-  user_config?: Record<string, UserConfigField>;
-  server: {
-    type: 'node' | 'python' | 'binary';
-    entry_point: string;
-    mcp_config: McpConfig;
-  };
-}
-
-interface CacheMetadata {
-  version: string;
-  pulledAt: string;
-  platform: { os: string; arch: string };
-}
-
-/**
- * Parse package specification into name and version
- * @example parsePackageSpec('@scope/name') => { name: '@scope/name' }
- * @example parsePackageSpec('@scope/name@1.0.0') => { name: '@scope/name', version: '1.0.0' }
- */
-export function parsePackageSpec(spec: string): { name: string; version?: string } {
-  const lastAtIndex = spec.lastIndexOf('@');
-
-  if (lastAtIndex <= 0) {
-    return { name: spec };
-  }
-
-  const name = spec.substring(0, lastAtIndex);
-  const version = spec.substring(lastAtIndex + 1);
-
-  if (!name.startsWith('@')) {
-    return { name: spec };
-  }
-
-  return { name, version };
-}
-
-/**
- * Get cache directory for a package
- * @example getCacheDir('@scope/name') => '~/.mpak/cache/scope-name'
- */
-export function getCacheDir(packageName: string): string {
-  const cacheBase = join(homedir(), '.mpak', 'cache');
-  // @scope/name -> scope/name
-  const safeName = packageName.replace('@', '').replace('/', '-');
-  return join(cacheBase, safeName);
-}
-
-/**
- * Read cache metadata
- */
-function getCacheMetadata(cacheDir: string): CacheMetadata | null {
-  const metaPath = join(cacheDir, '.mpak-meta.json');
-  if (!existsSync(metaPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(metaPath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write cache metadata
- */
-function writeCacheMetadata(cacheDir: string, metadata: CacheMetadata): void {
-  const metaPath = join(cacheDir, '.mpak-meta.json');
-  writeFileSync(metaPath, JSON.stringify(metadata, null, 2));
-}
-
-/**
- * Extract ZIP file to directory (simple implementation without external deps)
- */
-async function extractZip(zipPath: string, destDir: string): Promise<void> {
-  // Use native unzip command (available on macOS, Linux, and Windows with WSL)
-  const { execSync } = await import('child_process');
-
-  // Ensure destination exists
-  mkdirSync(destDir, { recursive: true });
-
-  try {
-    execSync(`unzip -o -q "${zipPath}" -d "${destDir}"`, { stdio: 'pipe' });
-  } catch (error: any) {
-    throw new Error(`Failed to extract bundle: ${error.message}`);
-  }
-}
-
-/**
- * Read manifest from extracted bundle
- */
-function readManifest(cacheDir: string): McpbManifest {
-  const manifestPath = join(cacheDir, 'manifest.json');
-  if (!existsSync(manifestPath)) {
-    throw new Error(`Manifest not found in bundle: ${manifestPath}`);
-  }
-  return JSON.parse(readFileSync(manifestPath, 'utf8'));
-}
-
-/**
- * Resolve placeholders in args (e.g., ${__dirname})
- * @example resolveArgs(['${__dirname}/index.js'], '/cache') => ['/cache/index.js']
- */
-export function resolveArgs(args: string[], cacheDir: string): string[] {
-  return args.map(arg =>
-    arg.replace(/\$\{__dirname\}/g, cacheDir)
-  );
-}
-
-/**
- * Substitute ${user_config.*} placeholders in a string
- * @example substituteUserConfig('${user_config.api_key}', { api_key: 'secret' }) => 'secret'
- */
-export function substituteUserConfig(
-  value: string,
-  userConfigValues: Record<string, string>
-): string {
-  return value.replace(/\$\{user_config\.([^}]+)\}/g, (match, key) => {
-    return userConfigValues[key] ?? match;
-  });
-}
-
-/**
- * Substitute ${user_config.*} placeholders in env vars
- */
-export function substituteEnvVars(
-  env: Record<string, string> | undefined,
-  userConfigValues: Record<string, string>
-): Record<string, string> {
-  if (!env) return {};
-  const result: Record<string, string> = {};
-  for (const [key, value] of Object.entries(env)) {
-    result[key] = substituteUserConfig(value, userConfigValues);
-  }
-  return result;
-}
-
-/**
- * Prompt user for a config value (interactive terminal input)
- */
-async function promptForValue(
-  field: UserConfigField,
-  key: string
-): Promise<string> {
-  return new Promise((resolve) => {
-    const rl = createInterface({
-      input: process.stdin,
-      output: process.stderr,
-      terminal: true,
-    });
-
-    const label = field.title || key;
-    const hint = field.description ? ` (${field.description})` : '';
-    const defaultHint = field.default !== undefined ? ` [${field.default}]` : '';
-    const prompt = `=> ${label}${hint}${defaultHint}: `;
-
-    // For sensitive fields, we'd ideally hide input, but Node's readline
-    // doesn't support this natively. We'll just note it's sensitive.
-    if (field.sensitive) {
-      process.stderr.write(`=> (sensitive input)\n`);
-    }
-
-    rl.question(prompt, (answer) => {
-      rl.close();
-      // Use default if empty and default exists
-      if (!answer && field.default !== undefined) {
-        resolve(String(field.default));
-      } else {
-        resolve(answer);
-      }
-    });
-  });
-}
-
-/**
- * Check if we're in an interactive terminal
- */
-function isInteractive(): boolean {
-  return process.stdin.isTTY === true;
-}
-
-/**
- * Gather user config values from stored config
- * Prompts for missing required values if interactive
- */
-async function gatherUserConfigValues(
-  packageName: string,
-  userConfig: Record<string, UserConfigField>,
-  configManager: ConfigManager
-): Promise<Record<string, string>> {
-  const result: Record<string, string> = {};
-  const storedConfig = configManager.getPackageConfig(packageName) || {};
-  const missingRequired: Array<{ key: string; field: UserConfigField }> = [];
-
-  for (const [key, field] of Object.entries(userConfig)) {
-    // Priority: 1) stored config, 2) default value
-    const storedValue = storedConfig[key];
-
-    if (storedValue !== undefined) {
-      result[key] = storedValue;
-    } else if (field.default !== undefined) {
-      result[key] = String(field.default);
-    } else if (field.required) {
-      missingRequired.push({ key, field });
-    }
-  }
-
-  // Prompt for missing required values if interactive
-  if (missingRequired.length > 0) {
-    if (!isInteractive()) {
-      const missingKeys = missingRequired.map(m => m.key).join(', ');
-      process.stderr.write(`=> Error: Missing required config: ${missingKeys}\n`);
-      process.stderr.write(`=> Run 'mpak config set ${packageName} <key>=<value>' to set values\n`);
-      process.exit(1);
-    }
-
-    process.stderr.write(`=> Package requires configuration:\n`);
-    for (const { key, field } of missingRequired) {
-      const value = await promptForValue(field, key);
-      if (!value && field.required) {
-        process.stderr.write(`=> Error: ${field.title || key} is required\n`);
-        process.exit(1);
-      }
-      result[key] = value;
-
-      // Offer to save the value
-      if (value) {
-        const rl = createInterface({
-          input: process.stdin,
-          output: process.stderr,
-          terminal: true,
-        });
-        await new Promise<void>((resolve) => {
-          rl.question(`=> Save ${field.title || key} for future runs? [Y/n]: `, (answer) => {
-            rl.close();
-            if (answer.toLowerCase() !== 'n') {
-              configManager.setPackageConfigValue(packageName, key, value);
-              process.stderr.write(`=> Saved to ~/.mpak/config.json\n`);
-            }
-            resolve();
-          });
-        });
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * Find Python executable (tries python3 first, then python)
- */
-function findPythonCommand(): string {
-  // Try python3 first (preferred on macOS/Linux)
-  const result = spawnSync('python3', ['--version'], { stdio: 'pipe' });
-  if (result.status === 0) {
-    return 'python3';
-  }
-  // Fall back to python
-  return 'python';
-}
-
-/**
- * Run a package from the registry
- */
-export async function handleRun(
-  packageSpec: string,
-  options: RunOptions = {}
-): Promise<void> {
-  const { name, version: requestedVersion } = parsePackageSpec(packageSpec);
-  const client = new RegistryClient();
-  const platform = RegistryClient.detectPlatform();
-  const cacheDir = getCacheDir(name);
-
-  let needsPull = true;
-  let cachedMeta = getCacheMetadata(cacheDir);
-
-  // Check if we have a cached version
-  if (cachedMeta && !options.update) {
-    if (requestedVersion) {
-      // Specific version requested - check if cached version matches
-      needsPull = cachedMeta.version !== requestedVersion;
-    } else {
-      // Latest requested - use cache (user can --update to refresh)
-      needsPull = false;
-    }
-  }
-
-  if (needsPull) {
-    // Fetch download info
-    const downloadInfo = await client.getDownloadInfo(name, requestedVersion, platform);
-    const bundle = downloadInfo.bundle;
-
-    // Check if cached version is already the latest
-    if (cachedMeta && cachedMeta.version === bundle.version && !options.update) {
-      needsPull = false;
-    }
-
-    if (needsPull) {
-      // Download to temp file
-      const tempPath = join(homedir(), '.mpak', 'tmp', `${Date.now()}.mcpb`);
-      mkdirSync(dirname(tempPath), { recursive: true });
-
-      process.stderr.write(`=> Pulling ${name}@${bundle.version}...\n`);
-      await client.downloadBundle(downloadInfo.url, tempPath);
-
-      // Clear old cache and extract
-      const { rmSync } = await import('fs');
-      if (existsSync(cacheDir)) {
-        rmSync(cacheDir, { recursive: true, force: true });
-      }
-      mkdirSync(cacheDir, { recursive: true });
-
-      await extractZip(tempPath, cacheDir);
-
-      // Write metadata
-      writeCacheMetadata(cacheDir, {
-        version: bundle.version,
-        pulledAt: new Date().toISOString(),
-        platform: bundle.platform,
-      });
-
-      // Cleanup temp file
-      rmSync(tempPath, { force: true });
-
-      process.stderr.write(`=> Cached ${name}@${bundle.version}\n`);
-    }
-  }
-
-  // Read manifest and execute
-  const manifest = readManifest(cacheDir);
-  const { type, entry_point, mcp_config } = manifest.server;
-
-  // Handle user_config substitution
-  let userConfigValues: Record<string, string> = {};
-  if (manifest.user_config && Object.keys(manifest.user_config).length > 0) {
-    const configManager = new ConfigManager();
-    userConfigValues = await gatherUserConfigValues(name, manifest.user_config, configManager);
-  }
-
-  // Substitute user_config placeholders in env vars
-  // Priority: process.env (from parent like Claude Desktop) > substituted values (from mpak config)
-  const substitutedEnv = substituteEnvVars(mcp_config.env, userConfigValues);
-
-  let command: string;
-  let args: string[];
-  let env: Record<string, string | undefined> = { ...substitutedEnv, ...process.env };
-
-  switch (type) {
-    case 'binary': {
-      // For binary, the entry_point is the executable path relative to bundle
-      command = join(cacheDir, entry_point);
-      args = resolveArgs(mcp_config.args || [], cacheDir);
-
-      // Ensure binary is executable
-      try {
-        chmodSync(command, 0o755);
-      } catch {
-        // Ignore chmod errors on Windows
-      }
-      break;
-    }
-
-    case 'node': {
-      command = mcp_config.command || 'node';
-      // Use mcp_config.args directly if provided, otherwise fall back to entry_point
-      if (mcp_config.args && mcp_config.args.length > 0) {
-        args = resolveArgs(mcp_config.args, cacheDir);
-      } else {
-        args = [join(cacheDir, entry_point)];
-      }
-      break;
-    }
-
-    case 'python': {
-      // Use manifest command if specified, otherwise auto-detect python
-      command = mcp_config.command === 'python' ? findPythonCommand() : (mcp_config.command || findPythonCommand());
-
-      // Use mcp_config.args directly if provided, otherwise fall back to entry_point
-      if (mcp_config.args && mcp_config.args.length > 0) {
-        args = resolveArgs(mcp_config.args, cacheDir);
-      } else {
-        args = [join(cacheDir, entry_point)];
-      }
-
-      // Set PYTHONPATH to deps/ directory for dependency resolution
-      const depsDir = join(cacheDir, 'deps');
-      const existingPythonPath = process.env.PYTHONPATH;
-      env.PYTHONPATH = existingPythonPath ? `${depsDir}:${existingPythonPath}` : depsDir;
-      break;
-    }
-
-    default:
-      throw new Error(`Unsupported server type: ${type}`);
-  }
-
-  // Spawn with stdio passthrough for MCP
-  const child = spawn(command, args, {
-    stdio: ['inherit', 'inherit', 'inherit'],
-    env,
-    cwd: cacheDir,
-  });
-
-  // Forward signals
-  process.on('SIGINT', () => child.kill('SIGINT'));
-  process.on('SIGTERM', () => child.kill('SIGTERM'));
-
-  // Wait for exit
-  child.on('exit', (code) => {
-    process.exit(code ?? 0);
-  });
-
-  child.on('error', (error) => {
-    process.stderr.write(`=> Failed to start server: ${error.message}\n`);
-    process.exit(1);
-  });
-}