@buda-ai/connector 0.1.2 → 0.1.4

package/README.md

@@ -57,7 +57,7 @@ printf '{"serverUrl":"https://buda.im","oauthToken":"..."}\n' \
 Supported launch config fields:
 
 - `serverUrl`
-- `spaceId`
+- `token`
 - `workdirRoot`
 - `oauthToken`
 - `bunnyDaemonHost`
@@ -65,11 +65,11 @@ Supported launch config fields:
 
 ## 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:
+Buda Space Settings can show a connector token command for the current space.
+The token selects that Space's independent local connector profile:
 
 ```bash
-npx -y @buda-ai/connector@latest daemon --space-id "org_..."
+npx -y @buda-ai/connector@latest daemon --token "cet_..."
 ```
 
 Desktop and other authenticated clients should use OAuth token launch config
@@ -83,17 +83,19 @@ printf '%s\n' '{"serverUrl":"https://buda.im","oauthToken":"..."}' \
 You can also pass launch options directly:
 
 ```bash
-buda-connector daemon --space-id "org_..." --workdir "$HOME/.buda/agents"
+buda-connector daemon --token "cet_..." --workdir "$HOME/.buda/agents"
 ```
 
 ## Local Files
 
-- `~/.buda/device.json` (versioned device identities keyed by normalized server origin)
+- `~/.buda/device.json` (versioned device profiles keyed by server origin and token fingerprint)
 - `~/.buda/connector.log`
 - `~/.buda/agents/`
 
 Server URL paths and query strings do not create a new identity. Scheme and non-default port
-changes do. Existing single-device config files are upgraded in place on first use.
+changes do. Connector tokens for different Spaces on the same server select independent profiles,
+so their daemons can run concurrently. Raw tokens are never used in profile keys or lock paths.
+The installation-level physical device ID remains shared across profiles.
 
 New server profiles share a privacy-preserving device ID derived by hashing the operating
 system's stable machine identifier. The raw machine identifier is never stored or sent. If the

package/dist/cli.js

@@ -147,6 +147,13 @@ function getServerOriginKey(serverUrl) {
   const digest = createHash2("sha256").update(origin).digest("hex").slice(0, 12);
   return `${hostnameKey}-${digest}`;
 }
+function getConnectorTokenFingerprint(token) {
+  return createHash2("sha256").update(`buda:connector-profile:v1:${token.trim()}`, "utf8").digest("hex");
+}
+function getConnectorProfileKey(serverUrl, token) {
+  const discriminator = token?.trim() ? getConnectorTokenFingerprint(token) : "legacy-no-token";
+  return `${getServerOriginKey(serverUrl)}--${discriminator}`;
+}
 function getConnectorPaths(serverUrl, configRoot = path.join(homedir(), ".buda")) {
   const scopedLegacyDir = path.join(configRoot, "servers", getServerOriginKey(serverUrl));
   return {
@@ -158,6 +165,16 @@ function getConnectorPaths(serverUrl, configRoot = path.join(homedir(), ".buda")
     scopedLegacyWorkdirRoot: path.join(scopedLegacyDir, "agents")
   };
 }
+function getConnectorDaemonLockTarget(serverUrl, connectorId, configRoot = path.join(homedir(), ".buda")) {
+  const connectorKey = connectorId.replace(/[^a-z0-9_-]+/gi, "-").toLowerCase();
+  return path.join(
+    configRoot,
+    "daemons",
+    getServerOriginKey(serverUrl),
+    connectorKey,
+    "connector-daemon"
+  );
+}
 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(/\/$/, "");
 }
@@ -211,29 +228,50 @@ async function readJsonFile(configPath) {
     return null;
   }
 }
