turnzero 0.33.1 → 0.34.0

package/dist/turnzero-cloud.mjs

@@ -220,6 +220,7 @@ var provisionBareLineOf = (call) => commandLineOf(call.origin, PROVISION_SUBCOMM
   ...call.envFile !== void 0 ? { quoted: [[PROVISION_OPTION.envFile, call.envFile]] } : {}
 });
 var DEPLOY_ROTATE_FLAG = "--rotate-database-credential";
+var DEPLOY_JSON_FLAG = "--json";
 var DEPLOY_PREPARED_LINE_HEAD = "prepared: ";
 var CREDENTIAL_LOOKUP_BUSY = "credential_lookup_busy";
 var RUN_SUBCOMMAND = "run";
@@ -901,8 +902,7 @@ var readStandardInputEnded = (input, boundMs = GRANT_READ_BOUND_MS) => new Promi
 });
 var unendedReadingOf = (read2) => read2.ending === "error" ? "error" : read2.ending === "full" ? "full" : read2.ending === "bound" && read2.bytes > 0 ? "bound" : null;
 var unendedReadSentence = (what, reading, closing, wayOn) => `${reading === "error" ? `The command could not read the ${what} piped to it to its end` : reading === "full" ? `The input piped to the command was longer than any ${what} can be` : `The ${what} piped to the command did not end within ${GRANT_READ_BOUND_MS / 1e3} seconds`}, so ${closing} ${wayOn}`;
-var NOTHING_PIPED_WAY_ON = "or, to run with nothing piped, close standard input or redirect it from an empty source";
-var pipeWholeWayOn = (aWhat, call, nothingPiped = false) => `Pipe ${aWhat} whole and end the input, as the line ${call} answers does${nothingPiped ? `, ${NOTHING_PIPED_WAY_ON}` : ""}.`;
+var pipeWholeWayOn = (aWhat, call) => `Pipe ${aWhat} whole and end the input, as the line ${call} answers does.`;
 
 // src/turnzero_cloud_command/line_form.ts
 var onWindows = (io2) => io2.windows ?? process.platform === "win32";
