deepline 0.1.265 → 0.1.267

package/dist/cli/index.js

@@ -718,8 +718,31 @@ var SDK_RELEASE = {
   // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
   // 0.1.254 removes the internal operations tree from the published SDK CLI.
   // Operators use the checkout-local deepline-admin binary instead.
-  version: "0.1.265",
-  apiContract: "2026-07-admin-cli-local-cutover",
+  version: "0.1.267",
+  contracts: {
+    api: {
+      name: "sdk-http-api",
+      // API v2 is append-only. A breaking public request/response change needs
+      // v3 and an explicit v2 support-window decision, never a patch release.
+      currentMajor: 2,
+      supportedMajors: [2],
+      // Accepted only to bridge SDKs released before X-Deepline-API-Major.
+      legacyWireIds: [
+        "2026-07-admin-cli-local-cutover",
+        "2026-07-native-monitor-launch-hard-cutover"
+      ]
+    },
+    playArtifact: {
+      name: "play-artifact-runtime",
+      currentVersion: 2,
+      supportedVersions: [1, 2]
+    },
+    release: {
+      name: "production-sdk-release",
+      publishFrom: "latest-successful-production-deployment",
+      coalesce: "latest-healthy"
+    }
+  },
   supportPolicy: {
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.219",
@@ -816,7 +839,8 @@ var SDK_RELEASE = {
 
 // src/version.ts
 var SDK_VERSION = SDK_RELEASE.version;
-var SDK_API_CONTRACT = SDK_RELEASE.apiContract;
+var SDK_API_MAJOR = SDK_RELEASE.contracts.api.currentMajor;
+var SDK_API_CONTRACT = SDK_RELEASE.contracts.api.legacyWireIds[0] ?? `api-v${SDK_API_MAJOR}`;
 
 // src/agent-runtime.ts
 var import_node_os2 = require("os");
@@ -4838,6 +4862,7 @@ function compatibilityCacheKey(baseUrl, command, skillsVersion) {
     baseUrl: baseUrl.replace(/\/$/, ""),
     version: SDK_VERSION,
     apiContract: SDK_API_CONTRACT,
+    apiMajor: SDK_API_MAJOR,
     command: command?.trim() || null,
     skillsVersion: skillsVersion ?? null
   });
@@ -4906,6 +4931,7 @@ async function checkSdkCompatibility(baseUrl, options = {}) {
       headers: {
         "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
         "X-Deepline-SDK-Version": SDK_VERSION,
+        "X-Deepline-API-Major": String(SDK_API_MAJOR),
         "X-Deepline-API-Contract": SDK_API_CONTRACT
       },
       signal: controller.signal
@@ -5284,26 +5310,29 @@ function browserOpeningDisabled() {
   ).trim().toLowerCase();
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
-function openInBrowser(url) {
+function openInBrowser(url, options = {}) {
   try {
-    if (browserOpeningDisabled()) return;
+    if (browserOpeningDisabled()) return "failed";
     const targetUrl = String(url || "").trim();
-    if (!targetUrl) return;
-    if (!claimBrowserOpen(Date.now(), void 0, targetUrl)) return;
+    if (!targetUrl) return "failed";
+    if (options.deduplicate !== false && !claimBrowserOpen(Date.now(), void 0, targetUrl)) {
+      return "suppressed";
+    }
     const allowFocus = true;
     if (process.platform === "darwin") {
-      openUrlMacos(targetUrl, allowFocus);
-      return;
+      return openUrlMacos(targetUrl, allowFocus) ? "opened" : "failed";
     }
-    if (!allowFocus) return;
+    if (!allowFocus) return "failed";
     if (process.platform === "win32") {
       childProcess.execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
         stdio: "ignore"
       });
-      return;
+      return "opened";
     }
     childProcess.execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
+    return "opened";
   } catch {
+    return "failed";
   }
 }
 function sleep3(ms) {
@@ -14256,6 +14285,26 @@ function withOrdinaryRunAgainCommand(status, options, resolvedRevisionId) {
     rerunCommand: buildOrdinaryPlayRunCommand(options, resolvedRevisionId)
   } : status;
 }
+function buildBillingRollupTextLines(status) {
+  const billing = status.billing;
+  const rollup = billing?.rollup;
+  if (!rollup) return [];
+  const total = formatCreditAmount(rollup.totalCreditsRollup);
+  if (rollup.childCredits > 0 && rollup.descendantRunCount > 0) {
+    const own = formatCreditAmount(rollup.ownCredits);
+    const child = formatCreditAmount(rollup.childCredits);
+    const suffix = rollup.rollupComplete ? "" : " (incomplete: child billing could not be fully resolved)";
+    return [
+      `  cost: ${total} credits total \u2014 ${own} this run + ${child} across ${rollup.descendantRunCount} child run${rollup.descendantRunCount === 1 ? "" : "s"}${suffix}`
+    ];
+  }
+  if (!rollup.rollupComplete) {
+    return [
+      `  cost: ${total} credits (incomplete: child billing could not be fully resolved${rollup.rollupError ? ` \u2014 ${rollup.rollupError}` : ""})`
+    ];
+  }
+  return [`  cost: ${total} credits`];
+}
 function writePlayResult(status, jsonOutput, options) {
   const packaged = getPlayRunPackage(status);
   if (jsonOutput) {
@@ -14318,6 +14367,7 @@ function writePlayResult(status, jsonOutput, options) {
     lines.push(...renderedServerView.lines);
   }
   lines.push(...renderedServerView.actions);
+  lines.push(...buildBillingRollupTextLines(status));
   const compact = compactPlayStatus(status);
   const payload = options?.fullJson ? status : compact;
   printCommandEnvelope(
@@ -29493,6 +29543,18 @@ function inferNpmGlobalPrefixFromEntrypoint(entrypoint) {
   const prefix = normalized.startsWith("/") && prefixParts[0] !== "" ? `/${prefixParts.join("/")}` : prefixParts.join("/");
   return prefix || null;
 }
+function isHomebrewFormulaEntrypoint(entrypoint) {
+  const normalized = (() => {
+    try {
+      return (0, import_node_fs17.realpathSync)(entrypoint);
+    } catch {
+      return (0, import_node_path19.resolve)(entrypoint);
+    }
+  })();
+  const parts = normalized.split(/[\\/]+/);
+  const cellarIndex = parts.lastIndexOf("Cellar");
+  return cellarIndex >= 0 && parts[cellarIndex + 1] === "deepline" && parts.slice(cellarIndex + 3).includes("libexec");
+}
 function resolveUpdatePlan(options = {}) {
   const env = options.env ?? process.env;
   const homeDir2 = options.homeDir ?? (0, import_node_os14.homedir)();
@@ -29505,6 +29567,12 @@ function resolveUpdatePlan(options = {}) {
       manualCommand: buildSourceUpdateCommand(sourceRoot)
     };
   }
+  if (entrypoint && isHomebrewFormulaEntrypoint(entrypoint)) {
+    return {
+      kind: "homebrew",
+      manualCommand: "brew upgrade deepline"
+    };
+  }
   const sidecarPlan = resolvePythonSidecarUpdatePlan({
     entrypoint,
     env,
@@ -29536,7 +29604,7 @@ function resolveUpdatePlan(options = {}) {
 }
 var AUTO_UPDATE_FAILURE_FILE = ".auto-update-failure.json";
 function autoUpdateFailurePath(plan) {
-  if (plan.kind === "source") return null;
+  if (plan.kind === "source" || plan.kind === "homebrew") return null;
   if (plan.kind === "python-sidecar") {
     return (0, import_node_path19.join)(plan.stateDir, AUTO_UPDATE_FAILURE_FILE);
   }
@@ -29549,7 +29617,7 @@ function autoUpdateFailurePath(plan) {
   );
 }
 function autoUpdatePackageSpec(plan) {
-  if (plan.kind === "source") return "";
+  if (plan.kind === "source" || plan.kind === "homebrew") return "";
   if (plan.kind === "python-sidecar") return plan.packageSpec;
   return plan.args[plan.args.length - 1] ?? plan.manualCommand;
 }
@@ -29570,7 +29638,7 @@ function readAutoUpdateFailure(plan) {
 }
 function writeAutoUpdateFailure(plan, exitCode) {
   const path = autoUpdateFailurePath(plan);
-  if (!path || plan.kind === "source") return;
+  if (!path || plan.kind === "source" || plan.kind === "homebrew") return;
   const marker = {
     kind: plan.kind,
     packageSpec: autoUpdatePackageSpec(plan),
@@ -29595,7 +29663,9 @@ function clearAutoUpdateFailure(plan) {
 }
 function matchingAutoUpdateFailure(plan) {
   const marker = readAutoUpdateFailure(plan);
-  if (!marker || plan.kind === "source") return null;
+  if (!marker || plan.kind === "source" || plan.kind === "homebrew") {
+    return null;
+  }
   if (marker.kind !== plan.kind) return null;
   if (marker.packageSpec !== autoUpdatePackageSpec(plan)) return null;
   return marker;
@@ -29853,6 +29923,8 @@ async function runUpdatePlan(plan) {
     });
   } else if (plan.kind === "python-sidecar") {
     exitCode = await runPythonSidecarUpdatePlan(plan);
+  } else if (plan.kind === "homebrew") {
+    exitCode = 0;
   }
   if (exitCode === 0) {
     clearAutoUpdateFailure(plan);
@@ -29891,6 +29963,9 @@ async function runUpdateCommand(options, dependencies = {}) {
         lines: plan.kind === "source" ? [
           "This Deepline CLI is running from SDK source, so it cannot safely update itself like an npm global.",
           `Update the backing checkout with: ${plan.manualCommand}`
+        ] : plan.kind === "homebrew" ? [
+          "This Deepline CLI was installed by Homebrew, which owns its upgrades.",
+          `Update it with: ${plan.manualCommand}`
         ] : plan.kind === "python-sidecar" ? [
           "This Deepline CLI is running from the Python-managed SDK sidecar.",
           "Updating will refresh that sidecar, not a global npm binary."
@@ -29915,7 +29990,7 @@ async function runUpdateCommand(options, dependencies = {}) {
     );
     return 0;
   }
-  if (plan.kind === "source") {
+  if (plan.kind === "source" || plan.kind === "homebrew") {
     printCommandEnvelope({ ...plan, render }, { json: false });
     return 0;
   }
@@ -29934,6 +30009,8 @@ function registerUpdateCommand(program) {
     `
 Notes:
   For the published npm CLI, this runs npm install -g deepline@latest.
+  For a Homebrew installation, this prints brew upgrade deepline; Homebrew
+  owns formula upgrades and Deepline never runs npm inside its Cellar.
   For Python-managed SDK sidecars, this refreshes the sidecar that launched
   the current SDK CLI instead of changing a global npm binary.
   For repo-backed SDK wrappers such as cli-env sdk-prod or sdk-worktree, this
@@ -30053,14 +30130,37 @@ function resolveScopeRoot(scope) {
 function authScopeForSetup(scope) {
   return scope === "local" ? "folder" : "global";
 }
-function shouldOpenSetupAuthorization(runtime = detectAgentRuntime()) {
-  return runtime !== "claude_cowork";
-}
 function openSetupAuthorization(authorizationUrl, options = {}) {
   const url = authorizationUrl.trim();
-  if (!url || !shouldOpenSetupAuthorization(options.runtime)) return false;
-  (options.open ?? openInBrowser)(url);
-  return true;
+  if (!url) return "failed";
+  if (options.open) return options.open(url);
+  const result = openInBrowser(url, { deduplicate: false });
+  return result === "opened" ? "opened" : "failed";
+}
+function buildPendingAuthorizationOutput(input2) {
+  const authorizationUrl = input2.authorizationUrl.trim();
+  if (input2.browserOpenStatus === "opened") {
+    return {
+      authorizationUrl: null,
+      next: `Complete browser approval, then run: ${input2.resumeCommand}`,
+      lines: ["Complete authorization in the browser window Deepline opened."]
+    };
+  }
+  if (authorizationUrl) {
+    return {
+      authorizationUrl,
+      next: `Open the authorization URL, approve it, then run: ${input2.resumeCommand}`,
+      lines: [
+        "Browser launch failed. Open the authorization URL to continue.",
+        authorizationUrl
+      ]
+    };
+  }
+  return {
+    authorizationUrl: null,
+    next: `Authorization is pending without a browser URL. Retry: ${input2.resumeCommand}`,
+    lines: ["Authorization is pending, but no browser URL was returned."]
+  };
 }
 function setupStatePath(baseUrl, scope, root) {
   return scope === "local" && root ? (0, import_node_path20.join)(root, ".deepline", "setup", "state.json") : (0, import_node_path20.join)(sdkCliStateDirPath(baseUrl), "setup.json");
@@ -30090,15 +30190,6 @@ function parseCapturedJson(stdout) {
 function asRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function printCapturedAuthorizationUrl(stdout) {
-  const urls = stdout.match(/https:\/\/[^\s]+/g) ?? [];
-  for (const url of new Set(
-    urls.map((value) => value.replace(/[).,]+$/, ""))
-  )) {
-    process.stderr.write(`Authorize Deepline: ${url}
-`);
-  }
-}
 function safeRead(path) {
   try {
     return (0, import_node_fs18.readFileSync)(path, "utf8");
@@ -30437,18 +30528,32 @@ function pendingResult(input2) {
     status: "authorization_pending",
     phases: input2.phases
   });
+  let browserOpenStatus = "failed";
   if (input2.authorizationUrl) {
-    openSetupAuthorization(input2.authorizationUrl);
-    process.stderr.write(`Authorize Deepline: ${input2.authorizationUrl}
+    browserOpenStatus = openSetupAuthorization(input2.authorizationUrl);
+    if (browserOpenStatus === "opened") {
+      process.stderr.write(
+        "Opened Deepline authorization in your browser. Complete approval there.\n"
+      );
+    } else if (browserOpenStatus === "failed") {
+      process.stderr.write(`Authorize Deepline: ${input2.authorizationUrl}
 `);
+    }
   }
+  const pendingOutput = buildPendingAuthorizationOutput({
+    authorizationUrl: input2.authorizationUrl,
+    browserOpenStatus,
+    resumeCommand: setupResumeCommand(input2.baseUrl, input2.scope)
+  });
   printCommandEnvelope(
     {
       ok: true,
       status: "authorization_pending",
       complete: false,
       scope: input2.scope,
-      authorizationUrl: input2.authorizationUrl || null,
+      authorizationUrl: pendingOutput.authorizationUrl,
+      browserOpened: browserOpenStatus === "opened",
+      browserOpenStatus,
       statePath,
       phases: input2.phases,
       currentPhase: "auth",
@@ -30458,15 +30563,12 @@ function pendingResult(input2) {
         scope: input2.scope,
         phase: "auth"
       }),
-      next: `Approve the link, then run: ${setupResumeCommand(input2.baseUrl, input2.scope)}`,
+      next: pendingOutput.next,
       render: {
         sections: [
           {
             title: "setup",
-            lines: [
-              "Authorization is waiting for browser approval.",
-              ...input2.authorizationUrl ? [input2.authorizationUrl] : []
-            ]
+            lines: pendingOutput.lines
           }
         ]
       }
@@ -30635,10 +30737,9 @@ async function runSetupCommand(options) {
     const pending = readPendingAuthClaim(baseUrl, authScope);
     if (pending) {
       process.stderr.write("Checking pending Deepline authorization...\n");
-      const waited = await captureStdout2(
+      await captureStdout2(
         () => handleWait(["--timeout", "1", "--auth-scope", authScope])
       );
-      printCapturedAuthorizationUrl(waited.stdout);
       auth = await readAuthStatus(authScope);
       const resumedAuthFailure = reportSetupAuthStatusFailure({
         auth,
@@ -30674,7 +30775,6 @@ async function runSetupCommand(options) {
     const registered = await captureStdout2(
       () => handleRegister(["--wait", waitMode, "--auth-scope", authScope])
     );
-    printCapturedAuthorizationUrl(registered.stdout);
     if (registered.exitCode !== 0) {
       return reportSetupPhaseFailure({
         baseUrl,