deepline 0.1.32 → 0.1.33

package/dist/cli/index.js

@@ -67,19 +67,12 @@ var ConfigError = class extends DeeplineError {
 };
 
 // src/config.ts
+var HOST_URL_ENV = "DEEPLINE_HOST_URL";
+var API_KEY_ENV = "DEEPLINE_API_KEY";
 var PROD_URL = "https://code.deepline.com";
 var DEFAULT_TIMEOUT = 6e4;
 var DEFAULT_MAX_RETRIES = 3;
-var ACTIVE_DEEPLINE_ENV_FILE = ".env.deepline";
-function isProdBaseUrl(baseUrl) {
-  return baseUrl.trim().replace(/\/$/, "") === PROD_URL;
-}
-function profileNameForBaseUrl(baseUrl) {
-  return isProdBaseUrl(baseUrl) ? "prod" : "dev";
-}
-function projectEnvStartDir() {
-  return process.env.DEEPLINE_PROJECT_ENV_DIR?.trim() || process.cwd();
-}
+var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
 function baseUrlSlug(baseUrl) {
   let url;
   try {
@@ -88,7 +81,7 @@ function baseUrlSlug(baseUrl) {
     return "unknown";
   }
   const host = url.hostname || "unknown";
-  const port = url.port ? parseInt(url.port, 10) : null;
+  const port = url.port ? Number.parseInt(url.port, 10) : null;
   let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
   if (port && port !== 80 && port !== 443) {
     slug = `${slug}-${port}`;
@@ -115,79 +108,52 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestEnvFile(names, startDir = process.cwd()) {
+function findNearestEnvFile(name, startDir = process.cwd()) {
   let current = (0, import_node_path.resolve)(startDir);
   while (true) {
-    for (const name of names) {
-      const filePath = (0, import_node_path.join)(current, name);
-      if ((0, import_node_fs.existsSync)(filePath)) return filePath;
-    }
+    const filePath = (0, import_node_path.join)(current, name);
+    if ((0, import_node_fs.existsSync)(filePath)) return filePath;
     const parent = (0, import_node_path.dirname)(current);
     if (parent === current) return null;
     current = parent;
   }
 }
-function findNearestEnv(names, startDir = process.cwd()) {
-  const filePath = findNearestEnvFile(names, startDir);
+function loadProjectDeeplineEnv(startDir = process.cwd()) {
+  const filePath = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
   return filePath ? parseEnvFile(filePath) : {};
 }
-function findNearestWorktreeEnv(startDir = process.cwd()) {
-  return findNearestEnv([".env.worktree"], startDir);
-}
-function resolveProfileEnvFileNames() {
-  const explicitProfile = process.env.DEEPLINE_ENV_PROFILE?.trim() || process.env.DEEPLINE_PROFILE?.trim() || "";
-  const names = [];
-  if (explicitProfile) names.push(`.env.deepline.${explicitProfile}`);
-  const nodeEnv = process.env.NODE_ENV?.trim();
-  if (nodeEnv === "production") names.push(".env.deepline.prod");
-  else if (nodeEnv === "staging") names.push(".env.deepline.staging");
-  names.push(ACTIVE_DEEPLINE_ENV_FILE);
-  return names;
-}
-function resolveProjectAppEnvFileNames() {
-  const nodeEnv = process.env.NODE_ENV?.trim();
-  const names = [];
-  if (nodeEnv === "production") names.push(".env.prod");
-  if (nodeEnv === "staging") names.push(".env.staging");
-  names.push(".env.local", ".env");
-  return names;
-}
-function resolveBaseUrlFromEnvValues(env) {
-  return env.DEEPLINE_ORIGIN_URL?.trim() || env.DEEPLINE_API_BASE_URL?.trim() || "";
-}
-function loadProjectDeeplineEnv() {
-  return findNearestEnv(resolveProfileEnvFileNames(), projectEnvStartDir());
-}
-function loadProjectAppEnv() {
-  return findNearestEnv(resolveProjectAppEnvFileNames(), projectEnvStartDir());
-}
-function normalizeWorktreeBaseUrl(baseUrl, worktreeEnv = findNearestWorktreeEnv()) {
-  const trimmed = baseUrl.trim().replace(/\/$/, "");
-  if (!trimmed) return trimmed;
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
-    if (parsed.hostname.endsWith(".localhost") && parsed.port === "1355") {
-      const port = worktreeEnv.WORKTREE_APP_PORT || worktreeEnv.PORT;
-      if (port) return `${parsed.protocol}//localhost:${port}`;
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "";
     }
+    return parsed.toString().replace(/\/+$/, "");
   } catch {
+    return "";
+  }
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
   }
-  return trimmed;
+  return "";
 }
-function resolveWorktreeBaseUrl() {
-  const worktreeEnv = findNearestWorktreeEnv();
-  const declared = worktreeEnv.DEEPLINE_API_BASE_URL || worktreeEnv.WORKTREE_PUBLIC_APP_URL || worktreeEnv.APP_URL || "";
-  if (declared) return normalizeWorktreeBaseUrl(declared, worktreeEnv);
-  const port = worktreeEnv.WORKTREE_APP_PORT || worktreeEnv.PORT || "";
-  return port ? `http://localhost:${port}` : "";
+function sdkCliConfigDir(baseUrl) {
+  const home = process.env.HOME?.trim() || (0, import_node_os.homedir)();
+  return (0, import_node_path.join)(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
 }
 function sdkCliEnvFilePath(baseUrl) {
-  const home = process.env.HOME?.trim() || (0, import_node_os.homedir)();
-  return (0, import_node_path.join)(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL), ".env");
+  return (0, import_node_path.join)(sdkCliConfigDir(baseUrl), ".env");
 }
 function loadCliEnv(baseUrl = PROD_URL) {
-  const envPath = sdkCliEnvFilePath(baseUrl);
-  return parseEnvFile(envPath);
+  return parseEnvFile(sdkCliEnvFilePath(baseUrl));
+}
+function hostConfigDirPath(baseUrl) {
+  return sdkCliConfigDir(baseUrl);
 }
 function hostEnvFilePath(baseUrl) {
   return sdkCliEnvFilePath(baseUrl);
@@ -198,9 +164,10 @@ function saveHostEnvValues(baseUrl, values) {
   if (!(0, import_node_fs.existsSync)(dir)) {
     (0, import_node_fs.mkdirSync)(dir, { recursive: true });
   }
-  const existing = (0, import_node_fs.existsSync)(filePath) ? parseEnvFile(filePath) : {};
+  const existing = parseEnvFile(filePath);
   const merged = { ...existing, ...values };
-  const lines = Object.entries(merged).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${value}`);
+  const allowedKeys = /* @__PURE__ */ new Set([HOST_URL_ENV, API_KEY_ENV]);
+  const lines = Object.entries(merged).filter(([key, value]) => allowedKeys.has(key) && value !== "").map(([key, value]) => `${key}=${value}`);
   (0, import_node_fs.writeFileSync)(filePath, `${lines.join("\n")}
 `, "utf-8");
 }
@@ -208,31 +175,36 @@ function loadGlobalCliEnv() {
   return loadCliEnv(PROD_URL);
 }
 function autoDetectBaseUrl() {
-  const envOrigin = process.env.DEEPLINE_ORIGIN_URL?.trim();
-  if (envOrigin) return normalizeWorktreeBaseUrl(envOrigin);
-  const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
-  if (envBase) return normalizeWorktreeBaseUrl(envBase);
-  const projectDeeplineBaseUrl = resolveBaseUrlFromEnvValues(loadProjectDeeplineEnv());
-  if (projectDeeplineBaseUrl) return normalizeWorktreeBaseUrl(projectDeeplineBaseUrl);
-  const projectAppBaseUrl = resolveBaseUrlFromEnvValues(loadProjectAppEnv());
-  if (projectAppBaseUrl) return normalizeWorktreeBaseUrl(projectAppBaseUrl);
-  const worktreeBaseUrl = resolveWorktreeBaseUrl();
-  if (worktreeBaseUrl) return worktreeBaseUrl;
+  const projectEnv = loadProjectDeeplineEnv();
   const globalEnv = loadGlobalCliEnv();
-  const globalOrigin = globalEnv.DEEPLINE_ORIGIN_URL?.trim();
-  if (globalOrigin) return normalizeWorktreeBaseUrl(globalOrigin);
-  return PROD_URL;
+  return normalizeBaseUrl(process.env[HOST_URL_ENV] ?? "") || normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? "") || normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? "") || PROD_URL;
+}
+function resolveApiKeyForBaseUrl(baseUrl, explicitApiKey) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const projectEnv = loadProjectDeeplineEnv();
+  const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
+  const projectBaseUrl = normalizeBaseUrl(projectEnv[HOST_URL_ENV] ?? "");
+  const projectKeyApplies = projectBaseUrl === normalizedBaseUrl;
+  return firstNonEmpty(
+    explicitApiKey,
+    process.env[API_KEY_ENV],
+    projectKeyApplies ? projectEnv[API_KEY_ENV] : "",
+    cliEnv[API_KEY_ENV]
+  );
 }
 function resolveConfig(options) {
-  const requestedBaseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
-  const baseUrl = normalizeWorktreeBaseUrl(requestedBaseUrl);
-  const cliEnv = loadCliEnv(baseUrl);
-  const projectDeeplineEnv = loadProjectDeeplineEnv();
-  const projectAppEnv = loadProjectAppEnv();
-  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || projectDeeplineEnv.DEEPLINE_API_KEY || projectAppEnv.DEEPLINE_API_KEY || cliEnv.DEEPLINE_API_KEY || "";
+  const baseUrl = normalizeBaseUrl(
+    options?.baseUrl?.trim() || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl, options?.apiKey);
   if (!apiKey) {
     throw new ConfigError(
-      `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
+      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
     );
   }
   return {
@@ -242,32 +214,10 @@ function resolveConfig(options) {
     maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES
   };
 }
-function mergeEnvFile(filePath, values) {
-  const existing = (0, import_node_fs.existsSync)(filePath) ? parseEnvFile(filePath) : {};
-  const merged = { ...existing, ...values };
-  const dir = (0, import_node_path.dirname)(filePath);
-  if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.mkdirSync)(dir, { recursive: true });
-  const lines = Object.entries(merged).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${value}`);
-  (0, import_node_fs.writeFileSync)(filePath, `${lines.join("\n")}
-`, "utf-8");
-}
-function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStartDir()) {
-  const root = (0, import_node_path.resolve)(startDir);
-  const profile = profileNameForBaseUrl(baseUrl);
-  const files = [
-    (0, import_node_path.join)(root, ACTIVE_DEEPLINE_ENV_FILE),
-    (0, import_node_path.join)(root, `.env.deepline.${profile}`)
-  ];
-  if (profile === "dev") files.push((0, import_node_path.join)(root, ".env"));
-  for (const filePath of files) {
-    mergeEnvFile(filePath, values);
-  }
-  return files;
-}
 
 // src/version.ts
-var SDK_VERSION = "0.1.32";
-var SDK_API_CONTRACT = "2026-05-generic-play-input-flags";
+var SDK_VERSION = "0.1.33";
+var SDK_API_CONTRACT = "2026-05-host-env-generic-play-input-flags";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -1686,10 +1636,11 @@ var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
-var import_node_child_process = require("child_process");
+var childProcess = __toESM(require("child_process"));
 var import_sync = require("csv-parse/sync");
 var import_sync2 = require("csv-stringify/sync");
 var BROWSER_FOCUS_COOLDOWN_MS = 3e4;
+var defaultBrowserCommandRunner = childProcess;
 function getAuthedHttpClient() {
   const config = resolveConfig();
   return { config, http: new HttpClient(config) };
@@ -1758,9 +1709,9 @@ function browserAppNameFromBundleId(bundleId) {
   };
   return names[bundleId.toLowerCase()] ?? "";
 }
-function readDefaultMacBrowserBundleId() {
+function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
   try {
-    const output = (0, import_node_child_process.execFileSync)(
+    const output = runner.execFileSync(
       "/usr/bin/defaults",
       [
         "read",
@@ -1796,8 +1747,8 @@ function browserStrategyForBundleId(bundleId) {
   }
   return normalized === "com.apple.safari" ? "safari" : "fallback";
 }
-function runAppleScript(script, args) {
-  const result = (0, import_node_child_process.spawnSync)("osascript", ["-", ...args], {
+function runAppleScript(script, args, runner = defaultBrowserCommandRunner) {
+  const result = runner.spawnSync("osascript", ["-", ...args], {
     input: script,
     encoding: "utf-8",
     stdio: ["pipe", "ignore", "ignore"],
@@ -1805,7 +1756,7 @@ function runAppleScript(script, args) {
   });
   return result.status === 0;
 }
-function retargetChromiumMacos(appName, targetUrl, allowFocus) {
+function retargetChromiumMacos(appName, targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
   const host = extractUrlHost(targetUrl);
   if (!host) return false;
   const escapedAppName = appName.replace(/"/g, '\\"');
@@ -1837,9 +1788,9 @@ ${newTabBlock}    end if
   end tell
 end run
 `;
-  return runAppleScript(script, [targetUrl, host]);
+  return runAppleScript(script, [targetUrl, host], runner);
 }
-function retargetSafariMacos(appName, targetUrl, allowFocus) {
+function retargetSafariMacos(appName, targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
   const host = extractUrlHost(targetUrl);
   if (!host) return false;
   const escapedAppName = appName.replace(/"/g, '\\"');
@@ -1871,30 +1822,38 @@ ${newTabBlock}    end if
   end tell
 end run
 `;
-  return runAppleScript(script, [targetUrl, host]);
+  return runAppleScript(script, [targetUrl, host], runner);
 }
-function openUrlMacos(targetUrl, allowFocus) {
-  const defaultBundleId = readDefaultMacBrowserBundleId();
+function openUrlMacos(targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
+  const defaultBundleId = readDefaultMacBrowserBundleId(runner);
   const appName = defaultBundleId ? browserAppNameFromBundleId(defaultBundleId) : "";
   const strategy = browserStrategyForBundleId(defaultBundleId);
-  if (appName && strategy === "chromium" && retargetChromiumMacos(appName, targetUrl, allowFocus)) {
+  if (appName && strategy === "chromium" && retargetChromiumMacos(appName, targetUrl, allowFocus, runner)) {
     return true;
   }
-  if (appName && strategy === "safari" && retargetSafariMacos(appName, targetUrl, allowFocus)) {
+  if (appName && strategy === "safari" && retargetSafariMacos(appName, targetUrl, allowFocus, runner)) {
     return true;
   }
-  if (!allowFocus) {
-    return false;
-  }
   try {
-    (0, import_node_child_process.execFileSync)("open", [targetUrl], { stdio: "ignore" });
+    runner.execFileSync(
+      "open",
+      [...allowFocus ? [] : ["-g"], targetUrl],
+      { stdio: "ignore" }
+    );
     return true;
   } catch {
     return false;
   }
 }
+function browserOpeningDisabled() {
+  const value = String(
+    process.env.DEEPLINE_NO_BROWSER ?? process.env.PLAYGROUND_HEADLESS ?? ""
+  ).trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
 function openInBrowser(url) {
   try {
+    if (browserOpeningDisabled()) return;
     const targetUrl = String(url || "").trim();
     if (!targetUrl) return;
     const allowFocus = claimBrowserFocus();
@@ -1904,12 +1863,12 @@ function openInBrowser(url) {
     }
     if (!allowFocus) return;
     if (process.platform === "win32") {
-      (0, import_node_child_process.execFileSync)("cmd.exe", ["/c", "start", "", targetUrl], {
+      childProcess.execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
         stdio: "ignore"
       });
       return;
     }
-    (0, import_node_child_process.execFileSync)("xdg-open", [targetUrl], { stdio: "ignore" });
+    childProcess.execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
   } catch {
   }
 }
@@ -2023,17 +1982,39 @@ var EXIT_SERVER = 2;
 function envFilePath(baseUrl) {
   return hostEnvFilePath(baseUrl);
 }
-function saveEnvValues(values, baseUrl) {
-  const filePath = envFilePath(baseUrl);
+function pendingClaimTokenPath(baseUrl) {
+  return `${hostConfigDirPath(baseUrl)}/pending-claim-token`;
+}
+function savePendingClaimToken(baseUrl, claimToken) {
+  const filePath = pendingClaimTokenPath(baseUrl);
   const dir = (0, import_node_path3.dirname)(filePath);
   if (!(0, import_node_fs3.existsSync)(dir)) {
     (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
   }
-  const existing = (0, import_node_fs3.existsSync)(filePath) ? parseEnvFile(filePath) : {};
-  const merged = { ...existing, ...values };
-  const lines = Object.entries(merged).filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
-  (0, import_node_fs3.writeFileSync)(filePath, lines.join("\n") + "\n", "utf-8");
-  saveProjectDeeplineEnvValues(baseUrl, values);
+  (0, import_node_fs3.writeFileSync)(filePath, `${claimToken}
+`, "utf-8");
+}
+function readPendingClaimToken(baseUrl) {
+  const filePath = pendingClaimTokenPath(baseUrl);
+  if (!(0, import_node_fs3.existsSync)(filePath)) return "";
+  try {
+    return (0, import_node_fs3.readFileSync)(filePath, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function clearPendingClaimToken(baseUrl) {
+  try {
+    (0, import_node_fs3.rmSync)(pendingClaimTokenPath(baseUrl), { force: true });
+  } catch {
+  }
+}
+function saveEnvValues(values, baseUrl) {
+  const filtered = {
+    ...values[HOST_URL_ENV] ? { [HOST_URL_ENV]: values[HOST_URL_ENV] } : {},
+    ...values[API_KEY_ENV] ? { [API_KEY_ENV]: values[API_KEY_ENV] } : {}
+  };
+  saveHostEnvValues(baseUrl, filtered);
 }
 async function httpJson(method, url, apiKey, body) {
   const headers = { "Content-Type": "application/json" };
@@ -2139,9 +2120,9 @@ async function handleRegister(args) {
   const claimUrl = String(data.claim_url || "");
   const claimToken = String(data.claim_token || "");
   if (claimToken) {
+    savePendingClaimToken(baseUrl, claimToken);
     saveEnvValues({
-      DEEPLINE_ORIGIN_URL: baseUrl,
-      DEEPLINE_CLAIM_TOKEN: claimToken
+      [HOST_URL_ENV]: baseUrl
     }, baseUrl);
   }
   if (claimUrl) {
@@ -2165,6 +2146,7 @@ async function handleRegister(args) {
       { claim_token: claimToken, reveal: true }
     );
     if (s === 401 || s === 403) {
+      clearPendingClaimToken(baseUrl);
       console.log("Status: unauthorized");
       return EXIT_AUTH;
     }
@@ -2181,15 +2163,16 @@ async function handleRegister(args) {
       const apiKey = String(statusData.api_key || "");
       if (apiKey) {
         saveEnvValues({
-          DEEPLINE_ORIGIN_URL: baseUrl,
-          DEEPLINE_API_KEY: apiKey,
-          DEEPLINE_CLAIM_TOKEN: ""
+          [HOST_URL_ENV]: baseUrl,
+          [API_KEY_ENV]: apiKey
         }, baseUrl);
+        clearPendingClaimToken(baseUrl);
         printClaimSuccessBanner(statusData);
         return EXIT_OK;
       }
     }
     if (state === "expired") {
+      clearPendingClaimToken(baseUrl);
       console.log("That approval link expired. Please run: deepline auth register");
       return EXIT_AUTH;
     }
@@ -2207,13 +2190,12 @@ async function handleWait(args) {
       }
     }
   }
-  const env = loadCliEnv(baseUrl);
-  if (env.DEEPLINE_API_KEY?.trim()) {
-    console.log("Already connected.");
-    return EXIT_OK;
-  }
-  const claimToken = env.DEEPLINE_CLAIM_TOKEN?.trim() || "";
+  const claimToken = readPendingClaimToken(baseUrl);
   if (!claimToken) {
+    if (resolveApiKeyForBaseUrl(baseUrl)) {
+      console.log("Already connected.");
+      return EXIT_OK;
+    }
     console.error("No pending approval. Run: deepline auth register --no-wait");
     return EXIT_AUTH;
   }
@@ -2226,6 +2208,7 @@ async function handleWait(args) {
       { claim_token: claimToken, reveal: true }
     );
     if (status === 401 || status === 403) {
+      clearPendingClaimToken(baseUrl);
       console.error("Claim is invalid. Run: deepline auth register");
       return EXIT_AUTH;
     }
@@ -2242,15 +2225,16 @@ async function handleWait(args) {
       const apiKey = String(data.api_key || "");
       if (apiKey) {
         saveEnvValues({
-          DEEPLINE_ORIGIN_URL: baseUrl,
-          DEEPLINE_API_KEY: apiKey,
-          DEEPLINE_CLAIM_TOKEN: ""
+          [HOST_URL_ENV]: baseUrl,
+          [API_KEY_ENV]: apiKey
         }, baseUrl);
+        clearPendingClaimToken(baseUrl);
         printClaimSuccessBanner(data);
         return EXIT_OK;
       }
     }
     if (state === "expired") {
+      clearPendingClaimToken(baseUrl);
       console.error("That approval link expired. Run: deepline auth register");
       return EXIT_AUTH;
     }
@@ -2285,10 +2269,9 @@ async function handleStatus(args) {
     };
     hostLines.push(`Host: ${baseUrl} (unreachable)`);
   }
-  const env = loadCliEnv(baseUrl);
-  const apiKey = process.env.DEEPLINE_API_KEY?.trim() || env.DEEPLINE_API_KEY || "";
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl);
   if (!apiKey) {
-    if (env.DEEPLINE_CLAIM_TOKEN?.trim()) {
+    if (readPendingClaimToken(baseUrl)) {
       printCommandEnvelope({
         ...hostStatusPayload ?? { host: baseUrl },
         status: "pending",
@@ -2334,6 +2317,7 @@ async function handleStatus(args) {
     console.error(`Auth status error (status ${status}).`);
     return EXIT_SERVER;
   }
+  clearPendingClaimToken(baseUrl);
   const payload = {
     ...hostStatusPayload ?? { host: baseUrl },
     status: data.status || "(unknown)",
@@ -2354,9 +2338,8 @@ async function handleStatus(args) {
     const apiKeyResp = String(data.api_key || apiKey);
     if (apiKeyResp) {
       saveEnvValues({
-        DEEPLINE_ORIGIN_URL: baseUrl,
-        DEEPLINE_API_KEY: apiKeyResp,
-        DEEPLINE_CLAIM_TOKEN: ""
+        [HOST_URL_ENV]: baseUrl,
+        [API_KEY_ENV]: apiKeyResp
       }, baseUrl);
       savedApiKeyPath = envFilePath(baseUrl);
     }
@@ -5843,10 +5826,6 @@ function openPlayDashboard(input) {
   }
   openInBrowser(input.dashboardUrl);
 }
-function getDashboardUrlFromLiveEvent(event) {
-  const dashboardUrl = getEventPayload(event).dashboardUrl;
-  return typeof dashboardUrl === "string" && dashboardUrl.trim() ? dashboardUrl.trim() : null;
-}
 function printPlayLogLines(input) {
   for (const line of input.lines) {
     if (input.emitLogs) {
@@ -5915,7 +5894,7 @@ async function waitForPlayCompletionByStream(input) {
           billing: false
         });
         if (TERMINAL_PLAY_STATUSES2.has(finalStatus.status)) {
-          return finalStatus;
+          return input.dashboardUrl ? { ...finalStatus, dashboardUrl: input.dashboardUrl } : finalStatus;
         }
       }
     }
@@ -5943,6 +5922,10 @@ async function waitForPlayCompletionByStream(input) {
 }
 async function startAndWaitForPlayCompletionByStream(input) {
   const startedAt = Date.now();
+  const dashboardUrl = buildPlayDashboardUrl(
+    input.client.baseUrl,
+    input.playName
+  );
   const state = {
     lastLogIndex: 0,
     emittedRunnerStarted: false
@@ -5973,7 +5956,6 @@ async function startAndWaitForPlayCompletionByStream(input) {
       }
       const workflowId = lastKnownWorkflowId || "pending";
       if (workflowId !== "pending" && !emittedDashboardUrl) {
-        const dashboardUrl = getDashboardUrlFromLiveEvent(event) ?? buildPlayDashboardUrl(input.client.baseUrl, input.playName);
         openPlayDashboard({
           dashboardUrl,
           jsonOutput: input.jsonOutput,
@@ -6022,7 +6004,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
           firstRunIdMs,
           lastPhase
         });
-        return finalStatus;
+        return { ...finalStatus, dashboardUrl };
       }
     }
   } catch (error) {
@@ -6059,6 +6041,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
       return waitForPlayCompletionByStream({
         client: input.client,
         workflowId: lastKnownWorkflowId,
+        dashboardUrl,
         jsonOutput: input.jsonOutput,
         emitLogs: input.emitLogs,
         waitTimeoutMs: input.waitTimeoutMs,
@@ -6093,6 +6076,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
     return waitForPlayCompletionByStream({
       client: input.client,
       workflowId: lastKnownWorkflowId,
+      dashboardUrl,
       jsonOutput: input.jsonOutput,
       emitLogs: input.emitLogs,
       waitTimeoutMs: input.waitTimeoutMs,
@@ -6263,12 +6247,16 @@ function buildRunWarnings(status, rowsInfo) {
   }
   return [];
 }
-function buildRunNextCommands(runId) {
-  return {
+function buildRunNextCommands(runId, dashboardUrl) {
+  const commands = {
     get: `deepline runs get ${runId} --json`,
     stop: `deepline runs stop ${runId} --reason "stale lock" --json`,
     logs: `deepline runs logs ${runId} --out run.log --json`
   };
+  if (dashboardUrl) {
+    commands.open = `Open ${dashboardUrl} to see results.`;
+  }
+  return commands;
 }
 var RUN_LOG_PREVIEW_LIMIT = 20;
 function getRecordField(value, key) {
@@ -6404,6 +6392,7 @@ function compactPlayStatus(status) {
     apiVersion: status.apiVersion ?? 1,
     ...typeof status.name === "string" ? { name: status.name } : {},
     ...typeof status.playName === "string" ? { playName: status.playName } : {},
+    ...status.dashboardUrl ? { dashboardUrl: status.dashboardUrl } : {},
     status: status.status,
     run: normalizeRunStatusForEnvelope(status),
     progress: normalizeProgressForEnvelope(status, rowsInfo),
@@ -6416,7 +6405,7 @@ function compactPlayStatus(status) {
     ...status.resultView ? { resultView: status.resultView } : {},
     ...datasetStats ? { dataset_stats: datasetStats } : {},
     ...billing ? { billing } : {},
-    next: buildRunNextCommands(status.runId)
+    next: buildRunNextCommands(status.runId, status.dashboardUrl)
   };
 }
 function enrichPlayStatusWithDatasetStats(status) {
@@ -6629,7 +6618,7 @@ async function exportPlayStatusRows(client, status, outPath, options = {}) {
     return null;
   }
   const availableRows = collectSerializedDatasetRowsInfos(status);
-  let rowsInfo = options.datasetPath ? availableRows.find((info) => info.source === options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
+  const rowsInfo = options.datasetPath ? availableRows.find((info) => info.source === options.datasetPath) ?? null : availableRows.length === 1 ? availableRows[0] : null;
   if (!rowsInfo && options.datasetPath) {
     const available = availableRows.map((info) => info.source).filter((source) => typeof source === "string");
     throw new DeeplineError(
@@ -7112,8 +7101,7 @@ async function handleFileBackedRun(options) {
     { targetKind: "file", playName },
     () => client.startPlayRun(startRequest)
   );
-  const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
-  const resolvedDashboardUrl = started.dashboardUrl ?? dashboardUrl;
+  const resolvedDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
   openPlayDashboard({
     dashboardUrl: resolvedDashboardUrl,
     jsonOutput: options.jsonOutput,
@@ -7248,11 +7236,7 @@ async function handleNamedRun(options) {
     { targetKind: "name", playName },
     () => client.startPlayRun(startRequest)
   );
-  const dashboardUrl = buildPlayDashboardUrl(
-    client.baseUrl,
-    playName
-  );
-  const resolvedDashboardUrl = started.dashboardUrl ?? dashboardUrl;
+  const resolvedDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
   openPlayDashboard({
     dashboardUrl: resolvedDashboardUrl,
     jsonOutput: options.jsonOutput,
@@ -9251,7 +9235,7 @@ async function executeTool(args) {
 }
 
 // src/cli/commands/update.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process = require("child_process");
 var import_node_fs10 = require("fs");
 var import_node_path12 = require("path");
 function posixShellQuote(value) {
@@ -9303,7 +9287,7 @@ function resolveUpdatePlan() {
 }
 function runCommand(command, args) {
   return new Promise((resolveExitCode) => {
-    const child = (0, import_node_child_process2.spawn)(command, args, {
+    const child = (0, import_node_child_process.spawn)(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       env: process.env
@@ -9376,7 +9360,7 @@ Examples:
 }
 
 // src/cli/skills-sync.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process2 = require("child_process");
 var import_node_fs11 = require("fs");
 var import_node_os8 = require("os");
 var import_node_path13 = require("path");
@@ -9468,7 +9452,7 @@ function buildBunxSkillsInstallArgs(baseUrl) {
   ];
 }
 function hasCommand(command) {
-  const result = (0, import_node_child_process3.spawnSync)(command, ["--version"], {
+  const result = (0, import_node_child_process2.spawnSync)(command, ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });
@@ -9499,7 +9483,7 @@ function resolveSkillsInstallCommands(baseUrl) {
 }
 function runOneSkillsInstall(install) {
   return new Promise((resolve10) => {
-    const child = (0, import_node_child_process3.spawn)(install.command, install.args, {
+    const child = (0, import_node_child_process2.spawn)(install.command, install.args, {
       stdio: ["ignore", "ignore", "pipe"],
       env: process.env
     });