@@ -1068,6 +1068,7 @@ var guarded = (io2) => {
   let valuePrinted = false;
   return {
     ...io2,
+    jsonResult: { printed: false, lines: [] },
     print: (line) => {
       io2.print(guardedOf(line));
     },
@@ -1099,8 +1100,7 @@ var TOKEN_CODE_UNREAD = `${TOKEN_CODE_UNREAD_FIRST} ${TOKEN_CODE_RUN_AGAIN}`;
 var tokenCodeFloorSentence = (version, found) => `${TURNZERO_CLOUD_PACKAGE} ${version} needs Node.js ${COMMAND_NODE_FLOOR} or later, and this machine runs Node.js ${found}, so nothing was read and nothing was started. A token code the line carried was not read: it is live until it expires, and it mints nothing without this computer's verifier. Install Node.js ${COMMAND_NODE_FLOOR} or later, then run the line again.`;
 var NOTHING_SENT = "Nothing was sent and nothing was started.";
 var MINT_UNPRESENTED = `Nothing was presented. ${TOKEN_CODE_RUN_AGAIN}`;
-var namesMint = (argv2) => argv2[0] === AUTHORIZE_SUBCOMMAND && argv2.slice(1).some((argument) => argument === MINT_OPTION || argument.startsWith(`${MINT_OPTION}=`));
-var carriesTokenCode = (argv2) => argv2[0] === AUTHORIZE_SUBCOMMAND && !namesMint(argv2) || argv2[0] === TOKEN_SUBCOMMAND && argv2[1] === TOKEN_CLAIM_ACT;
+var carriesTokenCode = (argv2) => argv2[0] === TOKEN_SUBCOMMAND && argv2[1] === TOKEN_CLAIM_ACT;
 var LABEL_FALLBACK = "authorized computer";
 var computerLabelOf = (host) => {
   let label = "";
@@ -1482,12 +1482,12 @@ async function kept(io2, place, tag, origin, minted, userAgent, say, named = fal
   say(standsSentence(`The token this computer held before for ${origin}, ${before.token_id},`, before.token_id, before.expires_at));
   return COMMAND_STATUS.failed;
 }
-var unendedCodeRefusal = (reading, nothingPiped = false) => `${unendedReadSentence(AUTHORIZE_CREDENTIAL.grant, reading, "nothing was sent and nothing was changed.", pipeWholeWayOn(AUTHORIZE_CREDENTIAL.aGrant, AUTHORIZE_CREDENTIAL.call, nothingPiped))} ${TOKEN_CODE_UNREAD}`;
-var emptyCodeRefusal = (kind, origin = DEFAULT_COMMAND_ORIGIN) => `The token code piped to the command was empty, so nothing was sent and nothing was changed. Pipe a token code whole, as the line the ${MINT_TOKEN_ACTION} call answers does, or ${kind === "authorized computer" ? `pipe nothing to run ${AUTHORIZE_SUBCOMMAND}'s first act` : `run ${firstActNamed(kind, origin)} for the first act`}, which prints the challenge. ${TOKEN_CODE_UNREAD}`;
+var unendedCodeRefusal = (reading) => `${unendedReadSentence(AUTHORIZE_CREDENTIAL.grant, reading, "nothing was sent and nothing was changed.", pipeWholeWayOn(AUTHORIZE_CREDENTIAL.aGrant, AUTHORIZE_CREDENTIAL.call))} ${TOKEN_CODE_UNREAD}`;
+var emptyCodeRefusal = (kind, origin = DEFAULT_COMMAND_ORIGIN) => `The token code piped to the command was empty, so nothing was sent and nothing was changed. Pipe a token code whole, as the line the ${MINT_TOKEN_ACTION} call answers does, or run ${firstActNamed(kind, origin)} for the first act, which prints the challenge. ${TOKEN_CODE_UNREAD}`;
 var readTokenCode = async (io2, kind, origin = DEFAULT_COMMAND_ORIGIN) => {
   const read2 = await readStandardInputEnded(io2.input, io2.grantBoundMs);
   const unended = unendedReadingOf(read2);
-  if (unended !== null) return { refusal: unendedCodeRefusal(unended, kind === "authorized computer" && read2.bytes === 0) };
+  if (unended !== null) return { refusal: unendedCodeRefusal(unended) };
   const code = read2.text.trim();
   return code === "" && read2.bytes > 0 ? { refusal: emptyCodeRefusal(kind, origin) } : { code };
 };
@@ -1512,64 +1512,62 @@ var AUTHORIZE_CREDENTIAL = Object.freeze({
   grant: "token code",
   aGrant: "a token code",
   call: `the ${MINT_TOKEN_ACTION} call`,
-  mintedToken: false,
-  pipes: `if the command pipes one in, as the command from a ${MINT_TOKEN_ACTION} call that sets no completion does`,
-  bare: `with nothing piped and no ${MINT_OPTION}, it keeps a verifier and prints the challenge and the ${MINT_TOKEN_ACTION} call that authorize this computer. That call returns ${AUTHORIZE_SUBCOMMAND} ${MINT_OPTION} <id>, a command that contains no code: with it, ${AUTHORIZE_SUBCOMMAND} reads nothing on standard input and presents the verifier for that mint`
+  mintedToken: false
 });
+var AUTHORIZE_READS = `standard input only to refuse a token code piped to it. With nothing piped and no ${MINT_OPTION}, it keeps a verifier and prints the challenge and the ${MINT_TOKEN_ACTION} call that authorize this computer. That call returns ${AUTHORIZE_SUBCOMMAND} ${MINT_OPTION} <id>, a command that contains no code: with it, ${AUTHORIZE_SUBCOMMAND} reads no standard input and presents the verifier for that mint`;
+var heldLinePlaceholderFor = (io2, origin) => printedLineOf(io2, commandLineOf(origin, AUTHORIZE_SUBCOMMAND, { options: [[MINT_OPTION, "<id>"]], ...origin !== DEFAULT_COMMAND_ORIGIN ? { origin } : {} }), origin);
+var pipedCodeRetiredSentence = (line) => `${AUTHORIZE_SUBCOMMAND} no longer reads a token code piped to it, so nothing was sent: run the command the ${MINT_TOKEN_ACTION} call returns, ${line}, as given.`;
 var AUTHORIZATION_ORIGIN_VARIABLE_LINE = `the platform's address the authorization reaches if the command has no ${DEPLOY_OPTION.origin}. It is the one address besides ${DEFAULT_COMMAND_ORIGIN} and ${DEVELOPMENT_COMMAND_ORIGIN} that ${DEPLOY_OPTION.origin} may give. It may be an address of this machine only if this variable is set to it.`;
 var CREDENTIAL_FILE_WORDS = `${CREDENTIAL_FILE_NAME} in a folder ${CREDENTIAL_FOLDER_NAME} under ${CONFIG_HOME_VARIABLE}, or under .config in your home folder if that is unset, readable by you alone. On Windows it is in a folder ${WINDOWS_CREDENTIAL_FOLDER_NAME} under your profile folder, ${PROFILE_VARIABLE}. A file under ${LOCAL_APP_DATA_VARIABLE} from an older version is moved there once`;
 var AUTHORIZE_AFTER_OWN_ERROR = "a token code the line carried may not have been presented. That code is live until it expires, and mints nothing without this computer's verifier. Where a token was minted, list_tokens from your tool shows it by its label, and revoke_token ends it";
 var MINT_AFTER_OWN_ERROR = "the verifier may not have been presented. Where a token was minted, list_tokens from your tool shows it by its label, and revoke_token ends it";
+var FIRST_ACT_AFTER_OWN_ERROR = "nothing was sent, so no token was minted";
 async function authorize(call, io2) {
   const mint = call.named[MINT_OPTION];
   if (mint !== void 0 && !MINT_ID_FORM.test(mint)) {
     io2.print(MINT_ID_REFUSAL);
     return COMMAND_STATUS.nothing_started;
   }
-  const unread = mint !== void 0 ? MINT_UNPRESENTED : TOKEN_CODE_UNREAD;
+  const closing = mint !== void 0 ? ` ${MINT_UNPRESENTED}` : "";
   const origin = authorizationOriginOf(io2.env, call.named[DEPLOY_OPTION.origin], NOTHING_SENT);
   if ("refusal" in origin) {
-    io2.print(`${origin.refusal} ${unread}`);
+    io2.print(`${origin.refusal}${closing}`);
     return COMMAND_STATUS.nothing_started;
   }
   const agent = userAgentOf(io2.env);
   if ("refusal" in agent) {
-    io2.print(`${agent.refusal} ${unread}`);
+    io2.print(`${agent.refusal}${closing}`);
     return COMMAND_STATUS.nothing_started;
   }
   if (mint !== void 0) return completeAct(io2, origin.origin, "authorized computer", { mint }, agent.userAgent, io2.print);
-  const read2 = await readTokenCode(io2, "authorized computer", origin.origin);
-  if ("refusal" in read2) {
-    io2.print(read2.refusal);
-    return COMMAND_STATUS.nothing_started;
-  }
-  const { code } = read2;
-  if (code === "") return firstAct(io2, origin.origin, "authorized computer", io2.print);
-  if (!isTokenCode(code)) {
-    io2.print(notTokenCodeSentence(`Run ${firstActNamed("authorized computer", origin.origin)} with nothing piped to print the challenge, or run the line the ${MINT_TOKEN_ACTION} call answered as given.`));
+  const read2 = await readStandardInputEnded(io2.input, io2.grantBoundMs);
+  if (read2.bytes > 0) {
+    const piped = read2.text.trim();
+    if (isTokenCode(piped)) io2.hide(piped, REDACTED_TOKEN_CODE);
+    io2.print(pipedCodeRetiredSentence(heldLinePlaceholderFor(io2, origin.origin)));
     return COMMAND_STATUS.nothing_started;
   }
-  io2.hide(code, REDACTED_TOKEN_CODE);
-  return completeAct(io2, origin.origin, "authorized computer", { code }, agent.userAgent, io2.print);
+  return firstAct(io2, origin.origin, "authorized computer", io2.print);
 }
 var AUTHORIZE_ROW = Object.freeze({
   name: AUTHORIZE_SUBCOMMAND,
-  summary: `Authorizes this computer at the platform's address, in two steps around one ${MINT_TOKEN_ACTION} call your tool makes. Run with nothing piped, it keeps a verifier in this computer's credential file, and prints the challenge and the call. Run as the command the call returns, with ${MINT_OPTION} and no code, or with a piped token code, it presents the verifier. It then keeps the minted token in that file, and prints authorized:. It prints no token, code, or verifier.`,
+  summary: `Authorizes this computer at the platform's address, in two steps around one ${MINT_TOKEN_ACTION} call your tool makes. Run without ${MINT_OPTION}, it keeps a verifier in this computer's credential file, and prints the challenge and the call. Run as the command the call returns, with ${MINT_OPTION} and no code, it presents the verifier. It then keeps the minted token in that file, and prints authorized:. It reads standard input only to refuse a token code piped to it. It prints no token, code, or verifier.`,
   example: AUTHORIZE_SUBCOMMAND,
   options: AUTHORIZE_OPTIONS,
-  credential: AUTHORIZE_CREDENTIAL,
+  credential: null,
+  reads: AUTHORIZE_READS,
   statuses: {
     done: "the challenge printed, or this computer authorized",
     failed: "a token was minted and not kept, or the token this computer had before was not revoked: the printed lines name revoke_token",
     unknown: "the exchange got no response, or a response that is not a refusal: list_tokens shows whether a token was minted",
-    nothing_started: `nothing was minted. An option, the mint's id, the credential file, or the token code was refused. Or no request was pending, the platform was too old, or the exchange was refused`
+    nothing_started: `nothing was minted. An option, the mint's id, the credential file, or a token code piped to it was refused. Or no request was pending, the platform was too old, or the exchange was refused`
   },
   variables: [[ORIGIN_VARIABLE, AUTHORIZATION_ORIGIN_VARIABLE_LINE]],
   note: [
-    `Authorizing this computer takes three steps, once for each platform address. Your signed-in tool takes them itself and then reports to you; login, run in a terminal of your own, is your own way. ${AUTHORIZE_SUBCOMMAND} run with nothing piped prints a challenge and the ${MINT_TOKEN_ACTION} call to make. Your tool makes that call through the connection you signed in with, and runs the command it returns once, as given, on this computer. That command contains no code, and it keeps the token.`,
+    `Authorizing this computer takes three steps, once for each platform address. Your signed-in tool takes them itself and then reports to you; login, run in a terminal of your own, is your own way. ${AUTHORIZE_SUBCOMMAND} run without ${MINT_OPTION} prints a challenge and the ${MINT_TOKEN_ACTION} call to make. Your tool makes that call through the connection you signed in with, and runs the command it returns once, as given, on this computer. That command contains no code, and it keeps the token.`,
     `The token is account-scoped and works from any computer until it expires or revoke_token ends it: keep it as you would a password, list_tokens shows it by this computer's host name, and logout ends it. The credential file is ${CREDENTIAL_FILE_WORDS}.`
   ],
-  afterOwnError: (call) => call.named[MINT_OPTION] !== void 0 ? MINT_AFTER_OWN_ERROR : AUTHORIZE_AFTER_OWN_ERROR,
+  afterOwnError: (call) => call.named[MINT_OPTION] !== void 0 ? MINT_AFTER_OWN_ERROR : FIRST_ACT_AFTER_OWN_ERROR,
   run: authorize
 });
 
@@ -3500,6 +3498,13 @@ var DEPLOY_OPTIONS = Object.freeze([
     flag: true,
     description: "Rotates production's database credential with this deploy, as given in the command a deploy call with rotate_database_credential returns."
   },
+  {
+    name: DEPLOY_JSON_FLAG,
+    value: "",
+    required: false,
+    flag: true,
+    description: "Prints the result as one JSON object on standard output when the run ends, and every other line on standard error: contract_version, status, outcome, application, environment, upload, version, address, failed_step, and error. The exit status is the same."
+  },
   {
     name: DEPLOY_OPTION.env,
     value: "<environment>",
@@ -3857,6 +3862,9 @@ var UPLOADING_LINE_HEAD = "uploading: ";
 var UPLOADED_LINE_HEAD = "uploaded: ";
 var STARTED_LINE_HEAD = "started: ";
 var WAITING_LINE_HEAD = "waiting: ";
+var ADDRESS_LINE_HEAD = "address: ";
+var ADDRESS_HOSTNAME = /^(?=.{1,253}$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$/;
+var addressLineOf = (hostname3) => typeof hostname3 === "string" && ADDRESS_HOSTNAME.test(hostname3) ? `${ADDRESS_LINE_HEAD}https://${hostname3}/` : null;
 var WAITING_AFTER_SECONDS = 25;
 var waitingLineOf = (seconds) => `${WAITING_LINE_HEAD}${seconds} seconds since the last progress line; the deploy is still running`;
 var deployOptionsOf = (named, cwd, flags = /* @__PURE__ */ new Set()) => {
@@ -4067,7 +4075,78 @@ var commandStartBodyOf = (application, upload, environment, commit) => ({
   ...startBodyOf(application, upload, environment),
   ...commit !== null ? { commit } : {}
 });
+var DEPLOY_RESULT_CONTRACT_VERSION = 1;
+var DEPLOY_OUTCOMES = Object.freeze({
+  [PROGRESS_EXIT_STATUS.deployed]: "deployed",
+  [PROGRESS_EXIT_STATUS.failed]: "failed",
+  [PROGRESS_EXIT_STATUS.refused]: "unknown",
+  [PROGRESS_EXIT_STATUS.nothing_started]: "nothing_started",
+  unwaited: "started"
+});
+var PREPARED_FACTS = new RegExp(`^${PREPARED_LINE_HEAD}upload (\\S+) to (\\S+), `);
+var ANSWER_LINE_ERROR = /^.+ (?:refused|failed) \(HTTP \d{3}\): (\S+)$/;
+var SETTLED_FAILED_FACTS = new RegExp(`^${PROGRESS_SETTLED_FAILED}(?: at (\\S+))?: (\\S+)$`);
+var deployResultOf = (status, application, lines, waited = true) => {
+  const result = {
+    contract_version: DEPLOY_RESULT_CONTRACT_VERSION,
+    status,
+    outcome: status === PROGRESS_EXIT_STATUS.deployed && !waited ? DEPLOY_OUTCOMES.unwaited : DEPLOY_OUTCOMES[status] ?? "unknown",
+    application: application !== void 0 && UPLOAD_ID.test(application) ? application : null,
+    environment: null,
+    upload: null,
+    version: null,
+    address: null,
+    failed_step: null,
+    error: null
+  };
+  let answered = null;
+  for (const line of lines) {
+    const prepared = PREPARED_FACTS.exec(line);
+    if (prepared !== null) {
+      result.upload = prepared[1];
+      result.environment = prepared[2];
+    } else if (line.startsWith(PROGRESS_SETTLED_DEPLOYED)) {
+      const version = Number(line.slice(PROGRESS_SETTLED_DEPLOYED.length));
+      result.version = Number.isInteger(version) ? version : null;
+    } else if (line.startsWith(ADDRESS_LINE_HEAD)) {
+      result.address = line.slice(ADDRESS_LINE_HEAD.length);
+    } else {
+      const failed = SETTLED_FAILED_FACTS.exec(line);
+      if (failed !== null) {
+        result.failed_step = failed[1] ?? null;
+        result.error = failed[2];
+      } else if (answered === null) answered = ANSWER_LINE_ERROR.exec(line)?.[1] ?? null;
+    }
+  }
+  result.error ??= answered;
+  return result;
+};
+var jsonResultHoldOf = (io2) => io2.jsonResult ?? { printed: false, lines: [] };
+var printDeployResultOnce = (io2, held, result) => {
+  if (held.printed) return;
+  held.printed = true;
+  io2.print(JSON.stringify(result));
+};
 async function deploy(named, io2, flags = /* @__PURE__ */ new Set()) {
+  if (!flags.has(DEPLOY_JSON_FLAG)) return deployRun(named, io2, flags);
+  const held = jsonResultHoldOf(io2);
+  const toError = io2.printError ?? io2.print;
+  const print = (line) => {
+    held.lines.push(line);
+    toError(line);
+  };
+  const waited = (io2.env[DEPLOY_NO_WAIT_VARIABLE] ?? "") === "";
+  let status;
+  try {
+    status = await deployRun(named, { ...io2, print }, flags);
+  } catch (error) {
+    printDeployResultOnce(io2, held, deployResultOf(PROGRESS_EXIT_STATUS.refused, named[DEPLOY_OPTION.application], held.lines));
+    throw error;
+  }
+  printDeployResultOnce(io2, held, deployResultOf(status, named[DEPLOY_OPTION.application], held.lines, waited));
+  return status;
+}
+async function deployRun(named, io2, flags) {
   const options = deployOptionsOf(named, io2.cwd, flags);
   if ("refusal" in options) {
     io2.print(options.refusal);
@@ -4266,7 +4345,11 @@ async function deploy(named, io2, flags = /* @__PURE__ */ new Set()) {
     }
     if (partial !== "") io2.print(oneLine(partial));
     cursor += lines.length;
-    if (settled !== null) return settled;
+    if (settled !== null) {
+      const addressLine = settled === PROGRESS_EXIT_STATUS.deployed ? addressLineOf(answer.hostname) : null;
+      if (addressLine !== null) io2.print(addressLine);
+      return settled;
+    }
     if (lines.length > 0 || partial !== "") lastProgressAt = io2.clock().getTime();
     else waitingIfSilent();
     if (lines.length === 0) await io2.sleep(PROGRESS_PAUSE_SECONDS * 1e3);
@@ -11081,6 +11164,7 @@ async function runGuarded(argv2, io2) {
   const belowFloor = nodeFloorRefusal(found, version);
   if (belowFloor !== null) {
     outputOf(argv2, io2)(carriesTokenCode(argv2) ? tokenCodeFloorSentence(version, found) : belowFloor);
+    if (jsonDeployOf(argv2)) printDeployResultOnce(io2, jsonResultHoldOf(io2), deployResultOf(COMMAND_STATUS.nothing_started, deployApplicationOf(argv2), []));
     return COMMAND_STATUS.nothing_started;
   }
   const parsed = parseArguments(argv2, io2.windows ?? ON_WINDOWS);
@@ -11107,6 +11191,7 @@ Get started: ${SETUP_GUIDE}`);
       say(`Paste this into Claude, ChatGPT, or Codex:
 ${SETUP_PROMPT}`);
     }
+    if (jsonDeployOf(argv2)) printDeployResultOnce(io2, jsonResultHoldOf(io2), deployResultOf(COMMAND_STATUS.nothing_started, deployApplicationOf(argv2), []));
     return COMMAND_STATUS.nothing_started;
   }
   const upgrade = startUpgradeCheck(io2, parsed.subcommand.name, parsed.call.named, version);
@@ -11115,7 +11200,22 @@ ${SETUP_PROMPT}`);
   for (const line of notices.finish(upgrade)) say(line);
   return status;
 }
-var outputOf = (argv2, io2) => argv2[0] === TOKEN_SUBCOMMAND && argv2[1] === TOKEN_CLAIM_ACT ? io2.printError ?? io2.print : io2.print;
+var jsonDeployOf = (argv2) => argv2[0] === DEPLOY_SUBCOMMAND && argv2.includes(DEPLOY_JSON_FLAG);
+var deployApplicationOf = (argv2) => {
+  const option = DEPLOY_OPTION.application;
+  for (let index = 1; index < argv2.length; index += 1) {
+    const argument = argv2[index];
+    if (argument === option) return argv2[index + 1];
+    if (argument.startsWith(`${option}=`)) return argument.slice(option.length + 1);
+  }
+  return void 0;
+};
+var printUnknownResult = (argv2, io2) => {
+  if (!jsonDeployOf(argv2)) return;
+  const held = jsonResultHoldOf(io2);
+  printDeployResultOnce(io2, held, deployResultOf(COMMAND_STATUS.unknown, deployApplicationOf(argv2), held.lines));
+};
+var outputOf = (argv2, io2) => argv2[0] === TOKEN_SUBCOMMAND && argv2[1] === TOKEN_CLAIM_ACT || jsonDeployOf(argv2) ? io2.printError ?? io2.print : io2.print;
 var NOTHING_REACHED = "no subcommand was reached, so nothing was started";
 var ownErrorSentence = (error, afterOwnError = NOTHING_REACHED) => `The command stopped on an error of its own (${error instanceof Error ? error.message : String(error)}). ${afterOwnError.charAt(0).toUpperCase()}${afterOwnError.slice(1)}.`;
 var ownErrorLineOf = (argv2, io2, error) => {
@@ -11126,6 +11226,7 @@ async function runProcess(argv2, unguarded2, io2 = guarded(unguarded2)) {
   try {
     return await runGuarded(argv2, io2);
   } catch (error) {
+    printUnknownResult(argv2, io2);
     outputOf(argv2, io2)(ownErrorLineOf(argv2, io2, error));
     return COMMAND_STATUS.unknown;
   }
@@ -11136,6 +11237,7 @@ var outsideErrorHandler = (argv2, io2, end) => {
     if (handled) return;
     handled = true;
     try {
+      printUnknownResult(argv2, io2);
       outputOf(argv2, io2)(ownErrorLineOf(argv2, io2, error));
     } finally {
       end(COMMAND_STATUS.unknown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turnzero",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "type": "module",
   "description": "Deploy and run AI-built apps with Turn Zero Cloud hosting and backend services.",
   "license": "Apache-2.0",