+function migrateLegacyProfiles(values) {
+  const profiles = {};
+  for (const value of values) {
+    if (!isDeviceConfig(value)) continue;
+    try {
+      profiles[getConnectorProfileKey(value.serverUrl, value.token)] = value;
+    } catch {
+    }
+  }
+  return profiles;
+}
 async function loadDeviceConfigStore(configPath) {
   const parsed = await readJsonFile(configPath);
   const candidate = parsed;
+  if (candidate?.version === 3 && candidate.profiles && typeof candidate.profiles === "object") {
+    return {
+      store: {
+        version: 3,
+        ...typeof candidate.systemDeviceId === "string" ? { systemDeviceId: candidate.systemDeviceId } : {},
+        profiles: candidate.profiles
+      },
+      needsWrite: false
+    };
+  }
   if (candidate && (candidate.version === 1 || candidate.version === 2) && candidate.servers && typeof candidate.servers === "object") {
     return {
       store: {
-        version: 2,
+        version: 3,
         ...typeof candidate.systemDeviceId === "string" ? { systemDeviceId: candidate.systemDeviceId } : {},
-        servers: candidate.servers
+        profiles: migrateLegacyProfiles(Object.values(candidate.servers))
       },
-      needsWrite: candidate.version !== 2
+      needsWrite: true
     };
   }
   if (isDeviceConfig(parsed)) {
     return {
       store: {
-        version: 2,
-        servers: { [normalizeServerOrigin(parsed.serverUrl)]: parsed }
+        version: 3,
+        profiles: migrateLegacyProfiles([parsed])
       },
       needsWrite: true
     };
   }
-  return { store: { version: 2, servers: {} }, needsWrite: false };
+  return { store: { version: 3, profiles: {} }, needsWrite: false };
 }
 function normalizeStoredWorkdirRoot(config, paths) {
   const configuredRoot = config.workdirRoot?.trim();
@@ -264,33 +302,21 @@ async function writeDeviceConfigStore(configPath, store) {
 async function readDeviceConfig(launchConfig, configRoot) {
   const serverUrl = getServerUrl(launchConfig);
   const paths = getConnectorPaths(serverUrl, configRoot);
-  const origin = normalizeServerOrigin(serverUrl);
+  const launchToken = getConnectorToken(launchConfig);
   await mkdir(paths.configDir, { recursive: true });
   return withExclusiveFileLock(paths.configPath, async () => {
     const { store, needsWrite } = await loadDeviceConfigStore(paths.configPath);
-    const storedConfig = store.servers[origin];
+    const profileKey = getConnectorProfileKey(serverUrl, launchToken);
+    const storedConfig = store.profiles[profileKey];
     let config = isDeviceConfig(storedConfig) ? storedConfig : null;
-    let migratedScopedConfig = false;
     let normalizedWorkdirRoot = false;
-    if (!config) {
-      const scopedLegacy = await readJsonFile(paths.scopedLegacyConfigPath);
-      if (isDeviceConfig(scopedLegacy)) {
-        try {
-          if (normalizeServerOrigin(scopedLegacy.serverUrl) === origin) {
-            config = scopedLegacy;
-            migratedScopedConfig = true;
-          }
-        } catch {
-        }
-      }
-    }
     if (config) {
       const normalized = normalizeStoredWorkdirRoot(config, paths);
       config = normalized.config;
       normalizedWorkdirRoot = normalized.changed;
-      store.servers[origin] = config;
+      store.profiles[getConnectorProfileKey(config.serverUrl, config.token)] = config;
     }
-    if (needsWrite || migratedScopedConfig || normalizedWorkdirRoot) {
+    if (needsWrite || normalizedWorkdirRoot) {
       await writeDeviceConfigStore(paths.configPath, store);
     }
     return config;
@@ -302,7 +328,7 @@ async function writeDeviceConfig(config, configRoot) {
   await mkdir(paths.configDir, { recursive: true });
   await withExclusiveFileLock(paths.configPath, async () => {
     const { store } = await loadDeviceConfigStore(paths.configPath);
-    store.servers[normalizeServerOrigin(config.serverUrl)] = config;
+    store.profiles[getConnectorProfileKey(config.serverUrl, config.token)] = config;
     await writeDeviceConfigStore(paths.configPath, store);
   });
 }
@@ -315,7 +341,7 @@ async function getOrCreateSystemDeviceId(configRoot, resolver = resolveSystemDev
       if (needsWrite) await writeDeviceConfigStore(paths.configPath, store);
       return store.systemDeviceId;
     }
-    const existingDeviceId = Object.values(store.servers).find(isDeviceConfig)?.deviceId;
+    const existingDeviceId = Object.values(store.profiles).find(isDeviceConfig)?.deviceId;
     store.systemDeviceId = resolver() || existingDeviceId || `dvc_${randomUUID()}`;
     await writeDeviceConfigStore(paths.configPath, store);
     return store.systemDeviceId;
@@ -325,19 +351,40 @@ async function createDeviceConfig(launchConfig, configRoot, resolver) {
   const deviceId = await getOrCreateSystemDeviceId(configRoot, resolver);
   return buildDeviceConfig(launchConfig, deviceId);
 }
-async function ensureDeviceConfig(launchConfig) {
-  const existing = await readDeviceConfig(launchConfig);
-  if (existing) {
-    const overrideToken = getConnectorToken(launchConfig);
-    return {
-      ...existing,
-      serverUrl: getServerUrl(launchConfig),
-      workdirRoot: launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || existing.workdirRoot || getWorkdirRoot(launchConfig),
-      ...overrideToken ? { token: overrideToken } : {}
-    };
-  }
-  const config = await createDeviceConfig(launchConfig);
-  await writeDeviceConfig(config);
+async function ensureDeviceConfig(launchConfig, configRoot, resolver = resolveSystemDeviceId) {
+  const serverUrl = getServerUrl(launchConfig);
+  const paths = getConnectorPaths(serverUrl, configRoot);
+  const token = getConnectorToken(launchConfig);
+  const profileKey = getConnectorProfileKey(serverUrl, token);
+  await mkdir(paths.configDir, { recursive: true });
+  const config = await withExclusiveFileLock(paths.configPath, async () => {
+    const { store, needsWrite } = await loadDeviceConfigStore(paths.configPath);
+    const storedConfig = store.profiles[profileKey];
+    if (isDeviceConfig(storedConfig)) {
+      const normalized = normalizeStoredWorkdirRoot(storedConfig, paths);
+      if (needsWrite || normalized.changed) {
+        store.profiles[profileKey] = normalized.config;
+        await writeDeviceConfigStore(paths.configPath, store);
+      }
+      const existing = normalized.config;
+      const overrideToken = getConnectorToken(launchConfig);
+      return {
+        ...existing,
+        serverUrl,
+        workdirRoot: launchConfig?.workdirRoot || process.env.BUDA_CONNECTOR_WORKDIR || existing.workdirRoot || getWorkdirRoot(launchConfig),
+        ...overrideToken ? { token: overrideToken } : {}
+      };
+    }
+    if (!store.systemDeviceId) {
+      const existingDeviceId = Object.values(store.profiles).find(isDeviceConfig)?.deviceId;
+      store.systemDeviceId = resolver() || existingDeviceId || `dvc_${randomUUID()}`;
+    }
+    const created = buildDeviceConfig(launchConfig, store.systemDeviceId);
+    store.profiles[profileKey] = created;
+    await writeDeviceConfigStore(paths.configPath, store);
+    return created;
+  });
+  await mkdir(config.workdirRoot, { recursive: true });
   return config;
 }
 function parseLaunchConfig(raw) {
@@ -2916,7 +2963,7 @@ import { mkdir as mkdir9 } from "fs/promises";
 import path9 from "path";
 async function runNewConnector(launchConfig) {
   const existing = await readDeviceConfig(launchConfig);
-  const config = existing ? await ensureDeviceConfig(launchConfig) : await createDeviceConfig(launchConfig);
+  const config = await ensureDeviceConfig(launchConfig);
   const paths = getConnectorPaths(config.serverUrl);
   await migrateLegacyWorkspaceRoot(config.workdirRoot);
   await provisionWorkdirLayout(config.workdirRoot);
@@ -2932,22 +2979,15 @@ async function runNewConnector(launchConfig) {
 }
 async function runConnectorDaemon(launchConfig) {
   const existing = await readDeviceConfig(launchConfig);
-  const config = existing ? await ensureDeviceConfig(launchConfig) : await createDeviceConfig(launchConfig);
+  const config = await ensureDeviceConfig(launchConfig);
   const paths = getConnectorPaths(config.serverUrl);
-  const daemonLockTarget = path9.join(
-    paths.configDir,
-    "servers",
-    getServerOriginKey(config.serverUrl),
-    "connector-daemon"
-  );
+  const daemonLockTarget = getConnectorDaemonLockTarget(config.serverUrl, config.connectorId);
   await mkdir9(path9.dirname(daemonLockTarget), { recursive: true, mode: 448 });
-  const daemonLock = await acquireExclusiveFileLock(daemonLockTarget, { timeoutMs: 0 }).catch(
-    () => {
-      throw new Error(
-        `Another Buda Connector daemon is already running for ${config.serverUrl}. Stop it before starting another instance.`
-      );
-    }
-  );
+  let daemonLock = await acquireExclusiveFileLock(daemonLockTarget, { timeoutMs: 0 }).catch(() => {
+    throw new Error(
+      `Another Buda Connector daemon is already running for this profile on ${config.serverUrl}. Stop it before starting another instance.`
+    );
+  });
   let bunnyDaemon;
   let relayProtocol;
   try {
@@ -2959,9 +2999,26 @@ async function runConnectorDaemon(launchConfig) {
     const registration = await registerConnector(config, launchConfig, activeBunnyDaemon, {
       recoverMissingProfile: !existing
     });
+    const connectorIdChanged = config.connectorId !== registration.connectorId;
+    if (connectorIdChanged) {
+      const registeredLockTarget = getConnectorDaemonLockTarget(
+        config.serverUrl,
+        registration.connectorId
+      );
+      await mkdir9(path9.dirname(registeredLockTarget), { recursive: true, mode: 448 });
+      const registeredLock = await acquireExclusiveFileLock(registeredLockTarget, {
+        timeoutMs: 0
+      }).catch(() => {
+        throw new Error(
+          `Another Buda Connector daemon is already running for this profile on ${config.serverUrl}. Stop it before starting another instance.`
+        );
+      });
+      await daemonLock.release();
+      daemonLock = registeredLock;
+    }
     config.connectorId = registration.connectorId;
     relayProtocol = registration.relayProtocol;
-    if (!existing) await writeDeviceConfig(config);
+    if (!existing || connectorIdChanged) await writeDeviceConfig(config);
     const relay = startConnectorRelay(
       config,
       activeBunnyDaemon,

package/package.json

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