@odla-ai/cli 0.27.0 → 0.27.2

package/README.md

@@ -426,12 +426,12 @@ shown-once credential.
    `--email <account>` or `ODLA_USER_EMAIL`; the matching existing account must
    sign in, review the exact code, and approve it. Opening the URL alone does
    not claim the request.
-   When the code is displayed it opens the approval page in your browser —
-   including from scripted and agent-driven shells; only CI, SSH sessions, and
-   display-less hosts skip the launch. Pass `--open` to force it anyway, or
-   `--no-open` to suppress it. Browser launch is best-effort; the printed URL
-   and code always remain the fallback and agents must relay that URL to the
-   human. The started handshake is persisted privately under `.odla/`, so a
+   Every real CLI handshake prints exactly one canonical `/studio?code=…` URL
+   and attempts to open it — including from CI, SSH, display-less, scripted,
+   and agent-driven shells. Only `--no-open` suppresses the attempt. Browser
+   launch is best-effort: an agent with browser control must open that exact URL
+   immediately; otherwise it gives the URL to the human verbatim. The started
+   handshake is persisted privately under `.odla/`, so a
    run killed before approval loses nothing: rerunning resumes the same code.
    Outside an interactive terminal the approval wait is capped (90 seconds by
    default; `--wait <seconds>` overrides), and a still-pending handshake exits

package/REQUIREMENTS.md

@@ -38,13 +38,15 @@ Agnacl, but none should mention or special-case Agnacl.
   credential; agents must not request either from the human.
 - Unknown and never-signed-in accounts must not yield a claimable request, but
   the public response must not disclose account existence.
-- The approval code must be printed in a copyable, server-supplied verification
-  URL. Opening it must not claim the request; the matching signed-in user must
+- The approval code must be printed in the one canonical, copyable
+  `<platform>/studio?code=…` URL. Optional server URL hints must not create a
+  second CLI path. Opening it must not claim the request; the matching user must
   explicitly review that exact code before approval controls appear.
 - Only one claimed pending or approved-but-uncollected request may be active per
   user. Unclaimed issued codes must not occupy that slot.
-- Interactive provisioning should launch the browser to the approval page when
-  possible. `--open` should force launch; `--no-open` should suppress it.
+- Every real CLI handshake must attempt to open that canonical approval URL,
+  including in CI, SSH, display-less, and agent-driven shells. `--no-open` is
+  the only production suppression; failures must visibly repeat the manual action.
 - Cached developer tokens must be mode `0600`, gitignored, and reused until
   expiry.
 - Minted developer tokens must have a metadata-only inventory (owner, label,

package/dist/bin.cjs

@@ -28,18 +28,22 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/admin-ai.ts
-var import_node_process6 = __toESM(require("process"), 1);
+var import_node_process7 = __toESM(require("process"), 1);
 
 // src/token.ts
 var import_db = require("@odla-ai/db");
-var import_node_process3 = __toESM(require("process"), 1);
+var import_node_process4 = __toESM(require("process"), 1);
+
+// src/handshake-approval.ts
+var import_node_process2 = __toESM(require("process"), 1);
 
 // src/approval-prompt.ts
 function approvalLines(prompt) {
   const lines = [""];
   lines.push(
-    `\u23F8  Human approval required${prompt.purpose ? ` to ${prompt.purpose}` : ""} \u2014 code ${prompt.userCode}, ${prompt.minutesLeft}m left.`
+    `\u23F8  AUTHORIZATION REQUIRED${prompt.purpose ? ` to ${prompt.purpose}` : ""} \u2014 code ${prompt.userCode}, ${prompt.minutesLeft}m left.`
   );
+  lines.push("   OPEN THIS URL IN THE APPROVER'S SIGNED-IN BROWSER NOW:");
   lines.push("");
   lines.push(`   ${prompt.approvalUrl}`);
   lines.push("");
@@ -53,8 +57,9 @@ function approvalLines(prompt) {
     lines.push(`   No browser was opened (${prompt.browserSkipped}).`);
   }
   lines.push("");
-  lines.push("   AGENTS: relay the URL above to the human verbatim, now, before waiting.");
-  lines.push("   You cannot approve it yourself \u2014 the grant is issued to you, not by you.");
+  lines.push("   AGENTS: use browser control to open the URL above now; do not wait silently.");
+  lines.push("   If browser control is unavailable, give the exact URL to the human verbatim.");
+  lines.push("   You cannot approve it yourself, retry it away, or start a substitute handshake.");
   lines.push("");
   return lines;
 }
@@ -68,10 +73,69 @@ function reminderLines(prompt) {
   ];
 }
 
