@elisym/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2134 @@
+#!/usr/bin/env node --no-deprecation
+import { readFileSync, writeFileSync, readdirSync, statSync, rmSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, basename, dirname } from 'node:path';
+import { SolanaPaymentStrategy, validateAgentName, ElisymIdentity, MediaService, RELAYS, formatSol, ElisymClient, jobRequestKind, DEFAULT_KIND_OFFSET, DEFAULTS, serializeConfig, LIMITS, calculateProtocolFee, BoundedSet } from '@elisym/sdk';
+import { isEncrypted, parseConfig, encryptSecret } from '@elisym/sdk/node';
+import { PublicKey, Connection } from '@solana/web3.js';
+import { nip19, getPublicKey, generateSecretKey } from 'nostr-tools';
+import { Command } from 'commander';
+import pLimit from 'p-limit';
+import YAML from 'yaml';
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function agentDir(name) {
+  return join(AGENTS_ROOT, name);
+}
+function configPath(name) {
+  return join(AGENTS_ROOT, name, "config.json");
+}
+function loadConfig(name, passphrase) {
+  validateAgentName(name);
+  const path = configPath(name);
+  const raw = readFileSync(path, "utf-8");
+  return parseConfig(raw, passphrase);
+}
+function saveConfig(config) {
+  validateAgentName(config.identity.name);
+  const dir = agentDir(config.identity.name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "config.json"), serializeConfig(config), { mode: 384 });
+}
+function listAgents() {
+  try {
+    return readdirSync(AGENTS_ROOT).filter((name) => {
+      try {
+        statSync(join(AGENTS_ROOT, name, "config.json"));
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function deleteAgent(name) {
+  validateAgentName(name);
+  const dir = agentDir(name);
+  for (const file of ["config.json", "jobs.json"]) {
+    try {
+      const filePath = join(dir, file);
+      const size = statSync(filePath).size;
+      writeFileSync(filePath, Buffer.alloc(size, 0));
+    } catch {
+    }
+  }
+  try {
+    for (const entry of readdirSync(dir)) {
+      if (entry.startsWith("jobs.json.corrupt.")) {
+        try {
+          const fp = join(dir, entry);
+          writeFileSync(fp, Buffer.alloc(statSync(fp).size, 0));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  rmSync(dir, { recursive: true, force: true });
+}
+var AGENTS_ROOT;
+var init_config = __esm({
+  "src/config.ts"() {
+    AGENTS_ROOT = join(homedir(), ".elisym", "agents");
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  cmdInit: () => cmdInit,
+  fetchModels: () => fetchModels
+});
+async function resolveImage(input, identity, media) {
+  if (!input) {
+    return "";
+  }
+  if (existsSync(input)) {
+    console.log(`  Uploading ${basename(input)}...`);
+    const data = readFileSync(input);
+    const blob = new Blob([data]);
+    const url = await media.upload(identity, blob, basename(input));
+    console.log(`  Uploaded: ${url}`);
+    return url;
+  }
+  return input;
+}
+async function fetchModels(provider, apiKey) {
+  try {
+    if (provider === "anthropic") {
+      const res = await fetch("https://api.anthropic.com/v1/models?limit=1000", {
+        headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" }
+      });
+      if (!res.ok) {
+        throw new Error(`${res.status}`);
+      }
+      const data = await res.json();
+      const models = (data.data ?? []).map((m) => m.id).sort();
+      return models.length > 0 ? models : FALLBACK_MODELS.anthropic;
+    }
+    if (provider === "openai") {
+      const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) {
+        throw new Error(`${res.status}`);
+      }
+      const data = await res.json();
+      const models = (data.data ?? []).map((m) => m.id).filter(
+        (id) => (id.startsWith("gpt-") || id.startsWith("o1") || id.startsWith("o3") || id.startsWith("o4") || id.startsWith("chatgpt-")) && !id.includes("instruct") && !id.includes("realtime") && !id.includes("audio") && !id.includes("tts") && !id.includes("whisper")
+      ).sort();
+      return models.length > 0 ? models : FALLBACK_MODELS.openai;
+    }
+    return ["gpt-4o"];
+  } catch (e) {
+    console.warn(`  ! Could not fetch models: ${e.message}. Using defaults.`);
+    return FALLBACK_MODELS[provider] ?? ["gpt-4o"];
+  }
+}
+async function cmdInit() {
+  const { default: inquirer } = await import('inquirer');
+  console.log("\n  elisym agent setup\n");
+  const { name } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name:",
+      validate: (v) => {
+        try {
+          validateAgentName(v);
+          return true;
+        } catch (e) {
+          return e.message;
+        }
+      }
+    }
+  ]);
+  const existing = listAgents();
+  if (existing.includes(name)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `Agent "${name}" already exists. Overwrite?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const { description } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: "An elisym AI agent"
+    }
+  ]);
+  const { pictureInput } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "pictureInput",
+      message: "Avatar image (URL or local path, optional):",
+      default: ""
+    }
+  ]);
+  const { bannerInput } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "bannerInput",
+      message: "Banner image (URL or local path, optional):",
+      default: ""
+    }
+  ]);
+  const { solanaAddress } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "solanaAddress",
+      message: "Solana address for receiving payments (leave empty to skip):",
+      default: "",
+      validate: (v) => {
+        if (!v) {
+          return true;
+        }
+        try {
+          const pk = new PublicKey(v);
+          return pk.toBase58().length > 0;
+        } catch {
+          return "Invalid Solana address";
+        }
+      }
+    }
+  ]);
+  const { network } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "network",
+      message: "Solana network:",
+      choices: [
+        { name: "devnet", value: "devnet" },
+        { name: "testnet", value: "testnet" },
+        { name: "mainnet", value: "mainnet" }
+      ],
+      default: "devnet"
+    }
+  ]);
+  const { llmProvider } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "llmProvider",
+      message: "LLM provider:",
+      choices: [
+        { name: "Anthropic (Claude)", value: "anthropic" },
+        { name: "OpenAI (GPT)", value: "openai" }
+      ]
+    }
+  ]);
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: `${llmProvider === "anthropic" ? "Anthropic" : "OpenAI"} API key:`,
+      mask: "*"
+    }
+  ]);
+  console.log("  Fetching available models...");
+  const models = await fetchModels(llmProvider, apiKey);
+  const { model } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "model",
+      message: "Model:",
+      choices: models
+    }
+  ]);
+  const { maxTokens } = await inquirer.prompt([
+    {
+      type: "number",
+      name: "maxTokens",
+      message: "Max tokens:",
+      default: 4096
+    }
+  ]);
+  const { passphrase } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "passphrase",
+      message: "Passphrase to encrypt secrets (leave empty to skip):",
+      mask: "*"
+    }
+  ]);
+  if (passphrase) {
+    const { confirmPassphrase } = await inquirer.prompt([
+      {
+        type: "password",
+        name: "confirmPassphrase",
+        message: "Confirm passphrase:",
+        mask: "*",
+        validate: (v) => v === passphrase ? true : "Passphrases do not match"
+      }
+    ]);
+  }
+  const nostrSecretKey = generateSecretKey();
+  const nostrPubkey = getPublicKey(nostrSecretKey);
+  const nostrSecretHex = Buffer.from(nostrSecretKey).toString("hex");
+  const identity = ElisymIdentity.fromHex(nostrSecretHex);
+  const media = new MediaService();
+  let picture = "";
+  let banner = "";
+  if (pictureInput || bannerInput) {
+    console.log();
+    if (pictureInput) {
+      picture = await resolveImage(pictureInput, identity, media);
+    }
+    if (bannerInput) {
+      banner = await resolveImage(bannerInput, identity, media);
+    }
+  }
+  const protect = (secret) => passphrase ? encryptSecret(secret, passphrase) : secret;
+  const config = {
+    identity: {
+      secret_key: protect(nostrSecretHex),
+      name,
+      description,
+      picture: picture || void 0,
+      banner: banner || void 0
+    },
+    relays: [...RELAYS],
+    payments: solanaAddress ? [{ chain: "solana", network, address: solanaAddress }] : void 0,
+    llm: {
+      provider: llmProvider,
+      api_key: protect(apiKey),
+      model,
+      max_tokens: maxTokens
+    }
+  };
+  saveConfig(config);
+  const npub = nip19.npubEncode(nostrPubkey);
+  console.log(`
+  Agent "${name}" created.`);
+  console.log(`  Nostr:  ${npub}`);
+  if (solanaAddress) {
+    console.log(`  Solana: ${solanaAddress}`);
+  }
+  if (passphrase) {
+    console.log("  Secrets encrypted with your passphrase.");
+  }
+  console.log(`  Config: ~/.elisym/agents/${name}/config.json
+`);
+}
+var FALLBACK_MODELS;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    init_config();
+    FALLBACK_MODELS = {
+      anthropic: ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"],
+      openai: ["gpt-4o", "gpt-4o-mini", "o3-mini"]
+    };
+  }
+});
+
+// src/index.ts
+init_init();
+
+// src/commands/profile.ts
+init_config();
+async function resolveImage2(input, identity, media) {
+  if (!input) {
+    return "";
+  }
+  if (existsSync(input)) {
+    console.log(`  Uploading ${basename(input)}...`);
+    const data = readFileSync(input);
+    const blob = new Blob([data]);
+    const url = await media.upload(identity, blob, basename(input));
+    console.log(`  Uploaded: ${url}`);
+    return url;
+  }
+  return input;
+}
+async function cmdProfile(name) {
+  const { default: inquirer } = await import('inquirer');
+  if (!name) {
+    const agents = listAgents();
+    if (agents.length === 0) {
+      console.error("No agents found. Run `elisym init` first.");
+      process.exit(1);
+    }
+    const { selected } = await inquirer.prompt([
+      { type: "list", name: "selected", message: "Select agent:", choices: agents }
+    ]);
+    name = selected;
+  }
+  const passphrase = process.env.ELISYM_PASSPHRASE;
+  const config = loadConfig(name, passphrase);
+  const identity = ElisymIdentity.fromHex(config.identity.secret_key);
+  console.log(`
+  Editing agent "${name}"
+`);
+  let done = false;
+  while (!done) {
+    const { section } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "section",
+        message: "What to edit?",
+        choices: [
+          { name: `Profile (name: ${config.identity.name})`, value: "profile" },
+          {
+            name: `Wallet (${config.payments?.[0]?.address ?? "not configured"})`,
+            value: "wallet"
+          },
+          {
+            name: `LLM (${config.llm?.provider ?? "not configured"} / ${config.llm?.model ?? "-"})`,
+            value: "llm"
+          },
+          { name: "Done", value: "done" }
+        ]
+      }
+    ]);
+    if (section === "done") {
+      done = true;
+      continue;
+    }
+    if (section === "profile") {
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "description",
+          message: "Description:",
+          default: config.identity.description ?? ""
+        },
+        {
+          type: "input",
+          name: "picture",
+          message: "Avatar (URL or local path):",
+          default: config.identity.picture ?? ""
+        },
+        {
+          type: "input",
+          name: "banner",
+          message: "Banner (URL or local path):",
+          default: config.identity.banner ?? ""
+        }
+      ]);
+      config.identity.description = answers.description || void 0;
+      const media = new MediaService();
+      if (answers.picture) {
+        config.identity.picture = await resolveImage2(answers.picture, identity, media);
+      } else {
+        config.identity.picture = void 0;
+      }
+      if (answers.banner) {
+        config.identity.banner = await resolveImage2(answers.banner, identity, media);
+      } else {
+        config.identity.banner = void 0;
+      }
+      saveConfig(config);
+      console.log("  Profile updated.\n");
+    }
+    if (section === "wallet") {
+      const currentAddress = config.payments?.[0]?.address ?? "";
+      const currentNetwork = config.payments?.[0]?.network ?? "devnet";
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "address",
+          message: "Solana address:",
+          default: currentAddress,
+          validate: (v) => {
+            if (!v) {
+              return true;
+            }
+            try {
+              const pk = new PublicKey(v);
+              return pk.toBase58().length > 0;
+            } catch {
+              return "Invalid Solana address";
+            }
+          }
+        },
+        {
+          type: "list",
+          name: "network",
+          message: "Network:",
+          choices: ["devnet", "testnet", "mainnet"],
+          default: currentNetwork
+        }
+      ]);
+      if (answers.address) {
+        config.payments = [{ chain: "solana", network: answers.network, address: answers.address }];
+      } else {
+        config.payments = void 0;
+      }
+      saveConfig(config);
+      console.log("  Wallet updated.\n");
+    }
+    if (section === "llm") {
+      const { llmProvider } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "llmProvider",
+          message: "LLM provider:",
+          choices: [
+            { name: "Anthropic (Claude)", value: "anthropic" },
+            { name: "OpenAI (GPT)", value: "openai" }
+          ],
+          default: config.llm?.provider ?? "anthropic"
+        }
+      ]);
+      const { apiKey } = await inquirer.prompt([
+        {
+          type: "password",
+          name: "apiKey",
+          message: `API key (leave empty to keep current):`,
+          mask: "*"
+        }
+      ]);
+      const effectiveKey = apiKey || config.llm?.api_key || "";
+      let plainKey = effectiveKey;
+      if (isEncrypted(plainKey) && passphrase) {
+        const { decryptSecret } = await import('@elisym/sdk/node');
+        plainKey = decryptSecret(plainKey, passphrase);
+      }
+      console.log("  Fetching available models...");
+      const { fetchModels: fetchModels2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      const models = await fetchModels2(llmProvider, plainKey);
+      const { model } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "model",
+          message: "Model:",
+          choices: models,
+          default: config.llm?.model
+        }
+      ]);
+      const { maxTokens } = await inquirer.prompt([
+        {
+          type: "number",
+          name: "maxTokens",
+          message: "Max tokens:",
+          default: config.llm?.max_tokens ?? 4096
+        }
+      ]);
+      const protect = (secret) => passphrase ? encryptSecret(secret, passphrase) : secret;
+      config.llm = {
+        provider: llmProvider,
+        api_key: apiKey ? protect(apiKey) : effectiveKey,
+        model,
+        max_tokens: maxTokens
+      };
+      saveConfig(config);
+      console.log("  LLM updated.\n");
+    }
+  }
+  console.log(`  Agent "${name}" saved.
+`);
+}
+
+// src/commands/start.ts
+init_config();
+var HEARTBEAT_INTERVAL_MS = 10 * 60 * 1e3;
+var MAX_CONCURRENT_JOBS = 10;
+var RECOVERY_MAX_RETRIES = 5;
+var RECOVERY_INTERVAL_SECS = 60;
+function getRpcUrl(network) {
+  const envUrl = process.env.SOLANA_RPC_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  switch (network) {
+    case "mainnet":
+      return "https://api.mainnet-beta.solana.com";
+    case "testnet":
+      return "https://api.testnet.solana.com";
+    default:
+      return "https://api.devnet.solana.com";
+  }
+}
+var VALID_TRANSITIONS = {
+  paid: ["executed", "failed"],
+  executed: ["delivered", "failed"],
+  delivered: [],
+  failed: []
+};
+var JobLedger = class {
+  entries = /* @__PURE__ */ new Map();
+  path;
+  constructor(agentName) {
+    this.path = join(homedir(), ".elisym", "agents", agentName, "jobs.json");
+    this.load();
+  }
+  load() {
+    try {
+      const raw = readFileSync(this.path, "utf-8");
+      const data = JSON.parse(raw);
+      for (const [id, entry] of Object.entries(data)) {
+        this.entries.set(id, entry);
+      }
+    } catch (e) {
+      if (e?.code !== "ENOENT") {
+        console.warn(`  ! Ledger load warning: ${e?.message ?? "unknown error"}`);
+        try {
+          renameSync(this.path, this.path + ".corrupt." + Date.now());
+        } catch {
+        }
+      }
+    }
+  }
+  flush() {
+    const dir = dirname(this.path);
+    mkdirSync(dir, { recursive: true });
+    const obj = Object.fromEntries(this.entries);
+    const tmp = this.path + ".tmp";
+    writeFileSync(tmp, JSON.stringify(obj, null, 2));
+    renameSync(tmp, this.path);
+  }
+  recordPaid(entry) {
+    if (this.entries.has(entry.job_id)) {
+      return;
+    }
+    this.entries.set(entry.job_id, { ...entry, status: "paid", retry_count: 0 });
+    this.flush();
+  }
+  updatePayment(jobId, netAmount, paymentRequest) {
+    const entry = this.entries.get(jobId);
+    if (entry) {
+      if (netAmount !== void 0) {
+        entry.net_amount = netAmount;
+      }
+      if (paymentRequest !== void 0) {
+        entry.payment_request = paymentRequest;
+      }
+      this.flush();
+    }
+  }
+  /** Attempt a state transition. Returns the entry if valid, undefined otherwise. */
+  transition(jobId, to) {
+    const entry = this.entries.get(jobId);
+    if (!entry) {
+      return void 0;
+    }
+    if (!VALID_TRANSITIONS[entry.status].includes(to)) {
+      return void 0;
+    }
+    entry.status = to;
+    return entry;
+  }
+  markExecuted(jobId, result) {
+    const entry = this.transition(jobId, "executed");
+    if (entry) {
+      entry.result = result;
+      this.flush();
+    }
+  }
+  markDelivered(jobId) {
+    const entry = this.transition(jobId, "delivered");
+    if (entry) {
+      entry.result = void 0;
+      this.flush();
+    }
+  }
+  markFailed(jobId) {
+    const entry = this.transition(jobId, "failed");
+    if (entry) {
+      entry.result = void 0;
+      try {
+        this.flush();
+      } catch {
+      }
+    }
+  }
+  incrementRetry(jobId) {
+    const entry = this.entries.get(jobId);
+    if (entry) {
+      entry.retry_count++;
+      this.flush();
+    }
+  }
+  getStatus(jobId) {
+    return this.entries.get(jobId)?.status;
+  }
+  pendingJobs() {
+    return [...this.entries.values()].filter((e) => e.status === "paid" || e.status === "executed");
+  }
+  /** Remove old delivered/failed entries (default: 7 days). */
+  gc(maxAgeSecs = 7 * 24 * 60 * 60) {
+    const cutoff = Math.floor(Date.now() / 1e3) - maxAgeSecs;
+    for (const [id, entry] of this.entries) {
+      if ((entry.status === "delivered" || entry.status === "failed") && entry.created_at < cutoff) {
+        this.entries.delete(id);
+      }
+    }
+    this.flush();
+  }
+};
+
+// src/llm/index.ts
+var LLM_TIMEOUT_MS = 12e4;
+var MAX_RETRIES = 2;
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function createAbortError() {
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  return err;
+}
+function sleepWithSignal(ms, signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+  if (!signal) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(createAbortError());
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithTimeout(url, init, signal) {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LLM_TIMEOUT_MS);
+  const onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+async function fetchWithRetry(url, init, signal) {
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await fetchWithTimeout(url, init, signal);
+    } catch (e) {
+      if (attempt >= MAX_RETRIES || e.name === "AbortError") {
+        throw e;
+      }
+      await sleepWithSignal(Math.min(1e3 * 2 ** attempt, 8e3), signal);
+      continue;
+    }
+    if (res.ok || attempt >= MAX_RETRIES || !RETRYABLE_STATUSES.has(res.status)) {
+      return res;
+    }
+    const retryAfter = res.headers.get("retry-after");
+    const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3 || 1e3 * 2 ** attempt, 3e4) : Math.min(1e3 * 2 ** attempt, 8e3);
+    await sleepWithSignal(delay, signal);
+  }
+}
+function createLlmClient(config) {
+  if (config.provider === "anthropic") {
+    return new AnthropicClient(config);
+  }
+  return new OpenAIClient(config);
+}
+var AnthropicClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  totalIn = 0;
+  totalOut = 0;
+  logTokens(usage) {
+    if (this.config.logUsage && usage) {
+      this.totalIn += usage.input_tokens ?? 0;
+      this.totalOut += usage.output_tokens ?? 0;
+      console.log(
+        `  [LLM] ${this.config.model} tokens: in=${usage.input_tokens ?? 0} out=${usage.output_tokens ?? 0} (total: in=${this.totalIn} out=${this.totalOut})`
+      );
+    }
+  }
+  async complete(systemPrompt, userInput, signal) {
+    const res = await fetchWithRetry(
+      "https://api.anthropic.com/v1/messages",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          max_tokens: this.config.maxTokens,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userInput }]
+        })
+      },
+      signal
+    );
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    this.logTokens(data.usage);
+    const textBlock = data.content?.find((b) => b.type === "text");
+    return textBlock?.text ?? "";
+  }
+  async completeWithTools(systemPrompt, messages, tools, signal) {
+    const anthropicTools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: {
+        type: "object",
+        properties: Object.fromEntries(
+          t.parameters.map((p) => [p.name, { type: "string", description: p.description }])
+        ),
+        required: t.parameters.filter((p) => p.required).map((p) => p.name)
+      }
+    }));
+    const res = await fetchWithRetry(
+      "https://api.anthropic.com/v1/messages",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.config.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          max_tokens: this.config.maxTokens,
+          system: systemPrompt,
+          messages,
+          tools: anthropicTools
+        })
+      },
+      signal
+    );
+    if (!res.ok) {
+      throw new Error(`Anthropic API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    this.logTokens(data.usage);
+    const content = data.content ?? [];
+    const toolUses = content.filter((b) => b.type === "tool_use");
+    if (toolUses.length > 0) {
+      const calls = toolUses.map((t) => ({
+        id: t.id,
+        name: t.name,
+        arguments: t.input ?? {}
+      }));
+      return {
+        type: "tool_use",
+        calls,
+        assistantMessage: { role: "assistant", content }
+      };
+    }
+    const textBlock = content.find((b) => b.type === "text");
+    return { type: "text", text: textBlock?.text ?? "" };
+  }
+  formatToolResultMessages(results) {
+    return [
+      {
+        role: "user",
+        content: results.map((r) => ({
+          type: "tool_result",
+          tool_use_id: r.callId,
+          content: r.content
+        }))
+      }
+    ];
+  }
+};
+var OpenAIClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  totalIn = 0;
+  totalOut = 0;
+  logTokens(usage) {
+    if (this.config.logUsage && usage) {
+      this.totalIn += usage.prompt_tokens ?? 0;
+      this.totalOut += usage.completion_tokens ?? 0;
+      console.log(
+        `  [LLM] ${this.config.model} tokens: in=${usage.prompt_tokens ?? 0} out=${usage.completion_tokens ?? 0} (total: in=${this.totalIn} out=${this.totalOut})`
+      );
+    }
+  }
+  async complete(systemPrompt, userInput, signal) {
+    const isReasoning = /^o\d/.test(this.config.model);
+    const res = await fetchWithRetry(
+      "https://api.openai.com/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          ...isReasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
+          messages: [
+            { role: isReasoning ? "developer" : "system", content: systemPrompt },
+            { role: "user", content: userInput }
+          ]
+        })
+      },
+      signal
+    );
+    if (!res.ok) {
+      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    this.logTokens(data.usage);
+    return data.choices?.[0]?.message?.content ?? "";
+  }
+  async completeWithTools(systemPrompt, messages, tools, signal) {
+    const openaiTools = tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: {
+          type: "object",
+          properties: Object.fromEntries(
+            t.parameters.map((p) => [p.name, { type: "string", description: p.description }])
+          ),
+          required: t.parameters.filter((p) => p.required).map((p) => p.name)
+        }
+      }
+    }));
+    const isReasoning = /^o\d/.test(this.config.model);
+    const res = await fetchWithRetry(
+      "https://api.openai.com/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          ...isReasoning ? { max_completion_tokens: this.config.maxTokens } : { max_tokens: this.config.maxTokens },
+          messages: [
+            { role: isReasoning ? "developer" : "system", content: systemPrompt },
+            ...messages
+          ],
+          tools: openaiTools
+        })
+      },
+      signal
+    );
+    if (!res.ok) {
+      throw new Error(`OpenAI API error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    this.logTokens(data.usage);
+    const message = data.choices?.[0]?.message;
+    if (message?.tool_calls?.length > 0) {
+      const calls = message.tool_calls.map((tc) => {
+        let args;
+        try {
+          args = JSON.parse(tc.function.arguments ?? "{}");
+        } catch {
+          args = {};
+        }
+        return { id: tc.id, name: tc.function.name, arguments: args };
+      });
+      return {
+        type: "tool_use",
+        calls,
+        assistantMessage: message
+      };
+    }
+    return { type: "text", text: message?.content ?? "" };
+  }
+  formatToolResultMessages(results) {
+    return results.map((r) => ({
+      role: "tool",
+      tool_call_id: r.callId,
+      content: r.content
+    }));
+  }
+};
+var payment = new SolanaPaymentStrategy();
+var LEDGER_GC_INTERVAL_MS = 60 * 60 * 1e3;
+var TOTAL_JOB_TIMEOUT_MS = 5 * 60 * 1e3;
+function resolveJobPrice(tags, skills) {
+  const skill = skills.route(tags);
+  return skill?.priceLamports ?? 0;
+}
+var RATE_LIMIT_WINDOW_MS = 10 * 60 * 1e3;
+var MAX_JOBS_PER_CUSTOMER = 20;
+var GLOBAL_MAX_JOBS_PER_WINDOW = 200;
+var AgentRuntime = class {
+  constructor(transport, skills, skillCtx, config, ledger, callbacks = {}) {
+    this.transport = transport;
+    this.skills = skills;
+    this.skillCtx = skillCtx;
+    this.config = config;
+    this.ledger = ledger;
+    this.callbacks = callbacks;
+    this.limit = pLimit(config.maxConcurrentJobs);
+    this.maxQueueSize = config.maxQueueSize ?? config.maxConcurrentJobs * 10;
+  }
+  limit;
+  inFlight = /* @__PURE__ */ new Set();
+  pending = 0;
+  maxQueueSize;
+  abortController = new AbortController();
+  jobAbortControllers = /* @__PURE__ */ new Set();
+  recoveryInterval = null;
+  gcInterval = null;
+  /** Per-customer sliding window rate limiter: pubkey -> timestamps. */
+  customerJobs = /* @__PURE__ */ new Map();
+  /** Global sliding window rate limiter (Sybil protection). */
+  globalJobs = [];
+  async run() {
+    const log = this.callbacks.onLog ?? console.log;
+    this.ledger.gc();
+    await this.recoverPendingJobs();
+    this.recoveryInterval = setInterval(
+      () => this.recoverPendingJobs().catch((e) => log(`Recovery error: ${e}`)),
+      this.config.recoveryIntervalSecs * 1e3
+    );
+    this.gcInterval = setInterval(() => {
+      try {
+        this.ledger.gc();
+      } catch (e) {
+        log(`GC error: ${e.message}`);
+      }
+      this.cleanupRateLimits();
+      if (!this.transport.isHealthy()) {
+        log("Warning: no events received in 30+ minutes. Check relay connectivity.");
+      }
+    }, LEDGER_GC_INTERVAL_MS);
+    this.transport.start((job) => {
+      if (this.abortController.signal.aborted) {
+        return;
+      }
+      if (this.inFlight.has(job.jobId)) {
+        return;
+      }
+      if (this.ledger.getStatus(job.jobId)) {
+        return;
+      }
+      if (this.pending >= this.maxQueueSize) {
+        this.transport.sendFeedback(job, { type: "error", message: "Server overloaded, try again later" }).catch(() => {
+        });
+        return;
+      }
+      if (this.isGlobalRateLimited()) {
+        this.transport.sendFeedback(job, { type: "error", message: "Server busy, try again later" }).catch(() => {
+        });
+        return;
+      }
+      if (this.isCustomerRateLimited(job.customerId)) {
+        this.transport.sendFeedback(job, { type: "error", message: "Rate limited, try again later" }).catch(() => {
+        });
+        return;
+      }
+      this.recordJobAccepted(job.customerId);
+      this.callbacks.onJobReceived?.(job);
+      this.inFlight.add(job.jobId);
+      this.pending++;
+      this.limit(() => this.processJob(job)).catch((e) => {
+        this.callbacks.onJobError?.(job.jobId, e.message);
+      }).finally(() => {
+        this.inFlight.delete(job.jobId);
+        this.pending--;
+      });
+    });
+    log("Agent runtime started. Listening for jobs...");
+    await new Promise((resolve) => {
+      this.abortController.signal.addEventListener("abort", () => resolve(), { once: true });
+      process.on("SIGINT", () => {
+        log("Shutting down...");
+        this.stop();
+        setTimeout(() => process.exit(0), 3e3).unref();
+      });
+      process.on("SIGTERM", () => {
+        log("Shutting down...");
+        this.stop();
+        setTimeout(() => process.exit(0), 3e3).unref();
+      });
+    });
+  }
+  /** Returns true if global job throughput has been exceeded (Sybil protection). Pure check - no side effects. */
+  isGlobalRateLimited() {
+    const now = Date.now();
+    this.globalJobs = this.globalJobs.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
+    return this.globalJobs.length >= GLOBAL_MAX_JOBS_PER_WINDOW;
+  }
+  /** Returns true if customer has exceeded the per-window job limit. Pure check - no side effects. */
+  isCustomerRateLimited(customerId) {
+    const now = Date.now();
+    const timestamps = this.customerJobs.get(customerId) ?? [];
+    const recent = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
+    this.customerJobs.set(customerId, recent);
+    return recent.length >= MAX_JOBS_PER_CUSTOMER;
+  }
+  /** Record a job acceptance for rate limiting. Called only after all checks pass. */
+  recordJobAccepted(customerId) {
+    const now = Date.now();
+    this.globalJobs.push(now);
+    const timestamps = this.customerJobs.get(customerId) ?? [];
+    timestamps.push(now);
+    this.customerJobs.set(customerId, timestamps);
+  }
+  /** Clean up expired rate limit entries. */
+  cleanupRateLimits() {
+    const now = Date.now();
+    this.globalJobs = this.globalJobs.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
+    for (const [key, timestamps] of this.customerJobs) {
+      const recent = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW_MS);
+      if (recent.length === 0) {
+        this.customerJobs.delete(key);
+      } else {
+        this.customerJobs.set(key, recent);
+      }
+    }
+  }
+  stop() {
+    this.abortController.abort();
+    for (const controller of this.jobAbortControllers) {
+      controller.abort();
+    }
+    if (this.recoveryInterval) {
+      clearInterval(this.recoveryInterval);
+      this.recoveryInterval = null;
+    }
+    if (this.gcInterval) {
+      clearInterval(this.gcInterval);
+      this.gcInterval = null;
+    }
+    this.transport.stop();
+  }
+  /** Wrapper with total job timeout and error handling. */
+  async processJob(job) {
+    let timeoutId;
+    const jobAbort = new AbortController();
+    this.jobAbortControllers.add(jobAbort);
+    try {
+      await Promise.race([
+        this.executeJob(job, jobAbort.signal),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            jobAbort.abort();
+            reject(new Error("Job processing timeout"));
+          }, TOTAL_JOB_TIMEOUT_MS);
+        })
+      ]);
+    } catch (e) {
+      const log = this.callbacks.onLog ?? console.log;
+      log(`[${job.jobId.slice(0, 8)}] Error: ${e.message}`);
+      const currentStatus = this.ledger.getStatus(job.jobId);
+      if (currentStatus !== "executed") {
+        this.ledger.markFailed(job.jobId);
+      }
+      this.callbacks.onJobError?.(job.jobId, e.message);
+      const safeMessage = e.message?.includes("API") ? "Internal processing error" : e.message ?? "Unknown error";
+      await this.transport.sendFeedback(job, { type: "error", message: safeMessage }).catch(() => {
+      });
+    } finally {
+      clearTimeout(timeoutId);
+      this.jobAbortControllers.delete(jobAbort);
+    }
+  }
+  /** Core job processing logic - payment, skill execution, result delivery. */
+  async executeJob(job, signal) {
+    const log = this.callbacks.onLog ?? console.log;
+    if (job.input.length > LIMITS.MAX_INPUT_LENGTH) {
+      throw new Error(`Input too long: ${job.input.length} chars (max ${LIMITS.MAX_INPUT_LENGTH})`);
+    }
+    const jobPrice = resolveJobPrice(job.tags, this.skills);
+    let netAmount;
+    let paymentRequest;
+    this.ledger.recordPaid({
+      job_id: job.jobId,
+      input: job.input,
+      input_type: job.inputType,
+      tags: job.tags,
+      customer_id: job.customerId,
+      bid: job.bid,
+      net_amount: void 0,
+      raw_event_json: JSON.stringify(job.rawEvent),
+      created_at: Math.floor(Date.now() / 1e3)
+    });
+    if (jobPrice > 0) {
+      const result = await this.collectPayment(job, jobPrice, signal);
+      netAmount = result.netAmount;
+      paymentRequest = result.paymentRequest;
+      this.ledger.updatePayment(job.jobId, netAmount, paymentRequest);
+      log(`[${job.jobId.slice(0, 8)}] Payment confirmed: ${netAmount} lamports`);
+      this.callbacks.onPaymentReceived?.(job.jobId, netAmount);
+    }
+    await this.transport.sendFeedback(job, { type: "processing" }).catch(() => {
+    });
+    const skill = this.skills.route(job.tags);
+    if (!skill) {
+      throw new Error("No skill matched for tags: " + job.tags.join(", "));
+    }
+    log(`[${job.jobId.slice(0, 8)}] Executing skill: ${skill.name}`);
+    const output = await skill.execute(
+      {
+        data: job.input,
+        inputType: job.inputType,
+        tags: job.tags,
+        jobId: job.jobId
+      },
+      { ...this.skillCtx, signal }
+    );
+    this.ledger.markExecuted(job.jobId, output.data);
+    log(`[${job.jobId.slice(0, 8)}] Skill completed, delivering result`);
+    const eventId = await this.transport.deliverResult(job, output.data, netAmount);
+    this.ledger.markDelivered(job.jobId);
+    log(`[${job.jobId.slice(0, 8)}] Delivered: ${eventId.slice(0, 16)}...`);
+    this.callbacks.onJobCompleted?.(job.jobId, output.data);
+  }
+  /**
+   * Collect payment for a job. Creates payment request, sends PaymentRequired feedback,
+   * polls for on-chain confirmation. Aborts if signal fires.
+   */
+  async collectPayment(job, jobPrice, signal) {
+    const log = this.callbacks.onLog ?? console.log;
+    if (!this.config.solanaAddress) {
+      throw new Error("Solana address not configured");
+    }
+    const request = payment.createPaymentRequest(
+      this.config.solanaAddress,
+      jobPrice,
+      this.config.paymentTimeoutSecs
+    );
+    const requestJson = JSON.stringify(request);
+    const fee = calculateProtocolFee(jobPrice);
+    const netAmount = jobPrice - fee;
+    log(`[${job.jobId.slice(0, 8)}] Payment required: ${jobPrice} lamports (fee: ${fee})`);
+    this.ledger.updatePayment(job.jobId, void 0, requestJson);
+    await this.transport.sendFeedback(job, {
+      type: "payment-required",
+      amount: jobPrice,
+      paymentRequest: requestJson,
+      chain: "solana"
+    });
+    const connection = new Connection(getRpcUrl(this.config.network), {
+      disableRetryOnRateLimit: true
+    });
+    let result;
+    if (signal) {
+      let abortHandler;
+      const abortPromise = new Promise((_, reject) => {
+        abortHandler = () => {
+          const err = new Error("The operation was aborted");
+          err.name = "AbortError";
+          reject(err);
+        };
+        if (signal.aborted) {
+          abortHandler();
+          return;
+        }
+        signal.addEventListener("abort", abortHandler, { once: true });
+      });
+      try {
+        result = await Promise.race([payment.verifyPayment(connection, request), abortPromise]);
+      } finally {
+        if (abortHandler) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+      }
+    } else {
+      result = await payment.verifyPayment(connection, request);
+    }
+    if (result.verified) {
+      return { netAmount, paymentRequest: requestJson };
+    }
+    log(
+      `[${job.jobId.slice(0, 8)}] WARNING: Payment verification timed out. Customer may have paid on-chain. Check address ${this.config.solanaAddress} manually.`
+    );
+    await this.transport.sendFeedback(job, { type: "error", message: "payment timeout" }).catch(() => {
+    });
+    throw new Error("Payment timeout");
+  }
+  async recoverPendingJobs() {
+    const pending = this.ledger.pendingJobs().filter((e) => !this.inFlight.has(e.job_id));
+    if (pending.length === 0) {
+      return;
+    }
+    const log = this.callbacks.onLog ?? console.log;
+    log(`Recovering ${pending.length} pending jobs...`);
+    for (const entry of pending) {
+      if (entry.retry_count >= this.config.recoveryMaxRetries) {
+        this.ledger.markFailed(entry.job_id);
+        if (entry.raw_event_json) {
+          try {
+            const rawEvent = JSON.parse(entry.raw_event_json);
+            await this.transport.sendFeedback(
+              {
+                jobId: entry.job_id,
+                input: entry.input,
+                inputType: entry.input_type,
+                tags: entry.tags,
+                customerId: entry.customer_id,
+                encrypted: false,
+                rawEvent
+              },
+              { type: "error", message: "Job permanently failed after maximum retries" }
+            ).catch(() => {
+            });
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (!entry.raw_event_json) {
+        continue;
+      }
+      if (this.pending >= this.maxQueueSize) {
+        break;
+      }
+      this.inFlight.add(entry.job_id);
+      this.pending++;
+      this.limit(async () => {
+        try {
+          await this.recoverSingleJob(entry, log);
+        } catch (e) {
+          log(`[${entry.job_id.slice(0, 8)}] Recovery: failed: ${e.message}`);
+        } finally {
+          this.inFlight.delete(entry.job_id);
+          this.pending--;
+        }
+      });
+    }
+  }
+  async recoverSingleJob(entry, log) {
+    const recoveryAbort = new AbortController();
+    this.jobAbortControllers.add(recoveryAbort);
+    const timeout = setTimeout(() => recoveryAbort.abort(), TOTAL_JOB_TIMEOUT_MS);
+    try {
+      this.ledger.incrementRetry(entry.job_id);
+      const rawEvent = JSON.parse(entry.raw_event_json);
+      const fakeJob = {
+        jobId: entry.job_id,
+        input: entry.input,
+        inputType: entry.input_type,
+        tags: entry.tags,
+        customerId: entry.customer_id,
+        encrypted: false,
+        rawEvent
+      };
+      if (entry.status === "executed" && entry.result !== void 0) {
+        await this.transport.deliverResult(fakeJob, entry.result, entry.net_amount);
+        this.ledger.markDelivered(entry.job_id);
+        log(`[${entry.job_id.slice(0, 8)}] Recovery: re-delivered`);
+      } else if (entry.status === "paid") {
+        const skill = this.skills.route(entry.tags);
+        if (!skill) {
+          log(`[${entry.job_id.slice(0, 8)}] Recovery: no skill for tags, marking failed`);
+          this.ledger.markFailed(entry.job_id);
+          return;
+        }
+        if (skill.priceLamports > 0 && !entry.net_amount) {
+          if (entry.payment_request) {
+            const verified = await this.reVerifyPayment(
+              entry,
+              skill.priceLamports,
+              log,
+              recoveryAbort.signal
+            );
+            if (!verified) {
+              this.ledger.markFailed(entry.job_id);
+              return;
+            }
+          } else {
+            log(`[${entry.job_id.slice(0, 8)}] Recovery: payment not confirmed, marking failed`);
+            this.ledger.markFailed(entry.job_id);
+            return;
+          }
+        }
+        const output = await skill.execute(
+          {
+            data: entry.input,
+            inputType: entry.input_type,
+            tags: entry.tags,
+            jobId: entry.job_id
+          },
+          { ...this.skillCtx, signal: recoveryAbort.signal }
+        );
+        this.ledger.markExecuted(entry.job_id, output.data);
+        await this.transport.deliverResult(fakeJob, output.data, entry.net_amount);
+        this.ledger.markDelivered(entry.job_id);
+        log(`[${entry.job_id.slice(0, 8)}] Recovery: re-executed and delivered`);
+      }
+    } finally {
+      clearTimeout(timeout);
+      this.jobAbortControllers.delete(recoveryAbort);
+    }
+  }
+  /**
+   * Re-verify an on-chain payment during crash recovery.
+   *
+   * Limitation: Solana transaction data expires after ~2-3 days (recent blockhash window).
+   * If the agent was down longer, a confirmed payment may not be found on-chain and the
+   * job will be marked failed. For mainnet: use monitoring, avoid extended downtime, or
+   * configure an archive RPC via SOLANA_RPC_URL.
+   */
+  async reVerifyPayment(entry, priceLamports, log, signal) {
+    try {
+      const request = JSON.parse(entry.payment_request);
+      const connection = new Connection(getRpcUrl(this.config.network), {
+        disableRetryOnRateLimit: true
+      });
+      let result;
+      if (signal) {
+        let abortHandler;
+        const abortPromise = new Promise((_, reject) => {
+          abortHandler = () => {
+            const err = new Error("The operation was aborted");
+            err.name = "AbortError";
+            reject(err);
+          };
+          if (signal.aborted) {
+            abortHandler();
+            return;
+          }
+          signal.addEventListener("abort", abortHandler, { once: true });
+        });
+        try {
+          result = await Promise.race([payment.verifyPayment(connection, request), abortPromise]);
+        } finally {
+          if (abortHandler) {
+            signal.removeEventListener("abort", abortHandler);
+          }
+        }
+      } else {
+        result = await payment.verifyPayment(connection, request);
+      }
+      if (result.verified) {
+        const fee = calculateProtocolFee(priceLamports);
+        const netAmount = priceLamports - fee;
+        this.ledger.updatePayment(entry.job_id, netAmount, entry.payment_request);
+        log(`[${entry.job_id.slice(0, 8)}] Recovery: payment re-verified (${netAmount} lamports)`);
+        return true;
+      }
+      log(`[${entry.job_id.slice(0, 8)}] Recovery: payment not found on-chain, marking failed`);
+      return false;
+    } catch (e) {
+      log(`[${entry.job_id.slice(0, 8)}] Recovery: payment re-verification error: ${e.message}`);
+      return false;
+    }
+  }
+};
+
+// src/skill/index.ts
+var SkillRegistry = class {
+  skills = [];
+  defaultIndex = null;
+  register(skill) {
+    if (this.defaultIndex === null) {
+      this.defaultIndex = this.skills.length;
+    }
+    this.skills.push(skill);
+  }
+  route(tags) {
+    for (const skill of this.skills) {
+      for (const tag of tags) {
+        if (skill.capabilities.some((cap) => cap === tag)) {
+          return skill;
+        }
+      }
+    }
+    return this.defaultIndex !== null ? this.skills[this.defaultIndex] : null;
+  }
+  allCapabilities() {
+    return this.skills.flatMap((s) => s.capabilities);
+  }
+  isEmpty() {
+    return this.skills.length === 0;
+  }
+  all() {
+    return this.skills;
+  }
+};
+var MAX_TOOL_OUTPUT = 1e6;
+var ScriptSkill = class {
+  name;
+  description;
+  capabilities;
+  priceLamports;
+  image;
+  imageFile;
+  skillDir;
+  systemPrompt;
+  tools;
+  maxToolRounds;
+  constructor(name, description, capabilities, priceLamports, image, imageFile, skillDir, systemPrompt, tools, maxToolRounds) {
+    this.name = name;
+    this.description = description;
+    this.capabilities = capabilities;
+    this.priceLamports = priceLamports;
+    this.image = image;
+    this.imageFile = imageFile;
+    this.skillDir = skillDir;
+    this.systemPrompt = systemPrompt;
+    this.tools = tools;
+    this.maxToolRounds = maxToolRounds;
+  }
+  async execute(input, ctx) {
+    if (!ctx.llm) {
+      throw new Error("LLM client not configured");
+    }
+    if (this.tools.length === 0) {
+      const result = await ctx.llm.complete(this.systemPrompt, input.data, ctx.signal);
+      return { data: result };
+    }
+    const toolDefs = this.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: (t.parameters ?? []).map((p) => ({
+        name: p.name,
+        description: p.description,
+        required: p.required ?? true
+      }))
+    }));
+    const messages = [{ role: "user", content: input.data }];
+    for (let round = 0; round < this.maxToolRounds; round++) {
+      if (ctx.signal?.aborted) {
+        throw new Error("Job aborted");
+      }
+      const result = await ctx.llm.completeWithTools(
+        this.systemPrompt,
+        messages,
+        toolDefs,
+        ctx.signal
+      );
+      if (result.type === "text") {
+        return { data: result.text };
+      }
+      messages.push(result.assistantMessage);
+      const toolResults = [];
+      for (const call of result.calls) {
+        const toolDef = this.tools.find((t) => t.name === call.name);
+        if (!toolDef) {
+          toolResults.push({
+            callId: call.id,
+            content: `Error: unknown tool "${call.name}"`
+          });
+          continue;
+        }
+        const output = await this.runTool(toolDef, call, ctx.signal);
+        toolResults.push({ callId: call.id, content: output });
+      }
+      messages.push(...ctx.llm.formatToolResultMessages(toolResults));
+    }
+    throw new Error(`Max tool rounds (${this.maxToolRounds}) exceeded`);
+  }
+  runTool(toolDef, call, signal) {
+    return new Promise((resolve, _reject) => {
+      const args = [...toolDef.command];
+      const cmd = args.shift();
+      const params = toolDef.parameters ?? [];
+      for (const param of params) {
+        const value = call.arguments[param.name];
+        if (value !== void 0) {
+          if (param.required && params.indexOf(param) === 0) {
+            args.push(String(value));
+          } else {
+            args.push(`--${param.name}`, String(value));
+          }
+        }
+      }
+      const child = spawn(cmd, args, {
+        cwd: this.skillDir,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 6e4,
+        killSignal: "SIGKILL",
+        signal
+      });
+      let stdout = "";
+      let stderr = "";
+      const stdoutDecoder = new StringDecoder("utf8");
+      const stderrDecoder = new StringDecoder("utf8");
+      child.stdout.on("data", (data) => {
+        if (stdout.length < MAX_TOOL_OUTPUT) {
+          stdout += stdoutDecoder.write(data);
+          if (stdout.length > MAX_TOOL_OUTPUT) {
+            stdout = stdout.slice(0, MAX_TOOL_OUTPUT);
+          }
+        }
+      });
+      child.stderr.on("data", (data) => {
+        if (stderr.length < MAX_TOOL_OUTPUT) {
+          stderr += stderrDecoder.write(data);
+          if (stderr.length > MAX_TOOL_OUTPUT) {
+            stderr = stderr.slice(0, MAX_TOOL_OUTPUT);
+          }
+        }
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout.trim());
+        } else {
+          resolve(`Error (exit ${code}): ${stderr.trim() || stdout.trim()}`);
+        }
+      });
+      child.on("error", (err) => {
+        resolve(`Error: ${err.message}`);
+      });
+    });
+  }
+};
+
+// src/skill/loader.ts
+var LAMPORTS_PER_SOL = 1e9;
+function solToLamports(sol) {
+  if (!Number.isFinite(sol) || sol < 0) {
+    return 0;
+  }
+  return Math.round(sol * LAMPORTS_PER_SOL);
+}
+function parseSkillMd(content) {
+  const lines = content.split("\n");
+  let start = -1;
+  let end = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      if (start === -1) {
+        start = i;
+      } else {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (start === -1 || end === -1) {
+    throw new Error("SKILL.md must have YAML frontmatter between --- delimiters");
+  }
+  const yamlStr = lines.slice(start + 1, end).join("\n");
+  const frontmatter = YAML.parse(yamlStr);
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    throw new Error('SKILL.md: missing or invalid "name" field');
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    throw new Error('SKILL.md: missing or invalid "description" field');
+  }
+  if (!Array.isArray(frontmatter.capabilities) || frontmatter.capabilities.length === 0) {
+    throw new Error('SKILL.md: "capabilities" must be a non-empty array');
+  }
+  const systemPrompt = lines.slice(end + 1).join("\n").trim();
+  return { frontmatter, systemPrompt };
+}
+function loadSkillsFromDir(skillsDir) {
+  const skills = [];
+  let entries;
+  try {
+    entries = readdirSync(skillsDir);
+  } catch {
+    return skills;
+  }
+  for (const entry of entries) {
+    const entryPath = join(skillsDir, entry);
+    try {
+      if (!statSync(entryPath).isDirectory()) {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    const skillMdPath = join(entryPath, "SKILL.md");
+    try {
+      const content = readFileSync(skillMdPath, "utf-8");
+      const { frontmatter, systemPrompt } = parseSkillMd(content);
+      skills.push(
+        new ScriptSkill(
+          frontmatter.name,
+          frontmatter.description,
+          frontmatter.capabilities,
+          solToLamports(frontmatter.price ?? 0),
+          frontmatter.image,
+          frontmatter.image_file,
+          entryPath,
+          systemPrompt,
+          frontmatter.tools ?? [],
+          frontmatter.max_tool_rounds ?? 10
+        )
+      );
+    } catch (e) {
+      console.warn(`  ! Skipping skill "${entry}": ${e?.message ?? "unknown error"}`);
+    }
+  }
+  return skills;
+}
+function isEncrypted2(event) {
+  return event.tags.some((t) => t[0] === "encrypted" && t[1] === "nip44");
+}
+var HEALTH_CHECK_IDLE_MS = 30 * 60 * 1e3;
+var NostrTransport = class {
+  constructor(client, identity, kindOffsets) {
+    this.client = client;
+    this.identity = identity;
+    this.kindOffsets = kindOffsets;
+  }
+  sub = null;
+  seenIds = new BoundedSet(1e4);
+  lastEventAt = Date.now();
+  /** Start listening for targeted job requests. Decrypts NIP-44 content. */
+  start(onJob) {
+    const kinds = this.kindOffsets.map(jobRequestKind);
+    this.sub = this.client.marketplace.subscribeToJobRequests(
+      this.identity,
+      kinds,
+      (event) => {
+        this.lastEventAt = Date.now();
+        if (this.seenIds.has(event.id)) {
+          return;
+        }
+        this.seenIds.add(event.id);
+        const hasElisym = event.tags.some((t) => t[0] === "t" && t[1] === "elisym");
+        if (!hasElisym) {
+          return;
+        }
+        const tags = event.tags.filter((t) => t[0] === "t").map((t) => t[1]);
+        const bidTag = event.tags.find((t) => t[0] === "bid");
+        const encrypted = isEncrypted2(event);
+        const iTag = event.tags.find((t) => t[0] === "i");
+        let inputType = "text";
+        if (iTag?.[2]) {
+          inputType = iTag[2];
+        }
+        const input = encrypted ? event.content : iTag?.[1] ?? event.content;
+        onJob({
+          jobId: event.id,
+          input,
+          inputType,
+          tags,
+          customerId: event.pubkey,
+          bid: bidTag?.[1] ? parseInt(bidTag[1], 10) : void 0,
+          encrypted,
+          rawEvent: event
+        });
+      }
+    );
+  }
+  /** Send job feedback to customer. */
+  async sendFeedback(job, status) {
+    if (status.type === "payment-required") {
+      await this.client.marketplace.submitPaymentRequiredFeedback(
+        this.identity,
+        job.rawEvent,
+        status.amount,
+        status.paymentRequest
+      );
+    } else if (status.type === "processing") {
+      await this.client.marketplace.submitProcessingFeedback(this.identity, job.rawEvent);
+    } else if (status.type === "error") {
+      await this.client.marketplace.submitErrorFeedback(
+        this.identity,
+        job.rawEvent,
+        status.message
+      );
+    }
+  }
+  /** Deliver result to customer. Retries with exponential backoff via SDK. */
+  async deliverResult(job, content, amount, retries = 3) {
+    return this.client.marketplace.submitJobResultWithRetry(
+      this.identity,
+      job.rawEvent,
+      content,
+      amount,
+      retries
+    );
+  }
+  /** Returns true if an event was received within the given idle window. */
+  isHealthy(maxIdleMs = HEALTH_CHECK_IDLE_MS) {
+    return Date.now() - this.lastEventAt < maxIdleMs;
+  }
+  stop() {
+    this.sub?.close();
+    this.sub = null;
+  }
+};
+
+// src/commands/start.ts
+async function cmdStart(name, options) {
+  if (!name) {
+    const agents = listAgents();
+    if (agents.length === 0) {
+      console.log("No agents configured. Run `elisym init` first.");
+      process.exit(1);
+    }
+    const { default: inquirer } = await import('inquirer');
+    const choices = [...agents, { name: "+ Create new agent", value: "__new__" }];
+    const { selected } = await inquirer.prompt([
+      { type: "list", name: "selected", message: "Select agent to start", choices }
+    ]);
+    if (selected === "__new__") {
+      const { cmdInit: cmdInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      await cmdInit2();
+      return;
+    }
+    name = selected;
+  }
+  const passphrase = process.env.ELISYM_PASSPHRASE;
+  const config = loadConfig(name, passphrase);
+  console.log(`
+  Starting agent ${name}...
+`);
+  let solanaAddress;
+  if (config.payments?.length) {
+    const solPayment = config.payments.find((p) => p.chain === "solana");
+    if (solPayment) {
+      solanaAddress = solPayment.address;
+    }
+  }
+  const walletNetwork = config.payments?.find((p) => p.chain === "solana")?.network ?? "devnet";
+  if (solanaAddress) {
+    try {
+      const rpcUrl = getRpcUrl(walletNetwork);
+      const connection = new Connection(rpcUrl, { disableRetryOnRateLimit: true });
+      const pubkey = new PublicKey(solanaAddress);
+      const balance = await connection.getBalance(pubkey);
+      console.log("  Wallet");
+      console.log(`     Network  ${walletNetwork}`);
+      console.log(`     Address  ${solanaAddress}`);
+      if (process.env.SOLANA_RPC_URL) {
+        console.log(`     RPC      ${process.env.SOLANA_RPC_URL} (custom)`);
+      }
+      console.log(`     Balance  ${formatSol(balance)} (${balance} lamports)`);
+      if (balance === 0) {
+        if (walletNetwork === "mainnet") {
+          console.log(
+            "  ! Warning: wallet is empty. First incoming payment needs rent-exempt SOL (~0.00089 SOL)."
+          );
+        } else {
+          console.log("  ! Wallet is empty. Get devnet SOL: https://faucet.solana.com");
+        }
+      }
+      if (walletNetwork === "mainnet" && !process.env.SOLANA_RPC_URL) {
+        console.log(
+          "  ! Warning: using public Solana RPC for mainnet. Set SOLANA_RPC_URL for reliable operation."
+        );
+      }
+      console.log();
+    } catch (e) {
+      console.warn(`  ! Wallet error: ${e.message}
+`);
+    }
+  }
+  if (!config.llm) {
+    console.error("  ! No LLM configured. Run `elisym init` to set up LLM.\n");
+    process.exit(1);
+  }
+  const skillsDir = join(process.cwd(), "skills");
+  const allSkills = loadSkillsFromDir(skillsDir);
+  if (allSkills.length === 0) {
+    console.error(`  ! No skills found in ${skillsDir}
+`);
+    console.error("  Create a skill directory with a SKILL.md to get started.");
+    console.error("  Example: ./skills/my-skill/SKILL.md\n");
+    process.exit(1);
+  }
+  const registry = new SkillRegistry();
+  for (const skill of allSkills) {
+    registry.register(skill);
+    const price = skill.priceLamports > 0 ? formatSol(skill.priceLamports) : "free";
+    console.log(`  * Skill: ${skill.name} [${skill.capabilities.join(", ")}] - ${price}`);
+  }
+  console.log();
+  const hasPaid = allSkills.some((s) => s.priceLamports > 0);
+  if (hasPaid && !solanaAddress) {
+    console.error("  ! Paid skills require a Solana address. Run `elisym init` to configure.\n");
+    process.exit(1);
+  }
+  const llm = createLlmClient({
+    provider: config.llm.provider,
+    apiKey: config.llm.api_key,
+    model: config.llm.model,
+    maxTokens: config.llm.max_tokens,
+    logUsage: true
+  });
+  const skillCtx = {
+    llm,
+    agentName: config.identity.name,
+    agentDescription: config.identity.description ?? ""
+  };
+  console.log("  Connecting to relays and publishing capabilities...");
+  const identity = ElisymIdentity.fromHex(config.identity.secret_key);
+  const relays = config.relays?.length ? config.relays : [...RELAYS];
+  const client = new ElisymClient({ relays });
+  const media = new MediaService();
+  for (const skill of allSkills) {
+    if (skill.image || !skill.imageFile) {
+      continue;
+    }
+    try {
+      const filePath = join(skillsDir, skill.name, skill.imageFile);
+      console.log(`  Uploading ${basename(filePath)}...`);
+      const data = readFileSync(filePath);
+      const blob = new Blob([data]);
+      const url = await media.upload(identity, blob, basename(filePath));
+      console.log(`  Uploaded: ${url}`);
+      skill.image = url;
+      const skillMdPath = join(skillsDir, skill.name, "SKILL.md");
+      const mdContent = readFileSync(skillMdPath, "utf-8");
+      const updated = mdContent.replace(/^(image_file:\s*.+)$/m, (m) => `${m}
+image: ${url}`);
+      writeFileSync(skillMdPath, updated);
+    } catch (e) {
+      console.warn(`  ! Failed to upload image for "${skill.name}": ${e.message}`);
+    }
+  }
+  try {
+    await client.discovery.publishProfile(
+      identity,
+      config.identity.name,
+      config.identity.description ?? "",
+      config.identity.picture,
+      config.identity.banner
+    );
+  } catch (e) {
+    console.warn(`  ! Failed to publish profile: ${e.message}`);
+  }
+  const kinds = [jobRequestKind(DEFAULT_KIND_OFFSET)];
+  function buildCard(skill) {
+    return {
+      name: skill.name,
+      description: skill.description,
+      capabilities: skill.capabilities,
+      image: skill.image,
+      payment: solanaAddress ? {
+        chain: "solana",
+        network: walletNetwork,
+        address: solanaAddress,
+        job_price: skill.priceLamports
+      } : void 0
+    };
+  }
+  for (const skill of allSkills) {
+    try {
+      await client.discovery.publishCapability(identity, buildCard(skill), kinds);
+    } catch (e) {
+      console.warn(`  ! Failed to publish "${skill.name}": ${e.message}`);
+    }
+  }
+  try {
+    const existingEvents = await client.pool.querySync({
+      kinds: [31990],
+      authors: [identity.publicKey],
+      "#t": ["elisym"]
+    });
+    const skillNames = new Set(allSkills.map((s) => s.name));
+    for (const ev of existingEvents) {
+      const dTag = ev.tags.find((t) => t[0] === "d")?.[1];
+      if (!dTag) {
+        continue;
+      }
+      try {
+        const card = JSON.parse(ev.content);
+        if (card.name && !skillNames.has(card.name)) {
+          await client.discovery.deleteCapability(identity, card.name);
+          console.log(`  Removed stale capability: ${card.name}`);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  console.log("  Connected.\n");
+  const pingSub = client.messaging.subscribeToPings(identity, (senderPubkey, nonce) => {
+    client.messaging.sendPong(identity, senderPubkey, nonce).catch(() => {
+    });
+  });
+  let heartbeatTimer = null;
+  if (allSkills.length > 0) {
+    const heartbeatCard = buildCard(allSkills[0]);
+    heartbeatTimer = setInterval(async () => {
+      try {
+        await client.discovery.publishCapability(identity, heartbeatCard, kinds);
+      } catch {
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  const transport = new NostrTransport(client, identity, [DEFAULT_KIND_OFFSET]);
+  const ledger = new JobLedger(name);
+  const runtimeConfig = {
+    paymentTimeoutSecs: DEFAULTS.PAYMENT_EXPIRY_SECS,
+    maxConcurrentJobs: MAX_CONCURRENT_JOBS,
+    recoveryMaxRetries: RECOVERY_MAX_RETRIES,
+    recoveryIntervalSecs: RECOVERY_INTERVAL_SECS,
+    network: walletNetwork,
+    solanaAddress
+  };
+  const runtime = new AgentRuntime(transport, registry, skillCtx, runtimeConfig, ledger, {
+    onJobReceived: (job) => {
+      const cap = job.tags.find((t) => t !== "elisym") ?? "unknown";
+      console.log(`  [job] ${job.jobId.slice(0, 16)} | cap=${cap}`);
+    },
+    onJobCompleted: (jobId) => {
+      console.log(`  [job] ${jobId.slice(0, 16)} | delivered`);
+    },
+    onJobError: (jobId, error) => {
+      console.error(`  [job] ${jobId.slice(0, 16)} | error: ${error}`);
+    },
+    onLog: (msg) => console.log(`  ${msg}`)
+  });
+  const originalStop = runtime.stop.bind(runtime);
+  runtime.stop = () => {
+    pingSub.close();
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+    }
+    originalStop();
+  };
+  console.log(`  * Running${options.headless ? " (headless)" : ""}. Press Ctrl+C to stop.
+`);
+  await runtime.run();
+}
+
+// src/commands/wallet.ts
+init_config();
+async function cmdWallet(name) {
+  if (!name) {
+    const agents = listAgents();
+    if (agents.length === 0) {
+      console.error("No agents found.");
+      process.exit(1);
+    }
+    const { default: inquirer } = await import('inquirer');
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message: "Select agent:",
+        choices: agents
+      }
+    ]);
+    name = selected;
+  }
+  const passphrase = process.env.ELISYM_PASSPHRASE;
+  const config = loadConfig(name, passphrase);
+  const solPayment = config.payments?.find((p) => p.chain === "solana");
+  if (!solPayment?.address) {
+    console.error("Solana address not configured for this agent.");
+    process.exit(1);
+  }
+  const network = solPayment.network ?? "devnet";
+  const rpcUrl = getRpcUrl(network);
+  const connection = new Connection(rpcUrl);
+  const pubkey = new PublicKey(solPayment.address);
+  const balance = await connection.getBalance(pubkey);
+  console.log(`
+  Agent: ${name}`);
+  console.log(`  Network: ${network}`);
+  console.log(`  Address: ${solPayment.address}`);
+  console.log(`  Balance: ${formatSol(balance)} (${balance} lamports)
+`);
+}
+async function cmdSend(_name, _address, _amount) {
+  console.error("Direct sending not yet implemented. Use the MCP server for payments.");
+}
+
+// src/index.ts
+init_config();
+process.removeAllListeners("warning");
+var program = new Command().name("elisym").description("CLI agent runner for the elisym network").version("0.1.0");
+program.command("init").description("Create a new agent (interactive wizard)").action(cmdInit);
+program.command("profile [name]").description("Edit agent profile, wallet, and LLM settings").action(cmdProfile);
+program.command("start [name]").description("Start agent in provider mode").option("--headless", "Run without TUI (log to stdout)").action(cmdStart);
+program.command("list").description("List all agents").action(() => {
+  const agents = listAgents();
+  if (agents.length === 0) {
+    console.log("No agents found. Run `elisym init` to create one.");
+    return;
+  }
+  console.log("\nAgents:");
+  for (const name of agents) {
+    try {
+      const config = loadConfig(name);
+      const secretKey = config.identity.secret_key;
+      let npub = "(encrypted)";
+      if (!secretKey.startsWith("encrypted:")) {
+        const secretBytes = Buffer.from(secretKey, "hex");
+        npub = secretBytes.length === 32 ? nip19.npubEncode(getPublicKey(secretBytes)) : "(invalid key)";
+      }
+      const solAddr = config.payments?.[0]?.address ? ` | Solana: ${config.payments[0].address}` : "";
+      console.log(`  ${name} | ${npub}${solAddr}`);
+    } catch {
+      console.log(`  ${name} (error loading config)`);
+    }
+  }
+  console.log();
+});
+program.command("status <name>").description("Show agent status").action((name) => {
+  try {
+    const config = loadConfig(name);
+    console.log(`
+Agent: ${name}`);
+    console.log(`  Description: ${config.identity.description || "(none)"}`);
+    console.log(
+      `  Capabilities: ${(config.capabilities ?? []).map((c) => c.name).join(", ") || "(none)"}`
+    );
+    console.log(`  Relays: ${config.relays.join(", ")}`);
+    if (config.payments?.length) {
+      console.log(`  Network: ${config.payments[0].network}`);
+      console.log(`  Address: ${config.payments[0].address}`);
+    }
+    if (config.llm) {
+      console.log(`  LLM: ${config.llm.provider} / ${config.llm.model}`);
+    }
+    console.log();
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+  }
+});
+program.command("wallet [name]").description("Show wallet balance").action(cmdWallet);
+program.command("send <name> <address> <amount>").description("Send SOL from agent wallet").action(cmdSend);
+program.command("delete <name>").description("Delete an agent").action(async (name) => {
+  const { default: inquirer } = await import('inquirer');
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Delete agent "${name}"? This cannot be undone.`,
+      default: false
+    }
+  ]);
+  if (confirm) {
+    deleteAgent(name);
+    console.log(`Agent "${name}" deleted.`);
+  }
+});
+program.command("config <name>").description("Show agent config (secrets redacted)").action((name) => {
+  try {
+    const config = loadConfig(name);
+    const redacted = {
+      ...config,
+      identity: { ...config.identity, secret_key: "***REDACTED***" },
+      wallet: config.wallet ? { ...config.wallet, secret_key: "***REDACTED***" } : void 0,
+      llm: config.llm ? { ...config.llm, api_key: "***REDACTED***" } : void 0
+    };
+    console.log(JSON.stringify(redacted, null, 2));
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map