@buda-ai/connector 0.1.11 → 0.1.14

package/dist/cli.js

@@ -517,7 +517,7 @@ import path2 from "path";
 // package.json
 var package_default = {
   name: "@buda-ai/connector",
-  version: "0.1.11",
+  version: "0.1.14",
   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(
@@ -2545,13 +2559,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 +2593,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 +2618,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 +2638,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 +2651,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 +2795,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 +2852,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 +3020,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"];
@@ -3196,17 +3212,13 @@ var proxyConnectorTerminalTunnel = async (input) => {
     headers: { "X-Buda-Local-Terminal-Token": input.localToken },
     handshakeTimeout: TERMINAL_HANDSHAKE_TIMEOUT_MS
   });
-  try {
-    await Promise.all([connectSocket(cloud), connectSocket(local)]);
-  } catch (error) {
-    cloud.terminate();
-    local.terminate();
-    throw error;
-  }
   let bridgeAccepted = false;
+  let activityStarted = false;
   let activityEnded = false;
+  let localCloseAfterBridge = null;
+  let localCloseAfterOpen = null;
   const endActivity = () => {
-    if (activityEnded) return;
+    if (!activityStarted || activityEnded) return;
     activityEnded = true;
     input.onActivityEnd?.();
   };
@@ -3228,7 +3240,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 });
         }
@@ -3238,6 +3252,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);
@@ -3254,25 +3271,51 @@ var proxyConnectorTerminalTunnel = async (input) => {
   });
   cloud.once("close", (code, reason) => {
     endActivity();
+    const normalizedCode = normalizeTerminalCloseCode(code);
+    const normalizedReason = truncateTerminalCloseReason(reason.toString());
     if (!bridgeAccepted) {
       void writeLog(
         "warn",
-        `terminal cloud tunnel closed before readiness session=${input.sessionId} code=${code} reason=${truncateTerminalCloseReason(reason.toString())}`
+        `terminal cloud tunnel closed before readiness session=${input.sessionId} code=${code} reason=${normalizedReason}`
       );
     }
     if (local.readyState === WebSocket.OPEN) {
-      local.close(normalizeTerminalCloseCode(code), truncateTerminalCloseReason(reason.toString()));
+      local.close(normalizedCode, normalizedReason);
+    } else if (local.readyState === WebSocket.CONNECTING) {
+      localCloseAfterOpen = { code: normalizedCode, reason: normalizedReason };
     }
   });
   local.once("close", (code, reason) => {
     endActivity();
-    if (cloud.readyState === WebSocket.OPEN) {
-      cloud.close(normalizeTerminalCloseCode(code), truncateTerminalCloseReason(reason.toString()));
+    const normalizedClose = {
+      code: normalizeTerminalCloseCode(code),
+      reason: truncateTerminalCloseReason(reason.toString())
+    };
+    if (!bridgeAccepted) {
+      localCloseAfterBridge = normalizedClose;
+    } else if (cloud.readyState === WebSocket.OPEN) {
+      cloud.close(normalizedClose.code, normalizedClose.reason);
+    }
+  });
+  local.once("open", () => {
+    if (localCloseAfterOpen && local.readyState === WebSocket.OPEN) {
+      local.close(localCloseAfterOpen.code, localCloseAfterOpen.reason);
     }
   });
   cloud.once("error", () => local.terminate());
   local.once("error", () => cloud.terminate());
-  input.onActivityStart?.();
+  try {
+    await Promise.all([connectSocket(cloud), connectSocket(local)]);
+  } catch (error) {
+    cloud.terminate();
+    local.terminate();
+    throw error;
+  }
+  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",
@@ -5396,9 +5439,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;
@@ -5430,7 +5471,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");
@@ -5518,15 +5568,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);
@@ -5567,9 +5614,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 = {
@@ -5678,7 +5723,6 @@ async function runConnectorDaemon(launchConfig, options = {}) {
     throw error;
   }
 }
-var shouldRecoverMissingProfile = (hasExistingProfile, launchConfig) => !hasExistingProfile && Boolean(getConnectorToken(launchConfig)) && !launchConfig?.oauthToken?.trim();
 
 // src/cli.ts
 function printHelp() {
@@ -5770,6 +5814,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.11",
+  "version": "0.1.14",
   "private": false,
   "type": "module",
   "publishConfig": {