+// src/open.ts
+var import_node_child_process = require("child_process");
+var import_node_process = __toESM(require("process"), 1);
+async function openUrl(url, options = {}) {
+  const command = openerFor(options.platform ?? import_node_process.default.platform);
+  const doSpawn = options.spawnImpl ?? import_node_child_process.spawn;
+  await new Promise((resolve13, reject) => {
+    const child = doSpawn(command.cmd, [...command.args, url], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve13();
+    });
+  });
+}
+function openerFor(platform) {
+  if (platform === "darwin") return { cmd: "open", args: [] };
+  if (platform === "win32") return { cmd: "cmd", args: ["/c", "start", ""] };
+  return { cmd: "xdg-open", args: [] };
+}
+
+// src/handshake-approval.ts
+function approvalBrowser(options, host = {}) {
+  if (options.open === false) return { open: false, reason: "disabled by --no-open" };
+  if (options.open === true) return { open: true, mode: "forced" };
+  const env = host.env ?? import_node_process2.default.env;
+  if (env.VITEST || env.NODE_ENV === "test") {
+    return { open: false, reason: "test environment" };
+  }
+  return { open: true, mode: "auto" };
+}
+async function presentHandshakeApproval(out, prompt, options) {
+  const browser = approvalBrowser(options);
+  printApproval(out, {
+    ...prompt,
+    browserAttempted: browser.open,
+    browserSkipped: browser.reason
+  });
+  if (!browser.open) {
+    out.error(`auth: browser launch skipped (${browser.reason}) \u2014 open the URL above manually`);
+    return;
+  }
+  try {
+    await (options.openApprovalUrl ?? openUrl)(prompt.approvalUrl);
+    out.error("auth: browser open requested for the approval URL above");
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    out.error(`auth: browser did not open (${reason}) \u2014 OPEN THE URL ABOVE NOW`);
+  }
+}
+function handshakeUrl(platformUrl, userCode) {
+  const url = new URL("/studio", platformUrl);
+  url.searchParams.set("code", userCode);
+  return url.toString();
+}
+
 // src/handshake-state.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-var import_node_process = __toESM(require("process"), 1);
+var import_node_process3 = __toESM(require("process"), 1);
 
 // src/local.ts
 var import_node_fs = require("fs");
