@buda-ai/connector 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# Buda Connector
+
+Standalone connector daemon for Buda Agent Connector runtimes.
+
+The cloud server defaults to `https://buda.im`. Pass `--server-url` or set
+`BUDA_CONNECTOR_SERVER_URL` only for local development or private deployments.
+
+## Role
+
+- Registers the local or remote host with `apps/buda`.
+- Starts an embedded `@bunny-agent/daemon` HTTP runtime in the same Node process.
+- Sends heartbeats and local log batches to the cloud registry.
+- Maintains a WebSocket relay so Buda Cloud can actively reach the connector.
+- Stores device identity and local logs under `~/.buda`.
+
+## Local Development
+
+Start Buda first:
+
+```bash
+pnpm --filter buda dev
+```
+
+Create/register a connector identity:
+
+```bash
+BUDA_CONNECTOR_SERVER_URL=http://localhost:3000 pnpm --filter @buda-ai/connector new
+```
+
+Run the daemon loop:
+
+```bash
+BUDA_CONNECTOR_SERVER_URL=http://localhost:3000 pnpm --filter @buda-ai/connector dev
+```
+
+The connector starts Bunny Agent daemon on `127.0.0.1` with an ephemeral port
+by default and reports the local daemon URL to Buda in connector metadata.
+
+The localhost API path bypasses auth for development. Desktop sidecars should pass
+an OAuth token with `--launch-config-stdin`.
+
+## Launch Config
+
+Desktop can start the sidecar with:
+
+```bash
+printf '{"serverUrl":"https://buda.im","oauthToken":"..."}\n' \
+  | buda-connector daemon --launch-config-stdin
+```
+
+Supported launch config fields:
+
+- `serverUrl`
+- `spaceId`
+- `workdirRoot`
+- `oauthToken`
+- `bunnyDaemonHost`
+- `bunnyDaemonPort`
+
+## One-line install
+
+Buda Space Settings can show a simple Space ID command for the current space.
+This mode identifies the Space, not a specific user:
+
+```bash
+npx -y @buda-ai/connector@latest daemon --space-id "org_..."
+```
+
+Desktop and other authenticated clients should use OAuth token launch config
+instead:
+
+```bash
+printf '%s\n' '{"serverUrl":"https://buda.im","oauthToken":"..."}' \
+  | npx -y @buda-ai/connector@latest daemon --launch-config-stdin
+```
+
+You can also pass launch options directly:
+
+```bash
+buda-connector daemon --space-id "org_..." --workdir "$HOME/.buda/agents"
+```
+
+## Local Files
+
+- `~/.buda/device.json`
+- `~/.buda/connector.log`
+- `~/.buda/agents/`

