@wayai/cli 0.3.51 → 0.3.52

package/dist/index.js

@@ -8867,111 +8867,132 @@ var init_logout = __esm({
   }
 });
 
-// src/lib/hub-lock.ts
+// src/lib/hub-binding.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import * as fs7 from "fs";
 import * as path7 from "path";
-function getLockPath() {
+function resolveGitDir() {
   const cwd = process.cwd();
-  if (_lockPathCache && _lockPathCache.cwd === cwd) return _lockPathCache.lockPath;
+  if (_gitDirCache && _gitDirCache.cwd === cwd) return _gitDirCache.gitDir;
   let gitDir;
   try {
-    gitDir = execFileSync2("git", ["rev-parse", "--git-dir"], {
+    const raw = execFileSync2("git", ["rev-parse", "--git-dir"], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
+    gitDir = raw ? path7.resolve(cwd, raw) : null;
   } catch {
-    _lockPathCache = { cwd, lockPath: null };
-    return null;
+    gitDir = null;
   }
-  const lockPath = gitDir ? path7.resolve(cwd, gitDir, LOCK_FILENAME) : null;
-  _lockPathCache = { cwd, lockPath };
-  return lockPath;
+  _gitDirCache = { cwd, gitDir };
+  return gitDir;
 }
-function readLock() {
-  const lockPath = getLockPath();
-  if (!lockPath) return null;
-  let raw;
-  try {
-    raw = fs7.readFileSync(lockPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
+function getBindingPath() {
+  const gitDir = resolveGitDir();
+  return gitDir ? path7.join(gitDir, BINDING_FILENAME) : null;
+}
+function getLegacyBindingPath() {
+  const gitDir = resolveGitDir();
+  return gitDir ? path7.join(gitDir, LEGACY_BINDING_FILENAME) : null;
+}
+function readBinding() {
+  for (const bindingPath of [getBindingPath(), getLegacyBindingPath()]) {
+    if (!bindingPath) continue;
+    let raw;
+    try {
+      raw = fs7.readFileSync(bindingPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    const trimmed = raw.trim();
+    return UUID_RE.test(trimmed) ? trimmed : null;
   }
-  const trimmed = raw.trim();
-  return UUID_RE.test(trimmed) ? trimmed : null;
+  return null;
 }
-function writeLock(hubId) {
+function writeBinding(hubId) {
   if (!UUID_RE.test(hubId)) {
     throw new Error(`Invalid hub_id (must be a UUID): ${hubId}`);
   }
-  const lockPath = getLockPath();
-  if (!lockPath) {
-    throw new Error("Not inside a git repository \u2014 cannot write hub lock.");
+  const bindingPath = getBindingPath();
+  if (!bindingPath) {
+    throw new Error("Not inside a git repository \u2014 cannot write hub binding.");
   }
-  fs7.writeFileSync(lockPath, `${hubId}
+  fs7.writeFileSync(bindingPath, `${hubId}
 `, "utf-8");
+  removeLegacyBinding();
 }
-function clearLock() {
-  const lockPath = getLockPath();
-  if (!lockPath) return false;
+function removeLegacyBinding() {
+  const legacyPath = getLegacyBindingPath();
+  if (!legacyPath) return;
   try {
-    fs7.unlinkSync(lockPath);
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
+    fs7.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+function clearBinding() {
+  let removed = false;
+  for (const bindingPath of [getBindingPath(), getLegacyBindingPath()]) {
+    if (!bindingPath) continue;
+    try {
+      fs7.unlinkSync(bindingPath);
+      removed = true;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
   }
+  return removed;
 }
-function assertHubMatchesLock(resolvedHubId, hubLabel) {
-  const locked = readLock();
-  if (!locked) return;
-  if (locked === resolvedHubId) return;
+function assertHubMatchesBinding(resolvedHubId, hubLabel) {
+  const bound = readBinding();
+  if (!bound) return;
+  if (bound === resolvedHubId) return;
   const target = hubLabel ? `${hubLabel} (${resolvedHubId})` : resolvedHubId;
   console.error(
     [
-      `This worktree is locked to hub ${locked}, but the command resolved to ${target}.`,
+      `This worktree is bound to hub ${bound}, but the command resolved to ${target}.`,
       "",
       "This usually means a prompt was routed to the wrong worktree.",
-      "Confirm with the user before unlocking. To override:",
-      "  wayai unlock              # clear the lock for this worktree",
+      "Confirm with the user before unbinding. To override:",
+      "  wayai unbind             # clear the binding for this worktree",
       `  wayai use ${resolvedHubId}  # rebind this worktree to the new hub`
     ].join("\n")
   );
   process.exit(1);
 }
-function autoLockIfUnlocked(hubId) {
+function autoBindIfUnbound(hubId) {
   try {
-    if (readLock()) return false;
-    writeLock(hubId);
-    console.log(`Worktree locked to hub ${hubId} (run \`wayai unlock\` to clear).`);
+    if (readBinding()) return false;
+    writeBinding(hubId);
+    console.log(`Worktree bound to hub ${hubId} (run \`wayai unbind\` to clear).`);
     return true;
   } catch (err) {
-    console.warn(`  Warning: could not auto-lock worktree (${err instanceof Error ? err.message : String(err)})`);
+    console.warn(`  Warning: could not auto-bind worktree (${err instanceof Error ? err.message : String(err)})`);
     return false;
   }
 }
-function assertNoLockBlocksHubCreation(newHubName) {
-  const locked = readLock();
-  if (!locked) return;
+function assertNoBindingBlocksHubCreation(newHubName) {
+  const bound = readBinding();
+  if (!bound) return;
   console.error(
     [
-      `This worktree is locked to hub ${locked}, but you're about to create a new hub "${newHubName}" here.`,
+      `This worktree is bound to hub ${bound}, but you're about to create a new hub "${newHubName}" here.`,
       "",
       "This usually means a prompt was routed to the wrong worktree.",
-      "Confirm with the user before unlocking. To override:",
-      "  wayai unlock              # clear the lock for this worktree"
+      "Confirm with the user before unbinding. To override:",
+      "  wayai unbind             # clear the binding for this worktree"
     ].join("\n")
   );
   process.exit(1);
 }
-var LOCK_FILENAME, _lockPathCache;
-var init_hub_lock = __esm({
-  "src/lib/hub-lock.ts"() {
+var BINDING_FILENAME, LEGACY_BINDING_FILENAME, _gitDirCache;
+var init_hub_binding = __esm({
+  "src/lib/hub-binding.ts"() {
     "use strict";
     init_utils();
-    LOCK_FILENAME = "wayai-lock";
+    BINDING_FILENAME = "wayai-binding";
+    LEGACY_BINDING_FILENAME = "wayai-lock";
   }
 });
 
@@ -9017,11 +9038,11 @@ async function statusCommand(args2, pkg2) {
   const cachedCliLatest = readCachedLatest(CLI_CACHE_FILE);
   const cliLatest = cachedCliLatest && isNewerVersion(cachedCliLatest, pkg2.version) ? cachedCliLatest : null;
   const skill = buildSkillState();
-  let lockedHubId = null;
+  let boundHubId = null;
   try {
-    lockedHubId = readLock();
+    boundHubId = readBinding();
   } catch {
-    lockedHubId = null;
+    boundHubId = null;
   }
   if (!config) {
     const snapshot2 = {
@@ -9035,7 +9056,8 @@ async function statusCommand(args2, pkg2) {
       orgs: [],
       active_org: null,
       workspace,
-      worktree_lock: { hub_id: lockedHubId }
+      worktree_binding: { hub_id: boundHubId },
+      worktree_lock: { hub_id: boundHubId }
     };
     if (json) {
       console.log(JSON.stringify(snapshot2, null, 2));
@@ -9089,7 +9111,8 @@ async function statusCommand(args2, pkg2) {
     orgs,
     active_org: activeOrg,
     workspace,
-    worktree_lock: { hub_id: lockedHubId }
+    worktree_binding: { hub_id: boundHubId },
+    worktree_lock: { hub_id: boundHubId }
   };
   if (json) {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -9119,8 +9142,8 @@ async function statusCommand(args2, pkg2) {
   } else {
     console.log("No .wayai.yaml found \u2014 run `wayai init` to scope this repo to an organization.");
   }
-  if (lockedHubId) {
-    console.log(`Worktree lock: ${lockedHubId} (run \`wayai unlock\` to clear)`);
+  if (boundHubId) {
+    console.log(`Worktree binding: ${boundHubId} (run \`wayai unbind\` to clear)`);
   }
   if (tokenValid === true && accessToken) {
     await nudgeReportActions(config.api_url, accessToken);
@@ -9133,7 +9156,7 @@ var init_status = __esm({
     init_auth();
     init_repo_config();
     init_workspace();
-    init_hub_lock();
+    init_hub_binding();
     init_api_client();
     init_version_cache();
     init_skill_version();
@@ -10243,7 +10266,7 @@ async function pullCommand(args2) {
   }
   if (gitRoot) warnLayoutOnce(gitRoot);
   const { hubId, hubFolder: existingFolder } = resolveHubTarget(workspaceDir, hubSelector);
-  assertHubMatchesLock(hubId);
+  assertHubMatchesBinding(hubId);
   console.log("Fetching hub configuration...");
   const payload = await client.pull(hubId, organizationId);
   if (payload.hub_environment === "production") {
@@ -10315,7 +10338,7 @@ async function pullCommand(args2) {
     }
     if (cancelled) return;
   }
-  if (wroteFiles) autoLockIfUnlocked(hubId);
+  if (wroteFiles) autoBindIfUnbound(hubId);
 }
 async function downloadBinaryResourceFiles(hubFolder, payload) {
   const resources = payload.resources || [];
@@ -10355,7 +10378,7 @@ var init_pull = __esm({
     init_workspace();
     init_layout();
     init_repo_config();
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -10602,7 +10625,7 @@ async function pushSingleHub(client, hubId, hubFolder, autoConfirm, organization
     } else {
       console.log("No changes to push; folder renamed.");
     }
-    autoLockIfUnlocked(hubId);
+    autoBindIfUnbound(hubId);
     return true;
   }
   console.log("\nChanges to push:");
@@ -10618,7 +10641,7 @@ async function pushSingleHub(client, hubId, hubFolder, autoConfirm, organization
   const result = await client.push(hubId, localConfig, organizationId);
   printSyncResult(result);
   await syncAfterPush(client, hubId, hubFolder, organizationId);
-  autoLockIfUnlocked(hubId);
+  autoBindIfUnbound(hubId);
   return true;
 }
 function resolveWorkspaceDir() {
@@ -10677,7 +10700,7 @@ async function pushCommand(args2) {
   const newHubs = scanNewHubs(workspaceDir);
   const existing = selectExistingHub(workspaceDir, existingHubs, hubSelector, wsLabel);
   if (existing) {
-    assertHubMatchesLock(existing.hubId, path14.basename(existing.hubFolder));
+    assertHubMatchesBinding(existing.hubId, path14.basename(existing.hubFolder));
     await pushSingleHub(client, existing.hubId, existing.hubFolder, autoConfirm, organizationId);
     return;
   }
@@ -10696,7 +10719,7 @@ async function pushCommand(args2) {
     }
     process.exit(1);
   }
-  assertNoLockBlocksHubCreation(newHub.hubName);
+  assertNoBindingBlocksHubCreation(newHub.hubName);
   const hubType = newHub.hubType || "chat";
   console.log(`
 New hub detected: "${newHub.hubName}" (${hubType})`);
@@ -10738,7 +10761,7 @@ hub_environment: preview
 ${content}`;
   }
   fs12.writeFileSync(hubYamlPath, updated, "utf-8");
-  autoLockIfUnlocked(hubId);
+  autoBindIfUnbound(hubId);
   await pushSingleHub(client, hubId, newHub.hubFolder, autoConfirm, organizationId, { skipAgentRename: true });
 }
 var init_push = __esm({
@@ -10754,7 +10777,7 @@ var init_push = __esm({
     init_workspace();
     init_layout();
     init_repo_config();
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -10792,13 +10815,13 @@ async function useCommand(args2) {
     }
     hubId = match.hubId;
   }
-  const previous = readLock();
+  const previous = readBinding();
   if (previous === hubId) {
-    console.log(`Worktree already locked to ${hubId}.`);
+    console.log(`Worktree already bound to ${hubId}.`);
     return;
   }
   try {
-    writeLock(hubId);
+    writeBinding(hubId);
   } catch (err) {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -10806,13 +10829,13 @@ async function useCommand(args2) {
   if (previous) {
     console.log(`Worktree rebound: ${previous} \u2192 ${hubId}`);
   } else {
-    console.log(`Worktree locked to hub ${hubId}.`);
+    console.log(`Worktree bound to hub ${hubId}.`);
   }
 }
 var init_use = __esm({
   "src/commands/use.ts"() {
     "use strict";
-    init_hub_lock();
+    init_hub_binding();
     init_workspace();
     init_layout();
     init_utils();
@@ -10912,24 +10935,24 @@ var init_migrate = __esm({
   }
 });
 
-// src/commands/unlock.ts
-var unlock_exports = {};
-__export(unlock_exports, {
-  unlockCommand: () => unlockCommand
+// src/commands/unbind.ts
+var unbind_exports = {};
+__export(unbind_exports, {
+  unbindCommand: () => unbindCommand
 });
-async function unlockCommand(_args) {
-  const previous = readLock();
+async function unbindCommand(_args) {
+  const previous = readBinding();
   if (!previous) {
-    console.log("No worktree lock to clear.");
+    console.log("No worktree binding to clear.");
     return;
   }
-  clearLock();
-  console.log(`Worktree unlocked (was: ${previous}).`);
+  clearBinding();
+  console.log(`Worktree unbound (was: ${previous}).`);
 }
-var init_unlock = __esm({
-  "src/commands/unlock.ts"() {
+var init_unbind = __esm({
+  "src/commands/unbind.ts"() {
     "use strict";
-    init_hub_lock();
+    init_hub_binding();
   }
 });
 
@@ -17027,11 +17050,11 @@ var init_admin = __esm({
 
 // src/commands/report-create.ts
 import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { dirname as dirname7, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getCliVersion() {
   try {
-    const pkg2 = JSON.parse(readFileSync14(join19(__dirname, "..", "..", "package.json"), "utf-8"));
+    const pkg2 = JSON.parse(readFileSync14(join20(__dirname, "..", "..", "package.json"), "utf-8"));
     return `cli@${pkg2.version}`;
   } catch {
     return "cli@unknown";
@@ -17415,7 +17438,7 @@ var init_update = __esm({
 init_sentry();
 import { readFileSync as readFileSync15 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname8, join as join20 } from "path";
+import { dirname as dirname8, join as join21 } from "path";
 
 // src/lib/errors.ts
 init_api_client();
@@ -17544,7 +17567,7 @@ Run \`npx skills add wayai-pro/wayai-skill -y\` to update.`);
 
 // src/index.ts
 var __dirname2 = dirname8(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync15(join20(__dirname2, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync15(join21(__dirname2, "..", "package.json"), "utf-8"));
 var [, , command, ...args] = process.argv;
 var isBackgroundRefresh = command === REFRESH_COMMAND;
 var OWN_HELP_COMMANDS = /* @__PURE__ */ new Set(["eval", "admin", "report"]);
@@ -17600,9 +17623,11 @@ async function main() {
       await migrateCommand2(args);
       break;
     }
+    // `unlock` is the deprecated pre-rename alias for `unbind` (kept for back-compat).
+    case "unbind":
     case "unlock": {
-      const { unlockCommand: unlockCommand2 } = await Promise.resolve().then(() => (init_unlock(), unlock_exports));
-      await unlockCommand2(args);
+      const { unbindCommand: unbindCommand2 } = await Promise.resolve().then(() => (init_unbind(), unbind_exports));
+      await unbindCommand2(args);
       break;
     }
     case "send-message": {
@@ -17726,9 +17751,9 @@ Commands:
   push               Parse local files, show diff, sync to preview (creates hub if new)
   org create         Create a new organization (you become its owner)
   org <pull|push|diff>  Sync org-scoped resources as code (wayai-ws/org/)
-  use <hub>          Lock this worktree to a specific hub (UUID or folder name)
+  use <hub>          Bind this worktree to a specific hub (UUID or folder name)
   migrate            Move a legacy repo to the wayai-ws/{hubs,org} layout
-  unlock             Clear the worktree hub lock
+  unbind             Clear the worktree hub binding
   send-message       Send a test message to a preview hub
   conversations      List or inspect conversations
   analytics          Show analytics summary and metrics (use \`analytics query\` for structured ClickHouse queries)
@@ -17786,12 +17811,12 @@ Org-scoped mode:
   pull/push operate on the single hub in the workspace, or pass
   \`--hub <uuid|name>\` to disambiguate when multiple hubs exist.
 
-Worktree hub lock:
-  Each git checkout (main or linked worktree) can be locked to a single hub.
-  push/pull refuse to run against a different hub once locked. The lock is
-  auto-set on first successful pull (or new-hub creation) into an unlocked
-  checkout. Use \`wayai use <hub>\` to bind manually and \`wayai unlock\` to clear.
-  The lock lives at \`<git-dir>/wayai-lock\` and is naturally per-checkout.
+Worktree hub binding:
+  Each git checkout (main or linked worktree) can be bound to a single hub.
+  push/pull refuse to run against a different hub once bound. The binding is
+  auto-set on first successful pull (or new-hub creation) into an unbound
+  checkout. Use \`wayai use <hub>\` to bind manually and \`wayai unbind\` to clear.
+  The binding lives at \`<git-dir>/wayai-binding\` and is naturally per-checkout.
 
 Examples:
   wayai login