@buda-ai/connector 0.1.0 → 0.1.1

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@buda-ai/connector",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "bin": {
     "buda-connector": "./dist/cli.js",
     "connector": "./dist/cli.js"
@@ -22,12 +26,12 @@
   },
   "dependencies": {
     "@bunny-agent/daemon": "0.9.43",
-    "relaylib": "workspace:*",
     "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/node": "^24.10.0",
     "@types/ws": "^8.18.1",
+    "relaylib": "workspace:*",
     "tsup": "^8.5.0",
     "tsx": "^4.20.5",
     "typescript": "^5.9.3"

package/src/bunny-daemon.ts

@@ -1,52 +0,0 @@
-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

@@ -1,97 +0,0 @@
-#!/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

@@ -1,134 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,44 +0,0 @@
-{
-  "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

@@ -1,20 +0,0 @@
-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")];
-  },
-});