@kudo-dev/sdk 0.0.0-stage → 0.2.0

package/dist/agent/index.js

@@ -0,0 +1,867 @@
+// src/agent/start.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/agent/agent.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/agent/log.ts
+import { randomBytes } from "crypto";
+var SECRETS = [
+  "PRIVATE_KEY",
+  "ANTHROPIC_API_KEY",
+  "TWITTER_API_KEY",
+  "TWITTER_API_SECRET_KEY",
+  "TWITTER_ACCESS_TOKEN",
+  "TWITTER_ACCESS_TOKEN_SECRET"
+];
+var MAX_OUTPUT = 1500;
+var MAX_COMMAND = 400;
+var debugEnabled = (env = process.env) => env.LOG_LEVEL?.trim().toLowerCase() === "debug";
+function redact(text, env = process.env) {
+  let out = text;
+  for (const name of SECRETS) {
+    const value = env[name]?.trim();
+    if (!value || value.length < 8) continue;
+    const forms = /* @__PURE__ */ new Set([value, value.replace(/^0x/i, "")]);
+    for (const form of forms) if (form.length >= 8) out = out.split(form).join(`[${name}]`);
+  }
+  return out;
+}
+function clip(text, max) {
+  const flat = text.trim();
+  return flat.length <= max ? flat : `${flat.slice(0, max)}\u2026 (${flat.length - max} more chars)`;
+}
+var time = () => (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+function runLog(label) {
+  const tag = `[${label} ${randomBytes(3).toString("hex")}]`;
+  const line = (message2) => `${time()} ${tag} ${redact(message2)}`;
+  return {
+    info: (message2) => console.log(line(message2)),
+    error: (message2) => console.error(line(message2)),
+    debug: (message2) => {
+      if (debugEnabled()) console.log(line(message2));
+    }
+  };
+}
+var limits = { MAX_OUTPUT, MAX_COMMAND };
+
+// src/agent/agent.ts
+var RESILIENCE_ENV = {
+  API_TIMEOUT_MS: "120000",
+  CLAUDE_CODE_MAX_RETRIES: "2",
+  CLAUDE_ENABLE_STREAM_WATCHDOG: "1",
+  CLAUDE_STREAM_IDLE_TIMEOUT_MS: "300000"
+};
+function agentOptions(session, log2) {
+  return {
+    model: session.model,
+    systemPrompt: session.systemPrompt,
+    cwd: session.cwd,
+    // Skills come only from the plugin assembled for this agent (skills.ts),
+    // and no project or user settings are read, so nothing else on the machine
+    // changes what the agent knows.
+    settingSources: [],
+    plugins: [{ type: "local", path: session.skills.path }],
+    skills: session.skills.names,
+    // The shell is the whole tool surface.
+    //
+    // `allowedTools` is an auto-approve list, not a filter: on its own it still
+    // leaves every other built-in tool, and any connector on the API key's
+    // account, advertised to the model. Denying them explicitly takes the tool
+    // list from 23 entries to Bash and Skill, so what the agent can do matches
+    // what this file says it can do — which is the claim the TEE attestation
+    // is supposed to stand behind.
+    allowedTools: ["Bash"],
+    disallowedTools: [
+      "Read",
+      "Write",
+      "Edit",
+      "WebFetch",
+      "WebSearch",
+      "mcp__*",
+      // connectors inherited from the account behind ANTHROPIC_API_KEY
+      "Task",
+      "Artifact",
+      "ArtifactComments",
+      "ArtifactData",
+      "CronCreate",
+      "CronDelete",
+      "CronList",
+      "DesignSync",
+      "EnterWorktree",
+      "ExitWorktree",
+      "ListAgents",
+      "Monitor",
+      "NotebookEdit",
+      "PushNotification",
+      "RemoteTrigger",
+      "ReportFindings",
+      "ScheduleWakeup",
+      "SendMessage",
+      "TaskStop",
+      "ToolSearch",
+      "Workflow"
+    ],
+    // Nobody is at the keyboard, so deny anything not pre-approved.
+    permissionMode: "dontAsk",
+    maxTurns: 40,
+    env: { ...process.env, ...RESILIENCE_ENV },
+    // Claude Code's own diagnostics: API errors, retries, a failed plugin load.
+    stderr: (data) => {
+      for (const line of data.split("\n")) if (line.trim()) log2.error(`stderr: ${clip(line, limits.MAX_OUTPUT)}`);
+    }
+  };
+}
+function proseOf(message2) {
+  return message2.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+var AgentRunError = class extends Error {
+};
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => block && typeof block === "object" && "text" in block ? String(block.text) : "").join("");
+}
+function logMessage(message2, log2, commands) {
+  if (message2.type === "system" && message2.subtype === "init") {
+    log2.debug(`session ${message2.session_id}, model ${message2.model}, tools ${message2.tools.join(", ")}`);
+    return;
+  }
+  if (message2.type === "assistant") {
+    for (const block of message2.message.content) {
+      if (block.type === "text" && block.text.trim()) log2.debug(`says: ${clip(block.text, limits.MAX_OUTPUT)}`);
+      if (block.type !== "tool_use") continue;
+      const input = block.input ?? {};
+      const what = block.name === "Bash" ? `$ ${clip(String(input.command ?? ""), limits.MAX_COMMAND)}` : block.name === "Skill" ? `skill ${String(input.skill ?? input.command ?? "")}` : `${block.name} ${clip(JSON.stringify(input), limits.MAX_COMMAND)}`;
+      commands.set(block.id, what);
+      log2.info(what);
+    }
+    return;
+  }
+  if (message2.type === "user" && Array.isArray(message2.message.content)) {
+    for (const block of message2.message.content) {
+      if (typeof block !== "object" || block.type !== "tool_result") continue;
+      const output = clip(resultText(block.content), limits.MAX_OUTPUT);
+      const what = commands.get(block.tool_use_id) ?? block.tool_use_id;
+      if (block.is_error) log2.error(`failed: ${what}
+${output}`);
+      else log2.debug(`output of ${what}
+${output}`);
+    }
+  }
+}
+function finish(result, log2) {
+  const stats = `${(result.duration_ms / 1e3).toFixed(1)}s, ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`;
+  for (const denial of result.permission_denials ?? []) {
+    log2.error(`denied tool ${denial.tool_name}: ${clip(JSON.stringify(denial.tool_input), limits.MAX_COMMAND)}`);
+  }
+  if (result.subtype === "success") {
+    log2.info(`done (${stats})`);
+    return void 0;
+  }
+  const errors = result.errors?.length ? `: ${result.errors.join("; ")}` : "";
+  log2.error(`ended ${result.subtype} (${stats})${errors}`);
+  return new AgentRunError(`Agent run ended: ${result.subtype}${errors}`);
+}
+async function runAgent(prompt, session, label = "run") {
+  const log2 = runLog(label);
+  const options = agentOptions(session, log2);
+  const said = [];
+  const commands = /* @__PURE__ */ new Map();
+  log2.info(`started: ${clip(prompt.split("\n")[0] ?? "", 120)}`);
+  try {
+    for await (const message2 of query({ prompt, options })) {
+      logMessage(message2, log2, commands);
+      if (message2.type === "assistant") said.push(proseOf(message2));
+      if (message2.type === "result") {
+        const error = finish(message2, log2);
+        if (error) throw error;
+        return said.join("").trim();
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof AgentRunError)) {
+      log2.error(`crashed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    }
+    throw error;
+  }
+  log2.error("ended without a result");
+  throw new AgentRunError("Agent run ended without a result.");
+}
+
+// src/agent/agent-id.ts
+import { mkdtemp, readFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { createPublicClient, getAbiItem, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/abi/registries.ts
+var identityRegistryAbi = [
+  {
+    type: "function",
+    name: "register",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" },
+      { name: "value", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "key", type: "string" }
+    ],
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tokenURI",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "Registered",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "agentURI", type: "string", indexed: false },
+      { name: "owner", type: "address", indexed: true }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ],
+    anonymous: false
+  }
+];
+
+// src/networks.ts
+import { defineChain } from "viem";
+var robinhood = defineChain({
+  id: 4663,
+  name: "Robinhood Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
+  blockExplorers: {
+    default: { name: "Blockscout", url: "https://robinhoodchain.blockscout.com" }
+  },
+  contracts: {
+    multicall3: { address: "0xca11bde05977b3631167028862be2a173976ca11" }
+  }
+});
+var networks = {
+  /** Robinhood Chain mainnet, where app.kudo.archi reads and writes. */
+  robinhood: {
+    key: "robinhood",
+    chain: robinhood,
+    kudo: "0x1930D0FEaB14b024353bF22adE03Db989aD640C7",
+    usdg: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63",
+    statuses: ["MINTED", "IN_PROGRESS", "COMPLETED", "FAILED"],
+    covenantUrl: "https://app.kudo.archi/share/{id}",
+    explorerUrl: "https://robinhoodchain.blockscout.com",
+    maxLogRange: 10000000n
+  }
+};
+
+// src/agent/agent-id.ts
+var ID = /^\d+$/;
+async function findRegisteredAgentId(client, registry, owner, maxLogRange = networks.robinhood.maxLogRange) {
+  const balance = await client.readContract({
+    address: registry,
+    abi: identityRegistryAbi,
+    functionName: "balanceOf",
+    args: [owner]
+  });
+  if (balance === 0n) return void 0;
+  const registered = getAbiItem({ abi: identityRegistryAbi, name: "Registered" });
+  let to = await client.getBlockNumber();
+  for (; ; ) {
+    const from = to >= maxLogRange ? to - maxLogRange + 1n : 0n;
+    const logs = await client.getLogs({ address: registry, event: registered, args: { owner }, fromBlock: from, toBlock: to });
+    for (const log2 of logs.reverse()) {
+      const id = log2.args.agentId;
+      if (id === void 0) continue;
+      const current = await client.readContract({
+        address: registry,
+        abi: identityRegistryAbi,
+        functionName: "ownerOf",
+        args: [id]
+      });
+      if (current.toLowerCase() === owner.toLowerCase()) return id;
+    }
+    if (from === 0n) return void 0;
+    to = from - 1n;
+  }
+}
+async function resolveAgentId(env = process.env) {
+  delete env.AGENT_ID;
+  const owner = privateKeyToAccount(env.PRIVATE_KEY.trim()).address;
+  const client = createPublicClient({ transport: http(env.RPC_URL.trim()) });
+  const id = await findRegisteredAgentId(client, env.IDENTITY_REGISTRY.trim(), owner);
+  if (id === void 0) {
+    console.log(`no ERC-8004 identity registered by ${owner} \u2014 the agent registers one at its first run`);
+    return;
+  }
+  env.AGENT_ID = id.toString();
+  console.log(`AGENT_ID ${env.AGENT_ID}, registered by ${owner}`);
+}
+async function prepareAgentIdFile(env = process.env) {
+  const file = join(await mkdtemp(join(tmpdir(), "kudo-agent-id-")), "agent-id");
+  env.KUDO_AGENT_ID_FILE = file;
+  return file;
+}
+async function syncAgentId(env = process.env) {
+  const file = env.KUDO_AGENT_ID_FILE;
+  if (!file) return void 0;
+  let recorded;
+  try {
+    recorded = (await readFile(file, "utf8")).trim();
+  } catch {
+    return void 0;
+  }
+  if (!ID.test(recorded)) {
+    if (recorded) console.error(`Ignoring ${file}: "${recorded.slice(0, 40)}" is not an agent id.`);
+    return void 0;
+  }
+  const previous = env.AGENT_ID?.trim();
+  env.AGENT_ID = recorded;
+  return previous === recorded ? void 0 : recorded;
+}
+
+// src/agent/config.ts
+var REQUIRED = [
+  "ANTHROPIC_API_KEY",
+  "PRIVATE_KEY",
+  "RPC_URL",
+  "KUDO",
+  "IDENTITY_REGISTRY"
+];
+var TWITTER = [
+  "TWITTER_API_KEY",
+  "TWITTER_API_SECRET_KEY",
+  "TWITTER_ACCESS_TOKEN",
+  "TWITTER_ACCESS_TOKEN_SECRET",
+  "TWITTER_HANDLE"
+];
+var unset = (keys) => keys.filter((key) => !process.env[key]?.trim());
+function requireEnvironment() {
+  const missing = unset(REQUIRED);
+  if (missing.length === 0) return;
+  console.error(`Missing required environment variables: ${missing.join(", ")}`);
+  console.error("See .env.example in @kudo-dev/sdk.");
+  process.exit(1);
+}
+function warnIfTwitterIncomplete() {
+  const missing = unset(TWITTER);
+  if (missing.length === 0 || missing.length === TWITTER.length) return;
+  console.error(
+    `Warning: X credentials are partially set (missing ${missing.join(", ")}). Posting will fail with 403 Unsupported Authentication.`
+  );
+}
+
+// src/agent/jobs.ts
+var DEFAULT_JOBS = { "settle-due": { interval: 300 } };
+var MIN_INTERVAL_SECONDS = 10;
+var log = (job, message2) => console.log(`${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)} ${job}: ${redact(message2)}`);
+function spec(name, seconds, prompt, source) {
+  if (!name || !Number.isFinite(seconds) || seconds < MIN_INTERVAL_SECONDS) {
+    throw new Error(`${source}: "${name}:${seconds}" is not <name>:<seconds> with seconds >= ${MIN_INTERVAL_SECONDS}.`);
+  }
+  return prompt === void 0 ? { name, intervalSeconds: seconds } : { name, intervalSeconds: seconds, prompt };
+}
+function resolveJobs(own, env = process.env) {
+  const raw = env.JOBS?.trim();
+  if (raw) {
+    return raw.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+      const [name = "", seconds = ""] = entry.split(":").map((part) => part.trim());
+      return spec(name, Number(seconds), own?.[name]?.prompt, "JOBS");
+    });
+  }
+  if (env.TICK_INTERVAL_SECONDS?.trim() === "0") return [];
+  return Object.entries(own ?? DEFAULT_JOBS).map(([name, job]) => spec(name, Number(job?.interval), job?.prompt, "jobs"));
+}
+var lock = Promise.resolve();
+function exclusive(work) {
+  const next = lock.then(work, work);
+  lock = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+function whenRunsIdle() {
+  return lock;
+}
+function startJob(job, run) {
+  let running = true;
+  let inFlight = Promise.resolve();
+  async function once() {
+    try {
+      const answer = await exclusive(() => run(job));
+      log(job.name, answer || "(no response)");
+    } catch (error) {
+      log(job.name, `failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async function loop() {
+    log(job.name, `every ${job.intervalSeconds}s`);
+    while (running) {
+      inFlight = once();
+      await inFlight;
+      const until = Date.now() + job.intervalSeconds * 1e3;
+      while (running && Date.now() < until) {
+        await new Promise((r) => setTimeout(r, Math.min(1e3, until - Date.now())));
+      }
+    }
+    log(job.name, "stopped");
+  }
+  const finished = loop();
+  return {
+    stop() {
+      running = false;
+    },
+    async whenIdle() {
+      await inFlight;
+      await finished;
+    }
+  };
+}
+function startJobs(jobs, run) {
+  if (jobs.length === 0) {
+    console.log("no scheduled jobs \u2014 something else owns this agent's work");
+    return { stop() {
+    }, async whenIdle() {
+    } };
+  }
+  const started = jobs.map((job) => startJob(job, run));
+  return {
+    stop: () => started.forEach((job) => job.stop()),
+    whenIdle: async () => {
+      await Promise.all(started.map((job) => job.whenIdle()));
+    }
+  };
+}
+
+// src/agent/prompts.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/agent/paths.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function findPackageDir() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const manifest = join2(dir, "package.json");
+    if (existsSync(manifest)) {
+      const { name } = JSON.parse(readFileSync(manifest, "utf8"));
+      if (name === "@kudo-dev/sdk") return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) throw new Error("Cannot find the @kudo-dev/sdk package directory.");
+    dir = parent;
+  }
+}
+var PACKAGE_DIR = findPackageDir();
+var PROMPTS_DIR = join2(PACKAGE_DIR, "prompts");
+var SKILLS_DIR = join2(PACKAGE_DIR, "skills");
+
+// src/agent/prompts.ts
+var SAFE_NAME = /^[a-z0-9][a-z0-9-]*$/i;
+var LOOKS_LIKE_PATH = /^(\.{1,2}\/|\/)\S*$|^\S+\.(md|txt)$/i;
+async function read(source) {
+  if (source instanceof URL) return readFile2(fileURLToPath2(source), "utf8");
+  if (!source.includes("\n") && existsSync2(source)) return readFile2(source, "utf8");
+  if (!source.includes("\n") && LOOKS_LIKE_PATH.test(source.trim())) {
+    throw new Error(`Prompt file ${source} does not exist.`);
+  }
+  return source;
+}
+async function loadSystemPrompt(character) {
+  const common = await readFile2(join3(PROMPTS_DIR, "common.md"), "utf8");
+  return `${common.trim()}
+
+---
+
+${(await read(character)).trim()}`;
+}
+async function bundledPrompts() {
+  return (await readdir(PROMPTS_DIR)).filter((f) => f.endsWith(".txt")).map((f) => f.replace(/\.txt$/, "")).sort();
+}
+async function loadPrompt(name, own) {
+  if (own !== void 0) return (await read(own)).trim();
+  if (!SAFE_NAME.test(name)) {
+    throw new Error(`Invalid prompt name "${name}" \u2014 use letters, digits and dashes.`);
+  }
+  try {
+    return (await readFile2(join3(PROMPTS_DIR, `${name}.txt`), "utf8")).trim();
+  } catch {
+    throw new Error(
+      `Job "${name}" has no prompt and none is bundled under that name. Give it a \`prompt\`, or use one of: ${(await bundledPrompts()).join(", ")}.`
+    );
+  }
+}
+
+// src/agent/server/index.ts
+import { createServer } from "http";
+
+// src/agent/server/http.ts
+var MAX_BODY_BYTES = 64 * 1024;
+function sendJson(response, status, body) {
+  const payload = JSON.stringify(body);
+  response.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(payload)
+  });
+  response.end(payload);
+}
+async function readBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) throw new Error("Request body too large.");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function allowLongRun(request, response) {
+  request.setTimeout(0);
+  response.setTimeout(0);
+}
+
+// src/agent/server/handlers.ts
+function health(_request, response) {
+  sendJson(response, 200, { ok: true });
+}
+function identity(_request, response) {
+  sendJson(response, 200, {
+    name: process.env.AGENT_NAME?.trim() || null,
+    agentId: process.env.AGENT_ID?.trim() || null,
+    teeId: process.env.TEE_ID?.trim() || null,
+    attestation: process.env.TEE_TRUST_URL?.trim() || null,
+    // False for a hand-set TEE_ID: the report exists, but describes another app.
+    attested: process.env.TEE_ID_SOURCE?.trim() === "dstack"
+  });
+}
+function notFound(_request, response) {
+  sendJson(response, 404, { error: "Not found. Try POST /message, GET /identity or GET /health." });
+}
+async function message(request, response, run) {
+  let body;
+  try {
+    body = JSON.parse(await readBody(request));
+  } catch (error) {
+    return sendJson(response, 400, {
+      error: error instanceof Error ? error.message : "Invalid JSON body."
+    });
+  }
+  const text = body?.message;
+  if (typeof text !== "string" || !text.trim()) {
+    return sendJson(response, 400, { error: 'Body must be {"message": "<text>"}.' });
+  }
+  try {
+    allowLongRun(request, response);
+    sendJson(response, 200, { response: redact(await run(text.trim())) });
+  } catch (error) {
+    const reason = redact(error instanceof Error ? error.message : String(error));
+    console.error(`POST /message failed: ${reason}`);
+    sendJson(response, error instanceof AgentRunError ? 502 : 500, { error: reason });
+  }
+}
+
+// src/agent/server/index.ts
+var DEFAULT_PORT = 3e3;
+function startServer(run, port) {
+  const listenOn = port ?? Number(process.env.PORT?.trim() || DEFAULT_PORT);
+  const routes = [
+    { method: "GET", path: "/health", handle: health },
+    { method: "GET", path: "/identity", handle: identity },
+    {
+      method: "POST",
+      path: "/message",
+      handle: (request, response) => message(request, response, run)
+    }
+  ];
+  function route(request, response) {
+    const match = routes.find(
+      (candidate) => candidate.method === request.method && candidate.path === request.url
+    );
+    void (match ? match.handle(request, response) : notFound(request, response));
+  }
+  const server = createServer(route);
+  server.listen(listenOn, () => console.log(`listening on :${listenOn}`));
+  return {
+    port: listenOn,
+    close: () => server.close()
+  };
+}
+
+// src/agent/skills.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, mkdtemp as mkdtemp2, readdir as readdir2, symlink, writeFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { basename, isAbsolute, join as join4, resolve } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var DEFAULT_SKILLS = ["kudo", "kudo-runtime", "twitter"];
+var PLUGIN_NAME = "kudo";
+async function bundledSkills() {
+  const entries = await readdir2(SKILLS_DIR, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name).sort();
+}
+function resolveSkill(ref) {
+  const isPath = ref instanceof URL || isAbsolute(ref) || ref.startsWith(".");
+  const dir = ref instanceof URL ? fileURLToPath3(ref) : isPath ? resolve(ref) : join4(SKILLS_DIR, ref);
+  if (!existsSync3(join4(dir, "SKILL.md"))) {
+    throw new Error(
+      isPath ? `Skill folder ${dir} has no SKILL.md.` : `No bundled skill "${ref}". Bundled: see ${SKILLS_DIR}, or pass a path to your own skill folder.`
+    );
+  }
+  return { name: basename(dir), dir };
+}
+async function assembleSkills(extra = []) {
+  const skills = /* @__PURE__ */ new Map();
+  for (const ref of [...DEFAULT_SKILLS, ...extra]) {
+    const { name, dir } = resolveSkill(ref);
+    const existing = skills.get(name);
+    if (existing && existing !== dir) throw new Error(`Two skills are named "${name}": ${existing} and ${dir}.`);
+    skills.set(name, dir);
+  }
+  const root = await mkdtemp2(join4(tmpdir2(), "kudo-agent-skills-"));
+  await mkdir(join4(root, ".claude-plugin"));
+  await writeFile(
+    join4(root, ".claude-plugin", "plugin.json"),
+    JSON.stringify({ name: PLUGIN_NAME, description: "Kudo agent skills", version: "0.0.0" })
+  );
+  await mkdir(join4(root, "skills"));
+  for (const [name, dir] of skills) await symlink(dir, join4(root, "skills", name), "dir");
+  return { path: root, names: [...skills.keys()].map((name) => `${PLUGIN_NAME}:${name}`) };
+}
+
+// src/errors.ts
+import { BaseError, ContractFunctionRevertedError } from "viem";
+var KudoError = class extends Error {
+  code;
+  revert;
+  constructor(code, message2, options = {}) {
+    super(message2, { cause: options.cause });
+    this.name = "KudoError";
+    this.code = code;
+    this.revert = options.revert;
+  }
+};
+
+// src/dstack.ts
+var DSTACK_SOCKET = "/var/run/dstack.sock";
+async function call(path, body, options) {
+  const { request } = await import("http");
+  const socketPath = options.socket ?? DSTACK_SOCKET;
+  return new Promise((resolve3, reject) => {
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    const req = request(
+      {
+        socketPath,
+        path,
+        method: payload ? "POST" : "GET",
+        headers: payload ? { "content-type": "application/json", "content-length": Buffer.byteLength(payload) } : {},
+        timeout: options.timeoutMs ?? 5e3
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          if (res.statusCode !== 200) return reject(new KudoError("NOT_FOUND", `dstack ${path} returned ${res.statusCode}.`));
+          try {
+            resolve3(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+          } catch {
+            reject(new KudoError("NOT_FOUND", `dstack ${path} did not return JSON.`));
+          }
+        });
+      }
+    );
+    req.on("timeout", () => req.destroy(new Error("timed out")));
+    req.on(
+      "error",
+      (e) => reject(new KudoError("NOT_FOUND", `Cannot reach dstack at ${socketPath} (${e.message}). Is this running in a Phala TEE?`))
+    );
+    req.end(payload);
+  });
+}
+async function dstackAppId(options = {}) {
+  const { app_id } = await call("/Info", void 0, options);
+  if (!app_id) throw new KudoError("NOT_FOUND", "dstack Info returned no app_id.");
+  return app_id.replace(/^0x/i, "").toLowerCase();
+}
+
+// src/agent/tee.ts
+var TRUST_CENTER = "https://trust.phala.com/app";
+var INFO_TIMEOUT_MS = 2e3;
+function bareHex(appId) {
+  return appId.trim().replace(/^0x/i, "").toLowerCase();
+}
+async function appIdFromDstack() {
+  try {
+    return await dstackAppId({ timeoutMs: INFO_TIMEOUT_MS });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.log(`no dstack socket (${reason}) \u2014 looking at the environment instead`);
+    return void 0;
+  }
+}
+async function resolveTeeIdentity() {
+  const attested = await appIdFromDstack();
+  const appId = attested || process.env.DSTACK_APP_ID?.trim() || process.env.TEE_ID?.trim();
+  if (!appId) return void 0;
+  const teeId = bareHex(appId);
+  return {
+    teeId,
+    trustCenterUrl: `${TRUST_CENTER}/${teeId}`,
+    source: attested ? "dstack" : "environment"
+  };
+}
+
+// src/agent/start.ts
+var SHUTDOWN_GRACE_MS = Number(process.env.SHUTDOWN_GRACE_SECONDS?.trim() || 120) * 1e3;
+async function announceTee() {
+  const tee = await resolveTeeIdentity();
+  if (!tee) {
+    console.log("no TEE app id \u2014 running without attestation");
+    return;
+  }
+  process.env.TEE_ID = tee.teeId;
+  process.env.TEE_TRUST_URL = tee.trustCenterUrl;
+  process.env.TEE_ID_SOURCE = tee.source;
+  if (tee.source === "dstack") {
+    console.log(`attestation: ${tee.trustCenterUrl}`);
+    return;
+  }
+  console.log(`TEE_ID set by hand: ${tee.trustCenterUrl}`);
+  console.log("  that report is NOT this process \u2014 local stand-in, attests nothing");
+}
+function defaultCwd(source) {
+  if (source instanceof URL) return dirname2(fileURLToPath4(source));
+  if (!source.includes("\n") && existsSync4(source)) return dirname2(resolve2(source));
+  return process.cwd();
+}
+async function createSession(options) {
+  const skills = await assembleSkills(options.skills);
+  return {
+    systemPrompt: await loadSystemPrompt(options.systemPrompt),
+    skills,
+    cwd: resolve2(options.cwd ?? defaultCwd(options.systemPrompt)),
+    model: options.model ?? "claude-opus-5"
+  };
+}
+async function startAgent(options) {
+  requireEnvironment();
+  warnIfTwitterIncomplete();
+  await resolveAgentId();
+  await announceTee();
+  process.env.KUDO_SPONSORED_SEND = join5(SKILLS_DIR, "kudo", "sponsored-send.mjs");
+  const session = await createSession(options);
+  console.log(`skills: ${session.skills.names.join(", ")}`);
+  const jobs = resolveJobs(options.jobs);
+  for (const job of jobs) await loadPrompt(job.name, job.prompt);
+  await prepareAgentIdFile();
+  const beforeRun = async () => {
+    const recorded = await syncAgentId();
+    if (recorded) console.log(`AGENT_ID ${recorded}, as the agent recorded it after registering`);
+  };
+  const run = (prompt) => exclusive(async () => {
+    await beforeRun();
+    return runAgent(prompt, session, "message");
+  });
+  const runJob = async (job) => {
+    await beforeRun();
+    return runAgent(await loadPrompt(job.name, job.prompt), session, job.name);
+  };
+  const server = startServer(run, options.port);
+  const scheduled = startJobs(jobs, runJob);
+  let shuttingDown = false;
+  function shutdown() {
+    if (shuttingDown) {
+      console.log("second signal \u2014 exiting now");
+      process.exit(130);
+    }
+    shuttingDown = true;
+    console.log(`shutting down (up to ${SHUTDOWN_GRACE_MS / 1e3}s for the current run)`);
+    server.close();
+    scheduled.stop();
+    const deadline = new Promise(
+      (resolveTimeout) => setTimeout(() => resolveTimeout("timeout"), SHUTDOWN_GRACE_MS).unref()
+    );
+    const idle = Promise.all([scheduled.whenIdle(), whenRunsIdle()]);
+    void Promise.race([idle, deadline]).then((outcome) => {
+      if (outcome === "timeout") console.error("run did not finish in time \u2014 exiting anyway");
+      process.exit(0);
+    });
+  }
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+export {
+  AgentRunError,
+  DEFAULT_SKILLS,
+  bundledPrompts,
+  bundledSkills,
+  createSession,
+  loadPrompt,
+  loadSystemPrompt,
+  resolveJobs,
+  runAgent,
+  startAgent
+};
+//# sourceMappingURL=index.js.map