cli4ai 1.2.0 → 1.2.1

package/dist/core/manifest.js

@@ -0,0 +1,224 @@
+/**
+ * cli4ai.json manifest validation and parsing
+ */
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname, basename } from 'path';
+import { outputError } from '../lib/cli.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// ERRORS
+// ═══════════════════════════════════════════════════════════════════════════
+export class ManifestValidationError extends Error {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = 'ManifestValidationError';
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION
+// ═══════════════════════════════════════════════════════════════════════════
+const NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
+export function validateManifest(manifest, source) {
+    if (!manifest || typeof manifest !== 'object') {
+        throw new ManifestValidationError('Manifest must be an object', { source });
+    }
+    const m = manifest;
+    // Required: name
+    if (typeof m.name !== 'string' || !NAME_PATTERN.test(m.name)) {
+        throw new ManifestValidationError('Invalid or missing "name" (lowercase letters, numbers, hyphens)', {
+            source,
+            got: m.name
+        });
+    }
+    // Required: version
+    if (typeof m.version !== 'string' || !VERSION_PATTERN.test(m.version)) {
+        throw new ManifestValidationError('Invalid or missing "version" (semver format: x.y.z)', {
+            source,
+            got: m.version
+        });
+    }
+    // Required: entry
+    if (typeof m.entry !== 'string' || m.entry.length === 0) {
+        throw new ManifestValidationError('Invalid or missing "entry" (path to main file)', {
+            source,
+            got: m.entry
+        });
+    }
+    // SECURITY: Validate entry is a relative path that stays within package directory
+    if (m.entry.startsWith('/') || m.entry.startsWith('\\') || m.entry.includes('..')) {
+        throw new ManifestValidationError('Invalid "entry" - must be a relative path without ".." (security: path traversal)', { source, got: m.entry });
+    }
+    // Optional: runtime (deno not supported)
+    if (m.runtime !== undefined && !['bun', 'node'].includes(m.runtime)) {
+        throw new ManifestValidationError('Invalid "runtime" (must be bun or node)', {
+            source,
+            got: m.runtime
+        });
+    }
+    // Optional: commands
+    if (m.commands !== undefined) {
+        if (typeof m.commands !== 'object' || m.commands === null) {
+            throw new ManifestValidationError('Invalid "commands" (must be an object)', { source });
+        }
+        for (const [cmdName, cmdDef] of Object.entries(m.commands)) {
+            if (typeof cmdDef !== 'object' || cmdDef === null) {
+                throw new ManifestValidationError(`Invalid command definition for "${cmdName}"`, { source });
+            }
+            const def = cmdDef;
+            if (typeof def.description !== 'string') {
+                throw new ManifestValidationError(`Command "${cmdName}" missing description`, { source });
+            }
+        }
+    }
+    return manifest;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// LOADING
+// ═══════════════════════════════════════════════════════════════════════════
+export const MANIFEST_FILENAME = 'cli4ai.json';
+export class ManifestNotFoundError extends Error {
+    path;
+    constructor(path) {
+        super(`No ${MANIFEST_FILENAME} found at ${path}`);
+        this.path = path;
+        this.name = 'ManifestNotFoundError';
+    }
+}
+export class ManifestParseError extends Error {
+    path;
+    constructor(path, message) {
+        super(message);
+        this.path = path;
+        this.name = 'ManifestParseError';
+    }
+}
+/**
+ * Load and validate cli4ai.json from a directory (throws on error)
+ * Use this for programmatic/testable usage
+ */
+export function loadManifestOrThrow(dir) {
+    const manifestPath = resolve(dir, MANIFEST_FILENAME);
+    if (!existsSync(manifestPath)) {
+        throw new ManifestNotFoundError(manifestPath);
+    }
+    let content;
+    try {
+        content = readFileSync(manifestPath, 'utf-8');
+    }
+    catch (err) {
+        throw new ManifestParseError(manifestPath, `Failed to read: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch {
+        throw new ManifestParseError(manifestPath, 'Invalid JSON');
+    }
+    return validateManifest(data, manifestPath);
+}
+/**
+ * Load manifest from package.json (fallback for npm packages)
+ */
+export function loadFromPackageJson(dir) {
+    const pkgJsonPath = resolve(dir, 'package.json');
+    if (!existsSync(pkgJsonPath))
+        return null;
+    try {
+        const content = readFileSync(pkgJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        // Extract name without @cli4ai/ scope
+        const name = pkg.name?.replace('@cli4ai/', '') || basename(dir);
+        return {
+            name,
+            version: pkg.version || '1.0.0',
+            entry: pkg.main || 'run.ts',
+            description: pkg.description,
+            author: pkg.author,
+            license: pkg.license,
+            runtime: 'node',
+            keywords: pkg.keywords
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load and validate cli4ai.json from a directory
+ * Falls back to package.json for npm packages
+ * Exits with error on failure (for CLI usage)
+ */
+export function loadManifest(dir) {
+    // Try cli4ai.json first
+    try {
+        return loadManifestOrThrow(dir);
+    }
+    catch (err) {
+        if (err instanceof ManifestNotFoundError) {
+            // Fallback to package.json
+            const fromPkgJson = loadFromPackageJson(dir);
+            if (fromPkgJson)
+                return fromPkgJson;
+            outputError('NOT_FOUND', `No ${MANIFEST_FILENAME} found`, {
+                path: err.path,
+                hint: 'Run "cli4ai init" to create one'
+            });
+        }
+        if (err instanceof ManifestParseError) {
+            outputError('PARSE_ERROR', err.message, { path: err.path });
+        }
+        if (err instanceof ManifestValidationError) {
+            outputError('MANIFEST_ERROR', err.message, err.details);
+        }
+        throw err;
+    }
+}
+/**
+ * Try to load manifest, return null if not found
+ */
+export function tryLoadManifest(dir) {
+    const manifestPath = resolve(dir, MANIFEST_FILENAME);
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        const content = readFileSync(manifestPath, 'utf-8');
+        const data = JSON.parse(content);
+        return validateManifest(data, manifestPath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find manifest by walking up directory tree
+ */
+export function findManifest(startDir) {
+    let dir = startDir || process.cwd();
+    for (let i = 0; i < 10; i++) {
+        const manifest = tryLoadManifest(dir);
+        if (manifest) {
+            return { manifest, dir };
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Create a minimal manifest
+ */
+export function createManifest(name, options = {}) {
+    return {
+        name: name.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        version: '1.0.0',
+        entry: 'run.ts',
+        runtime: 'node',
+        description: options.description || `${name} tool`,
+        ...options
+    };
+}

package/dist/core/registry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Package Registry
+ *
+ * Fetches and caches package metadata from cli4ai.com registry.
+ * Provides integrity hashes for verification.
+ */
+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[];
+}
+/**
+ * Fetch registry from cli4ai.com
+ */
+export declare function fetchRegistry(): Promise<Registry | null>;
+/**
+ * Get package info from registry
+ */
+export declare function getRegistryPackage(name: string): Promise<RegistryPackage | null>;
+/**
+ * Get integrity hash for a package from registry
+ */
+export declare function getRegistryIntegrity(name: string): Promise<string | null>;
+/**
+ * Get all package names from registry
+ */
+export declare function getRegistryPackageNames(): Promise<string[]>;
+/**
+ * Compute SHA-512 integrity hash for a directory
+ * Same algorithm as used by generate-registry.ts
+ */
+export declare function computeDirectoryIntegrity(dirPath: string): string;
+/**
+ * Verify package integrity against registry
+ */
+export declare function verifyPackageIntegrity(packageName: string, packagePath: string): Promise<{
+    valid: boolean;
+    expected: string | null;
+    actual: string;
+}>;
+/**
+ * Clear the registry cache
+ */
+export declare function clearRegistryCache(): void;
+export {};

package/dist/core/registry.js

@@ -0,0 +1,116 @@
+/**
+ * Package Registry
+ *
+ * Fetches and caches package metadata from cli4ai.com registry.
+ * Provides integrity hashes for verification.
+ */
+import { createHash } from 'crypto';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+const REGISTRY_URL = 'https://cli4ai.com/registry/packages.json';
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+// In-memory cache
+let cachedRegistry = null;
+let cacheTimestamp = 0;
+/**
+ * Fetch registry from cli4ai.com
+ */
+export async function fetchRegistry() {
+    // 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();
+        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) {
+    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) {
+    const pkg = await getRegistryPackage(name);
+    return pkg?.integrity || null;
+}
+/**
+ * Get all package names from registry
+ */
+export async function getRegistryPackageNames() {
+    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) {
+    const hash = createHash('sha512');
+    function processDir(dir) {
+        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, packagePath) {
+    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() {
+    cachedRegistry = null;
+    cacheTimestamp = 0;
+}

package/dist/core/remote-client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Remote client for executing cli4ai commands on remote hosts.
+ *
+ * This module provides functions to call remote cli4ai services
+ * configured via `cli4ai remotes add`.
+ */
+import type { ScopeLevel } from './execute.js';
+import type { RoutineRunSummary } from './routine-engine.js';
+export interface RemoteRunOptions {
+    /** Package name to execute */
+    package: string;
+    /** Command within the package */
+    command?: string;
+    /** Arguments to pass */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Standard input to pass */
+    stdin?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Scope level for execution */
+    scope?: ScopeLevel;
+}
+export interface RemoteRunResult {
+    success: boolean;
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+    durationMs: number;
+    error?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export interface RemoteHealthResult {
+    status: 'ok';
+    hostname: string;
+    version: string;
+    uptime: number;
+}
+export interface RemotePackageInfo {
+    name: string;
+    version: string;
+    description?: string;
+    commands?: Record<string, {
+        description: string;
+    }>;
+}
+export interface RemotePackageList {
+    packages: Array<{
+        name: string;
+        version: string;
+        path: string;
+        source: 'local' | 'registry';
+    }>;
+}
+export declare class RemoteConnectionError extends Error {
+    remoteName: string;
+    url: string;
+    constructor(remoteName: string, url: string, message: string);
+}
+export declare class RemoteApiError extends Error {
+    remoteName: string;
+    statusCode: number;
+    code: string;
+    details?: Record<string, unknown> | undefined;
+    constructor(remoteName: string, statusCode: number, code: string, message: string, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Check health of a remote service
+ */
+export declare function remoteHealth(remoteName: string): Promise<RemoteHealthResult>;
+/**
+ * List packages on a remote
+ */
+export declare function remoteListPackages(remoteName: string): Promise<RemotePackageList>;
+/**
+ * Get package info from a remote
+ */
+export declare function remotePackageInfo(remoteName: string, packageName: string): Promise<RemotePackageInfo | null>;
+/**
+ * Run a tool on a remote
+ */
+export declare function remoteRunTool(remoteName: string, options: RemoteRunOptions): Promise<RemoteRunResult>;
+/**
+ * Run a routine on a remote
+ */
+export declare function remoteRunRoutine(remoteName: string, routineName: string, vars?: Record<string, string>): Promise<RoutineRunSummary>;
+/**
+ * Test connection to a remote
+ */
+export declare function testRemoteConnection(remoteName: string): Promise<{
+    success: boolean;
+    message: string;
+    details?: Record<string, unknown>;
+}>;