package/dist/cli.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir, hostname, platform } from "os";
+import path from "path";
+var CONFIG_DIR = path.join(homedir(), ".buda");
+var CONFIG_PATH = path.join(CONFIG_DIR, "device.json");
+var LOG_PATH = path.join(CONFIG_DIR, "connector.log");
+var DEFAULT_SERVER_URL = "https://buda.im";
+var DEFAULT_WORKDIR_ROOT = path.join(CONFIG_DIR, "agents");
+var DEFAULT_BUNNY_DAEMON_HOST = "127.0.0.1";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var RELAY_RECONNECT_INTERVAL_MS = 3e3;
+var LAUNCH_CONFIG_STDIN_FLAG = "--launch-config-stdin";
+function getServerUrl(launchConfig) {
+  return (launchConfig?.serverUrl || process.env.BUDA_CONNECTOR_SERVER_URL || process.env.BUDA_SERVER_URL || process.env.NEXT_PUBLIC_APP_URL || DEFAULT_SERVER_URL).replace(/\/$/, "");
+}
+function getConnectorRelayUrl(serverUrl, connectorId) {
+  const url = new URL("/api/connectors/ws", serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("connectorId", connectorId);
+  return url.toString();
+}
+function getWorkdirRoot(launchConfig) {
+  return launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || DEFAULT_WORKDIR_ROOT;
+}
+function getBunnyDaemonHost(launchConfig) {
+  return launchConfig?.bunnyDaemonHost || process.env.BUDA_CONNECTOR_BUNNY_DAEMON_HOST || DEFAULT_BUNNY_DAEMON_HOST;
+}
+function getBunnyDaemonPort(launchConfig) {
+  if (launchConfig?.bunnyDaemonPort !== void 0) return launchConfig.bunnyDaemonPort;
+  const raw = process.env.BUDA_CONNECTOR_BUNNY_DAEMON_PORT;
+  if (!raw) return 0;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+function getSpaceId(launchConfig) {
+  return launchConfig?.spaceId || process.env.BUDA_CONNECTOR_SPACE_ID;
+}
+function buildDeviceConfig(launchConfig) {
+  const host = hostname();
+  return {
+    connectorId: `cnr_${randomUUID()}`,
+    deviceId: `dev_${randomUUID()}`,
+    deviceName: host,
+    hostLabel: `${host} (${platform()})`,
+    serverUrl: getServerUrl(launchConfig),
+    workdirRoot: getWorkdirRoot(launchConfig),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function readDeviceConfig() {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeDeviceConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await mkdir(config.workdirRoot, { recursive: true });
+  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+async function ensureDeviceConfig(launchConfig) {
+  const existing = await readDeviceConfig();
+  if (existing) {
+    return {
+      ...existing,
+      serverUrl: getServerUrl(launchConfig),
+      workdirRoot: launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || existing.workdirRoot || getWorkdirRoot(launchConfig)
+    };
+  }
+  const config = buildDeviceConfig(launchConfig);
+  await writeDeviceConfig(config);
+  return config;
+}
+function parseLaunchConfig(raw) {
+  if (!raw.trim()) return {};
+  const parsed = JSON.parse(raw);
+  const bunnyDaemonPort = typeof parsed.bunnyDaemonPort === "number" && Number.isInteger(parsed.bunnyDaemonPort) ? parsed.bunnyDaemonPort : void 0;
+  return {
+    serverUrl: typeof parsed.serverUrl === "string" ? parsed.serverUrl : void 0,
+    workdirRoot: typeof parsed.workdirRoot === "string" ? parsed.workdirRoot : void 0,
+    oauthToken: typeof parsed.oauthToken === "string" ? parsed.oauthToken : void 0,
+    spaceId: typeof parsed.spaceId === "string" ? parsed.spaceId : void 0,
+    bunnyDaemonHost: typeof parsed.bunnyDaemonHost === "string" ? parsed.bunnyDaemonHost : void 0,
+    bunnyDaemonPort
+  };
+}
+
+// src/bunny-daemon.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import { createDaemon } from "@bunny-agent/daemon";
+
+// src/logger.ts
+import { appendFile, mkdir as mkdir2 } from "fs/promises";
+var pendingLogs = [];
+async function writeLog(level, message, metadata) {
+  const entry = {
+    level,
+    message,
+    metadata,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  pendingLogs.push(entry);
+  if (pendingLogs.length > 100) pendingLogs.splice(0, pendingLogs.length - 100);
+  await mkdir2(CONFIG_DIR, { recursive: true }).catch(() => void 0);
+  await appendFile(LOG_PATH, `${JSON.stringify(entry)}
+`).catch(() => void 0);
+  const line = `[buda-connector] ${message}`;
+  if (level === "error") console.error(line);
+  else if (level === "warn") console.warn(line);
+  else console.log(line);
+}
+function takePendingLogs() {
+  return pendingLogs.splice(0, pendingLogs.length);
+}
+function restorePendingLogs(logs) {
+  pendingLogs.unshift(...logs);
+}
+
+// src/bunny-daemon.ts
+async function startEmbeddedBunnyDaemon(config, launchConfig) {
+  const host = getBunnyDaemonHost(launchConfig);
+  const port = getBunnyDaemonPort(launchConfig);
+  const root = config.workdirRoot;
+  await mkdir3(root, { recursive: true });
+  const server = createDaemon({ host, port, root });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const baseUrl = `http://${host}:${actualPort}`;
+  await writeLog("info", `bunny daemon listening ${baseUrl}`, {
+    root
+  });
+  return {
+    server,
+    host,
+    port: actualPort,
+    baseUrl,
+    root
+  };
+}
+async function stopEmbeddedBunnyDaemon(daemon) {
+  await new Promise((resolve) => {
+    daemon.server.close(() => resolve());
+  });
+  await writeLog("info", `bunny daemon stopped ${daemon.baseUrl}`);
+}
+
+// src/cloud-client.ts
+import { platform as platform2, release } from "os";
+function buildPayload(config, extra) {
+  return {
+    connectorId: config.connectorId,
+    deviceId: config.deviceId,
+    deviceName: config.deviceName,
+    hostLabel: config.hostLabel,
+    platform: `${platform2()} ${release()}`,
+    version: "dev",
+    pid: process.pid,
+    workdirRoot: config.workdirRoot,
+    baseUrl: extra?.bunnyDaemon?.baseUrl,
+    bunnyDaemon: extra?.bunnyDaemon ? {
+      baseUrl: extra.bunnyDaemon.baseUrl,
+      host: extra.bunnyDaemon.host,
+      port: extra.bunnyDaemon.port,
+      root: extra.bunnyDaemon.root,
+      status: "online"
+    } : void 0,
+    capabilities: ["connector", "bunny-daemon", "coding", "filesystem", "shell", "git"],
+    ...extra?.logs?.length ? { logs: extra.logs } : {}
+  };
+}
+async function postJson(serverUrl, pathname, body, launchConfig) {
+  const token = launchConfig?.oauthToken?.trim();
+  const spaceId = getSpaceId(launchConfig)?.trim();
+  const response = await fetch(`${serverUrl}${pathname}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...!token && spaceId ? { "X-Buda-Space-Id": spaceId } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`${pathname} failed: ${response.status} ${text}`);
+  }
+  return await response.json();
+}
+function formatConnectorOwner(connector) {
+  return connector.userEmail ?? connector.userId ?? "anonymous";
+}
+async function registerConnector(config, launchConfig, bunnyDaemon) {
+  const result = await postJson(
+    config.serverUrl,
+    "/api/connectors/register",
+    buildPayload(config, { bunnyDaemon }),
+    launchConfig
+  );
+  await writeLog(
+    "info",
+    `registered connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`
+  );
+}
+async function heartbeatConnector(config, launchConfig, bunnyDaemon) {
+  const logs = takePendingLogs();
+  const result = await postJson(
+    config.serverUrl,
+    "/api/connectors/heartbeat",
+    buildPayload(config, {
+      bunnyDaemon,
+      logs
+    }),
+    launchConfig
+  ).catch((error) => {
+    restorePendingLogs(logs);
+    throw error;
+  });
+  await writeLog(
+    "info",
+    `heartbeat connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`
+  );
+}
+async function unregisterConnector(config, launchConfig) {
+  await postJson(
+    config.serverUrl,
+    "/api/connectors/unregister",
+    {
+      connectorId: config.connectorId
+    },
+    launchConfig
+  ).catch((error) => {
+    void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
+  });
+}
+
+// ../../packages/relaylib/src/protocol.ts
+var utf8Encoder = new TextEncoder();
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+
+// ../../packages/relaylib/src/relay-client.ts
+function attachRelayClient(socket, handler, options = {}) {
+  const chunkEncoding = options.chunkEncoding ?? "base64";
+  socket.on("message", (raw) => {
+    let message;
+    try {
+      message = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (message.type !== "request") return;
+    void handleRequest(socket, message.requestId, message.request, handler, chunkEncoding);
+  });
+}
+async function handleRequest(socket, requestId, request, handler, chunkEncoding) {
+  const send = (message) => {
+    if (socket.readyState === 1) socket.send(JSON.stringify(message));
+  };
+  let response;
+  try {
+    response = await handler(request);
+  } catch (error) {
+    send({ type: "error", requestId, error: errorMessage(error) });
+    return;
+  }
+  send({
+    type: "start",
+    requestId,
+    status: response.status,
+    headers: headersToRecord(response.headers)
+  });
+  try {
+    const body = response.body;
+    if (body) {
+      const reader = body.getReader();
+      if (chunkEncoding === "utf8") {
+        const decoder = new TextDecoder();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          if (text) send({ type: "chunk", requestId, data: text });
+        }
+        const tail = decoder.decode();
+        if (tail) send({ type: "chunk", requestId, data: tail });
+      } else {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value && value.length > 0) {
+            send({
+              type: "chunk",
+              requestId,
+              encoding: "base64",
+              data: bytesToBase64(value)
+            });
+          }
+        }
+      }
+    }
+    send({ type: "end", requestId });
+  } catch (error) {
+    send({ type: "error", requestId, error: errorMessage(error) });
+  }
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/relay.ts
+import WebSocket from "ws";
+function startConnectorRelay(config, bunnyDaemon, launchConfig) {
+  let socket = null;
+  let reconnectTimer = null;
+  let stopped = false;
+  const handler = createRelayHandler(bunnyDaemon);
+  const connect = () => {
+    if (stopped) return;
+    const relayUrl = getConnectorRelayUrl(config.serverUrl, config.connectorId);
+    const token = launchConfig?.oauthToken?.trim();
+    socket = new WebSocket(relayUrl, {
+      headers: token ? { Authorization: `Bearer ${token}` } : void 0
+    });
+    socket.on("open", () => {
+      void writeLog("info", `relay connected ${relayUrl}`);
+    });
+    attachRelayClient(socket, handler, { chunkEncoding: "utf8" });
+    socket.on("close", () => {
+      void writeLog("warn", "relay disconnected");
+      if (stopped) return;
+      reconnectTimer = setTimeout(connect, RELAY_RECONNECT_INTERVAL_MS);
+    });
+    socket.on("error", (error) => {
+      void writeLog("warn", `relay error: ${error instanceof Error ? error.message : error}`);
+    });
+  };
+  connect();
+  return {
+    stop() {
+      stopped = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      socket?.close();
+    }
+  };
+}
+function createRelayHandler(bunnyDaemon) {
+  const allowedOrigin = new URL(bunnyDaemon.baseUrl).origin;
+  return async (request) => {
+    const requestUrl = new URL(request.path, bunnyDaemon.baseUrl);
+    if (requestUrl.origin !== allowedOrigin) {
+      throw new Error("Relay request must target the embedded bunny daemon.");
+    }
+    await writeLog("info", `relay request ${request.method} ${requestUrl.pathname}`, {
+      actorEmail: getHeaderValue(request.headers, "x-buda-relay-actor-email") || null,
+      actorId: getHeaderValue(request.headers, "x-buda-relay-actor-id") || null,
+      source: getHeaderValue(request.headers, "x-buda-relay-source") || "unknown",
+      action: getHeaderValue(request.headers, "x-buda-relay-action") || "unknown",
+      target: requestUrl.toString()
+    });
+    return fetch(requestUrl, {
+      method: request.method,
+      headers: {
+        "Content-Type": "application/json",
+        ...request.headers ?? {}
+      },
+      body: request.body === void 0 ? void 0 : JSON.stringify(request.body)
+    });
+  };
+}
+function getHeaderValue(headers, name) {
+  if (!headers) return void 0;
+  const normalized = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === normalized) return value;
+  }
+  return void 0;
+}
+
+// src/runtime.ts
+async function runNewConnector(launchConfig) {
+  const config = buildDeviceConfig(launchConfig);
+  await writeDeviceConfig(config);
+  await registerConnector(config, launchConfig);
+  await writeLog("info", `wrote ${CONFIG_PATH}`);
+  await writeLog("info", `workdir root ${config.workdirRoot}`);
+  await writeLog("info", `log file ${LOG_PATH}`);
+}
+async function runConnectorDaemon(launchConfig) {
+  const config = await ensureDeviceConfig(launchConfig);
+  const bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
+  try {
+    await registerConnector(config, launchConfig, bunnyDaemon);
+  } catch (error) {
+    await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    throw error;
+  }
+  const relay = startConnectorRelay(config, bunnyDaemon, launchConfig);
+  await writeLog("info", `server ${config.serverUrl}`);
+  await writeLog("info", `config ${CONFIG_PATH}`);
+  await writeLog("info", `workdir root ${config.workdirRoot}`);
+  await writeLog("info", `log file ${LOG_PATH}`);
+  await writeLog("info", `bunny daemon ${bunnyDaemon.baseUrl}`);
+  const interval = setInterval(() => {
+    heartbeatConnector(config, launchConfig, bunnyDaemon).catch((error) => {
+      void writeLog(
+        "warn",
+        `heartbeat failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+  }, HEARTBEAT_INTERVAL_MS);
+  const shutdown = async () => {
+    clearInterval(interval);
+    relay.stop();
+    await unregisterConnector(config, launchConfig);
+    await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/cli.ts
+function printUsage() {
+  console.log(
+    "Usage: buda-connector new | dev | daemon [--space-id <space>] [--server-url <url>] [--token <token>] [--workdir <path>] [--launch-config-stdin]\n       pnpm --filter @buda-ai/connector dev\n\nCommands:\n  new     Create/register a new connector identity\n  dev     Run the connector daemon in development\n  daemon  Run the connector daemon for sidecar/service usage"
+  );
+}
+function readFlagValue(name) {
+  const index = process.argv.indexOf(name);
+  if (index < 0) return void 0;
+  const value = process.argv[index + 1];
+  return value && !value.startsWith("--") ? value : void 0;
+}
+function readCliLaunchConfig() {
+  const bunnyDaemonPort = readFlagValue("--bunny-daemon-port");
+  return {
+    serverUrl: readFlagValue("--server-url"),
+    workdirRoot: readFlagValue("--workdir"),
+    oauthToken: readFlagValue("--token"),
+    spaceId: readFlagValue("--space-id"),
+    bunnyDaemonHost: readFlagValue("--bunny-daemon-host"),
+    bunnyDaemonPort: bunnyDaemonPort && Number.isInteger(Number(bunnyDaemonPort)) ? Number(bunnyDaemonPort) : void 0
+  };
+}
+async function readLaunchConfig() {
+  const cliConfig = readCliLaunchConfig();
+  if (!process.argv.includes(LAUNCH_CONFIG_STDIN_FLAG)) return cliConfig;
+  process.stdin.setEncoding("utf8");
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("error", onError);
+      process.stdin.off("end", onEnd);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onData = (chunk) => {
+      raw += chunk;
+      if (!raw.includes("\n")) return;
+      cleanup();
+      resolve({ ...cliConfig, ...parseLaunchConfig(raw.split("\n")[0] ?? "") });
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve({ ...cliConfig, ...parseLaunchConfig(raw) });
+    };
+    process.stdin.on("data", onData);
+    process.stdin.on("error", onError);
+    process.stdin.on("end", onEnd);
+    process.stdin.resume();
+  });
+}
+async function main() {
+  const command = process.argv[2];
+  if (!command || process.argv.includes("--help") || process.argv.includes("-h")) {
+    printUsage();
+    return;
+  }
+  const launchConfig = await readLaunchConfig();
+  if (command === "new") {
+    await runNewConnector(launchConfig);
+    return;
+  }
+  if (command === "dev" || command === "daemon") {
+    await runConnectorDaemon(launchConfig);
+    return;
+  }
+  printUsage();
+  process.exit(1);
+}
+main().catch((error) => {
+  console.error("[buda-connector] failed:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@buda-ai/connector",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "buda-connector": "./dist/cli.js",
+    "connector": "./dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts dev",
+    "daemon": "tsx src/cli.ts daemon",
+    "new": "tsx src/cli.ts new",
+    "start": "node dist/cli.js daemon",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome format . --write && biome check .",
+    "lint:err": "biome format . --write && biome check . --write --diagnostic-level=error"
+  },
+  "dependencies": {
+    "@bunny-agent/daemon": "0.9.43",
+    "relaylib": "workspace:*",
+    "ws": "^8.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.0",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/src/bunny-daemon.ts

@@ -0,0 +1,52 @@
+import { mkdir } from "node:fs/promises";
+import { createDaemon } from "@bunny-agent/daemon";
+import { getBunnyDaemonHost, getBunnyDaemonPort } from "./config.js";
+import { writeLog } from "./logger.js";
+import type { ConnectorLaunchConfig, DeviceConfig, EmbeddedBunnyDaemon } from "./types.js";
+
+export async function startEmbeddedBunnyDaemon(
+  config: DeviceConfig,
+  launchConfig?: ConnectorLaunchConfig,
+): Promise<EmbeddedBunnyDaemon> {
+  const host = getBunnyDaemonHost(launchConfig);
+  const port = getBunnyDaemonPort(launchConfig);
+  const root = config.workdirRoot;
+  await mkdir(root, { recursive: true });
+
+  const server = createDaemon({ host, port, root });
+  await new Promise<void>((resolve, reject) => {
+    const onError = (error: Error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+
+  const address = server.address();
+  const actualPort = typeof address === "object" && address ? address.port : port;
+  const baseUrl = `http://${host}:${actualPort}`;
+  await writeLog("info", `bunny daemon listening ${baseUrl}`, {
+    root,
+  });
+
+  return {
+    server,
+    host,
+    port: actualPort,
+    baseUrl,
+    root,
+  };
+}
+
+export async function stopEmbeddedBunnyDaemon(daemon: EmbeddedBunnyDaemon) {
+  await new Promise<void>((resolve) => {
+    daemon.server.close(() => resolve());
+  });
+  await writeLog("info", `bunny daemon stopped ${daemon.baseUrl}`);
+}

package/src/cli.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import { LAUNCH_CONFIG_STDIN_FLAG, parseLaunchConfig } from "./config.js";
+import { runConnectorDaemon, runNewConnector } from "./runtime.js";
+import type { ConnectorCliCommand, ConnectorLaunchConfig } from "./types.js";
+
+function printUsage() {
+  console.log(
+    "Usage: buda-connector new | dev | daemon [--space-id <space>] [--server-url <url>] [--token <token>] [--workdir <path>] [--launch-config-stdin]\n" +
+      "       pnpm --filter @buda-ai/connector dev\n\n" +
+      "Commands:\n" +
+      "  new     Create/register a new connector identity\n" +
+      "  dev     Run the connector daemon in development\n" +
+      "  daemon  Run the connector daemon for sidecar/service usage",
+  );
+}
+
+function readFlagValue(name: string): string | undefined {
+  const index = process.argv.indexOf(name);
+  if (index < 0) return undefined;
+  const value = process.argv[index + 1];
+  return value && !value.startsWith("--") ? value : undefined;
+}
+
+function readCliLaunchConfig(): ConnectorLaunchConfig {
+  const bunnyDaemonPort = readFlagValue("--bunny-daemon-port");
+  return {
+    serverUrl: readFlagValue("--server-url"),
+    workdirRoot: readFlagValue("--workdir"),
+    oauthToken: readFlagValue("--token"),
+    spaceId: readFlagValue("--space-id"),
+    bunnyDaemonHost: readFlagValue("--bunny-daemon-host"),
+    bunnyDaemonPort:
+      bunnyDaemonPort && Number.isInteger(Number(bunnyDaemonPort))
+        ? Number(bunnyDaemonPort)
+        : undefined,
+  };
+}
+
+async function readLaunchConfig(): Promise<ConnectorLaunchConfig> {
+  const cliConfig = readCliLaunchConfig();
+  if (!process.argv.includes(LAUNCH_CONFIG_STDIN_FLAG)) return cliConfig;
+
+  process.stdin.setEncoding("utf8");
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.off("error", onError);
+      process.stdin.off("end", onEnd);
+    };
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+    const onData = (chunk: string) => {
+      raw += chunk;
+      if (!raw.includes("\n")) return;
+      cleanup();
+      resolve({ ...cliConfig, ...parseLaunchConfig(raw.split("\n")[0] ?? "") });
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve({ ...cliConfig, ...parseLaunchConfig(raw) });
+    };
+    process.stdin.on("data", onData);
+    process.stdin.on("error", onError);
+    process.stdin.on("end", onEnd);
+    process.stdin.resume();
+  });
+}
+
+async function main() {
+  const command = process.argv[2] as ConnectorCliCommand | undefined;
+  if (!command || process.argv.includes("--help") || process.argv.includes("-h")) {
+    printUsage();
+    return;
+  }
+
+  const launchConfig = await readLaunchConfig();
+  if (command === "new") {
+    await runNewConnector(launchConfig);
+    return;
+  }
+  if (command === "dev" || command === "daemon") {
+    await runConnectorDaemon(launchConfig);
+    return;
+  }
+
+  printUsage();
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error("[buda-connector] failed:", error);
+  process.exit(1);
+});

package/src/cloud-client.ts

@@ -0,0 +1,134 @@
+import { platform, release } from "node:os";
+import { getSpaceId } from "./config.js";
+import { restorePendingLogs, takePendingLogs, writeLog } from "./logger.js";
+import type {
+  ConnectorLaunchConfig,
+  ConnectorLogEntry,
+  DeviceConfig,
+  EmbeddedBunnyDaemon,
+} from "./types.js";
+
+function buildPayload(
+  config: DeviceConfig,
+  extra?: {
+    bunnyDaemon?: EmbeddedBunnyDaemon;
+    logs?: ConnectorLogEntry[];
+  },
+) {
+  return {
+    connectorId: config.connectorId,
+    deviceId: config.deviceId,
+    deviceName: config.deviceName,
+    hostLabel: config.hostLabel,
+    platform: `${platform()} ${release()}`,
+    version: "dev",
+    pid: process.pid,
+    workdirRoot: config.workdirRoot,
+    baseUrl: extra?.bunnyDaemon?.baseUrl,
+    bunnyDaemon: extra?.bunnyDaemon
+      ? {
+          baseUrl: extra.bunnyDaemon.baseUrl,
+          host: extra.bunnyDaemon.host,
+          port: extra.bunnyDaemon.port,
+          root: extra.bunnyDaemon.root,
+          status: "online",
+        }
+      : undefined,
+    capabilities: ["connector", "bunny-daemon", "coding", "filesystem", "shell", "git"],
+    ...(extra?.logs?.length ? { logs: extra.logs } : {}),
+  };
+}
+
+async function postJson<T>(
+  serverUrl: string,
+  pathname: string,
+  body: unknown,
+  launchConfig?: ConnectorLaunchConfig,
+): Promise<T> {
+  const token = launchConfig?.oauthToken?.trim();
+  const spaceId = getSpaceId(launchConfig)?.trim();
+  const response = await fetch(`${serverUrl}${pathname}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      ...(!token && spaceId ? { "X-Buda-Space-Id": spaceId } : {}),
+    },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`${pathname} failed: ${response.status} ${text}`);
+  }
+  return (await response.json()) as T;
+}
+
+interface RegisteredConnectorResponse {
+  connector: {
+    connectorId: string;
+    status: string;
+    userId?: string | null;
+    userEmail?: string | null;
+  };
+}
+
+function formatConnectorOwner(connector: RegisteredConnectorResponse["connector"]): string {
+  return connector.userEmail ?? connector.userId ?? "anonymous";
+}
+
+export async function registerConnector(
+  config: DeviceConfig,
+  launchConfig?: ConnectorLaunchConfig,
+  bunnyDaemon?: EmbeddedBunnyDaemon,
+) {
+  const result = await postJson<RegisteredConnectorResponse>(
+    config.serverUrl,
+    "/api/connectors/register",
+    buildPayload(config, { bunnyDaemon }),
+    launchConfig,
+  );
+  await writeLog(
+    "info",
+    `registered connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`,
+  );
+}
+
+export async function heartbeatConnector(
+  config: DeviceConfig,
+  launchConfig?: ConnectorLaunchConfig,
+  bunnyDaemon?: EmbeddedBunnyDaemon,
+) {
+  const logs = takePendingLogs();
+  const result = await postJson<RegisteredConnectorResponse>(
+    config.serverUrl,
+    "/api/connectors/heartbeat",
+    buildPayload(config, {
+      bunnyDaemon,
+      logs,
+    }),
+    launchConfig,
+  ).catch((error) => {
+    restorePendingLogs(logs);
+    throw error;
+  });
+  await writeLog(
+    "info",
+    `heartbeat connector=${result.connector.connectorId} status=${result.connector.status} owner=${formatConnectorOwner(result.connector)}`,
+  );
+}
+
+export async function unregisterConnector(
+  config: DeviceConfig,
+  launchConfig?: ConnectorLaunchConfig,
+) {
+  await postJson(
+    config.serverUrl,
+    "/api/connectors/unregister",
+    {
+      connectorId: config.connectorId,
+    },
+    launchConfig,
+  ).catch((error) => {
+    void writeLog("warn", `unregister failed: ${error instanceof Error ? error.message : error}`);
+  });
+}

package/src/config.ts

@@ -0,0 +1,122 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir, hostname, platform } from "node:os";
+import path from "node:path";
+import type { ConnectorLaunchConfig, DeviceConfig } from "./types.js";
+
+export const CONFIG_DIR = path.join(homedir(), ".buda");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "device.json");
+export const LOG_PATH = path.join(CONFIG_DIR, "connector.log");
+export const DEFAULT_SERVER_URL = "https://buda.im";
+export const DEFAULT_WORKDIR_ROOT = path.join(CONFIG_DIR, "agents");
+export const DEFAULT_BUNNY_DAEMON_HOST = "127.0.0.1";
+export const HEARTBEAT_INTERVAL_MS = 5_000;
+export const RELAY_RECONNECT_INTERVAL_MS = 3_000;
+export const LAUNCH_CONFIG_STDIN_FLAG = "--launch-config-stdin";
+
+export function getServerUrl(launchConfig?: ConnectorLaunchConfig) {
+  return (
+    launchConfig?.serverUrl ||
+    process.env.BUDA_CONNECTOR_SERVER_URL ||
+    process.env.BUDA_SERVER_URL ||
+    process.env.NEXT_PUBLIC_APP_URL ||
+    DEFAULT_SERVER_URL
+  ).replace(/\/$/, "");
+}
+
+export function getConnectorRelayUrl(serverUrl: string, connectorId: string) {
+  const url = new URL("/api/connectors/ws", serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.searchParams.set("connectorId", connectorId);
+  return url.toString();
+}
+
+export function getWorkdirRoot(launchConfig?: ConnectorLaunchConfig) {
+  return launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || DEFAULT_WORKDIR_ROOT;
+}
+
+export function getBunnyDaemonHost(launchConfig?: ConnectorLaunchConfig) {
+  return (
+    launchConfig?.bunnyDaemonHost ||
+    process.env.BUDA_CONNECTOR_BUNNY_DAEMON_HOST ||
+    DEFAULT_BUNNY_DAEMON_HOST
+  );
+}
+
+export function getBunnyDaemonPort(launchConfig?: ConnectorLaunchConfig) {
+  if (launchConfig?.bunnyDaemonPort !== undefined) return launchConfig.bunnyDaemonPort;
+  const raw = process.env.BUDA_CONNECTOR_BUNNY_DAEMON_PORT;
+  if (!raw) return 0;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export function getSpaceId(launchConfig?: ConnectorLaunchConfig) {
+  return launchConfig?.spaceId || process.env.BUDA_CONNECTOR_SPACE_ID;
+}
+
+export function buildDeviceConfig(launchConfig?: ConnectorLaunchConfig): DeviceConfig {
+  const host = hostname();
+  return {
+    connectorId: `cnr_${randomUUID()}`,
+    deviceId: `dev_${randomUUID()}`,
+    deviceName: host,
+    hostLabel: `${host} (${platform()})`,
+    serverUrl: getServerUrl(launchConfig),
+    workdirRoot: getWorkdirRoot(launchConfig),
+    createdAt: new Date().toISOString(),
+  };
+}
+
+export async function readDeviceConfig(): Promise<DeviceConfig | null> {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf8");
+    return JSON.parse(raw) as DeviceConfig;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeDeviceConfig(config: DeviceConfig) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await mkdir(config.workdirRoot, { recursive: true });
+  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+export async function ensureDeviceConfig(
+  launchConfig?: ConnectorLaunchConfig,
+): Promise<DeviceConfig> {
+  const existing = await readDeviceConfig();
+  if (existing) {
+    return {
+      ...existing,
+      serverUrl: getServerUrl(launchConfig),
+      workdirRoot:
+        launchConfig?.workdirRoot ||
+        process.env.BUDA_CONNECTOR_WORKDIR ||
+        existing.workdirRoot ||
+        getWorkdirRoot(launchConfig),
+    };
+  }
+  const config = buildDeviceConfig(launchConfig);
+  await writeDeviceConfig(config);
+  return config;
+}
+
+export function parseLaunchConfig(raw: string): ConnectorLaunchConfig {
+  if (!raw.trim()) return {};
+  const parsed = JSON.parse(raw) as Partial<ConnectorLaunchConfig>;
+  const bunnyDaemonPort =
+    typeof parsed.bunnyDaemonPort === "number" && Number.isInteger(parsed.bunnyDaemonPort)
+      ? parsed.bunnyDaemonPort
+      : undefined;
+  return {
+    serverUrl: typeof parsed.serverUrl === "string" ? parsed.serverUrl : undefined,
+    workdirRoot: typeof parsed.workdirRoot === "string" ? parsed.workdirRoot : undefined,
+    oauthToken: typeof parsed.oauthToken === "string" ? parsed.oauthToken : undefined,
+    spaceId: typeof parsed.spaceId === "string" ? parsed.spaceId : undefined,
+    bunnyDaemonHost:
+      typeof parsed.bunnyDaemonHost === "string" ? parsed.bunnyDaemonHost : undefined,
+    bunnyDaemonPort,
+  };
+}

package/src/logger.ts

@@ -0,0 +1,36 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { CONFIG_DIR, LOG_PATH } from "./config.js";
+import type { ConnectorLogEntry } from "./types.js";
+
+const pendingLogs: ConnectorLogEntry[] = [];
+
+export async function writeLog(
+  level: ConnectorLogEntry["level"],
+  message: string,
+  metadata?: Record<string, unknown>,
+) {
+  const entry: ConnectorLogEntry = {
+    level,
+    message,
+    metadata,
+    createdAt: new Date().toISOString(),
+  };
+  pendingLogs.push(entry);
+  if (pendingLogs.length > 100) pendingLogs.splice(0, pendingLogs.length - 100);
+
+  await mkdir(CONFIG_DIR, { recursive: true }).catch(() => undefined);
+  await appendFile(LOG_PATH, `${JSON.stringify(entry)}\n`).catch(() => undefined);
+
+  const line = `[buda-connector] ${message}`;
+  if (level === "error") console.error(line);
+  else if (level === "warn") console.warn(line);
+  else console.log(line);
+}
+
+export function takePendingLogs(): ConnectorLogEntry[] {
+  return pendingLogs.splice(0, pendingLogs.length);
+}
+
+export function restorePendingLogs(logs: ConnectorLogEntry[]) {
+  pendingLogs.unshift(...logs);
+}

package/src/relay.ts

@@ -0,0 +1,96 @@
+import { attachRelayClient, type RelayRequestHandler } from "relaylib";
+import WebSocket from "ws";
+import { getConnectorRelayUrl, RELAY_RECONNECT_INTERVAL_MS } from "./config.js";
+import { writeLog } from "./logger.js";
+import type { ConnectorLaunchConfig, DeviceConfig, EmbeddedBunnyDaemon } from "./types.js";
+
+export function startConnectorRelay(
+  config: DeviceConfig,
+  bunnyDaemon: EmbeddedBunnyDaemon,
+  launchConfig?: ConnectorLaunchConfig,
+) {
+  let socket: WebSocket | null = null;
+  let reconnectTimer: NodeJS.Timeout | null = null;
+  let stopped = false;
+  const handler = createRelayHandler(bunnyDaemon);
+
+  const connect = () => {
+    if (stopped) return;
+    const relayUrl = getConnectorRelayUrl(config.serverUrl, config.connectorId);
+    const token = launchConfig?.oauthToken?.trim();
+    socket = new WebSocket(relayUrl, {
+      headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+    });
+
+    socket.on("open", () => {
+      void writeLog("info", `relay connected ${relayUrl}`);
+    });
+
+    // The protocol loop (request -> handler -> streamed start/chunk/end) lives in
+    // relaylib. `chunkEncoding: "utf8"` keeps the legacy text wire format, since a
+    // base64-aware hub is not guaranteed to be deployed yet (the connector ships
+    // independently of the cloud). Switch to base64 once that hub is rolled out.
+    attachRelayClient(socket, handler, { chunkEncoding: "utf8" });
+
+    socket.on("close", () => {
+      void writeLog("warn", "relay disconnected");
+      if (stopped) return;
+      reconnectTimer = setTimeout(connect, RELAY_RECONNECT_INTERVAL_MS);
+    });
+
+    socket.on("error", (error) => {
+      void writeLog("warn", `relay error: ${error instanceof Error ? error.message : error}`);
+    });
+  };
+
+  connect();
+
+  return {
+    stop() {
+      stopped = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      socket?.close();
+    },
+  };
+}
+
+/**
+ * App-specific relay handler: forwards each request to the embedded bunny daemon
+ * only (origin guard), records the relay audit headers, then proxies via fetch.
+ */
+function createRelayHandler(bunnyDaemon: EmbeddedBunnyDaemon): RelayRequestHandler {
+  const allowedOrigin = new URL(bunnyDaemon.baseUrl).origin;
+
+  return async (request) => {
+    const requestUrl = new URL(request.path, bunnyDaemon.baseUrl);
+    if (requestUrl.origin !== allowedOrigin) {
+      throw new Error("Relay request must target the embedded bunny daemon.");
+    }
+
+    await writeLog("info", `relay request ${request.method} ${requestUrl.pathname}`, {
+      actorEmail: getHeaderValue(request.headers, "x-buda-relay-actor-email") || null,
+      actorId: getHeaderValue(request.headers, "x-buda-relay-actor-id") || null,
+      source: getHeaderValue(request.headers, "x-buda-relay-source") || "unknown",
+      action: getHeaderValue(request.headers, "x-buda-relay-action") || "unknown",
+      target: requestUrl.toString(),
+    });
+
+    return fetch(requestUrl, {
+      method: request.method,
+      headers: {
+        "Content-Type": "application/json",
+        ...(request.headers ?? {}),
+      },
+      body: request.body === undefined ? undefined : JSON.stringify(request.body),
+    });
+  };
+}
+
+function getHeaderValue(headers: Record<string, string> | undefined, name: string) {
+  if (!headers) return undefined;
+  const normalized = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === normalized) return value;
+  }
+  return undefined;
+}

package/src/runtime.ts

@@ -0,0 +1,59 @@
+import { startEmbeddedBunnyDaemon, stopEmbeddedBunnyDaemon } from "./bunny-daemon.js";
+import { heartbeatConnector, registerConnector, unregisterConnector } from "./cloud-client.js";
+import {
+  buildDeviceConfig,
+  CONFIG_PATH,
+  ensureDeviceConfig,
+  HEARTBEAT_INTERVAL_MS,
+  LOG_PATH,
+  writeDeviceConfig,
+} from "./config.js";
+import { writeLog } from "./logger.js";
+import { startConnectorRelay } from "./relay.js";
+import type { ConnectorLaunchConfig } from "./types.js";
+
+export async function runNewConnector(launchConfig?: ConnectorLaunchConfig) {
+  const config = buildDeviceConfig(launchConfig);
+  await writeDeviceConfig(config);
+  await registerConnector(config, launchConfig);
+  await writeLog("info", `wrote ${CONFIG_PATH}`);
+  await writeLog("info", `workdir root ${config.workdirRoot}`);
+  await writeLog("info", `log file ${LOG_PATH}`);
+}
+
+export async function runConnectorDaemon(launchConfig?: ConnectorLaunchConfig) {
+  const config = await ensureDeviceConfig(launchConfig);
+  const bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
+  try {
+    await registerConnector(config, launchConfig, bunnyDaemon);
+  } catch (error) {
+    await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    throw error;
+  }
+  const relay = startConnectorRelay(config, bunnyDaemon, launchConfig);
+  await writeLog("info", `server ${config.serverUrl}`);
+  await writeLog("info", `config ${CONFIG_PATH}`);
+  await writeLog("info", `workdir root ${config.workdirRoot}`);
+  await writeLog("info", `log file ${LOG_PATH}`);
+  await writeLog("info", `bunny daemon ${bunnyDaemon.baseUrl}`);
+
+  const interval = setInterval(() => {
+    heartbeatConnector(config, launchConfig, bunnyDaemon).catch((error) => {
+      void writeLog(
+        "warn",
+        `heartbeat failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    });
+  }, HEARTBEAT_INTERVAL_MS);
+
+  const shutdown = async () => {
+    clearInterval(interval);
+    relay.stop();
+    await unregisterConnector(config, launchConfig);
+    await stopEmbeddedBunnyDaemon(bunnyDaemon);
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}

package/src/types.ts

@@ -0,0 +1,37 @@
+import type { Server } from "node:http";
+
+export type ConnectorCliCommand = "new" | "dev" | "daemon";
+
+export interface DeviceConfig {
+  connectorId: string;
+  deviceId: string;
+  deviceName: string;
+  hostLabel: string;
+  serverUrl: string;
+  workdirRoot: string;
+  createdAt: string;
+}
+
+export interface ConnectorLaunchConfig {
+  serverUrl?: string;
+  workdirRoot?: string;
+  oauthToken?: string;
+  spaceId?: string;
+  bunnyDaemonHost?: string;
+  bunnyDaemonPort?: number;
+}
+
+export interface EmbeddedBunnyDaemon {
+  server: Server;
+  host: string;
+  port: number;
+  baseUrl: string;
+  root: string;
+}
+
+export interface ConnectorLogEntry {
+  level: "info" | "warn" | "error";
+  message: string;
+  metadata?: Record<string, unknown>;
+  createdAt: string;
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "types": ["node"],
+    "paths": {
+      "kui/ai-elements/*": ["../../packages/kui/src/components/ai-elements/*"],
+      "kui/hooks/*": ["../../packages/kui/src/hooks/*"],
+      "kui/tour": ["../../packages/kui/src/components/tour.tsx"],
+      "kui/utils": ["../../packages/kui/src/lib/utils.ts"],
+      "kui/*": ["../../packages/kui/src/components/ui/*"],
+      "sharelib": ["../../packages/sharelib/index.ts"],
+      "sharelib/onboarding-types": ["../../packages/sharelib/src/onboarding-types.ts"],
+      "sharelib/scheduler/cache": ["../../packages/sharelib/scheduler/scheduler-cache.ts"],
+      "sharelib/scheduler/cron": ["../../packages/sharelib/scheduler/cron-parser.ts"],
+      "sharelib/ui/ProductScreenshot": ["../../packages/sharelib/ui/common/ProductScreenshot.tsx"],
+      "sharelib/ui/ProductShowcase": ["../../packages/sharelib/ui/common/ProductShowcase.tsx"],
+      "sharelib/ui/LanguageSwitcher": ["../../packages/sharelib/ui/common/LanguageSwitcher.tsx"],
+      "sharelib/ui/dashboard": ["../../packages/sharelib/ui/dashboard/index.ts"],
+      "sharelib/*": ["../../packages/sharelib/*"],
+      "share-domains/*": ["../../packages/share-domains/*"],
+      "billing": ["../../packages/billing/index.ts"],
+      "billing/*": ["../../packages/billing/*"],
+      "emaillib": ["../../packages/emaillib/index.ts"],
+      "emaillib/types": ["../../packages/emaillib/types/index.ts"],
+      "transactional/components": ["../../packages/transactional/emails/_components/index.ts"],
+      "transactional/emails/*": ["../../packages/transactional/emails/*.tsx"],
+      "transactional/*": ["../../packages/transactional/emails/*.tsx"],
+      "@mcpsdk/sdk-ts": ["../../packages/@mcpsdk/sdk-ts/src/index.ts"],
+      "@mcpsdk/sdk-ts/*": ["../../packages/@mcpsdk/sdk-ts/src/*"],
+      "@mcpsdk/plugin-core": ["../../packages/@mcpsdk/plugin-core/src/index.ts"],
+      "@mcpsdk/plugin-core/*": ["../../packages/@mcpsdk/plugin-core/src/*"],
+      "@mcpsdk/mcp-server": ["../../packages/@mcpsdk/mcp-server/index.js"]
+    }
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,20 @@
+import { resolve } from "node:path";
+import { defineConfig } from "tsup";
+
+// relaylib ships TypeScript source (its package exports point at `./src/*.ts`),
+// so it cannot be a runtime dependency of this published npm CLI. Bundle it
+// straight into dist instead — the connector stays standalone. `ws` and
+// @bunny-agent/* stay external (real runtime deps).
+export default defineConfig({
+  entry: { cli: "src/cli.ts" },
+  format: ["esm"],
+  target: "node20",
+  platform: "node",
+  outDir: "dist",
+  clean: true,
+  dts: false,
+  noExternal: [/^relaylib/],
+  esbuildOptions(options) {
+    options.nodePaths = [resolve(process.cwd(), "node_modules")];
+  },
+});