deepline 0.1.32 → 0.1.33

package/dist/cli/index.mjs

@@ -4,7 +4,7 @@
 import { Command as Command2 } from "commander";
 
 // src/config.ts
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 
@@ -44,19 +44,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 {
@@ -65,7 +58,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}`;
@@ -92,79 +85,52 @@ function parseEnvFile(filePath) {
   }
   return env;
 }
-function findNearestEnvFile(names, startDir = process.cwd()) {
+function findNearestEnvFile(name, startDir = process.cwd()) {
   let current = resolve(startDir);
   while (true) {
-    for (const name of names) {
-      const filePath = join(current, name);
-      if (existsSync(filePath)) return filePath;
-    }
+    const filePath = join(current, name);
+    if (existsSync(filePath)) return filePath;
     const parent = 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 "";
   }
-  return trimmed;
 }
-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 firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
 }
-function sdkCliEnvFilePath(baseUrl) {
+function sdkCliConfigDir(baseUrl) {
   const home = process.env.HOME?.trim() || homedir();
-  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL), ".env");
+  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
+}
+function sdkCliEnvFilePath(baseUrl) {
+  return 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);
@@ -175,9 +141,10 @@ function saveHostEnvValues(baseUrl, values) {
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  const existing = 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}`);
   writeFileSync(filePath, `${lines.join("\n")}
 `, "utf-8");
 }
@@ -185,31 +152,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 {
@@ -219,32 +191,10 @@ function resolveConfig(options) {
     maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES
   };
 }
