@itz4blitz/agentful 1.2.0 → 1.3.0

package/lib/pipeline/schemas.js

@@ -1,288 +0,0 @@
-/**
- * JSON Schemas for Pipeline Definitions
- *
- * Provides validation schemas for pipeline YAML files
- */
-
-export const pipelineSchema = {
-  type: 'object',
-  required: ['name', 'jobs'],
-  properties: {
-    name: {
-      type: 'string',
-      description: 'Pipeline name',
-      pattern: '^[a-z0-9-]+$'
-    },
-    version: {
-      type: 'string',
-      description: 'Pipeline version',
-      pattern: '^\\d+\\.\\d+(\\.\\d+)?$',
-      default: '1.0'
-    },
-    description: {
-      type: 'string',
-      description: 'Pipeline description'
-    },
-    triggers: {
-      type: 'array',
-      description: 'Pipeline triggers',
-      items: {
-        $ref: '#/definitions/trigger'
-      }
-    },
-    env: {
-      type: 'object',
-      description: 'Environment variables',
-      additionalProperties: { type: 'string' }
-    },
-    jobs: {
-      type: 'array',
-      description: 'Pipeline jobs',
-      minItems: 1,
-      items: {
-        $ref: '#/definitions/job'
-      }
-    },
-    concurrency: {
-      type: 'object',
-      description: 'Concurrency settings',
-      properties: {
-        maxConcurrentJobs: {
-          type: 'integer',
-          minimum: 1,
-          maximum: 10,
-          default: 3
-        },
-        cancelInProgress: {
-          type: 'boolean',
-          default: false
-        }
-      }
-    },
-    timeout: {
-      type: 'integer',
-      description: 'Default job timeout in milliseconds',
-      minimum: 1000,
-      default: 1800000 // 30 minutes
-    }
-  },
-  definitions: {
-    trigger: {
-      type: 'object',
-      required: ['type'],
-      properties: {
-        type: {
-          type: 'string',
-          enum: ['push', 'pull_request', 'schedule', 'manual', 'webhook']
-        },
-        branches: {
-          type: 'array',
-          items: { type: 'string' }
-        },
-        cron: {
-          type: 'string',
-          description: 'Cron expression for scheduled triggers'
-        },
-        webhook: {
-          type: 'object',
-          properties: {
-            secret: { type: 'string' },
-            filters: { type: 'object' }
-          }
-        }
-      }
-    },
-    job: {
-      type: 'object',
-      required: ['id', 'agent'],
-      properties: {
-        id: {
-          type: 'string',
-          description: 'Unique job identifier',
-          pattern: '^[a-z0-9-]+$'
-        },
-        name: {
-          type: 'string',
-          description: 'Human-readable job name'
-        },
-        agent: {
-          type: 'string',
-          description: 'Agent to execute (name or path)'
-        },
-        task: {
-          type: 'string',
-          description: 'Task description for the agent'
-        },
-        prompt: {
-          type: 'string',
-          description: 'Additional prompt instructions'
-        },
-        dependsOn: {
-          oneOf: [
-            { type: 'string' },
-            { type: 'array', items: { type: 'string' } }
-          ],
-          description: 'Job dependencies'
-        },
-        when: {
-          type: 'string',
-          description: 'Conditional execution expression'
-        },
-        inputs: {
-          type: 'object',
-          description: 'Job-specific inputs',
-          additionalProperties: true
-        },
-        timeout: {
-          type: 'integer',
-          description: 'Job timeout in milliseconds',
-          minimum: 1000
-        },
-        retry: {
-          $ref: '#/definitions/retry'
-        },
-        continueOnError: {
-          type: 'boolean',
-          description: 'Continue pipeline even if this job fails',
-          default: false
-        },
-        execution: {
-          type: 'object',
-          description: 'Execution configuration',
-          properties: {
-            method: {
-              type: 'string',
-              enum: ['subprocess', 'api'],
-              default: 'subprocess'
-            },
-            isolation: {
-              type: 'string',
-              enum: ['shared', 'isolated'],
-              default: 'shared'
-            }
-          }
-        },
-        runsOn: {
-          type: 'string',
-          description: 'Runner environment (for CI/CD integrations)',
-          default: 'ubuntu-latest'
-        },
-        stage: {
-          type: 'string',
-          description: 'Pipeline stage (for GitLab CI)',
-          default: 'test'
-        },
-        setup: {
-          type: 'array',
-          description: 'Setup steps before job execution',
-          items: {
-            type: 'object',
-            required: ['command'],
-            properties: {
-              name: { type: 'string' },
-              command: { type: 'string' }
-            }
-          }
-        }
-      }
-    },
-    retry: {
-      type: 'object',
-      description: 'Retry policy',
-      properties: {
-        maxAttempts: {
-          type: 'integer',
-          minimum: 0,
-          maximum: 5,
-          default: 0
-        },
-        backoff: {
-          type: 'string',
-          enum: ['exponential', 'linear', 'fixed'],
-          default: 'exponential'
-        },
-        delayMs: {
-          type: 'integer',
-          minimum: 0,
-          default: 2000
-        }
-      }
-    }
-  }
-};
-
-/**
- * Validate pipeline definition
- *
- * @param {Object} pipeline - Pipeline definition
- * @returns {Object} Validation result { valid: boolean, errors: array }
- */
-export function validatePipeline(pipeline) {
-  // Basic validation
-  const errors = [];
-
-  if (!pipeline || typeof pipeline !== 'object') {
-    errors.push('Pipeline must be a valid object');
-    return { valid: false, errors };
-  }
-
-  if (!pipeline.name) {
-    errors.push('Pipeline must have a name');
-  }
-
-  if (!pipeline.jobs || !Array.isArray(pipeline.jobs) || pipeline.jobs.length === 0) {
-    errors.push('Pipeline must have at least one job');
-  }
-
-  // Collect all job IDs first
-  const jobIds = new Set();
-  for (const job of pipeline.jobs || []) {
-    if (job.id) {
-      if (jobIds.has(job.id)) {
-        errors.push(`Duplicate job id: ${job.id}`);
-      } else {
-        jobIds.add(job.id);
-      }
-    }
-  }
-
-  // Validate jobs
-  for (const job of pipeline.jobs || []) {
-    // Check if job is a valid object
-    if (!job || typeof job !== 'object') {
-      errors.push('Each job must be a valid object');
-      continue;
-    }
-
-    if (!job.id) {
-      errors.push('Each job must have an id');
-    }
-
-    if (!job.agent) {
-      errors.push(`Job ${job.id} must specify an agent`);
-    }
-
-    // Validate dependencies
-    if ('dependsOn' in job) {
-      const deps = Array.isArray(job.dependsOn) ? job.dependsOn : [job.dependsOn];
-      for (const depId of deps) {
-        // Check for empty string or invalid values
-        if (typeof depId !== 'string' || depId === '') {
-          errors.push(`Job ${job.id} depends on unknown job: ${depId}`);
-        } else if (!jobIds.has(depId)) {
-          errors.push(`Job ${job.id} depends on unknown job: ${depId}`);
-        }
-      }
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-
-export default {
-  pipelineSchema,
-  validatePipeline
-};

package/lib/remote/client.js

@@ -1,361 +0,0 @@
-/**
- * Agentful Remote Client
- *
- * HTTP client for triggering agent execution on remote agentful servers.
- * Supports Tailscale, HMAC, and SSH tunnel authentication modes.
- *
- * @module remote/client
- */
-
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-/**
- * Remote configuration storage
- */
-const CONFIG_DIR = path.join(os.homedir(), '.agentful');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'remotes.json');
-
-/**
- * Ensure config directory exists
- */
-function ensureConfigDir() {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-}
-
-/**
- * Load remote configurations
- * @returns {Object} Remote configurations
- */
-export function loadRemotes() {
-  ensureConfigDir();
-
-  if (!fs.existsSync(CONFIG_FILE)) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
-  } catch (error) {
-    console.error('Failed to load remotes.json:', error.message);
-    return {};
-  }
-}
-
-/**
- * Save remote configurations
- * @param {Object} remotes - Remote configurations
- */
-export function saveRemotes(remotes) {
-  ensureConfigDir();
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(remotes, null, 2), 'utf-8');
-}
-
-/**
- * Add a remote configuration
- * @param {string} name - Remote name
- * @param {string} url - Server URL
- * @param {Object} options - Remote options
- * @param {string} [options.auth='tailscale'] - Auth mode
- * @param {string} [options.secret] - HMAC secret
- */
-export function addRemote(name, url, options = {}) {
-  const { auth = 'tailscale', secret } = options;
-
-  // Validate auth mode
-  if (auth === 'hmac' && !secret) {
-    throw new Error('HMAC auth requires --secret');
-  }
-
-  // Parse and validate URL
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(url);
-  } catch (error) {
-    throw new Error(`Invalid URL: ${url}`);
-  }
-
-  const remotes = loadRemotes();
-
-  remotes[name] = {
-    url: parsedUrl.toString(),
-    auth,
-    secret: secret || null,
-    added: new Date().toISOString(),
-  };
-
-  saveRemotes(remotes);
-}
-
-/**
- * Remove a remote configuration
- * @param {string} name - Remote name
- */
-export function removeRemote(name) {
-  const remotes = loadRemotes();
-
-  if (!remotes[name]) {
-    throw new Error(`Remote not found: ${name}`);
-  }
-
-  delete remotes[name];
-  saveRemotes(remotes);
-}
-
-/**
- * Get a remote configuration
- * @param {string} name - Remote name
- * @returns {Object} Remote configuration
- */
-export function getRemote(name) {
-  const remotes = loadRemotes();
-
-  if (!remotes[name]) {
-    throw new Error(`Remote not found: ${name}. Run: agentful remote add ${name} <url>`);
-  }
-
-  return remotes[name];
-}
-
-/**
- * List all remote configurations
- * @returns {Object} Remote configurations
- */
-export function listRemotes() {
-  return loadRemotes();
-}
-
-/**
- * Generate HMAC signature for request
- * @param {string} body - Request body
- * @param {string} secret - HMAC secret
- * @returns {Object} Headers with signature
- */
-function generateHMACHeaders(body, secret) {
-  const timestamp = Date.now().toString();
-  const signature = crypto
-    .createHmac('sha256', secret)
-    .update(timestamp + body)
-    .digest('hex');
-
-  return {
-    'X-Agentful-Signature': signature,
-    'X-Agentful-Timestamp': timestamp,
-  };
-}
-
-/**
- * Execute an agent on a remote server
- * @param {string} remoteName - Remote name
- * @param {string} agent - Agent name
- * @param {string} task - Task description
- * @param {Object} options - Execution options
- * @param {number} [options.timeout] - Execution timeout in ms
- * @param {Object} [options.env] - Environment variables
- * @returns {Promise<Object>} Execution result
- */
-export async function executeRemoteAgent(remoteName, agent, task, options = {}) {
-  const remote = getRemote(remoteName);
-  const { timeout, env } = options;
-
-  // Build request body
-  const body = JSON.stringify({
-    agent,
-    task,
-    timeout,
-    env,
-  });
-
-  // Build headers
-  const headers = {
-    'Content-Type': 'application/json',
-  };
-
-  // Add HMAC signature if needed
-  if (remote.auth === 'hmac') {
-    Object.assign(headers, generateHMACHeaders(body, remote.secret));
-  }
-
-  // Make request
-  const response = await fetch(`${remote.url}/trigger`, {
-    method: 'POST',
-    headers,
-    body,
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(`Request failed (${response.status}): ${error.message || error.error}`);
-  }
-
-  return await response.json();
-}
-
-/**
- * Get execution status from remote server
- * @param {string} remoteName - Remote name
- * @param {string} executionId - Execution ID
- * @returns {Promise<Object>} Execution status
- */
-export async function getRemoteExecutionStatus(remoteName, executionId) {
-  const remote = getRemote(remoteName);
-
-  // Build headers
-  const headers = {};
-
-  // Add HMAC signature if needed
-  if (remote.auth === 'hmac') {
-    Object.assign(headers, generateHMACHeaders('', remote.secret));
-  }
-
-  // Make request
-  const response = await fetch(`${remote.url}/status/${executionId}`, {
-    method: 'GET',
-    headers,
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(`Request failed (${response.status}): ${error.message || error.error}`);
-  }
-
-  return await response.json();
-}
-
-/**
- * List executions on remote server
- * @param {string} remoteName - Remote name
- * @param {Object} filters - Filter options
- * @param {string} [filters.agent] - Filter by agent name
- * @param {string} [filters.state] - Filter by state
- * @param {number} [filters.limit] - Maximum number of results
- * @returns {Promise<Object>} Executions list
- */
-export async function listRemoteExecutions(remoteName, filters = {}) {
-  const remote = getRemote(remoteName);
-
-  // Build query string
-  const params = new URLSearchParams();
-  if (filters.agent) params.append('agent', filters.agent);
-  if (filters.state) params.append('state', filters.state);
-  if (filters.limit) params.append('limit', filters.limit.toString());
-
-  // Build headers
-  const headers = {};
-
-  // Add HMAC signature if needed
-  if (remote.auth === 'hmac') {
-    Object.assign(headers, generateHMACHeaders('', remote.secret));
-  }
-
-  // Make request
-  const url = `${remote.url}/executions${params.toString() ? '?' + params.toString() : ''}`;
-  const response = await fetch(url, {
-    method: 'GET',
-    headers,
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(`Request failed (${response.status}): ${error.message || error.error}`);
-  }
-
-  return await response.json();
-}
-
-/**
- * List available agents on remote server
- * @param {string} remoteName - Remote name
- * @returns {Promise<Object>} Agents list
- */
-export async function listRemoteAgents(remoteName) {
-  const remote = getRemote(remoteName);
-
-  // Build headers
-  const headers = {};
-
-  // Add HMAC signature if needed
-  if (remote.auth === 'hmac') {
-    Object.assign(headers, generateHMACHeaders('', remote.secret));
-  }
-
-  // Make request
-  const response = await fetch(`${remote.url}/agents`, {
-    method: 'GET',
-    headers,
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(`Request failed (${response.status}): ${error.message || error.error}`);
-  }
-
-  return await response.json();
-}
-
-/**
- * Check remote server health
- * @param {string} remoteName - Remote name
- * @returns {Promise<Object>} Health status
- */
-export async function checkRemoteHealth(remoteName) {
-  const remote = getRemote(remoteName);
-
-  // No auth required for /health endpoint
-  const response = await fetch(`${remote.url}/health`, {
-    method: 'GET',
-  });
-
-  if (!response.ok) {
-    const error = await response.json().catch(() => ({ message: response.statusText }));
-    throw new Error(`Health check failed (${response.status}): ${error.message || error.error}`);
-  }
-
-  return await response.json();
-}
-
-/**
- * Poll execution until completion
- * @param {string} remoteName - Remote name
- * @param {string} executionId - Execution ID
- * @param {Object} options - Polling options
- * @param {number} [options.interval=5000] - Polling interval in ms
- * @param {Function} [options.onUpdate] - Callback for status updates
- * @returns {Promise<Object>} Final execution status
- */
-export async function pollExecution(remoteName, executionId, options = {}) {
-  const { interval = 5000, onUpdate } = options;
-
-  while (true) {
-    const status = await getRemoteExecutionStatus(remoteName, executionId);
-
-    if (onUpdate) {
-      onUpdate(status);
-    }
-
-    // Check if completed
-    if (status.state === 'completed' || status.state === 'failed') {
-      return status;
-    }
-
-    // Wait before next poll
-    await new Promise((resolve) => setTimeout(resolve, interval));
-  }
-}
-
-export default {
-  addRemote,
-  removeRemote,
-  getRemote,
-  listRemotes,
-  executeRemoteAgent,
-  getRemoteExecutionStatus,
-  listRemoteExecutions,
-  listRemoteAgents,
-  checkRemoteHealth,
-  pollExecution,
-};