@buda-ai/connector 0.1.12 → 0.1.15

package/dist/cli.js

@@ -517,7 +517,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.12",
+  version: "0.1.15",
   private: false,
   type: "module",
   publishConfig: {
@@ -2357,6 +2357,20 @@ async function registerConnector(config, launchConfig, bunnyDaemon, options) {
     relayProtocol: result.relayProtocol
   };
 }
+async function registerConnectorForExplicitEnrollment(config, launchConfig, bunnyDaemon) {
+  try {
+    return await registerConnector(config, launchConfig, bunnyDaemon);
+  } catch (error) {
+    const hasSpaceToken = Boolean(config.token?.trim() || getConnectorToken(launchConfig));
+    const hasOauthToken = Boolean(launchConfig?.oauthToken?.trim());
+    if (!(error instanceof ConnectorDeletedError) || !hasSpaceToken || hasOauthToken) {
+      throw error;
+    }
+    return registerConnector(config, launchConfig, bunnyDaemon, {
+      recoverMissingProfile: true
+    });
+  }
+}
 async function heartbeatConnector(config, launchConfig, bunnyDaemon) {
   const logs = takePendingLogs();
   const result = await postJson(
@@ -2397,6 +2411,13 @@ import path6 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var RUNTIME_INSTALL_TIMEOUT_MS = 5 * 6e4;
+var resolveBundledNodePlacement = (sourceRoot, sourceNode, pathApi = path6) => {
+  const relativeNode = pathApi.relative(sourceRoot, sourceNode);
+  return {
+    copyNode: relativeNode.startsWith("..") || pathApi.isAbsolute(relativeNode),
+    relativeNode
+  };
+};
 var exists = async (filePath) => access(filePath).then(() => true).catch(() => false);
 var runtimeRoot = () => process.env.BUDA_CONNECTOR_RUNTIME_ROOT || path6.join(homedir3(), ".buda", "runtime");
 var runtimePlatformKey = `${process.platform}-${process.arch}-node${process.versions.modules}`;
@@ -2468,10 +2489,10 @@ var installFromBundledRuntime = async (directory, sourceRoot) => {
   if (relativeEntrypoint.startsWith("..") || path6.isAbsolute(relativeEntrypoint)) {
     throw new Error("Bundled Connector entrypoint must be inside its runtime root");
   }
-  const relativeNode = path6.relative(sourceRoot, sourceNode);
+  const { copyNode, relativeNode } = resolveBundledNodePlacement(sourceRoot, sourceNode);
   const entrypoint = path6.join(directory, relativeEntrypoint);
-  const nodeExecutable = relativeNode.startsWith("..") ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
-  if (relativeNode.startsWith("..")) {
+  const nodeExecutable = copyNode ? path6.join(directory, "node", path6.basename(sourceNode)) : path6.join(directory, relativeNode);
+  if (copyNode) {
     await mkdir5(path6.dirname(nodeExecutable), { recursive: true });
     await cp(sourceNode, nodeExecutable, { force: true });
   }
@@ -2545,13 +2566,14 @@ var isProcessAlive2 = (pid) => {
     return !(typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH");
   }
 };
-var getRuntimeCommandArgs = (runtime, mode) => [
+var getRuntimeCommandArgs = (runtime, mode, options = {}) => [
   ...runtime.nodeArgs ?? [],
   runtime.entrypoint,
   "daemon",
   "--internal-daemon",
   "--daemon-mode",
   mode,
+  ...options.explicitEnrollment ? ["--explicit-enrollment"] : [],
   "--plain"
 ];
 var compareVersions = (left, right) => {
@@ -2578,9 +2600,9 @@ var waitForDaemon = async (launchConfig, deadline) => {
     lastConfig ? "Connector daemon did not expose its control channel in time" : "Connector registration did not create a canonical local identity in time"
   );
 };
-var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime) => {
+var spawnInternalDaemon = async (launchConfig, mode, preparedRuntime, options = {}) => {
   const runtime = preparedRuntime ?? await ensureStableConnectorRuntime();
-  const child = spawn(runtime.nodeExecutable, getRuntimeCommandArgs(runtime, mode), {
+  const child = spawn(runtime.nodeExecutable, getRuntimeCommandArgs(runtime, mode, options), {
     detached: true,
     env: {
       ...process.env,
@@ -2603,7 +2625,7 @@ var stopOlderIdleDaemon = async (config, status) => {
   }
   throw new Error("Older Connector daemon did not stop cleanly; existing identity was preserved");
 };
-async function ensureConnectorDaemon(launchConfig, mode) {
+async function ensureConnectorDaemon(launchConfig, mode, options = {}) {
   const deviceId = await getOrCreateSystemDeviceId(getConfigRoot());
   const scope = await resolveConnectorScope(deviceId, launchConfig);
   launchConfig = { ...launchConfig, spaceId: scope.spaceId };
@@ -2623,7 +2645,7 @@ async function ensureConnectorDaemon(launchConfig, mode) {
           const status = mode === "persistent" ? await requestDaemonControl(existingConfig, "persist", getConfigRoot()) : existingStatus;
           return { config: existingConfig, status };
         }
-        await spawnInternalDaemon(launchConfig, mode, preparedRuntime);
+        await spawnInternalDaemon(launchConfig, mode, preparedRuntime, options);
         return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
       }
       const persistedStatus = await readPersistedDaemonStatus(
@@ -2636,7 +2658,7 @@ async function ensureConnectorDaemon(launchConfig, mode) {
         );
       }
     }
-    await spawnInternalDaemon(launchConfig, mode);
+    await spawnInternalDaemon(launchConfig, mode, void 0, options);
     return await waitForDaemon(launchConfig, Date.now() + START_TIMEOUT_MS);
   } finally {
     await bootstrapLock.release();
@@ -2780,7 +2802,9 @@ async function runConnectorDashboard(launchConfig, options = {}) {
     plain: options.plain
   });
   if (!dashboard) {
-    const { config } = await ensureConnectorDaemon(launchConfig, "persistent");
+    const { config } = await ensureConnectorDaemon(launchConfig, "persistent", {
+      explicitEnrollment: true
+    });
     const stopLogs2 = streamDaemonLogs({
       connectorId: config.connectorId,
       dashboardActive: false,
@@ -2835,7 +2859,7 @@ async function runConnectorDashboard(launchConfig, options = {}) {
     preferredConnectorId = config.connectorId;
   }).catch(() => void 0).finally(() => refresh());
   const timer = setInterval(() => void refresh(), 1e3);
-  void ensureConnectorDaemon(launchConfig, "persistent").then(async ({ config }) => {
+  void ensureConnectorDaemon(launchConfig, "persistent", { explicitEnrollment: true }).then(async ({ config }) => {
     pendingConnector = void 0;
     preferredConnectorId = config.connectorId;
     await refresh();
@@ -3003,13 +3027,12 @@ var createTerminalSession = async (grant, nodePtyLoader) => {
   try {
     nodePty = await nodePtyLoader();
   } catch (error) {
+    const message = serializeErrorMessage(error);
     void writeLog(
       "error",
       `local terminal could not load node-pty: ${serializeErrorMessage(error)}`
     );
-    throw new LocalTerminalUnavailableError(
-      "Local terminal is unavailable because node-pty could not be loaded. The connector remains available for other capabilities."
-    );
+    throw new LocalTerminalUnavailableError(message);
   }
   const shell = process.platform === "win32" ? "powershell.exe" : process.env.SHELL || "/bin/bash";
   const shellArgs = process.platform === "win32" ? [] : ["-l"];
@@ -3199,7 +3222,7 @@ var proxyConnectorTerminalTunnel = async (input) => {
   let bridgeAccepted = false;
   let activityStarted = false;
   let activityEnded = false;
-  let cloudCloseAfterOpen = null;
+  let localCloseAfterBridge = null;
   let localCloseAfterOpen = null;
   const endActivity = () => {
     if (!activityStarted || activityEnded) return;
@@ -3224,7 +3247,9 @@ var proxyConnectorTerminalTunnel = async (input) => {
     if (!bridgeAccepted) {
       if (!isBinary && data.toString() === '{"type":"bridge-accepted"}') {
         bridgeAccepted = true;
-        local.send(JSON.stringify({ type: "bridge-start" }));
+        if (local.readyState === WebSocket.OPEN) {
+          local.send(JSON.stringify({ type: "bridge-start" }));
+        }
         for (const [frame, binary] of pendingCloudFrames) {
           if (local.readyState === WebSocket.OPEN) local.send(frame, { binary });
         }
@@ -3234,6 +3259,9 @@ var proxyConnectorTerminalTunnel = async (input) => {
         pendingCloudFrames.length = 0;
         pendingLocalFrames.length = 0;
         pendingBytes = 0;
+        if (localCloseAfterBridge && cloud.readyState === WebSocket.OPEN) {
+          cloud.close(localCloseAfterBridge.code, localCloseAfterBridge.reason);
+        }
         return;
       }
       bufferFrame(pendingCloudFrames, data, isBinary);
@@ -3270,15 +3298,10 @@ var proxyConnectorTerminalTunnel = async (input) => {
       code: normalizeTerminalCloseCode(code),
       reason: truncateTerminalCloseReason(reason.toString())
     };
-    if (cloud.readyState === WebSocket.OPEN) {
+    if (!bridgeAccepted) {
+      localCloseAfterBridge = normalizedClose;
+    } else if (cloud.readyState === WebSocket.OPEN) {
       cloud.close(normalizedClose.code, normalizedClose.reason);
-    } else if (cloud.readyState === WebSocket.CONNECTING) {
-      cloudCloseAfterOpen = normalizedClose;
-    }
-  });
-  cloud.once("open", () => {
-    if (cloudCloseAfterOpen && cloud.readyState === WebSocket.OPEN) {
-      cloud.close(cloudCloseAfterOpen.code, cloudCloseAfterOpen.reason);
     }
   });
   local.once("open", () => {
@@ -3295,9 +3318,11 @@ var proxyConnectorTerminalTunnel = async (input) => {
     local.terminate();
     throw error;
   }
-  if (cloud.readyState !== WebSocket.OPEN || local.readyState !== WebSocket.OPEN) return;
-  activityStarted = true;
-  input.onActivityStart?.();
+  if (cloud.readyState !== WebSocket.OPEN) return;
+  if (local.readyState === WebSocket.OPEN) {
+    activityStarted = true;
+    input.onActivityStart?.();
+  }
   cloud.send(JSON.stringify({ type: "bridge-ready" }));
   await writeLog(
     "info",
@@ -5421,9 +5446,7 @@ async function runOnboard(launchConfig, options = {}) {
     await migrateLegacyWorkspaceRoot(config2.workdirRoot);
     await provisionWorkdirLayout(config2.workdirRoot);
     try {
-      const registration = await registerConnector(config2, launchConfig, void 0, {
-        recoverMissingProfile: false
-      });
+      const registration = await registerConnectorForExplicitEnrollment(config2, launchConfig);
       config2.connectorId = registration.connectorId;
       config2.spaceId = registration.spaceId ?? config2.spaceId;
       relayProtocol = registration.relayProtocol;
@@ -5455,7 +5478,16 @@ async function runOnboard(launchConfig, options = {}) {
   if (!existing) {
   } else {
     try {
-      relayProtocol = (await registerConnector(config, launchConfig, bunnyDaemon)).relayProtocol;
+      const registration = await registerConnectorForExplicitEnrollment(
+        config,
+        launchConfig,
+        bunnyDaemon
+      );
+      config.connectorId = registration.connectorId;
+      config.spaceId = registration.spaceId ?? config.spaceId;
+      if (!config.spaceId) throw new Error("Registration did not resolve a Space");
+      relayProtocol = registration.relayProtocol;
+      await writeDeviceConfig(config);
     } catch (error) {
       await stopEmbeddedBunnyDaemon(bunnyDaemon);
       s.stop("Failed to register");
@@ -5543,15 +5575,12 @@ async function stopRecoveredIdleDaemon(config, configRoot) {
   throw new Error(`Recovered Connector ${config.connectorId} did not stop cleanly.`);
 }
 async function runNewConnector(launchConfig) {
-  const existing = await readDeviceConfig(launchConfig);
   const config = await ensureDeviceConfig(launchConfig);
   const paths = getConnectorPaths(config.serverUrl);
   await migrateLegacyWorkspaceRoot(config.workdirRoot);
   await provisionWorkdirLayout(config.workdirRoot);
   await LocalWorkspaceRegistry.open(config.workdirRoot);
-  const registration = await registerConnector(config, launchConfig, void 0, {
-    recoverMissingProfile: shouldRecoverMissingProfile(Boolean(existing), launchConfig)
-  });
+  const registration = await registerConnectorForExplicitEnrollment(config, launchConfig);
   config.connectorId = registration.connectorId;
   config.spaceId = registration.spaceId ?? config.spaceId;
   await writeDeviceConfig(config);
@@ -5592,9 +5621,7 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     const workspaceRegistry = await LocalWorkspaceRegistry.open(config.workdirRoot);
     bunnyDaemon = await startEmbeddedBunnyDaemon(config, launchConfig);
     const activeBunnyDaemon = bunnyDaemon;
-    const registration = await registerConnector(config, launchConfig, activeBunnyDaemon, {
-      recoverMissingProfile: shouldRecoverMissingProfile(Boolean(existing), launchConfig)
-    });
+    const registration = options.explicitEnrollment ? await registerConnectorForExplicitEnrollment(config, launchConfig, activeBunnyDaemon) : await registerConnector(config, launchConfig, activeBunnyDaemon);
     const connectorIdChanged = config.connectorId !== registration.connectorId;
     if (connectorIdChanged) {
       const registeredConfig = {
@@ -5703,7 +5730,6 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     throw error;
   }
 }
-var shouldRecoverMissingProfile = (hasExistingProfile, launchConfig) => !hasExistingProfile && Boolean(getConnectorToken(launchConfig)) && !launchConfig?.oauthToken?.trim();
 
 // src/cli.ts
 function printHelp() {
@@ -5795,6 +5821,7 @@ async function main() {
   if (command === "daemon" && process.argv.includes("--internal-daemon")) {
     await runConnectorDaemon(launchConfig, {
       captureConsole: true,
+      explicitEnrollment: process.argv.includes("--explicit-enrollment"),
       mode: getDaemonModeFlag(),
       version: CONNECTOR_RUNTIME_VERSION
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buda-ai/connector",
-  "version": "0.1.12",
+  "version": "0.1.15",
   "private": false,
   "type": "module",
   "publishConfig": {