-function mergeEnvFile(filePath, values) {
-  const existing = existsSync(filePath) ? parseEnvFile(filePath) : {};
-  const merged = { ...existing, ...values };
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  const lines = Object.entries(merged).filter(([, value]) => value !== "").map(([key, value]) => `${key}=${value}`);
-  writeFileSync(filePath, `${lines.join("\n")}
-`, "utf-8");
-}
-function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStartDir()) {
-  const root = resolve(startDir);
-  const profile = profileNameForBaseUrl(baseUrl);
-  const files = [
-    join(root, ACTIVE_DEEPLINE_ENV_FILE),
-    join(root, `.env.deepline.${profile}`)
-  ];
-  if (profile === "dev") files.push(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";
@@ -1654,7 +1604,7 @@ async function enforceSdkCompatibility(baseUrl) {
 }
 
 // src/cli/commands/auth.ts
-import { writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname3 } from "path";
 
@@ -1668,10 +1618,11 @@ import {
 import { mkdir, writeFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { execFileSync, spawnSync } from "child_process";
+import * as childProcess from "child_process";
 import { parse } from "csv-parse/sync";
 import { stringify } from "csv-stringify/sync";
 var BROWSER_FOCUS_COOLDOWN_MS = 3e4;
+var defaultBrowserCommandRunner = childProcess;
 function getAuthedHttpClient() {
   const config = resolveConfig();
   return { config, http: new HttpClient(config) };
@@ -1740,9 +1691,9 @@ function browserAppNameFromBundleId(bundleId) {
   };
   return names[bundleId.toLowerCase()] ?? "";
 }
-function readDefaultMacBrowserBundleId() {
+function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
   try {
-    const output = execFileSync(
+    const output = runner.execFileSync(
       "/usr/bin/defaults",
       [
         "read",
@@ -1778,8 +1729,8 @@ function browserStrategyForBundleId(bundleId) {
   }
   return normalized === "com.apple.safari" ? "safari" : "fallback";
 }
-function runAppleScript(script, args) {
-  const result = spawnSync("osascript", ["-", ...args], {
+function runAppleScript(script, args, runner = defaultBrowserCommandRunner) {
+  const result = runner.spawnSync("osascript", ["-", ...args], {
     input: script,
     encoding: "utf-8",
     stdio: ["pipe", "ignore", "ignore"],
@@ -1787,7 +1738,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, '\\"');
@@ -1819,9 +1770,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, '\\"');
@@ -1853,30 +1804,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 {
-    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();
@@ -1886,12 +1845,12 @@ function openInBrowser(url) {
     }
     if (!allowFocus) return;
     if (process.platform === "win32") {
-      execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
+      childProcess.execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
         stdio: "ignore"
       });
       return;
     }
-    execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
+    childProcess.execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
   } catch {
   }
 }
@@ -2005,17 +1964,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 = dirname3(filePath);
   if (!existsSync3(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
-  const existing = existsSync3(filePath) ? parseEnvFile(filePath) : {};
-  const merged = { ...existing, ...values };
-  const lines = Object.entries(merged).filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
-  writeFileSync3(filePath, lines.join("\n") + "\n", "utf-8");
-  saveProjectDeeplineEnvValues(baseUrl, values);
+  writeFileSync3(filePath, `${claimToken}
+`, "utf-8");
+}
+function readPendingClaimToken(baseUrl) {
+  const filePath = pendingClaimTokenPath(baseUrl);
+  if (!existsSync3(filePath)) return "";
+  try {
+    return readFileSync3(filePath, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function clearPendingClaimToken(baseUrl) {
+  try {
+    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" };
@@ -2121,9 +2102,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) {
@@ -2147,6 +2128,7 @@ async function handleRegister(args) {
       { claim_token: claimToken, reveal: true }
     );
     if (s === 401 || s === 403) {
+      clearPendingClaimToken(baseUrl);
       console.log("Status: unauthorized");
       return EXIT_AUTH;
     }
@@ -2163,15 +2145,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;
     }
@@ -2189,13 +2172,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;
   }
@@ -2208,6 +2190,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;
     }
@@ -2224,15 +2207,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;
     }
@@ -2267,10 +2251,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",
@@ -2316,6 +2299,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)",
@@ -2336,9 +2320,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);
     }
@@ -3675,7 +3658,7 @@ Examples:
 import { createHash as createHash3 } from "crypto";
 import {
   existsSync as existsSync6,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readdirSync,
   realpathSync,
   writeFileSync as writeFileSync5
@@ -3690,7 +3673,7 @@ import { existsSync as existsSync5 } from "fs";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { mkdir as mkdir3, readFile, realpath, stat, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir } from "os";
 import { basename, dirname as dirname5, extname, isAbsolute, join as join3, resolve as resolve5 } from "path";
@@ -3944,7 +3927,7 @@ function extractDefinedPlayName(sourceCode) {
 }
 function readPackageVersionFromPackageJson(packageJsonPath, packageName) {
   try {
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
     if (packageJson.name === packageName && typeof packageJson.version === "string") {
       return packageJson.version;
     }
@@ -4239,7 +4222,7 @@ function resolvePackageImport(specifier, fromFile, adapter) {
   const packageName = getPackageName(specifier);
   if (packageName === "deepline" && existsSync4(adapter.sdkPackageJson)) {
     const packageJson = JSON.parse(
-      readFileSync3(adapter.sdkPackageJson, "utf-8")
+      readFileSync4(adapter.sdkPackageJson, "utf-8")
     );
     return {
       name: "deepline",
@@ -5370,7 +5353,7 @@ function materializeRemotePlaySource(input) {
   }
   const outputPath = input.outPath ?? defaultMaterializedPlayPath(input.playName);
   if (existsSync6(outputPath)) {
-    const existingSource = readFileSync4(outputPath, "utf-8");
+    const existingSource = readFileSync5(outputPath, "utf-8");
     if (existingSource === input.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
     }
@@ -5441,7 +5424,7 @@ function parsePositiveInteger2(value, flagName) {
   return parsed;
 }
 function parseJsonInput(raw) {
-  const source = raw.startsWith("@") ? readFileSync4(resolve8(raw.slice(1)), "utf-8") : raw;
+  const source = raw.startsWith("@") ? readFileSync5(resolve8(raw.slice(1)), "utf-8") : raw;
   const parsed = JSON.parse(source);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("--input must be a JSON object.");
@@ -5593,7 +5576,7 @@ async function stageFileInputArgs(input) {
   };
 }
 function stageFile(logicalPath, absolutePath) {
-  const buffer = readFileSync4(absolutePath);
+  const buffer = readFileSync5(absolutePath);
   return {
     logicalPath,
     contentBase64: buffer.toString("base64"),
@@ -5830,10 +5813,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) {
@@ -5902,7 +5881,7 @@ async function waitForPlayCompletionByStream(input) {
           billing: false
         });
         if (TERMINAL_PLAY_STATUSES2.has(finalStatus.status)) {
-          return finalStatus;
+          return input.dashboardUrl ? { ...finalStatus, dashboardUrl: input.dashboardUrl } : finalStatus;
         }
       }
     }
@@ -5930,6 +5909,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
@@ -5960,7 +5943,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,
@@ -6009,7 +5991,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
           firstRunIdMs,
           lastPhase
         });
-        return finalStatus;
+        return { ...finalStatus, dashboardUrl };
       }
     }
   } catch (error) {
@@ -6046,6 +6028,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
       return waitForPlayCompletionByStream({
         client: input.client,
         workflowId: lastKnownWorkflowId,
+        dashboardUrl,
         jsonOutput: input.jsonOutput,
         emitLogs: input.emitLogs,
         waitTimeoutMs: input.waitTimeoutMs,
@@ -6080,6 +6063,7 @@ async function startAndWaitForPlayCompletionByStream(input) {
     return waitForPlayCompletionByStream({
       client: input.client,
       workflowId: lastKnownWorkflowId,
+      dashboardUrl,
       jsonOutput: input.jsonOutput,
       emitLogs: input.emitLogs,
       waitTimeoutMs: input.waitTimeoutMs,
@@ -6250,12 +6234,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) {
@@ -6391,6 +6379,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),
@@ -6403,7 +6392,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) {
@@ -6616,7 +6605,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(
@@ -6930,7 +6919,7 @@ async function handlePlayCheck(args) {
     return 1;
   }
   const absolutePlayPath = resolve8(options.target);
-  const sourceCode = readFileSync4(absolutePlayPath, "utf-8");
+  const sourceCode = readFileSync5(absolutePlayPath, "utf-8");
   let graph;
   try {
     graph = await collectBundledPlayGraph(absolutePlayPath);
@@ -6998,7 +6987,7 @@ async function handleFileBackedRun(options) {
   const sourceCode = traceCliSync(
     "cli.play_file_read_source",
     { targetKind: "file" },
-    () => readFileSync4(absolutePlayPath, "utf-8")
+    () => readFileSync5(absolutePlayPath, "utf-8")
   );
   const runtimeInput = options.input ? { ...options.input } : {};
   let graph;
@@ -7099,8 +7088,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,
@@ -7235,11 +7223,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,
@@ -7530,7 +7514,7 @@ async function handlePlayGet(args) {
       outPath = resolve8(args[++index]);
     }
   }
-  const playName = isFileTarget(target) ? extractPlayName(readFileSync4(resolve8(target), "utf-8"), resolve8(target)) : parseReferencedPlayTarget(target).playName;
+  const playName = isFileTarget(target) ? extractPlayName(readFileSync5(resolve8(target), "utf-8"), resolve8(target)) : parseReferencedPlayTarget(target).playName;
   const detail = isFileTarget(target) ? await client.getPlay(playName) : await assertCanonicalNamedPlayReference(client, target);
   const resolvedSource = detail.play.workingRevision?.sourceCode ?? detail.play.liveRevision?.sourceCode ?? detail.play.currentRevision?.sourceCode ?? detail.play.sourceCode ?? "";
   const materializedFile = outPath ? materializeRemotePlaySource({
@@ -9363,8 +9347,8 @@ Examples:
 }
 
 // src/cli/skills-sync.ts
-import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync8 } from "fs";
+import { spawn as spawn2, spawnSync } from "child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname10, join as join10 } from "path";
 var CHECK_TIMEOUT_MS2 = 3e3;
@@ -9383,7 +9367,7 @@ function readLocalSkillsVersion(baseUrl) {
   const path = sdkSkillsVersionPath(baseUrl);
   if (!existsSync8(path)) return "";
   try {
-    return readFileSync5(path, "utf-8").trim();
+    return readFileSync6(path, "utf-8").trim();
   } catch {
     return "";
   }
@@ -9455,7 +9439,7 @@ function buildBunxSkillsInstallArgs(baseUrl) {
   ];
 }
 function hasCommand(command) {
-  const result = spawnSync2(command, ["--version"], {
+  const result = spawnSync(command, ["--version"], {
     stdio: "ignore",
     shell: process.platform === "win32"
   });