@@ -207,9 +271,13 @@ var RESUME_MARGIN_MS = 5e3;
 function readPendingHandshake(path, platform, email) {
   const pending = readJsonFile(path);
   if (!pending || pending.platform !== platform || pending.email !== email) return null;
-  if (typeof pending.userCode !== "string" || typeof pending.deviceCode !== "string" || typeof pending.approvalUrl !== "string") return null;
+  if (typeof pending.userCode !== "string" || typeof pending.deviceCode !== "string") return null;
   if (typeof pending.expiresAt !== "number" || pending.expiresAt <= Date.now() + RESUME_MARGIN_MS) return null;
-  return { interval: 3, ...pending };
+  return {
+    interval: typeof pending.interval === "number" ? pending.interval : 3,
+    ...pending,
+    approvalUrl: handshakeUrl(platform, pending.userCode)
+  };
 }
 function writePendingHandshake(path, pending) {
   writePrivateJson(path, pending);
@@ -235,47 +303,23 @@ function approvalReminder(out, pending, periodMs = 3e4) {
   timer.unref?.();
   return () => clearInterval(timer);
 }
-function handshakeWaitMs(waitSeconds, interactive = import_node_process.default.stdout.isTTY === true) {
+function handshakeWaitMs(waitSeconds, interactive = import_node_process3.default.stdout.isTTY === true) {
   if (waitSeconds !== void 0) return waitSeconds * 1e3;
   return interactive ? void 0 : 9e4;
 }
 
-// src/open.ts
-var import_node_child_process = require("child_process");
-var import_node_process2 = __toESM(require("process"), 1);
-async function openUrl(url, options = {}) {
-  const command = openerFor(options.platform ?? import_node_process2.default.platform);
-  const doSpawn = options.spawnImpl ?? import_node_child_process.spawn;
-  await new Promise((resolve13, reject) => {
-    const child = doSpawn(command.cmd, [...command.args, url], {
-      stdio: "ignore",
-      detached: true
-    });
-    child.once("error", reject);
-    child.once("spawn", () => {
-      child.unref();
-      resolve13();
-    });
-  });
-}
-function openerFor(platform) {
-  if (platform === "darwin") return { cmd: "open", args: [] };
-  if (platform === "win32") return { cmd: "cmd", args: ["/c", "start", ""] };
-  return { cmd: "xdg-open", args: [] };
-}
-
 // src/token.ts
 async function getDeveloperToken(cfg, options, doFetch, out) {
   if (options.token) return options.token;
   const audience = platformAudience(cfg.platformUrl);
-  if (import_node_process3.default.env.ODLA_DEV_TOKEN) {
-    const declared = import_node_process3.default.env.ODLA_DEV_TOKEN_AUDIENCE;
+  if (import_node_process4.default.env.ODLA_DEV_TOKEN) {
+    const declared = import_node_process4.default.env.ODLA_DEV_TOKEN_AUDIENCE;
     if (declared) {
       if (platformAudience(declared) !== audience) throw new Error("ODLA_DEV_TOKEN_AUDIENCE does not match the configured platform");
     } else if (audience !== "https://odla.ai") {
       throw new Error("ODLA_DEV_TOKEN_AUDIENCE is required for a non-default platform");
     }
-    return import_node_process3.default.env.ODLA_DEV_TOKEN;
+    return import_node_process4.default.env.ODLA_DEV_TOKEN;
   }
   const cached = readJsonFile(cfg.local.tokenFile);
   if (cached?.token && cached.platform === audience && (cached.expiresAt ?? 0) > Date.now() + 6e4) {
@@ -288,7 +332,6 @@ async function getDeveloperToken(cfg, options, doFetch, out) {
     doFetch,
     out,
     audience,
-    browser: approvalBrowser(options),
     email: handshakeEmail(options.email, cached?.platform === audience ? cached.email : void 0),
     pendingFile: handshakeFile(cfg)
   };
@@ -304,7 +347,12 @@ async function resumePendingHandshake(ctx, waitMs) {
   if (!pending) return null;
   ctx.out.error("");
   ctx.out.error(`auth: resuming pending handshake \u2014 ${approvalHint(pending)}`);
-  await launchApproval(ctx, pending.approvalUrl);
+  await presentHandshakeApproval(ctx.out, {
+    userCode: pending.userCode,
+    approvalUrl: pending.approvalUrl,
+    minutesLeft: Math.max(1, Math.floor((pending.expiresAt - Date.now()) / 6e4)),
+    purpose: `sign this terminal in as ${ctx.email}`
+  }, ctx.options);
   ctx.out.error("");
   const stopReminder = approvalReminder(ctx.out, pending);
   try {
@@ -338,10 +386,11 @@ async function freshHandshake(ctx, waitMs) {
       endpoint: ctx.cfg.platformUrl,
       email: ctx.email,
       label: `${ctx.cfg.app.id} provisioner`,
+      projectIds: [ctx.cfg.app.id],
       fetch: ctx.doFetch,
       waitMs,
-      onCode: async ({ userCode, deviceCode, expiresIn, interval, verificationUriComplete }) => {
-        const approvalUrl = verificationUriComplete ?? handshakeUrl(ctx.cfg.platformUrl, userCode);
+      onCode: async ({ userCode, deviceCode, expiresIn, interval }) => {
+        const approvalUrl = handshakeUrl(ctx.audience, userCode);
         started = {
           platform: ctx.audience,
           email: ctx.email,
@@ -352,15 +401,12 @@ async function freshHandshake(ctx, waitMs) {
           expiresAt: Date.now() + expiresIn * 1e3
         };
         writePendingHandshake(ctx.pendingFile, started);
-        printApproval(ctx.out, {
+        await presentHandshakeApproval(ctx.out, {
           userCode,
           approvalUrl,
           minutesLeft: Math.floor(expiresIn / 60),
-          purpose: `sign this terminal in as ${ctx.email}`,
-          browserAttempted: ctx.browser.open,
-          browserSkipped: ctx.browser.reason
-        });
-        await launchApproval(ctx, approvalUrl);
+          purpose: `sign this terminal in as ${ctx.email}`
+        }, ctx.options);
         stopReminder = approvalReminder(ctx.out, started);
       }
     });
@@ -375,18 +421,6 @@ async function freshHandshake(ctx, waitMs) {
     stopReminder?.();
   }
 }
-async function launchApproval(ctx, approvalUrl) {
-  if (ctx.browser.open) {
-    try {
-      await (ctx.options.openApprovalUrl ?? openUrl)(approvalUrl);
-      ctx.out.error(`auth: asked the OS to open a browser${ctx.browser.mode === "auto" ? " (auto)" : ""} \u2014 if no tab appeared, use the URL above`);
-    } catch (err) {
-      ctx.out.error(`auth: could not open browser (${err instanceof Error ? err.message : String(err)})`);
-    }
-  } else if (ctx.browser.reason) {
-    ctx.out.error(`auth: browser launch skipped (${ctx.browser.reason}) \u2014 show the human the URL above`);
-  }
-}
 function stillPending(pending, email) {
   return new import_db.OdlaError(
     "handshake_pending",
@@ -395,30 +429,12 @@ function stillPending(pending, email) {
   );
 }
 function handshakeEmail(value2, cached) {
-  const email = (value2 ?? import_node_process3.default.env.ODLA_USER_EMAIL ?? cached ?? "").trim().toLowerCase();
+  const email = (value2 ?? import_node_process4.default.env.ODLA_USER_EMAIL ?? cached ?? "").trim().toLowerCase();
   if (email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
     throw new Error("a fresh odla handshake requires --email <account> or ODLA_USER_EMAIL");
   }
   return email;
 }
-function approvalBrowser(options, host = {}) {
-  if (options.open === true) return { open: true, mode: "forced" };
-  if (options.open === false) return { open: false, reason: "disabled by --no-open" };
-  const env = host.env ?? import_node_process3.default.env;
-  if (env.VITEST || env.NODE_ENV === "test") return { open: false, reason: "test environment" };
-  if (env.CI) return { open: false, reason: "CI environment" };
-  if (env.SSH_CONNECTION || env.SSH_TTY) return { open: false, reason: "SSH session; pass --open to force" };
-  const platform = host.platform ?? import_node_process3.default.platform;
-  if (platform !== "darwin" && platform !== "win32" && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
-    return { open: false, reason: "no graphical display; pass --open to force" };
-  }
-  return { open: true, mode: "auto" };
-}
-function handshakeUrl(platformUrl, userCode) {
-  const url = new URL("/studio", platformUrl);
-  url.searchParams.set("code", userCode);
-  return url.toString();
-}
 function platformAudience(value2) {
   let url;
   try {
@@ -437,12 +453,12 @@ function platformAudience(value2) {
 }
 
 // src/secret-input.ts
-var import_node_process4 = __toESM(require("process"), 1);
+var import_node_process5 = __toESM(require("process"), 1);
 var MAX_BYTES = 64 * 1024;
 async function secretInputValue(options, kind = "credential") {
   if (options.fromEnv && options.stdin) throw new Error("choose exactly one of --from-env or --stdin");
   let value2;
-  if (options.fromEnv) value2 = import_node_process4.default.env[options.fromEnv];
+  if (options.fromEnv) value2 = import_node_process5.default.env[options.fromEnv];
   else if (options.stdin) value2 = await (options.readStdin ?? (() => readSecretStream(kind)))();
   else throw new Error(`${kind} input required: use --from-env <NAME> or --stdin; values are never accepted as arguments`);
   value2 = value2?.replace(/[\r\n]+$/, "");
@@ -450,7 +466,7 @@ async function secretInputValue(options, kind = "credential") {
   if (new TextEncoder().encode(value2).byteLength > MAX_BYTES) throw new Error(`${kind} exceeds 64 KiB`);
   return value2;
 }
-async function readSecretStream(kind, stream = import_node_process4.default.stdin) {
+async function readSecretStream(kind, stream = import_node_process5.default.stdin) {
   let value2 = "";
   for await (const chunk of stream) {
     value2 += String(chunk);
@@ -462,7 +478,7 @@ async function readSecretStream(kind, stream = import_node_process4.default.stdi
 // src/admin-ai-auth.ts
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
-var import_node_process5 = __toESM(require("process"), 1);
+var import_node_process6 = __toESM(require("process"), 1);
 var import_db2 = require("@odla-ai/db");
 async function getScopedPlatformToken(options) {
   return resolveAdminPlatformToken(options);
@@ -470,7 +486,7 @@ async function getScopedPlatformToken(options) {
 async function resolveAdminPlatformToken(options) {
   const audience = platformAudience(options.platform);
   if (options.token) return options.token;
-  const fromEnv = import_node_process5.default.env.ODLA_ADMIN_TOKEN;
+  const fromEnv = import_node_process6.default.env.ODLA_ADMIN_TOKEN;
   if (fromEnv) return audienceBoundEnvToken(fromEnv, audience);
   return scopedToken(
     audience,
@@ -482,7 +498,7 @@ async function resolveAdminPlatformToken(options) {
 }
 function audienceBoundEnvToken(token, platform) {
   const audience = platformAudience(platform);
-  const declared = import_node_process5.default.env.ODLA_ADMIN_TOKEN_AUDIENCE;
+  const declared = import_node_process6.default.env.ODLA_ADMIN_TOKEN_AUDIENCE;
   if (declared) {
     if (platformAudience(declared) !== audience) throw new Error("ODLA_ADMIN_TOKEN_AUDIENCE does not match the configured platform");
   } else if (audience !== "https://odla.ai") {
@@ -507,7 +523,7 @@ var SCOPE_PURPOSE = {
 };
 async function scopedToken(platform, scope, options, doFetch, out) {
   const audience = platformAudience(platform);
-  const rootDir = options.rootDir ?? import_node_process5.default.cwd();
+  const rootDir = options.rootDir ?? import_node_process6.default.cwd();
   const tokenFile = options.tokenFile ?? (0, import_node_path3.join)(rootDir, ".odla/admin-token.local.json");
   const cache = options.cache === false ? null : readJsonFile(tokenFile);
   const cached = cache?.platform === audience ? cache.tokens?.[scope] : void 0;
@@ -522,21 +538,14 @@ async function scopedToken(platform, scope, options, doFetch, out) {
     label: options.label ?? `odla CLI (${scope})`,
     scopes: [scope],
     fetch: doFetch,
-    onCode: async ({ userCode, expiresIn, verificationUriComplete }) => {
-      const approvalUrl = verificationUriComplete ?? handshakeUrl(audience, userCode);
-      const browser = approvalBrowser({ open: options.open });
-      printApproval(out, {
+    onCode: async ({ userCode, expiresIn }) => {
+      await presentHandshakeApproval(out, {
         userCode,
-        approvalUrl,
+        approvalUrl: handshakeUrl(audience, userCode),
         minutesLeft: Math.floor(expiresIn / 60),
         purpose: SCOPE_PURPOSE[scope] ?? `use ${scope}`,
-        approver: scope.startsWith("app:") ? "A signed-in app owner" : "A signed-in odla platform admin",
-        browserAttempted: browser.open,
-        browserSkipped: browser.reason
-      });
-      if (browser.open) {
-        await (options.openApprovalUrl ?? openUrl)(approvalUrl).catch(() => void 0);
-      }
+        approver: scope.startsWith("app:") ? "A signed-in app owner" : "A signed-in odla platform admin"
+      }, options);
     }
   });
   if (options.cache !== false) {
@@ -719,7 +728,7 @@ function isRecord2(value2) {
 
 // src/admin-ai.ts
 async function adminAi(options) {
-  const platform = platformAudience(options.platform ?? import_node_process6.default.env.ODLA_PLATFORM ?? "https://odla.ai");
+  const platform = platformAudience(options.platform ?? import_node_process7.default.env.ODLA_PLATFORM ?? "https://odla.ai");
   const doFetch = options.fetch ?? fetch;
   const out = options.stdout ?? console;
   const usageQuery = options.action === "usage" ? adminAiUsageQuery(options) : void 0;
@@ -976,7 +985,7 @@ function addOption(options, name, value2) {
 // src/operator-context.ts
 var import_node_fs6 = require("fs");
 var import_node_path6 = require("path");
-var import_node_process8 = __toESM(require("process"), 1);
+var import_node_process9 = __toESM(require("process"), 1);
 
 // src/config.ts
 var import_node_fs4 = require("fs");
@@ -1282,15 +1291,15 @@ function unique2(values) {
 var import_node_fs5 = require("fs");
 var import_node_os = require("os");
 var import_node_path5 = require("path");
-var import_node_process7 = __toESM(require("process"), 1);
+var import_node_process8 = __toESM(require("process"), 1);
 function operatorProfileFile() {
   return (0, import_node_path5.resolve)(
-    clean(import_node_process7.default.env.ODLA_CONTEXT_FILE) ?? (0, import_node_path5.join)((0, import_node_os.homedir)(), ".odla", "contexts.json")
+    clean(import_node_process8.default.env.ODLA_CONTEXT_FILE) ?? (0, import_node_path5.join)((0, import_node_os.homedir)(), ".odla", "contexts.json")
   );
 }
 function resolveOperatorProfile(parsed) {
   const fromFlag = clean(stringOpt(parsed.options.context));
-  const fromEnvironment = clean(import_node_process7.default.env.ODLA_CONTEXT);
+  const fromEnvironment = clean(import_node_process8.default.env.ODLA_CONTEXT);
   const name = fromFlag ?? fromEnvironment ?? null;
   const file = operatorProfileFile();
   if (!name) {
@@ -1419,13 +1428,13 @@ async function resolveOperatorContext(parsed, options = {}) {
   }
   const loaded = hasConfig ? await loadProjectConfig(configArgument) : void 0;
   const platformFlag = clean2(stringOpt(parsed.options.platform));
-  const platformEnvironment = clean2(import_node_process8.default.env.ODLA_PLATFORM_URL);
+  const platformEnvironment = clean2(import_node_process9.default.env.ODLA_PLATFORM_URL);
   const platformValue = platformAudience(
     platformFlag ?? platformEnvironment ?? profile.value?.platform ?? loaded?.platformUrl ?? DEFAULT_PLATFORM2
   );
   const platformSource = platformFlag ? "flag" : platformEnvironment ? "environment" : profile.value ? "profile" : loaded ? "config" : "default";
   const appFlag = clean2(stringOpt(parsed.options.app));
-  const appEnvironment = clean2(import_node_process8.default.env.ODLA_APP_ID);
+  const appEnvironment = clean2(import_node_process9.default.env.ODLA_APP_ID);
   const appValue = appFlag ?? appEnvironment ?? profile.value?.app ?? loaded?.app.id ?? null;
   const appSource = appFlag ? "flag" : appEnvironment ? "environment" : profile.value?.app ? "profile" : loaded ? "config" : "unresolved";
   if (appValue) assertOperatorName(appValue, "app");
@@ -1435,16 +1444,16 @@ async function resolveOperatorContext(parsed, options = {}) {
     );
   }
   const envFlag = clean2(stringOpt(parsed.options.env));
-  const envEnvironment = clean2(import_node_process8.default.env.ODLA_ENV);
+  const envEnvironment = clean2(import_node_process9.default.env.ODLA_ENV);
   const environmentValue = envFlag ?? envEnvironment ?? profile.value?.environment ?? options.defaultEnvironment ?? null;
   const environmentSource = envFlag ? "flag" : envEnvironment ? "environment" : profile.value?.environment ? "profile" : options.defaultEnvironment ? "default" : "unresolved";
   if (environmentValue) {
     assertOperatorName(environmentValue, "environment");
   }
-  const rootDir = loaded?.rootDir ?? import_node_process8.default.cwd();
+  const rootDir = loaded?.rootDir ?? import_node_process9.default.cwd();
   const profileCredentials = operatorCredentialFiles(profile);
-  const tokenFile = clean2(import_node_process8.default.env.ODLA_DEV_TOKEN_FILE) ? (0, import_node_path6.resolve)(import_node_process8.default.env.ODLA_DEV_TOKEN_FILE) : profile.name ? profileCredentials.developer : loaded?.local.tokenFile ?? profileCredentials.developer;
-  const scopedTokenFile = clean2(import_node_process8.default.env.ODLA_ADMIN_TOKEN_FILE) ? (0, import_node_path6.resolve)(import_node_process8.default.env.ODLA_ADMIN_TOKEN_FILE) : profile.name ? profileCredentials.scoped : loaded ? (0, import_node_path6.join)(loaded.rootDir, ".odla", "admin-token.local.json") : profileCredentials.scoped;
+  const tokenFile = clean2(import_node_process9.default.env.ODLA_DEV_TOKEN_FILE) ? (0, import_node_path6.resolve)(import_node_process9.default.env.ODLA_DEV_TOKEN_FILE) : profile.name ? profileCredentials.developer : loaded?.local.tokenFile ?? profileCredentials.developer;
+  const scopedTokenFile = clean2(import_node_process9.default.env.ODLA_ADMIN_TOKEN_FILE) ? (0, import_node_path6.resolve)(import_node_process9.default.env.ODLA_ADMIN_TOKEN_FILE) : profile.name ? profileCredentials.scoped : loaded ? (0, import_node_path6.join)(loaded.rootDir, ".odla", "admin-token.local.json") : profileCredentials.scoped;
   const cfg = loaded ? {
     ...loaded,
     platformUrl: platformValue,
@@ -8496,13 +8505,13 @@ async function codeCommand(parsed, dependencies) {
 }
 
 // src/operator-credentials.ts
-var import_node_process9 = __toESM(require("process"), 1);
+var import_node_process10 = __toESM(require("process"), 1);
 function developerTokenStatus(context, parsed, now = Date.now()) {
   const cached = readJsonFile(context.cfg.local.tokenFile);
   const cacheStatus = !cached?.token ? "missing" : cached.platform !== context.platform.value ? "other-platform" : (cached.expiresAt ?? 0) <= now + 6e4 ? "expired" : "valid";
   const source = clean3(
     stringOpt(parsed.options.token)
-  ) ? "flag" : clean3(import_node_process9.default.env.ODLA_DEV_TOKEN) ? "environment" : cacheStatus === "valid" ? "cache" : "missing";
+  ) ? "flag" : clean3(import_node_process10.default.env.ODLA_DEV_TOKEN) ? "environment" : cacheStatus === "valid" ? "cache" : "missing";
   return {
     source,
     cacheFile: context.cfg.local.tokenFile,
@@ -8876,15 +8885,16 @@ Safety:
   the metadata file. Flags and specific ODLA_* scope variables beat a selected
   context, which beats project config. There is no ambient current context.
   "context show" reports only provenance and cache state and never authenticates.
-  Provision opens the approval page in your browser automatically whenever the
-  machine can show one, including agent-driven runs; only CI, SSH, and
-  display-less hosts skip it. Use --open to force or --no-open to suppress.
-  Browser launch is best-effort: the printed approval URL is authoritative and
-  agents must relay it to the human verbatim. A started handshake is persisted
+  Every real CLI handshake prints one canonical /studio?code= approval URL and
+  attempts to open it \u2014 including in CI, SSH, display-less, and agent-driven
+  shells. Only --no-open suppresses the attempt. Browser launch is best-effort:
+  agents with browser control must open that exact URL immediately; otherwise
+  they must give it to the human verbatim. A started handshake is persisted
   under .odla/, so a command killed mid-wait loses nothing \u2014 rerunning resumes
   the same code. Outside an interactive terminal the wait is capped (90s by
   default, --wait <seconds> to change); a still-pending handshake then exits
-  with code 75: relay the URL, wait for approval, and re-run to collect.
+  with code 75: open the same URL (or relay it if browser control is unavailable),
+  wait for approval, and re-run to collect.
   A fresh device handshake requires --email <odla-account> or ODLA_USER_EMAIL.
   The email is a non-secret identity hint: never provide a password or session
   token. The matching account must already exist, be signed in, explicitly
@@ -10293,7 +10303,7 @@ async function read2(url, headers, doFetch) {
 // src/provision.ts
 var import_apps12 = require("@odla-ai/apps");
 var import_ai3 = require("@odla-ai/ai");
-var import_node_process10 = __toESM(require("process"), 1);
+var import_node_process11 = __toESM(require("process"), 1);
 
 // src/integration-provision.ts
 var import_db3 = require("@odla-ai/db");
@@ -10600,7 +10610,7 @@ ${env}: credentials are already saved; retry "odla-ai secrets push --env ${env}$
       await provisionIntegrationSeeds(doFetch, cfg.dbEndpoint, tenantId, dbKey, database.integrations, env, out);
     }
     if (cfg.services.includes("ai") && cfg.ai?.provider && cfg.ai.keyEnv) {
-      const key = import_node_process10.default.env[cfg.ai.keyEnv];
+      const key = import_node_process11.default.env[cfg.ai.keyEnv];
       if (key) {
         const secretName = cfg.ai.secretName ?? defaultSecretName(cfg.ai.provider);
         await (0, import_ai3.putSecret)({ endpoint: cfg.dbEndpoint, token, fetch: doFetch }, tenantId, secretName, key);
@@ -10642,7 +10652,7 @@ ${env}: credentials are already saved; retry "odla-ai secrets push --env ${env}$
 
 // src/record.ts
 var import_node_fs16 = require("fs");
-var import_node_process11 = __toESM(require("process"), 1);
+var import_node_process12 = __toESM(require("process"), 1);
 
 // src/surface.ts
 var PM_ACTIONS = {
@@ -10791,7 +10801,7 @@ function invocationPath(words2) {
 
 // src/record.ts
 function recordInvocation(parsed) {
-  const file = import_node_process11.default.env.ODLA_CLI_RECORD;
+  const file = import_node_process12.default.env.ODLA_CLI_RECORD;
   if (!file) return;
   try {
     const entry = {
@@ -11463,9 +11473,9 @@ var import_node_child_process8 = require("child_process");
 var import_node_fs20 = require("fs");
 var import_node_os5 = require("os");
 var import_node_path18 = require("path");
-var import_node_process12 = __toESM(require("process"), 1);
+var import_node_process13 = __toESM(require("process"), 1);
 var EDITOR_ENV = ["ODLA_EDITOR", "VISUAL", "EDITOR"];
-function resolveEditor(env = import_node_process12.default.env) {
+function resolveEditor(env = import_node_process13.default.env) {
   for (const name of EDITOR_ENV) {
     const value2 = env[name];
     if (value2 && value2.trim()) return value2.trim();
@@ -11479,8 +11489,8 @@ function defaultRun(command, path) {
   return result.status ?? 0;
 }
 function editText(initial, slug, deps = {}) {
-  const env = deps.env ?? import_node_process12.default.env;
-  const interactive = deps.interactive ?? (() => Boolean(import_node_process12.default.stdin.isTTY));
+  const env = deps.env ?? import_node_process13.default.env;
+  const interactive = deps.interactive ?? (() => Boolean(import_node_process13.default.stdin.isTTY));
   const editor = resolveEditor(env);
   if (!editor)
     throw new Error(