cli4ai 1.2.0 → 1.2.1

package/src/core/remote-client.ts

@@ -1,419 +0,0 @@
-/**
- * Remote client for executing cli4ai commands on remote hosts.
- *
- * This module provides functions to call remote cli4ai services
- * configured via `cli4ai remotes add`.
- */
-
-import { request as httpRequest, type RequestOptions, type OutgoingHttpHeaders } from 'http';
-import { request as httpsRequest } from 'https';
-import { getRemoteOrThrow, updateRemoteLastConnected, type RemoteHost } from './remotes.js';
-import type { ScopeLevel } from './execute.js';
-import type { RoutineRunSummary } from './routine-engine.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// TYPES
-// ═══════════════════════════════════════════════════════════════════════════
-
-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';
-  }>;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ERRORS
-// ═══════════════════════════════════════════════════════════════════════════
-
-export class RemoteConnectionError extends Error {
-  constructor(
-    public remoteName: string,
-    public url: string,
-    message: string
-  ) {
-    super(`Failed to connect to remote "${remoteName}" at ${url}: ${message}`);
-    this.name = 'RemoteConnectionError';
-  }
-}
-
-export class RemoteApiError extends Error {
-  constructor(
-    public remoteName: string,
-    public statusCode: number,
-    public code: string,
-    message: string,
-    public details?: Record<string, unknown>
-  ) {
-    super(`Remote "${remoteName}" error [${code}]: ${message}`);
-    this.name = 'RemoteApiError';
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// HTTP CLIENT
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface HttpResponse {
-  statusCode: number;
-  body: string;
-}
-
-function makeRequest(
-  url: URL,
-  method: string,
-  headers: Record<string, string>,
-  body?: string,
-  timeoutMs: number = 30000
-): Promise<HttpResponse> {
-  return new Promise((resolve, reject) => {
-    const isHttps = url.protocol === 'https:';
-    const requestFn = isHttps ? httpsRequest : httpRequest;
-
-    const reqHeaders: OutgoingHttpHeaders = {
-      ...headers,
-      'Content-Type': 'application/json'
-    };
-
-    if (body) {
-      reqHeaders['Content-Length'] = Buffer.byteLength(body);
-    }
-
-    const options: RequestOptions = {
-      method,
-      hostname: url.hostname,
-      port: url.port || (isHttps ? 443 : 80),
-      path: url.pathname + url.search,
-      headers: reqHeaders,
-      timeout: timeoutMs
-    };
-
-    const req = requestFn(options, (res) => {
-      const chunks: Buffer[] = [];
-      res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-      res.on('end', () => {
-        resolve({
-          statusCode: res.statusCode ?? 500,
-          body: Buffer.concat(chunks).toString('utf-8')
-        });
-      });
-    });
-
-    req.on('error', (err) => {
-      reject(err);
-    });
-
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timeout'));
-    });
-
-    if (body) {
-      req.write(body);
-    }
-
-    req.end();
-  });
-}
-
-function buildHeaders(remote: RemoteHost): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Accept': 'application/json'
-  };
-
-  if (remote.apiKey) {
-    headers['X-API-Key'] = remote.apiKey;
-  }
-
-  return headers;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// CLIENT FUNCTIONS
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Check health of a remote service
- */
-export async function remoteHealth(remoteName: string): Promise<RemoteHealthResult> {
-  const remote = getRemoteOrThrow(remoteName);
-  const url = new URL('/health', remote.url);
-
-  try {
-    const response = await makeRequest(url, 'GET', buildHeaders(remote));
-
-    if (response.statusCode !== 200) {
-      const error = JSON.parse(response.body)?.error;
-      throw new RemoteApiError(
-        remoteName,
-        response.statusCode,
-        error?.code ?? 'API_ERROR',
-        error?.message ?? 'Unknown error',
-        error?.details
-      );
-    }
-
-    const data = JSON.parse(response.body) as RemoteHealthResult;
-    updateRemoteLastConnected(remoteName);
-
-    return data;
-  } catch (err) {
-    if (err instanceof RemoteApiError) throw err;
-    throw new RemoteConnectionError(
-      remoteName,
-      remote.url,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-
-/**
- * List packages on a remote
- */
-export async function remoteListPackages(remoteName: string): Promise<RemotePackageList> {
-  const remote = getRemoteOrThrow(remoteName);
-  const url = new URL('/packages', remote.url);
-
-  try {
-    const response = await makeRequest(url, 'GET', buildHeaders(remote));
-
-    if (response.statusCode !== 200) {
-      const error = JSON.parse(response.body)?.error;
-      throw new RemoteApiError(
-        remoteName,
-        response.statusCode,
-        error?.code ?? 'API_ERROR',
-        error?.message ?? 'Unknown error',
-        error?.details
-      );
-    }
-
-    updateRemoteLastConnected(remoteName);
-    return JSON.parse(response.body) as RemotePackageList;
-  } catch (err) {
-    if (err instanceof RemoteApiError) throw err;
-    throw new RemoteConnectionError(
-      remoteName,
-      remote.url,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-
-/**
- * Get package info from a remote
- */
-export async function remotePackageInfo(remoteName: string, packageName: string): Promise<RemotePackageInfo | null> {
-  const remote = getRemoteOrThrow(remoteName);
-  const url = new URL(`/packages/${encodeURIComponent(packageName)}`, remote.url);
-
-  try {
-    const response = await makeRequest(url, 'GET', buildHeaders(remote));
-
-    if (response.statusCode === 404) {
-      return null;
-    }
-
-    if (response.statusCode !== 200) {
-      const error = JSON.parse(response.body)?.error;
-      throw new RemoteApiError(
-        remoteName,
-        response.statusCode,
-        error?.code ?? 'API_ERROR',
-        error?.message ?? 'Unknown error',
-        error?.details
-      );
-    }
-
-    updateRemoteLastConnected(remoteName);
-    return JSON.parse(response.body) as RemotePackageInfo;
-  } catch (err) {
-    if (err instanceof RemoteApiError) throw err;
-    throw new RemoteConnectionError(
-      remoteName,
-      remote.url,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-
-/**
- * Run a tool on a remote
- */
-export async function remoteRunTool(remoteName: string, options: RemoteRunOptions): Promise<RemoteRunResult> {
-  const remote = getRemoteOrThrow(remoteName);
-  const url = new URL('/run', remote.url);
-
-  const body = JSON.stringify({
-    package: options.package,
-    command: options.command,
-    args: options.args,
-    env: options.env,
-    stdin: options.stdin,
-    timeout: options.timeout,
-    scope: options.scope
-  });
-
-  // Use longer timeout for execution (tool timeout + network overhead)
-  const requestTimeout = (options.timeout ?? 30000) + 10000;
-
-  try {
-    const response = await makeRequest(url, 'POST', buildHeaders(remote), body, requestTimeout);
-
-    const data = JSON.parse(response.body);
-
-    // Check for API-level error
-    if (data.error && response.statusCode >= 400 && response.statusCode !== 500) {
-      throw new RemoteApiError(
-        remoteName,
-        response.statusCode,
-        data.error.code ?? 'API_ERROR',
-        data.error.message ?? 'Unknown error',
-        data.error.details
-      );
-    }
-
-    updateRemoteLastConnected(remoteName);
-
-    // Return the run result (may indicate success: false for tool failure)
-    return data as RemoteRunResult;
-  } catch (err) {
-    if (err instanceof RemoteApiError) throw err;
-    throw new RemoteConnectionError(
-      remoteName,
-      remote.url,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-
-/**
- * Run a routine on a remote
- */
-export async function remoteRunRoutine(
-  remoteName: string,
-  routineName: string,
-  vars?: Record<string, string>
-): Promise<RoutineRunSummary> {
-  const remote = getRemoteOrThrow(remoteName);
-  const url = new URL(`/routines/${encodeURIComponent(routineName)}/run`, remote.url);
-
-  const body = vars ? JSON.stringify({ vars }) : '{}';
-
-  try {
-    const response = await makeRequest(url, 'POST', buildHeaders(remote), body, 300000); // 5 min timeout for routines
-
-    if (response.statusCode === 404) {
-      throw new RemoteApiError(
-        remoteName,
-        404,
-        'NOT_FOUND',
-        `Routine not found: ${routineName}`
-      );
-    }
-
-    const data = JSON.parse(response.body);
-
-    if (data.error && response.statusCode >= 400) {
-      throw new RemoteApiError(
-        remoteName,
-        response.statusCode,
-        data.error.code ?? 'API_ERROR',
-        data.error.message ?? 'Unknown error',
-        data.error.details
-      );
-    }
-
-    updateRemoteLastConnected(remoteName);
-    return data as RoutineRunSummary;
-  } catch (err) {
-    if (err instanceof RemoteApiError) throw err;
-    throw new RemoteConnectionError(
-      remoteName,
-      remote.url,
-      err instanceof Error ? err.message : String(err)
-    );
-  }
-}
-
-/**
- * Test connection to a remote
- */
-export async function testRemoteConnection(remoteName: string): Promise<{ success: boolean; message: string; details?: Record<string, unknown> }> {
-  try {
-    const health = await remoteHealth(remoteName);
-    return {
-      success: true,
-      message: `Connected to ${health.hostname}`,
-      details: {
-        hostname: health.hostname,
-        version: health.version,
-        uptime: health.uptime
-      }
-    };
-  } catch (err) {
-    if (err instanceof RemoteConnectionError) {
-      return {
-        success: false,
-        message: err.message
-      };
-    }
-    if (err instanceof RemoteApiError) {
-      return {
-        success: false,
-        message: `${err.code}: ${err.message}`,
-        details: err.details
-      };
-    }
-    return {
-      success: false,
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-}

package/src/core/remotes.ts

@@ -1,268 +0,0 @@
-/**
- * Remote host configuration for distributed cli4ai execution.
- *
- * Manages named remote hosts that can execute cli4ai commands.
- * Each remote is a cli4ai instance running `cli4ai serve`.
- */
-
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { CLI4AI_HOME, ensureCli4aiHome } from './config.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// TYPES
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface RemoteHost {
-  /** Unique name for this remote (e.g., "chrome-server", "gpu-box") */
-  name: string;
-  /** Base URL of the remote cli4ai service (e.g., "http://192.168.1.50:4100") */
-  url: string;
-  /** Optional API key for authentication */
-  apiKey?: string;
-  /** Optional description */
-  description?: string;
-  /** When this remote was added */
-  addedAt: string;
-  /** Last successful connection time */
-  lastConnected?: string;
-}
-
-export interface RemotesConfig {
-  version: 1;
-  remotes: RemoteHost[];
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// PATHS
-// ═══════════════════════════════════════════════════════════════════════════
-
-const REMOTES_FILE = resolve(CLI4AI_HOME, 'remotes.json');
-
-// ═══════════════════════════════════════════════════════════════════════════
-// LOADING & SAVING
-// ═══════════════════════════════════════════════════════════════════════════
-
-const DEFAULT_REMOTES_CONFIG: RemotesConfig = {
-  version: 1,
-  remotes: []
-};
-
-/**
- * Load remotes configuration
- */
-export function loadRemotesConfig(): RemotesConfig {
-  ensureCli4aiHome();
-
-  if (!existsSync(REMOTES_FILE)) {
-    return { ...DEFAULT_REMOTES_CONFIG };
-  }
-
-  try {
-    const content = readFileSync(REMOTES_FILE, 'utf-8');
-    const data = JSON.parse(content);
-
-    // Validate and migrate if needed
-    if (!data.version || data.version !== 1) {
-      return { ...DEFAULT_REMOTES_CONFIG };
-    }
-
-    return data as RemotesConfig;
-  } catch {
-    return { ...DEFAULT_REMOTES_CONFIG };
-  }
-}
-
-/**
- * Save remotes configuration
- */
-export function saveRemotesConfig(config: RemotesConfig): void {
-  ensureCli4aiHome();
-  const content = JSON.stringify(config, null, 2) + '\n';
-  writeFileSync(REMOTES_FILE, content, { mode: 0o600 });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REMOTE MANAGEMENT
-// ═══════════════════════════════════════════════════════════════════════════
-
-export class RemoteNotFoundError extends Error {
-  constructor(public remoteName: string) {
-    super(`Remote not found: ${remoteName}`);
-    this.name = 'RemoteNotFoundError';
-  }
-}
-
-export class RemoteAlreadyExistsError extends Error {
-  constructor(public remoteName: string) {
-    super(`Remote already exists: ${remoteName}`);
-    this.name = 'RemoteAlreadyExistsError';
-  }
-}
-
-export class InvalidRemoteUrlError extends Error {
-  constructor(public url: string, public reason: string) {
-    super(`Invalid remote URL "${url}": ${reason}`);
-    this.name = 'InvalidRemoteUrlError';
-  }
-}
-
-/**
- * Validate and normalize a remote URL
- */
-export function validateRemoteUrl(url: string): string {
-  // Basic URL validation
-  let parsed: URL;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new InvalidRemoteUrlError(url, 'Not a valid URL');
-  }
-
-  // Only allow http and https
-  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-    throw new InvalidRemoteUrlError(url, 'Must use http or https protocol');
-  }
-
-  // Remove trailing slash for consistency
-  let normalized = parsed.origin;
-  if (parsed.pathname && parsed.pathname !== '/') {
-    normalized += parsed.pathname.replace(/\/$/, '');
-  }
-
-  return normalized;
-}
-
-/**
- * Validate remote name (alphanumeric, dashes, underscores)
- */
-export function validateRemoteName(name: string): void {
-  if (!name || name.length === 0) {
-    throw new Error('Remote name cannot be empty');
-  }
-
-  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
-    throw new Error('Remote name must start with a letter and contain only letters, numbers, dashes, and underscores');
-  }
-
-  if (name.length > 64) {
-    throw new Error('Remote name must be 64 characters or less');
-  }
-}
-
-/**
- * Get all configured remotes
- */
-export function getRemotes(): RemoteHost[] {
-  const config = loadRemotesConfig();
-  return config.remotes;
-}
-
-/**
- * Get a remote by name
- */
-export function getRemote(name: string): RemoteHost | null {
-  const config = loadRemotesConfig();
-  return config.remotes.find(r => r.name === name) ?? null;
-}
-
-/**
- * Get a remote by name, throwing if not found
- */
-export function getRemoteOrThrow(name: string): RemoteHost {
-  const remote = getRemote(name);
-  if (!remote) {
-    throw new RemoteNotFoundError(name);
-  }
-  return remote;
-}
-
-/**
- * Add a new remote
- */
-export function addRemote(
-  name: string,
-  url: string,
-  options?: { apiKey?: string; description?: string }
-): RemoteHost {
-  validateRemoteName(name);
-  const normalizedUrl = validateRemoteUrl(url);
-
-  const config = loadRemotesConfig();
-
-  // Check for duplicate name
-  if (config.remotes.some(r => r.name === name)) {
-    throw new RemoteAlreadyExistsError(name);
-  }
-
-  const remote: RemoteHost = {
-    name,
-    url: normalizedUrl,
-    apiKey: options?.apiKey,
-    description: options?.description,
-    addedAt: new Date().toISOString()
-  };
-
-  config.remotes.push(remote);
-  saveRemotesConfig(config);
-
-  return remote;
-}
-
-/**
- * Update an existing remote
- */
-export function updateRemote(
-  name: string,
-  updates: { url?: string; apiKey?: string; description?: string }
-): RemoteHost {
-  const config = loadRemotesConfig();
-  const index = config.remotes.findIndex(r => r.name === name);
-
-  if (index === -1) {
-    throw new RemoteNotFoundError(name);
-  }
-
-  const remote = config.remotes[index];
-
-  if (updates.url !== undefined) {
-    remote.url = validateRemoteUrl(updates.url);
-  }
-  if (updates.apiKey !== undefined) {
-    remote.apiKey = updates.apiKey || undefined;
-  }
-  if (updates.description !== undefined) {
-    remote.description = updates.description || undefined;
-  }
-
-  saveRemotesConfig(config);
-  return remote;
-}
-
-/**
- * Remove a remote
- */
-export function removeRemote(name: string): void {
-  const config = loadRemotesConfig();
-  const index = config.remotes.findIndex(r => r.name === name);
-
-  if (index === -1) {
-    throw new RemoteNotFoundError(name);
-  }
-
-  config.remotes.splice(index, 1);
-  saveRemotesConfig(config);
-}
-
-/**
- * Update last connected time for a remote
- */
-export function updateRemoteLastConnected(name: string): void {
-  const config = loadRemotesConfig();
-  const remote = config.remotes.find(r => r.name === name);
-
-  if (remote) {
-    remote.lastConnected = new Date().toISOString();
-    saveRemotesConfig(config);
-  }
-}