@runfusion/fusion 0.21.0 → 0.22.0

package/dist/plugins/fusion-plugin-paperclip-runtime/bundled.js

@@ -0,0 +1,966 @@
+// ../plugin-sdk/dist/index.js
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-paperclip-runtime/dist/paperclip-client.js
+var ConflictError = class extends Error {
+  status = 409;
+  constructor(message) {
+    super(message);
+    this.name = "ConflictError";
+  }
+};
+function normalizeApiUrl(url) {
+  return url.replace(/\/+$/, "");
+}
+function buildUrl(apiUrl, path, query) {
+  const base = normalizeApiUrl(apiUrl);
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const qs = query && query.size > 0 ? `?${query.toString()}` : "";
+  return `${base}/api${normalizedPath}${qs}`;
+}
+function buildHeaders(apiKey, extra) {
+  const headers = {
+    Accept: "application/json",
+    ...extra
+  };
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+async function parseJsonBody(response) {
+  const raw = await response.text();
+  if (raw.trim() === "") {
+    return { value: void 0, raw };
+  }
+  try {
+    return { value: JSON.parse(raw), raw };
+  } catch {
+    throw new Error(`Paperclip API ${response.status} ${response.statusText}: invalid JSON response body`);
+  }
+}
+function toErrorMessage(status, statusText, body, raw) {
+  if (body && typeof body === "object") {
+    const b = body;
+    if (typeof b.error === "string")
+      return b.error;
+    if (typeof b.message === "string")
+      return b.message;
+  }
+  if (raw.trim() !== "")
+    return raw.slice(0, 200).trim();
+  return `${status} ${statusText}`.trim();
+}
+async function request(apiUrl, path, options) {
+  const method = options?.method ?? "GET";
+  const url = buildUrl(apiUrl, path, options?.query);
+  const headers = buildHeaders(options?.apiKey);
+  let bodyStr;
+  if (options && "body" in options && options.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    bodyStr = JSON.stringify(options.body);
+  }
+  let response;
+  try {
+    response = await fetch(url, { method, headers, body: bodyStr });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Paperclip API network error (${method} ${url}): ${reason}`);
+  }
+  const { value, raw } = await parseJsonBody(response);
+  if (!response.ok) {
+    const msg = toErrorMessage(response.status, response.statusText, value, raw);
+    const full = `Paperclip API ${response.status} (${method} ${path}): ${msg}`;
+    if (response.status === 409)
+      throw new ConflictError(full);
+    throw new Error(full);
+  }
+  return value;
+}
+function getSettingString(settings, key) {
+  const v = settings?.[key];
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
+}
+function resolvePaperclipConfig(settings) {
+  const apiUrl = normalizeApiUrl(getSettingString(settings, "apiUrl") ?? process.env.PAPERCLIP_API_URL?.trim() ?? "http://localhost:3100");
+  const apiKey = getSettingString(settings, "apiKey") ?? (process.env.PAPERCLIP_API_KEY?.trim() || void 0);
+  const agentId = getSettingString(settings, "agentId") ?? process.env.PAPERCLIP_AGENT_ID?.trim() ?? void 0;
+  const companyId = getSettingString(settings, "companyId") ?? process.env.PAPERCLIP_COMPANY_ID?.trim() ?? void 0;
+  const mode = getSettingString(settings, "mode") ?? process.env.PAPERCLIP_RUNTIME_MODE?.trim() ?? "rolling-issue";
+  const transportRaw = getSettingString(settings, "transport") ?? process.env.PAPERCLIP_TRANSPORT?.trim() ?? "api";
+  const transport = transportRaw === "cli" ? "cli" : "api";
+  const cliBinaryPath = getSettingString(settings, "cliBinaryPath") ?? process.env.PAPERCLIPAI_BIN?.trim() ?? "paperclipai";
+  const cliConfigPath = getSettingString(settings, "cliConfigPath") ?? process.env.PAPERCLIP_CLI_CONFIG?.trim() ?? void 0;
+  const parentIssueId = getSettingString(settings, "parentIssueId") ?? process.env.PAPERCLIP_PARENT_ISSUE_ID?.trim() ?? void 0;
+  const projectId = getSettingString(settings, "projectId") ?? process.env.PAPERCLIP_PROJECT_ID?.trim() ?? void 0;
+  const goalId = getSettingString(settings, "goalId") ?? process.env.PAPERCLIP_GOAL_ID?.trim() ?? void 0;
+  const runTimeoutMs = parseInt(getSettingString(settings, "runTimeoutMs") ?? process.env.PAPERCLIP_RUN_TIMEOUT_MS ?? "600000", 10);
+  const pollIntervalMs = parseInt(getSettingString(settings, "pollIntervalMs") ?? process.env.PAPERCLIP_POLL_INTERVAL_MS ?? "500", 10);
+  const pollIntervalMaxMs = parseInt(getSettingString(settings, "pollIntervalMaxMs") ?? process.env.PAPERCLIP_POLL_INTERVAL_MAX_MS ?? "2000", 10);
+  return {
+    apiUrl,
+    apiKey,
+    agentId,
+    companyId,
+    mode,
+    transport,
+    cliBinaryPath,
+    cliConfigPath,
+    parentIssueId,
+    projectId,
+    goalId,
+    runTimeoutMs: isFinite(runTimeoutMs) ? runTimeoutMs : 6e5,
+    pollIntervalMs: isFinite(pollIntervalMs) ? pollIntervalMs : 500,
+    pollIntervalMaxMs: isFinite(pollIntervalMaxMs) ? pollIntervalMaxMs : 2e3
+  };
+}
+async function discoverPaperclipCliConfig(opts = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const os = await import("node:os");
+  const configPath = opts.configPath ?? path.join(os.homedir(), ".paperclip", "instances", "default", "config.json");
+  let raw;
+  try {
+    raw = await fs.readFile(configPath, "utf-8");
+  } catch (error) {
+    const code = error.code;
+    return {
+      ok: false,
+      configPath,
+      reason: code === "ENOENT" ? `Paperclip CLI config not found at ${configPath}. Install paperclipai and run \`paperclipai onboard\`, or use API mode.` : `Could not read ${configPath}: ${error.message}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { ok: false, configPath, reason: `Invalid JSON in ${configPath}` };
+  }
+  const server = parsed.server ?? {};
+  const host = typeof server.host === "string" ? server.host : "127.0.0.1";
+  const port = typeof server.port === "number" ? server.port : Number(server.port ?? 3100) || 3100;
+  const deploymentMode = typeof server.deploymentMode === "string" ? server.deploymentMode : void 0;
+  return {
+    ok: true,
+    apiUrl: `http://${host}:${port}`,
+    apiKey: void 0,
+    configPath,
+    deploymentMode
+  };
+}
+async function agentsMe(apiUrl, apiKey) {
+  const raw = await request(apiUrl, "/agents/me", { apiKey });
+  const id = typeof raw.id === "string" ? raw.id : void 0;
+  const name = typeof raw.name === "string" ? raw.name : void 0;
+  const role = typeof raw.role === "string" ? raw.role : void 0;
+  const cId = typeof raw.companyId === "string" ? raw.companyId : void 0;
+  const cName = typeof raw.companyName === "string" ? raw.companyName : void 0;
+  if (!id || !cId) {
+    throw new Error("Paperclip /api/agents/me returned a response missing `id` or `companyId`");
+  }
+  return { agentId: id, agentName: name ?? id, role, companyId: cId, companyName: cName };
+}
+async function createIssue(apiUrl, apiKey, companyId, body) {
+  return request(apiUrl, `/companies/${companyId}/issues`, {
+    method: "POST",
+    apiKey,
+    body
+  });
+}
+async function getIssue(apiUrl, apiKey, issueId) {
+  return request(apiUrl, `/issues/${issueId}`, { apiKey });
+}
+async function getIssueComments(apiUrl, apiKey, issueId) {
+  return request(apiUrl, `/issues/${issueId}/comments`, { apiKey });
+}
+async function wakeAgent(apiUrl, apiKey, agentId, body) {
+  return request(apiUrl, `/agents/${agentId}/wakeup`, {
+    method: "POST",
+    apiKey,
+    body
+  });
+}
+async function getRunEvents(apiUrl, apiKey, runId, afterSeq, limit = 100) {
+  const query = new URLSearchParams({
+    afterSeq: String(afterSeq),
+    limit: String(limit)
+  });
+  const result = await request(apiUrl, `/heartbeat-runs/${runId}/events`, {
+    apiKey,
+    query
+  });
+  if (Array.isArray(result))
+    return result;
+  const r = result;
+  if (Array.isArray(r.events))
+    return r.events;
+  return [];
+}
+async function listCompanies(apiUrl, apiKey) {
+  const raw = await request(apiUrl, "/companies", { apiKey });
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const r = entry;
+    const id = typeof r.id === "string" ? r.id : void 0;
+    if (!id)
+      continue;
+    const name = typeof r.name === "string" ? r.name : id;
+    const urlKey = typeof r.urlKey === "string" ? r.urlKey : typeof r.slug === "string" ? r.slug : void 0;
+    out.push({ id, name, urlKey });
+  }
+  return out;
+}
+async function listCompanyAgents(apiUrl, apiKey, companyId) {
+  const raw = await request(apiUrl, `/companies/${companyId}/agents`, { apiKey });
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const r = entry;
+    const id = typeof r.id === "string" ? r.id : void 0;
+    if (!id)
+      continue;
+    const name = typeof r.name === "string" ? r.name : id;
+    const role = typeof r.role === "string" ? r.role : void 0;
+    const cId = typeof r.companyId === "string" ? r.companyId : companyId;
+    const status = typeof r.status === "string" ? r.status : void 0;
+    out.push({ id, name, role, companyId: cId, status });
+  }
+  return out;
+}
+async function probePaperclipConnection(opts) {
+  const { apiKey, timeoutMs = 5e3 } = opts;
+  const apiUrl = normalizeApiUrl(opts.apiUrl);
+  const url = buildUrl(apiUrl, "/agents/me");
+  const started = Date.now();
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: buildHeaders(apiKey),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      available: false,
+      apiUrl,
+      reason: `Paperclip server not reachable at ${apiUrl}: ${reason}`,
+      probeDurationMs: Date.now() - started
+    };
+  }
+  const probeDurationMs = Date.now() - started;
+  if (response.status === 401 || response.status === 403) {
+    return { available: false, apiUrl, reason: "API key rejected", probeDurationMs };
+  }
+  if (response.status === 404) {
+    return {
+      available: false,
+      apiUrl,
+      reason: `Paperclip server not reachable at ${apiUrl}: 404 Not Found`,
+      probeDurationMs
+    };
+  }
+  if (!response.ok) {
+    let body = "";
+    try {
+      body = (await response.text()).slice(0, 200);
+    } catch {
+    }
+    return {
+      available: false,
+      apiUrl,
+      reason: `${response.status} ${response.statusText}: ${body}`.trim(),
+      probeDurationMs
+    };
+  }
+  let identity;
+  try {
+    const { value: raw } = await parseJsonBody(response);
+    const r = raw;
+    const agentId = typeof r.id === "string" ? r.id : "";
+    const companyId = typeof r.companyId === "string" ? r.companyId : "";
+    identity = {
+      agentId,
+      agentName: typeof r.name === "string" ? r.name : agentId,
+      role: typeof r.role === "string" ? r.role : void 0,
+      companyId,
+      companyName: typeof r.companyName === "string" ? r.companyName : void 0
+    };
+  } catch {
+    return {
+      available: false,
+      apiUrl,
+      reason: "Paperclip server responded 200 but returned invalid JSON",
+      probeDurationMs
+    };
+  }
+  return { available: true, apiUrl, identity, probeDurationMs };
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*[mGKJHFABCDSTsu]/g, "");
+}
+async function mintAgentApiKeyViaCli(opts) {
+  const { spawn } = await import("node:child_process");
+  const bin = opts.cliBinaryPath ?? "paperclipai";
+  const args = [
+    "agent",
+    "local-cli",
+    opts.agentRef,
+    "--json",
+    "--no-install-skills",
+    "--key-name",
+    opts.keyName ?? "fusion-runtime"
+  ];
+  if (opts.companyId) {
+    args.push("--company-id", opts.companyId);
+  }
+  if (opts.configPath) {
+    args.push("--config", opts.configPath);
+  }
+  if (opts.dataDir) {
+    args.push("--data-dir", opts.dataDir);
+  }
+  const timeoutMs = opts.cliTimeoutMs ?? 3e4;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        reject(new Error(`paperclipai binary not found at ${bin}; install via \`npm i -g paperclipai\``));
+      } else {
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+      return;
+    }
+    const stdoutChunks = [];
+    const stderrLines = [];
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+      reject(new Error(`paperclipai agent local-cli timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const lines = chunk.toString("utf-8").split("\n");
+      for (const line of lines) {
+        const stripped = stripAnsi(line).trim();
+        if (stripped)
+          stderrLines.push(stripped);
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if (err.code === "ENOENT") {
+        reject(new Error(`paperclipai binary not found at ${bin}; install via \`npm i -g paperclipai\``));
+      } else {
+        reject(err);
+      }
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed)
+        return;
+      const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
+      const cleanedStdout = stripAnsi(rawStdout).trim();
+      if (code !== 0) {
+        const lastStderrLine = stderrLines.filter(Boolean).pop() ?? "";
+        const hint = "run `paperclipai onboard` to authenticate the CLI";
+        const msg = lastStderrLine ? `paperclipai agent local-cli exited ${code}: ${lastStderrLine} \u2014 ${hint}` : `paperclipai agent local-cli exited ${code} \u2014 ${hint}`;
+        reject(new Error(msg));
+        return;
+      }
+      if (!cleanedStdout) {
+        const hint = "run `paperclipai onboard` to authenticate the CLI";
+        reject(new Error(`paperclipai agent local-cli produced no output \u2014 ${hint}`));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(cleanedStdout);
+      } catch {
+        reject(new Error(`paperclipai agent local-cli returned non-JSON output: ${cleanedStdout.slice(0, 200)}`));
+        return;
+      }
+      const r = parsed;
+      const apiKey = (typeof r.apiKey === "string" ? r.apiKey : void 0) ?? (typeof r.api_key === "string" ? r.api_key : void 0) ?? (typeof r.token === "string" ? r.token : void 0);
+      if (!apiKey) {
+        reject(new Error(`paperclipai agent local-cli JSON missing apiKey/api_key/token field: ${cleanedStdout.slice(0, 200)}`));
+        return;
+      }
+      const apiBase = (typeof r.apiBase === "string" ? r.apiBase : void 0) ?? (typeof r.api_base === "string" ? r.api_base : void 0);
+      const agentId = (typeof r.agentId === "string" ? r.agentId : void 0) ?? (typeof r.id === "string" ? r.id : void 0);
+      const companyId = typeof r.companyId === "string" ? r.companyId : void 0;
+      resolve({ apiKey, apiBase, agentId, companyId, raw: parsed });
+    });
+  });
+}
+function remapSpawnError(err, bin) {
+  const code = err?.code;
+  if (code === "ENOENT") {
+    return new Error(`paperclipai binary not found at ${bin}; install via \`npm i -g paperclipai\``);
+  }
+  return err instanceof Error ? err : new Error(String(err));
+}
+async function spawnPaperclipCliJson(args, opts) {
+  const { spawn } = await import("node:child_process");
+  const bin = opts.cliBinaryPath ?? "paperclipai";
+  const fullArgs = [...args, "--json"];
+  if (opts.cliConfigPath) {
+    fullArgs.push("--config", opts.cliConfigPath);
+  }
+  const timeoutMs = opts.cliTimeoutMs ?? 15e3;
+  const label = ["paperclipai", ...args].join(" ");
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(bin, fullArgs, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (err) {
+      reject(remapSpawnError(err, bin));
+      return;
+    }
+    const stdoutChunks = [];
+    const stderrLines = [];
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const lines = chunk.toString("utf-8").split("\n");
+      for (const line of lines) {
+        const stripped = stripAnsi(line).trim();
+        if (stripped)
+          stderrLines.push(stripped);
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(remapSpawnError(err, bin));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed)
+        return;
+      const cleaned = stripAnsi(Buffer.concat(stdoutChunks).toString("utf-8")).trim();
+      if (code !== 0) {
+        const lastErr = stderrLines.filter(Boolean).pop() ?? "";
+        reject(new Error(lastErr ? `${label} exited ${code}: ${lastErr}` : `${label} exited ${code}`));
+        return;
+      }
+      if (!cleaned) {
+        reject(new Error(`${label} produced no output`));
+        return;
+      }
+      try {
+        resolve(JSON.parse(cleaned));
+      } catch {
+        reject(new Error(`${label} returned non-JSON output: ${cleaned.slice(0, 200)}`));
+      }
+    });
+  });
+}
+async function listCompaniesViaCli(opts) {
+  const raw = await spawnPaperclipCliJson(["company", "list"], opts);
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const r = entry;
+    const id = typeof r.id === "string" ? r.id : void 0;
+    if (!id)
+      continue;
+    const name = typeof r.name === "string" ? r.name : id;
+    const urlKey = typeof r.urlKey === "string" ? r.urlKey : typeof r.slug === "string" ? r.slug : void 0;
+    out.push({ id, name, urlKey });
+  }
+  return out;
+}
+async function listCompanyAgentsViaCli(opts) {
+  const raw = await spawnPaperclipCliJson(["agent", "list", "--company-id", opts.companyId], opts);
+  if (!Array.isArray(raw))
+    return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const r = entry;
+    const id = typeof r.id === "string" ? r.id : void 0;
+    if (!id)
+      continue;
+    const name = typeof r.name === "string" ? r.name : id;
+    const role = typeof r.role === "string" ? r.role : void 0;
+    const cId = typeof r.companyId === "string" ? r.companyId : opts.companyId;
+    const status = typeof r.status === "string" ? r.status : void 0;
+    out.push({ id, name, role, companyId: cId, status });
+  }
+  return out;
+}
+async function createIssueViaCli(opts) {
+  const args = ["issue", "create", "--company-id", opts.companyId];
+  args.push("--title", opts.body.title);
+  if (opts.body.description)
+    args.push("--description", opts.body.description);
+  if (opts.body.status)
+    args.push("--status", opts.body.status);
+  if (opts.body.assigneeAgentId)
+    args.push("--assignee-agent-id", opts.body.assigneeAgentId);
+  if (opts.body.parentId)
+    args.push("--parent-id", opts.body.parentId);
+  if (opts.body.projectId)
+    args.push("--project-id", opts.body.projectId);
+  if (opts.body.goalId)
+    args.push("--goal-id", opts.body.goalId);
+  const raw = await spawnPaperclipCliJson(args, opts);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`paperclipai issue create returned unexpected payload: ${JSON.stringify(raw).slice(0, 200)}`);
+  }
+  return raw;
+}
+async function getIssueViaCli(opts) {
+  const raw = await spawnPaperclipCliJson(["issue", "get", opts.issueId], opts);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`paperclipai issue get returned unexpected payload: ${JSON.stringify(raw).slice(0, 200)}`);
+  }
+  return raw;
+}
+async function agentsMeViaCli(opts) {
+  const raw = await spawnPaperclipCliJson(["agent", "get", opts.agentId], opts);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`paperclipai agent get returned unexpected payload: ${JSON.stringify(raw).slice(0, 200)}`);
+  }
+  const id = typeof raw.id === "string" ? raw.id : void 0;
+  const cId = typeof raw.companyId === "string" ? raw.companyId : void 0;
+  if (!id || !cId) {
+    throw new Error("paperclipai agent get returned a response missing `id` or `companyId`");
+  }
+  return {
+    agentId: id,
+    agentName: typeof raw.name === "string" ? raw.name : id,
+    role: typeof raw.role === "string" ? raw.role : void 0,
+    companyId: cId,
+    companyName: typeof raw.companyName === "string" ? raw.companyName : void 0
+  };
+}
+async function probePaperclipViaCli(opts) {
+  const started = Date.now();
+  let apiUrl = "(via paperclipai CLI)";
+  try {
+    const disc = await discoverPaperclipCliConfig({ configPath: opts.cliConfigPath });
+    if (disc.ok)
+      apiUrl = disc.apiUrl;
+  } catch {
+  }
+  try {
+    await spawnPaperclipCliJson(["company", "list"], opts);
+    return { available: true, apiUrl, probeDurationMs: Date.now() - started };
+  } catch (err) {
+    return {
+      available: false,
+      apiUrl,
+      reason: err instanceof Error ? err.message : String(err),
+      probeDurationMs: Date.now() - started
+    };
+  }
+}
+
+// ../../plugins/fusion-plugin-paperclip-runtime/dist/runtime-adapter.js
+import { randomUUID } from "node:crypto";
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "cancelled",
+  "timed_out"
+]);
+var VALID_MODES = /* @__PURE__ */ new Set([
+  "issue-per-prompt",
+  "rolling-issue",
+  "wakeup-only"
+]);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function deriveIssueTitle(prompt) {
+  const firstLine = prompt.split("\n").find((line) => line.trim() !== "") ?? "Fusion runtime prompt";
+  return firstLine.slice(0, 200);
+}
+function buildIssueDescription(session, prompt) {
+  return [
+    `System Prompt:
+${session.systemPrompt}`,
+    `Working Directory: ${session.cwd}`,
+    `Prompt:
+${prompt}`
+  ].join("\n\n");
+}
+function pickIssueId(issue) {
+  const issueId = asString(issue.id);
+  if (!issueId) {
+    throw new Error("Paperclip createIssue response missing issue id");
+  }
+  return issueId;
+}
+function normalizeMode(mode) {
+  if (mode && VALID_MODES.has(mode))
+    return mode;
+  return "rolling-issue";
+}
+var PaperclipRuntimeAdapter = class {
+  id = "paperclip";
+  name = "Paperclip Runtime";
+  config;
+  logger;
+  constructor(config, logger) {
+    const resolved = resolvePaperclipConfig(config);
+    this.config = {
+      ...resolved,
+      mode: normalizeMode(resolved.mode),
+      ...config
+    };
+    this.logger = logger ?? console;
+  }
+  async createSession(options) {
+    let effectiveApiUrl = this.config.apiUrl;
+    let effectiveApiKey = this.config.apiKey;
+    if (this.config.transport === "cli") {
+      const discovery = await discoverPaperclipCliConfig({
+        configPath: this.config.cliConfigPath
+      });
+      if (!discovery.ok) {
+        throw new Error(`Paperclip CLI mode failed: ${discovery.reason} (Switch to API mode in settings if paperclipai isn't installed.)`);
+      }
+      effectiveApiUrl = discovery.apiUrl;
+      if (!effectiveApiKey) {
+        effectiveApiKey = discovery.apiKey;
+      }
+      this.logger.info(`Paperclip CLI mode resolved apiUrl=${effectiveApiUrl} (deploymentMode=${discovery.deploymentMode ?? "unknown"})`);
+    }
+    let agentId = this.config.agentId;
+    let companyId = this.config.companyId;
+    if (!agentId || !companyId) {
+      try {
+        if (this.config.transport === "cli") {
+          if (!agentId) {
+            throw new Error("agentId is required in Local CLI mode (paperclipai has no `agents/me` equivalent \u2014 pick an agent in settings)");
+          }
+          const me = await agentsMeViaCli({
+            agentId,
+            cliBinaryPath: this.config.cliBinaryPath,
+            cliConfigPath: this.config.cliConfigPath
+          });
+          companyId = companyId ?? me.companyId;
+        } else {
+          const me = await agentsMe(effectiveApiUrl, effectiveApiKey);
+          agentId = agentId ?? me.agentId;
+          companyId = companyId ?? me.companyId;
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Paperclip runtime could not derive agentId/companyId. Configure them explicitly or check the API key / CLI auth. Underlying error: ${reason}`);
+      }
+    }
+    if (!agentId || !companyId) {
+      throw new Error("Paperclip runtime is missing required config: agentId or companyId. Configure plugin settings (apiUrl, apiKey, agentId, companyId) or PAPERCLIP_* env vars.");
+    }
+    const session = {
+      apiUrl: effectiveApiUrl,
+      apiKey: effectiveApiKey,
+      agentId,
+      companyId,
+      sessionId: randomUUID(),
+      systemPrompt: options.systemPrompt,
+      cwd: options.cwd,
+      mode: normalizeMode(this.config.mode),
+      parentIssueId: this.config.parentIssueId,
+      projectId: this.config.projectId,
+      goalId: this.config.goalId,
+      issueId: void 0,
+      transport: this.config.transport ?? "api",
+      cliBinaryPath: this.config.cliBinaryPath,
+      cliConfigPath: this.config.cliConfigPath,
+      turnIndex: 0,
+      runTimeoutMs: this.config.runTimeoutMs ?? 6e5,
+      pollIntervalMs: this.config.pollIntervalMs ?? 500,
+      pollIntervalMaxMs: this.config.pollIntervalMaxMs ?? 2e3,
+      onText: options.onText,
+      onThinking: options.onThinking,
+      onToolStart: options.onToolStart,
+      onToolEnd: options.onToolEnd,
+      dispose: () => void 0
+    };
+    return { session, sessionFile: void 0 };
+  }
+  async promptWithFallback(session, prompt, _options) {
+    session.turnIndex += 1;
+    const turn = session.turnIndex;
+    session.onToolStart?.("paperclip.run", {
+      sessionId: session.sessionId,
+      mode: session.mode,
+      turn
+    });
+    let issueId;
+    if (session.mode === "issue-per-prompt") {
+      issueId = await this.createIssueForPrompt(session, prompt);
+    } else if (session.mode === "rolling-issue") {
+      if (!session.issueId) {
+        session.issueId = await this.createIssueForPrompt(session, prompt);
+      }
+      issueId = session.issueId;
+    }
+    const idempotencyKey = `${session.sessionId}:${turn}`;
+    let runId;
+    try {
+      const wakeResponse = await wakeAgent(session.apiUrl, session.apiKey, session.agentId, {
+        source: "on_demand",
+        triggerDetail: "manual",
+        reason: "Fusion runtime prompt",
+        idempotencyKey,
+        payload: {
+          fusionSessionId: session.sessionId,
+          prompt,
+          issueId
+        }
+      });
+      if (wakeResponse.status === "skipped") {
+        session.onToolEnd?.("paperclip.run", true, {
+          issueId,
+          runStatus: "skipped",
+          reason: "Paperclip coalesced this wakeup with a recent one (status=skipped)."
+        });
+        return;
+      }
+      runId = wakeResponse.id;
+      if (!runId) {
+        session.onToolEnd?.("paperclip.run", true, {
+          issueId,
+          reason: "Paperclip wakeup response missing run id"
+        });
+        return;
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Paperclip wakeup failed: ${reason}`);
+      session.onToolEnd?.("paperclip.run", true, { issueId, reason });
+      return;
+    }
+    const stream = await this.streamRunEvents(session, runId);
+    let issueStatus;
+    let finalText = stream.text;
+    if (issueId) {
+      try {
+        const issue = session.transport === "cli" ? await getIssueViaCli({
+          issueId,
+          cliBinaryPath: session.cliBinaryPath,
+          cliConfigPath: session.cliConfigPath
+        }) : await getIssue(session.apiUrl, session.apiKey, issueId);
+        issueStatus = asString(issue.status) ?? void 0;
+        if (!finalText) {
+          const comments = await getIssueComments(session.apiUrl, session.apiKey, issueId);
+          const latest = pickLatestVisibleComment(comments);
+          if (latest)
+            finalText = latest;
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        this.logger.warn(`Paperclip post-run fetch failed: ${reason}`);
+      }
+    }
+    if (finalText)
+      session.onText?.(finalText);
+    if (stream.thinking)
+      session.onThinking?.(stream.thinking);
+    const isError = stream.runStatus === "failed" || stream.runStatus === "timed_out";
+    session.onToolEnd?.("paperclip.run", isError || stream.timedOutLocally, {
+      runId,
+      runStatus: stream.runStatus,
+      issueId,
+      issueStatus,
+      timedOutLocally: stream.timedOutLocally,
+      deepLink: issueId ? `${session.apiUrl.replace(/\/$/, "")}/issues/${issueId}` : void 0
+    });
+  }
+  describeModel(session) {
+    return `paperclip/${session.agentId}`;
+  }
+  async dispose(_session) {
+  }
+  // ---------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------
+  async createIssueForPrompt(session, prompt) {
+    const body = {
+      title: deriveIssueTitle(prompt),
+      description: buildIssueDescription(session, prompt),
+      status: "todo",
+      assigneeAgentId: session.agentId,
+      ...session.parentIssueId ? { parentId: session.parentIssueId } : {},
+      ...session.projectId ? { projectId: session.projectId } : {},
+      ...session.goalId ? { goalId: session.goalId } : {}
+    };
+    const created = session.transport === "cli" ? await createIssueViaCli({
+      companyId: session.companyId,
+      body,
+      cliBinaryPath: session.cliBinaryPath,
+      cliConfigPath: session.cliConfigPath
+    }) : await createIssue(session.apiUrl, session.apiKey, session.companyId, body);
+    return pickIssueId(created);
+  }
+  async streamRunEvents(session, runId) {
+    const startedAt = Date.now();
+    let afterSeq = 0;
+    let interval = session.pollIntervalMs;
+    let runStatus = "running";
+    let timedOutLocally = false;
+    let textBuf = "";
+    let thinkBuf = "";
+    while (true) {
+      let events = [];
+      try {
+        events = await getRunEvents(session.apiUrl, session.apiKey, runId, afterSeq, 200);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        this.logger.warn(`Paperclip getRunEvents failed: ${reason}`);
+      }
+      for (const ev of events) {
+        if (typeof ev.seq === "number" && ev.seq > afterSeq)
+          afterSeq = ev.seq;
+        const type = ev.type ?? "";
+        const payload = ev.payload ?? {};
+        if (type === "heartbeat.run.status") {
+          const next = asString(payload.status);
+          if (next)
+            runStatus = next;
+        } else if (type === "heartbeat.run.log") {
+          const chunk = asString(payload.chunk) ?? "";
+          if (!chunk)
+            continue;
+          if (payload.stream === "stdout") {
+            textBuf += chunk;
+            session.onText?.(chunk);
+          } else if (payload.stream === "stderr") {
+            this.logger.warn(`[paperclip:run:${runId}] ${chunk.trimEnd()}`);
+          } else if (payload.stream === "system") {
+            const message = asString(payload.message) ?? chunk;
+            thinkBuf += (thinkBuf ? "\n" : "") + message;
+          }
+        }
+      }
+      if (TERMINAL_RUN_STATUSES.has(runStatus))
+        break;
+      if (Date.now() - startedAt > session.runTimeoutMs) {
+        timedOutLocally = true;
+        this.logger.warn(`Paperclip run ${runId} exceeded local runTimeoutMs=${session.runTimeoutMs}; abandoning poll. Run continues server-side.`);
+        break;
+      }
+      await sleep(interval);
+      interval = Math.min(interval * 2, session.pollIntervalMaxMs);
+    }
+    return { text: textBuf, thinking: thinkBuf, runStatus, timedOutLocally };
+  }
+};
+function pickLatestVisibleComment(comments) {
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const c = comments[i];
+    const body = asString(c.body)?.trim();
+    if (body)
+      return body;
+  }
+  return void 0;
+}
+
+// ../../plugins/fusion-plugin-paperclip-runtime/dist/index.js
+function getSettingsConfig(settings) {
+  return resolvePaperclipConfig(settings ?? {});
+}
+async function paperclipRuntimeFactory(ctx) {
+  const config = getSettingsConfig(ctx.settings);
+  return new PaperclipRuntimeAdapter(config, ctx.logger);
+}
+var paperclipRuntime = {
+  metadata: {
+    runtimeId: "paperclip",
+    name: "Paperclip Runtime",
+    description: "Drives a Paperclip agent via the wakeup + heartbeat-run REST API",
+    version: "1.0.0"
+  },
+  factory: paperclipRuntimeFactory
+};
+var plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-paperclip-runtime",
+    name: "Paperclip Runtime Plugin",
+    version: "1.0.0",
+    description: "Drives a Paperclip agent via the wakeup + heartbeat-run REST API",
+    author: "Fusion Team",
+    homepage: "https://paperclip.ing/",
+    fusionVersion: ">=0.1.0",
+    runtime: {
+      runtimeId: "paperclip",
+      name: "Paperclip Runtime",
+      description: "Drives a Paperclip agent via the wakeup + heartbeat-run REST API",
+      version: "1.0.0"
+    }
+  },
+  state: "installed",
+  runtime: paperclipRuntime,
+  hooks: {
+    onLoad: async (ctx) => {
+      const config = getSettingsConfig(ctx.settings);
+      ctx.logger.info(`Paperclip Runtime Plugin loaded (apiUrl=${config.apiUrl})`);
+      try {
+        const status = await probePaperclipConnection({
+          apiUrl: config.apiUrl,
+          apiKey: config.apiKey
+        });
+        if (status.available) {
+          const ident = status.identity;
+          ctx.logger.info(ident ? `Paperclip reachable as ${ident.agentName} (${ident.role ?? "agent"}) at ${ident.companyName ?? ident.companyId}` : `Paperclip reachable at ${config.apiUrl}`);
+        } else {
+          ctx.logger.warn(`Paperclip probe failed: ${status.reason ?? "unknown"}`);
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        ctx.logger.warn(`Paperclip probe threw: ${reason}`);
+      }
+    }
+  }
+});
+var index_default = plugin;
+export {
+  PaperclipRuntimeAdapter,
+  agentsMe,
+  agentsMeViaCli,
+  createIssueViaCli,
+  index_default as default,
+  discoverPaperclipCliConfig,
+  getIssueViaCli,
+  listCompanies,
+  listCompaniesViaCli,
+  listCompanyAgents,
+  listCompanyAgentsViaCli,
+  mintAgentApiKeyViaCli,
+  probePaperclipConnection,
+  probePaperclipViaCli
+};