@agento-nexus/sdk 0.1.0

package/dist/chunk-UXIUTT4T.js

@@ -0,0 +1,672 @@
+// src/utils/logger.ts
+var levels = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  constructor(prefix, level = "info") {
+    this.prefix = prefix;
+    this.minLevel = levels[level];
+  }
+  minLevel;
+  debug(msg, data) {
+    this.log("debug", msg, data);
+  }
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  log(level, msg, data) {
+    if (levels[level] < this.minLevel) return;
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component: this.prefix,
+      msg,
+      ...data
+    };
+    const out = level === "error" ? console.error : console.log;
+    out(JSON.stringify(entry));
+  }
+};
+
+// src/template-builder.ts
+import { Sandbox } from "e2b";
+var DEFAULT_BASE_TEMPLATE = "claude";
+var TemplateBuilder = class {
+  log;
+  constructor() {
+    this.log = new Logger("template-builder");
+  }
+  /** Build an E2B template with OpenFang installed */
+  async build(config = {}) {
+    const base = config.baseTemplate ?? DEFAULT_BASE_TEMPLATE;
+    this.log.info("Building template", { base });
+    const sandbox = await Sandbox.create(base, {
+      timeoutMs: 3e5
+    });
+    try {
+      const installCmd = config.openfangVersion ? `pip install openfang==${config.openfangVersion}` : "pip install openfang";
+      this.log.info("Installing OpenFang", { cmd: installCmd });
+      const installResult = await sandbox.commands.run(installCmd, {
+        timeoutMs: 12e4
+      });
+      if (installResult.exitCode !== 0) {
+        throw new Error(
+          `Failed to install OpenFang: ${installResult.stderr}`
+        );
+      }
+      if (config.packages?.length) {
+        const pkgCmd = `pip install ${config.packages.join(" ")}`;
+        this.log.info("Installing additional packages", { cmd: pkgCmd });
+        const pkgResult = await sandbox.commands.run(pkgCmd, {
+          timeoutMs: 12e4
+        });
+        if (pkgResult.exitCode !== 0) {
+          throw new Error(
+            `Failed to install packages: ${pkgResult.stderr}`
+          );
+        }
+      }
+      if (config.setupScript) {
+        this.log.info("Running custom setup script");
+        const setupResult = await sandbox.commands.run(config.setupScript, {
+          timeoutMs: 12e4
+        });
+        if (setupResult.exitCode !== 0) {
+          throw new Error(
+            `Setup script failed: ${setupResult.stderr}`
+          );
+        }
+      }
+      const versionResult = await sandbox.commands.run(
+        "openfang --version",
+        { timeoutMs: 1e4 }
+      );
+      if (versionResult.exitCode !== 0) {
+        throw new Error("OpenFang installation verification failed");
+      }
+      const openfangVersion = versionResult.stdout.trim();
+      this.log.info("OpenFang installed", { version: openfangVersion });
+      return {
+        templateId: sandbox.sandboxId,
+        openfangVersion
+      };
+    } finally {
+      await sandbox.kill();
+    }
+  }
+  /** Verify an existing template has OpenFang ready */
+  async verify(templateId) {
+    this.log.info("Verifying template", { templateId });
+    const sandbox = await Sandbox.create(templateId, {
+      timeoutMs: 6e4
+    });
+    try {
+      const result = await sandbox.commands.run("openfang --version", {
+        timeoutMs: 1e4
+      });
+      if (result.exitCode !== 0) {
+        return { healthy: false, error: "openfang not found" };
+      }
+      return { healthy: true, version: result.stdout.trim() };
+    } catch (error) {
+      return {
+        healthy: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      await sandbox.kill();
+    }
+  }
+};
+
+// src/utils/retry.ts
+var defaults = {
+  maxAttempts: 3,
+  initialDelayMs: 500,
+  maxDelayMs: 1e4,
+  backoffMultiplier: 2
+};
+async function retry(fn, opts = {}) {
+  const { maxAttempts, initialDelayMs, maxDelayMs, backoffMultiplier } = {
+    ...defaults,
+    ...opts
+  };
+  const retryIf = opts.retryIf ?? (() => true);
+  let lastError;
+  let delay = initialDelayMs;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts || !retryIf(error)) {
+        throw error;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * backoffMultiplier, maxDelayMs);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/openfang-client.ts
+var OpenFangClient = class {
+  baseUrl;
+  timeoutMs;
+  retryOpts;
+  log;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.retryOpts = config.retryOptions ?? { maxAttempts: 3 };
+    this.log = new Logger("openfang-client");
+  }
+  /** Check daemon health */
+  async health() {
+    return this.request("GET", "/health");
+  }
+  /** Wait for daemon to become healthy */
+  async waitForHealthy(maxWaitMs = 3e4) {
+    const startTime = Date.now();
+    return retry(
+      async () => {
+        if (Date.now() - startTime > maxWaitMs) {
+          throw new Error(
+            `OpenFang daemon not healthy after ${maxWaitMs}ms`
+          );
+        }
+        return this.health();
+      },
+      { maxAttempts: Math.ceil(maxWaitMs / 2e3), initialDelayMs: 1e3 }
+    );
+  }
+  /** Spawn a new agent from a Hand manifest */
+  async spawnAgent(manifest) {
+    this.log.info("Spawning agent", { name: manifest.name });
+    return this.request("POST", "/agents", manifest);
+  }
+  /** List all running agents */
+  async listAgents() {
+    return this.request("GET", "/agents");
+  }
+  /** Get agent info by ID */
+  async getAgent(agentId) {
+    return this.request("GET", `/agents/${agentId}`);
+  }
+  /** Send a message to an agent */
+  async messageAgent(agentId, content) {
+    return this.request(
+      "POST",
+      `/agents/${agentId}/messages`,
+      { content }
+    );
+  }
+  /** Stop an agent */
+  async stopAgent(agentId) {
+    await this.request("DELETE", `/agents/${agentId}`);
+  }
+  /** List available tools */
+  async listTools() {
+    return this.request("GET", "/tools");
+  }
+  async request(method, path, body) {
+    return retry(async () => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+          method,
+          headers: body ? { "Content-Type": "application/json" } : void 0,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          throw new OpenFangError(
+            `${method} ${path} returned ${res.status}: ${text}`,
+            res.status
+          );
+        }
+        if (res.status === 204) return void 0;
+        return await res.json();
+      } finally {
+        clearTimeout(timer);
+      }
+    }, this.retryOpts);
+  }
+};
+var OpenFangError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "OpenFangError";
+  }
+};
+
+// src/claude-bridge.ts
+var ClaudeBridge = class {
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+    this.log = new Logger("claude-bridge");
+  }
+  log;
+  /** Execute a Claude Code prompt inside the sandbox */
+  async execute(request) {
+    const start = Date.now();
+    const args = this.buildArgs(request);
+    this.log.info("Executing Claude Code", {
+      prompt: request.prompt.slice(0, 100),
+      outputFormat: request.outputFormat
+    });
+    const result = await this.sandbox.commands.run(
+      `claude ${args.join(" ")}`,
+      {
+        cwd: request.cwd ?? "/home/user",
+        timeoutMs: (request.maxTokens ?? 120) * 1e3
+      }
+    );
+    const durationMs = Date.now() - start;
+    const output = result.stdout;
+    let parsed;
+    if (request.outputFormat === "json") {
+      try {
+        parsed = JSON.parse(output);
+      } catch {
+        this.log.warn("Failed to parse JSON output from Claude Code");
+      }
+    }
+    return {
+      output,
+      exitCode: result.exitCode,
+      parsed,
+      durationMs,
+      sessionId: request.sessionId
+    };
+  }
+  /** Check if Claude Code is installed in the sandbox */
+  async isAvailable() {
+    try {
+      const result = await this.sandbox.commands.run("claude --version", {
+        timeoutMs: 1e4
+      });
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  buildArgs(request) {
+    const args = ["-p", this.shellEscape(request.prompt)];
+    if (request.outputFormat === "json") {
+      args.push("--output-format", "json");
+    }
+    if (request.sessionId) {
+      args.push("--session-id", request.sessionId);
+    }
+    if (request.maxTokens) {
+      args.push("--max-tokens", String(request.maxTokens));
+    }
+    if (request.flags) {
+      args.push(...request.flags);
+    }
+    return args;
+  }
+  shellEscape(str) {
+    return `'${str.replace(/'/g, "'\\''")}'`;
+  }
+};
+
+// src/utils/events.ts
+var TypedEmitter = class {
+  listeners = /* @__PURE__ */ new Set();
+  on(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+};
+
+// src/fangbox.ts
+import { Sandbox as Sandbox2 } from "e2b";
+var DEFAULT_TEMPLATE = "openfang-claude";
+var DEFAULT_PORT = 4200;
+var DEFAULT_TIMEOUT = 300;
+var FangBox = class _FangBox {
+  sandbox;
+  client;
+  claudeBridge;
+  events = new TypedEmitter();
+  log;
+  constructor(sandbox, client, claudeBridge) {
+    this.sandbox = sandbox;
+    this.client = client;
+    this.claudeBridge = claudeBridge;
+    this.log = new Logger("fangbox");
+  }
+  /**
+   * Create a new FangBox — spins up sandbox, starts daemon, waits for health.
+   * All commands run inside the E2B cloud sandbox (not local shell).
+   */
+  static async create(config = {}) {
+    const emitter = new TypedEmitter();
+    const log = new Logger("fangbox");
+    const port = config.openfangPort ?? DEFAULT_PORT;
+    emitter.emit({ type: "sandbox:creating" });
+    log.info("Creating sandbox", {
+      template: config.templateId ?? DEFAULT_TEMPLATE
+    });
+    const sandbox = await Sandbox2.create(config.templateId ?? DEFAULT_TEMPLATE, {
+      envs: config.envs,
+      timeoutMs: (config.timeout ?? DEFAULT_TIMEOUT) * 1e3,
+      metadata: config.metadata
+    });
+    const sandboxId = sandbox.sandboxId;
+    emitter.emit({ type: "sandbox:ready", sandboxId });
+    const baseUrl = `https://${sandboxId}-${port}.e2b.dev`;
+    const client = new OpenFangClient({ baseUrl });
+    const claudeBridge = new ClaudeBridge(sandbox);
+    const box = new _FangBox(sandbox, client, claudeBridge);
+    box.events.on((e) => emitter.emit(e));
+    const daemonCmd = ["openfang", "serve", "--port", String(port)].join(" ");
+    emitter.emit({ type: "daemon:starting" });
+    await sandbox.commands.run(daemonCmd, { background: true });
+    try {
+      const health = await client.waitForHealthy(3e4);
+      emitter.emit({ type: "daemon:healthy", version: health.version });
+      log.info("Daemon healthy", { version: health.version });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      emitter.emit({ type: "daemon:unhealthy", error: msg });
+      throw new Error(`OpenFang daemon failed to start: ${msg}`);
+    }
+    return box;
+  }
+  get sandboxId() {
+    return this.sandbox.sandboxId;
+  }
+  /** Check daemon health */
+  async health() {
+    return this.client.health();
+  }
+  /** Spawn an agent from a Hand manifest or name */
+  async spawnAgent(handOrName) {
+    const manifest = typeof handOrName === "string" ? { name: handOrName } : handOrName;
+    const agent = await this.client.spawnAgent(manifest);
+    this.events.emit({
+      type: "agent:spawned",
+      agentId: agent.id,
+      name: agent.name
+    });
+    return agent;
+  }
+  /** Send a message to a running agent */
+  async messageAgent(agentId, content) {
+    const response = await this.client.messageAgent(agentId, content);
+    this.events.emit({
+      type: "agent:message",
+      agentId,
+      content: response.content
+    });
+    return response;
+  }
+  /** List all running agents */
+  async listAgents() {
+    return this.client.listAgents();
+  }
+  /** Stop an agent */
+  async stopAgent(agentId) {
+    await this.client.stopAgent(agentId);
+    this.events.emit({ type: "agent:completed", agentId });
+  }
+  /** Execute Claude Code in the sandbox */
+  async runClaude(request) {
+    return this.claudeBridge.execute(request);
+  }
+  /** Upload a file to the sandbox */
+  async uploadFile(path, content) {
+    await this.sandbox.files.write(path, content);
+  }
+  /** Read a file from the sandbox */
+  async readFile(path) {
+    return this.sandbox.files.read(path);
+  }
+  /**
+   * Run a command inside the E2B cloud sandbox.
+   * This uses E2B's sandbox.commands.run() which executes remotely,
+   * not on the local machine.
+   */
+  async runInSandbox(command, opts) {
+    const result = await this.sandbox.commands.run(command, opts);
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    };
+  }
+  /** Destroy the sandbox */
+  async destroy() {
+    const id = this.sandboxId;
+    this.log.info("Destroying sandbox", { sandboxId: id });
+    await this.sandbox.kill();
+    this.events.emit({ type: "sandbox:destroyed", sandboxId: id });
+    this.events.removeAll();
+  }
+};
+async function createFangBox(config) {
+  return FangBox.create(config);
+}
+
+// src/fleet.ts
+var Fleet = class {
+  events = new TypedEmitter();
+  log;
+  maxConcurrency;
+  defaultTimeout;
+  envs;
+  constructor(config = {}) {
+    this.maxConcurrency = config.maxConcurrency ?? 3;
+    this.defaultTimeout = config.defaultTimeout ?? 300;
+    this.envs = config.envs ?? {};
+    this.log = new Logger("fleet");
+  }
+  /** Run a workflow from a parsed definition */
+  async run(workflow) {
+    const start = Date.now();
+    this.log.info("Starting workflow", { name: workflow.name });
+    this.events.emit({ type: "workflow:start", name: workflow.name });
+    const sorted = this.topologicalSort(workflow.steps);
+    const outputs = {};
+    const results = [];
+    const completed = /* @__PURE__ */ new Set();
+    const pending = [...sorted];
+    while (pending.length > 0) {
+      const ready = pending.filter(
+        (step) => (step.dependsOn ?? []).every((dep) => completed.has(dep))
+      );
+      if (ready.length === 0 && pending.length > 0) {
+        throw new Error(
+          "Deadlock: no steps can proceed. Check for circular dependencies."
+        );
+      }
+      const batch = ready.slice(0, this.maxConcurrency);
+      const batchResults = await Promise.allSettled(
+        batch.map((step) => this.executeStep(step, outputs, workflow.envs))
+      );
+      for (let i = 0; i < batch.length; i++) {
+        const step = batch[i];
+        const settled = batchResults[i];
+        let result;
+        if (settled.status === "fulfilled") {
+          result = settled.value;
+        } else {
+          result = {
+            stepId: step.id,
+            status: "failure",
+            error: settled.reason instanceof Error ? settled.reason.message : String(settled.reason),
+            durationMs: 0
+          };
+        }
+        results.push(result);
+        completed.add(step.id);
+        if (result.status === "success" && step.outputKey && result.output) {
+          outputs[step.outputKey] = result.output;
+        }
+        this.events.emit({ type: "step:complete", stepId: step.id, result });
+        const idx = pending.indexOf(step);
+        if (idx !== -1) pending.splice(idx, 1);
+      }
+    }
+    const status = results.every((r) => r.status === "success") ? "success" : results.some((r) => r.status === "success") ? "partial" : "failure";
+    const workflowResult = {
+      workflowName: workflow.name,
+      status,
+      steps: results,
+      totalDurationMs: Date.now() - start,
+      outputs
+    };
+    this.events.emit({ type: "workflow:complete", result: workflowResult });
+    return workflowResult;
+  }
+  /** Load and run a workflow from a JSON file path */
+  async runFromFile(filePath) {
+    const fs = await import("fs/promises");
+    const content = await fs.readFile(filePath, "utf-8");
+    const workflow = JSON.parse(content);
+    return this.run(workflow);
+  }
+  async executeStep(step, outputs, workflowEnvs) {
+    const start = Date.now();
+    if (step.condition) {
+      const shouldRun = this.evaluateCondition(step.condition, outputs);
+      if (!shouldRun) {
+        this.events.emit({
+          type: "step:skip",
+          stepId: step.id,
+          reason: `Condition not met: ${step.condition}`
+        });
+        return {
+          stepId: step.id,
+          status: "skipped",
+          durationMs: Date.now() - start
+        };
+      }
+    }
+    this.events.emit({ type: "step:start", stepId: step.id });
+    this.log.info("Executing step", { stepId: step.id, name: step.name });
+    const box = await createFangBox({
+      ...step.config,
+      envs: { ...this.envs, ...workflowEnvs, ...step.config?.envs },
+      timeout: step.timeout ?? this.defaultTimeout
+    });
+    try {
+      const prompt = this.interpolate(step.prompt, outputs);
+      const manifest = typeof step.hand === "string" ? { name: step.hand } : step.hand;
+      const agent = await box.spawnAgent(manifest);
+      const response = await box.messageAgent(agent.id, prompt);
+      return {
+        stepId: step.id,
+        status: "success",
+        output: response.content,
+        durationMs: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        stepId: step.id,
+        status: "failure",
+        error: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - start
+      };
+    } finally {
+      await box.destroy();
+    }
+  }
+  /** Interpolate {{outputKey}} placeholders in a string */
+  interpolate(template, outputs) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+      return outputs[key] ?? match;
+    });
+  }
+  /**
+   * Evaluate a condition against available outputs.
+   * Supports safe expressions: "outputKey", "!outputKey",
+   * "outputKey == 'value'", "outputKey != 'value'"
+   */
+  evaluateCondition(condition, outputs) {
+    const trimmed = condition.trim();
+    if (trimmed.startsWith("!")) {
+      const key = trimmed.slice(1).trim();
+      return !outputs[key];
+    }
+    const eqMatch = trimmed.match(/^(\w+)\s*(==|!=)\s*['"](.*)['"]$/);
+    if (eqMatch) {
+      const [, key, op, value] = eqMatch;
+      const actual = outputs[key];
+      return op === "==" ? actual === value : actual !== value;
+    }
+    return Boolean(outputs[trimmed]);
+  }
+  /** Topological sort of workflow steps using Kahn's algorithm */
+  topologicalSort(steps) {
+    const stepMap = new Map(steps.map((s) => [s.id, s]));
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      inDegree.set(step.id, (step.dependsOn ?? []).length);
+      for (const dep of step.dependsOn ?? []) {
+        const existing = adjacency.get(dep) ?? [];
+        existing.push(step.id);
+        adjacency.set(dep, existing);
+      }
+    }
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+      if (degree === 0) queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      sorted.push(stepMap.get(id));
+      for (const neighbor of adjacency.get(id) ?? []) {
+        const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) queue.push(neighbor);
+      }
+    }
+    if (sorted.length !== steps.length) {
+      throw new Error("Workflow contains circular dependencies");
+    }
+    return sorted;
+  }
+};
+
+export {
+  Logger,
+  TemplateBuilder,
+  retry,
+  OpenFangClient,
+  OpenFangError,
+  ClaudeBridge,
+  TypedEmitter,
+  FangBox,
+  createFangBox,
+  Fleet
+};
+//# sourceMappingURL=chunk-UXIUTT4T.js.map