@my-life-buddies/cli 0.25.2 → 0.26.0

package/dist/bin/core.js

@@ -268,8 +268,8 @@ async function cached(definition3, root, lock) {
   }
   const skill = join2(root, "node_modules", definition3.name);
   try {
-    const record2 = JSON.parse(await readFile3(join2(root, "package-lock.json"), "utf8"));
-    const entry2 = record2.packages?.[`node_modules/${definition3.name}`];
+    const record3 = JSON.parse(await readFile3(join2(root, "package-lock.json"), "utf8"));
+    const entry2 = record3.packages?.[`node_modules/${definition3.name}`];
     if (entry2?.version !== lock.version || entry2.integrity !== lock.integrity) throw new Error("\u7F13\u5B58\u6821\u9A8C\u8BB0\u5F55\u4E0D\u5339\u914D");
     await installed(definition3, skill, lock.version);
     return skill;
@@ -1398,7 +1398,7 @@ async function latestRuntimeTemplate(template, options) {
       "--prefer-online",
       "--fetch-retries=0",
       "--fetch-timeout=20000"
-    ], { cwd: temporaryRoot, signal: options.signal, timeout: 6e4 });
+    ], { cwd: temporaryRoot, signal: options.signal, timeout: 18e4 });
     const result = {
       packageJson: await readFile9(join8(temporaryRoot, "package.json"), "utf8"),
       packageLock: await readFile9(join8(temporaryRoot, "package-lock.json"), "utf8")
@@ -1414,7 +1414,8 @@ async function latestRuntimeTemplate(template, options) {
     return result;
   } catch (cause) {
     if (options.signal?.aborted) throw new Error("Runtime \u7248\u672C\u9009\u62E9\u5DF2\u53D6\u6D88");
-    const reason = cause instanceof Error && !cause.message.includes("Command failed") ? cause.message : "npm \u672A\u5B8C\u6210\u9501\u6587\u4EF6\u751F\u6210";
+    const interrupted = cause instanceof Error && (cause.code === "ETIMEDOUT" || cause.killed);
+    const reason = interrupted ? "\u4F9D\u8D56\u9501\u6587\u4EF6\u751F\u6210\u8D85\u65F6\u6216\u88AB\u4E2D\u65AD\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5" : cause instanceof Error && !cause.message.includes("Command failed") ? cause.message : "npm \u672A\u5B8C\u6210\u9501\u6587\u4EF6\u751F\u6210";
     throw new Error(`\u672A\u80FD\u9501\u5B9A\u6700\u65B0\u6B63\u5F0F\u7248 Runtime\uFF1A${reason}\u3002\u5DF2\u505C\u6B62\u751F\u6210\u5DE5\u7A0B\u4F9D\u8D56\uFF0C\u8BF7\u4FEE\u590D\u540E\u91CD\u8BD5\uFF1B\u4E0D\u4F1A\u4F7F\u7528\u9884\u7F6E\u6216\u7F13\u5B58\u7684\u65E7\u7248\u672C\u3002`, { cause });
   } finally {
     if (temporaryRoot) await rm3(temporaryRoot, { recursive: true, force: true });
@@ -1664,8 +1665,8 @@ async function selectInitModel(root, requested, io, options = {}) {
     throw new ModelSelectionError(`\u65E0\u6CD5\u786E\u8BA4\u6A21\u578B\uFF1A${cause instanceof Error ? cause.message : String(cause)}\u3002\u8BF7\u4FEE\u590D\u540E\u91CD\u8BD5\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u9009\u62E9\u9ED8\u8BA4\u6A21\u578B\u3002`);
   }
 }
-function checkModelTemplate(template, selection) {
-  if (selection && runtimeDependencyVersion(JSON.parse(template.packageJson)) !== selection.runtimeVersion) {
+function checkModelTemplate(template, selection2) {
+  if (selection2 && runtimeDependencyVersion(JSON.parse(template.packageJson)) !== selection2.runtimeVersion) {
     throw new ModelSelectionError("Runtime \u7248\u672C\u5728\u9009\u62E9\u6A21\u578B\u540E\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C init \u786E\u8BA4\u8BE5\u7248\u672C\u7684\u6A21\u578B\u3002");
   }
   return template;
@@ -2479,7 +2480,7 @@ ${KNOWLEDGE_HELP}`);
 }
 
 // packages/cli-core/src/index.ts
-import { join as join23, resolve as resolve18 } from "node:path";
+import { join as join24, resolve as resolve19 } from "node:path";
 
 // packages/cli-core/src/init/creator.ts
 import { createHash as createHash3, randomUUID as randomUUID7 } from "node:crypto";
@@ -3148,10 +3149,10 @@ function browserCommand(url) {
 }
 async function openExternalUrl(url) {
   const launch = browserCommand(url);
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     const child = spawn(launch.command, launch.args, { shell: false, stdio: "ignore", windowsHide: true });
     child.once("error", reject);
-    child.once("exit", (code2) => code2 === 0 ? resolve19() : reject(new Error(`browser launcher exited with ${code2 ?? "unknown"}`)));
+    child.once("exit", (code2) => code2 === 0 ? resolve20() : reject(new Error(`browser launcher exited with ${code2 ?? "unknown"}`)));
   });
 }
 async function write(res, status, title, message, webUrl, tone = "error") {
@@ -3163,10 +3164,10 @@ async function write(res, status, title, message, webUrl, tone = "error") {
     "referrer-policy": "no-referrer",
     "x-content-type-options": "nosniff"
   });
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     res.once("error", reject);
-    res.once("close", resolve19);
-    res.end(renderLoginResult(title, message, webUrl, tone), resolve19);
+    res.once("close", resolve20);
+    res.end(renderLoginResult(title, message, webUrl, tone), resolve20);
   });
 }
 async function readJson(response) {
@@ -3202,11 +3203,11 @@ var LoopbackBrowserLoginAdapter = class {
     let settle;
     let reject;
     let settled = false;
-    const result = new Promise((resolve19, rejectResult) => {
+    const result = new Promise((resolve20, rejectResult) => {
       settle = (value) => {
         if (!settled) {
           settled = true;
-          resolve19(value);
+          resolve20(value);
         }
       };
       reject = (reason) => {
@@ -3225,9 +3226,9 @@ var LoopbackBrowserLoginAdapter = class {
         state: request.state
       }).then(settle, reject);
     });
-    await new Promise((resolve19, rejectListen) => {
+    await new Promise((resolve20, rejectListen) => {
       server.once("error", rejectListen);
-      server.listen(0, "127.0.0.1", () => resolve19());
+      server.listen(0, "127.0.0.1", () => resolve20());
     });
     const address = server.address();
     if (!address || typeof address === "string") {
@@ -3260,8 +3261,8 @@ var LoopbackBrowserLoginAdapter = class {
     } finally {
       clearTimeout(timer);
       request.signal?.removeEventListener("abort", abort);
-      await new Promise((resolve19) => {
-        server.close(() => resolve19());
+      await new Promise((resolve20) => {
+        server.close(() => resolve20());
         server.closeIdleConnections();
         server.closeAllConnections();
       });
@@ -3345,7 +3346,9 @@ var CLI_HELP = `\u642D\u642D Developer Platform CLI
   knowledge  \u5C06\u521B\u4F5C\u8D44\u6599\u540C\u6B65\u4E3A\u672C\u5730\u8FD0\u884C\u77E5\u8BC6
   dev        \u5728\u7EC8\u7AEF\u542F\u52A8\u5F00\u53D1\u7248\u642D\u5B50\uFF1Bdev stop \u505C\u6B62\u672C\u673A DEV
   preview    \u8FDE\u63A5\u5DE5\u7A0B\u5E76\u6253\u5F00\u540E\u53F0\u5F00\u53D1\u8C03\u8BD5
-  push       \u4E0A\u4F20\u7A0B\u5E8F\u5305\u548C\u6539\u52A8\u8BF4\u660E
+  push       \u4E0A\u4F20\u7A0B\u5E8F\u5305\uFF0C\u53EF\u7528 --product \u540C\u6B65\u63D0\u4EA4\u5546\u54C1\u5BA1\u6838
+  products   \u4E3A\u5DF2\u6709\u7248\u672C\u8865\u63D0\u5546\u54C1\uFF0C\u6216\u6062\u590D\u539F\u63D0\u5BA1\u8BF7\u6C42
+  release    \u4ECE\u660E\u786E\u56DE\u6267\u53D1\u5E03\uFF0C\u67E5\u8BE2\u3001\u6062\u590D\u3001\u91CD\u8BD5\u6216\u53D6\u6D88\u53D1\u5E03
   status     \u67E5\u770B\u4E91\u7AEF\u7248\u672C\u3001\u8FD0\u884C\u3001\u5BA1\u6838\u548C\u6784\u5EFA\u72B6\u6001
   meta       \u67E5\u770B\u4E91\u7AEF\u8D44\u6599\uFF1Bmeta update \u4FEE\u6539\u8D44\u6599\u6216\u66FF\u6362\u5934\u50CF
   avatar     \u65E7\u5934\u50CF\u547D\u4EE4\u517C\u5BB9\u5165\u53E3\uFF0C\u63A8\u8350 meta update --avatar
@@ -3491,16 +3494,16 @@ var NodeAgentProcessLauncher = class {
     }
     let hasExited = false;
     let spawned = false;
-    const exit = new Promise((resolve19) => {
+    const exit = new Promise((resolve20) => {
       child.once("error", (error2) => {
         if (!spawned) {
           hasExited = true;
-          resolve19({ code: null, signal: null, error: error2 });
+          resolve20({ code: null, signal: null, error: error2 });
         }
       });
       child.once("exit", (code2, signal) => {
         hasExited = true;
-        resolve19({ code: code2, signal });
+        resolve20({ code: code2, signal });
       });
     });
     child.stdout?.setEncoding("utf8");
@@ -3518,11 +3521,11 @@ var NodeAgentProcessLauncher = class {
       }
     });
     try {
-      await new Promise((resolve19, reject) => {
+      await new Promise((resolve20, reject) => {
         const onSpawn = () => {
           spawned = true;
           child.off("error", onError);
-          resolve19();
+          resolve20();
         };
         const onError = (error2) => {
           child.off("spawn", onSpawn);
@@ -3561,11 +3564,11 @@ var NodeAgentProcessLauncher = class {
 };
 function waitForExit(process2, timeoutMs) {
   if (process2.hasExited()) return Promise.resolve(true);
-  return new Promise((resolve19) => {
-    const timeout = setTimeout(() => resolve19(false), timeoutMs);
+  return new Promise((resolve20) => {
+    const timeout = setTimeout(() => resolve20(false), timeoutMs);
     process2.exit.then(() => {
       clearTimeout(timeout);
-      resolve19(true);
+      resolve20(true);
     });
   });
 }
@@ -3648,7 +3651,7 @@ async function waitForGroupExit(pid, isGroupAlive, timeoutMs) {
   while (isGroupAlive(pid)) {
     const remaining = deadline - Date.now();
     if (remaining <= 0) return false;
-    await new Promise((resolve19) => setTimeout(resolve19, Math.min(25, remaining)));
+    await new Promise((resolve20) => setTimeout(resolve20, Math.min(25, remaining)));
   }
   return true;
 }
@@ -3703,11 +3706,11 @@ async function acquireDevInstanceLock(options) {
     }
   }) : void 0;
   try {
-    if (server) await new Promise((resolve19, reject) => {
+    if (server) await new Promise((resolve20, reject) => {
       server.once("error", reject);
       server.listen(0, "127.0.0.1", () => {
         server.off("error", reject);
-        resolve19();
+        resolve20();
       });
     });
     const address = server?.address();
@@ -4437,25 +4440,25 @@ import { join as join18 } from "node:path";
 var DATA_ACCESS_FILENAME = "data-access.json";
 function parseDataAccessRequirements(source) {
   if (source === void 0) return [];
-  const invalid3 = (reason) => {
+  const invalid4 = (reason) => {
     throw new Error(`${DATA_ACCESS_FILENAME}\uFF1A${reason}`);
   };
   let value;
   try {
     value = JSON.parse(source);
   } catch {
-    return invalid3("\u4E0D\u662F\u6709\u6548 JSON");
+    return invalid4("\u4E0D\u662F\u6709\u6548 JSON");
   }
   if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => key !== "requirements") || !Array.isArray(value.requirements) || value.requirements.length > 32) {
-    return invalid3("\u5FC5\u987B\u662F\u4EC5\u5305\u542B requirements \u6570\u7EC4\u7684\u5BF9\u8C61\uFF0C\u6700\u591A\u58F0\u660E 32 \u9879");
+    return invalid4("\u5FC5\u987B\u662F\u4EC5\u5305\u542B requirements \u6570\u7EC4\u7684\u5BF9\u8C61\uFF0C\u6700\u591A\u58F0\u660E 32 \u9879");
   }
   const seen = /* @__PURE__ */ new Set();
   return value.requirements.map((item, index) => {
     if (!item || typeof item !== "object" || Array.isArray(item) || Object.keys(item).some((key) => key !== "id" && key !== "purpose") || !("id" in item) || typeof item.id !== "string" || !item.id.trim() || !("purpose" in item) || typeof item.purpose !== "string" || !item.purpose.trim() || item.purpose.trim().length > 200) {
-      return invalid3(`requirements[${index}] \u5FC5\u987B\u5305\u542B\u975E\u7A7A id \u548C 1\u2013200 \u5B57\u7684 purpose`);
+      return invalid4(`requirements[${index}] \u5FC5\u987B\u5305\u542B\u975E\u7A7A id \u548C 1\u2013200 \u5B57\u7684 purpose`);
     }
     const id = item.id.trim(), purpose = item.purpose.trim();
-    if (seen.has(id)) return invalid3(`\u6570\u636E\u96C6\u4E0D\u80FD\u91CD\u590D\u58F0\u660E\uFF1A${id}`);
+    if (seen.has(id)) return invalid4(`\u6570\u636E\u96C6\u4E0D\u80FD\u91CD\u590D\u58F0\u660E\uFF1A${id}`);
     seen.add(id);
     return { id, purpose };
   });
@@ -4987,18 +4990,18 @@ function parse(source) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new CloudLifecycleError("AUTH_CREDENTIAL_CORRUPT", "\u7CFB\u7EDF\u51ED\u636E\u683C\u5F0F\u65E0\u6548");
   }
-  const record2 = value;
-  if (Object.keys(record2).length !== 3 || typeof record2.accessToken !== "string" || typeof record2.subject !== "string" || !Number.isSafeInteger(record2.expiresAt)) {
+  const record3 = value;
+  if (Object.keys(record3).length !== 3 || typeof record3.accessToken !== "string" || typeof record3.subject !== "string" || !Number.isSafeInteger(record3.expiresAt)) {
     throw new CloudLifecycleError("AUTH_CREDENTIAL_CORRUPT", "\u7CFB\u7EDF\u51ED\u636E\u683C\u5F0F\u65E0\u6548");
   }
   return Object.freeze({
-    accessToken: record2.accessToken,
-    subject: record2.subject,
-    expiresAt: record2.expiresAt
+    accessToken: record3.accessToken,
+    subject: record3.subject,
+    expiresAt: record3.expiresAt
   });
 }
 async function runCredentialCommand(input) {
-  return await new Promise((resolve19, reject) => {
+  return await new Promise((resolve20, reject) => {
     const child = spawn2(input.command, [...input.args], {
       shell: false,
       windowsHide: true,
@@ -5014,7 +5017,7 @@ async function runCredentialCommand(input) {
     child.stdout.on("data", (chunk) => collect(stdout, chunk));
     child.stderr.on("data", (chunk) => collect(stderr, chunk));
     child.once("error", reject);
-    child.once("close", (code2) => resolve19({
+    child.once("close", (code2) => resolve20({
       code: code2 ?? 1,
       stdout: Buffer.concat(stdout).toString("utf8"),
       stderr: Buffer.concat(stderr).toString("utf8")
@@ -5303,9 +5306,424 @@ async function runDevCommand(args, io, options = {}) {
   }
 }
 
-// packages/cli-core/src/commands/cloud.ts
+// packages/cli-core/src/commands/cloud-errors.ts
+var CloudCommandUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CloudCommandUsageError";
+  }
+};
+
+// packages/cli-core/src/commands/product-lifecycle.ts
+import { createHash as createHash10, randomUUID as randomUUID9 } from "node:crypto";
+import { resolve as resolve15 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 
+// packages/cli-core/src/cloud/product-protocol.ts
+function invalid2(message) {
+  throw new CloudLifecycleError("PLATFORM_RESPONSE_INVALID", message);
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid2("\u64CD\u4F5C\u56DE\u6267\u5FC5\u987B\u4E3A\u5BF9\u8C61");
+  return value;
+}
+function isProductId(value) {
+  return typeof value === "string" && /^(?:prd_[0-9]{8}|ps_[A-Za-z0-9_-]{1,61})$/u.exec(value)?.[0] === value;
+}
+function operationId(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) invalid2("\u64CD\u4F5C\u56DE\u6267\u6807\u8BC6\u65E0\u6548");
+  return value;
+}
+function selectedReviewIds(value) {
+  if (!Array.isArray(value) || value.length > 10 || value.some((id) => typeof id !== "string" || !/^pr_[A-Za-z0-9_-]{1,61}$/.test(id)) || new Set(value).size !== value.length) invalid2("\u5546\u54C1\u5BA1\u6838\u56DE\u6267\u96C6\u5408\u65E0\u6548");
+  return value;
+}
+function parsePushMetadata(value) {
+  const m = record(value);
+  if (typeof m.commit !== "string" || !m.commit.trim() || m.commit.length > 2e3 || /[\u0000-\u001f\u007f]/u.test(m.commit) || typeof m.sourceSha256 !== "string" || !/^[a-f0-9]{64}$/.test(m.sourceSha256) || !Array.isArray(m.productReviews) || m.productReviews.length > 10) invalid2("\u4E0A\u4F20\u5143\u6570\u636E\u56DE\u6267\u65E0\u6548");
+  const productReviews = m.productReviews.map((value2) => {
+    const r = record(value2);
+    if (!isProductId(r.productId) || !Number.isSafeInteger(r.expectedDraftVersion) || Number(r.expectedDraftVersion) < 1) invalid2("\u5546\u54C1\u8349\u7A3F\u7248\u672C\u56DE\u6267\u65E0\u6548");
+    return { productId: r.productId, reviewId: selectedReviewIds([r.reviewId])[0], expectedDraftVersion: Number(r.expectedDraftVersion) };
+  });
+  if (new Set(productReviews.map((r) => r.productId)).size !== productReviews.length || new Set(productReviews.map((r) => r.reviewId)).size !== productReviews.length) invalid2("\u56DE\u6267\u5305\u542B\u91CD\u590D\u5546\u54C1\u6216\u5BA1\u6838 ID");
+  return { pushId: operationId(m.pushId), commit: m.commit, sourceSha256: m.sourceSha256, productReviews };
+}
+function parsePackagePush(value) {
+  const p = record(value);
+  const metadata = parsePushMetadata(p.metadata);
+  if (!["receiving", "stored", "completed", "product_reviews_failed", "failed"].includes(String(p.status))) invalid2("\u4E0A\u4F20\u64CD\u4F5C\u72B6\u6001\u65E0\u6548");
+  if (p.uploadVersion !== null && (typeof p.uploadVersion !== "string" || !p.uploadVersion.trim() || /[\u0000-\u001f\u007f]/u.test(p.uploadVersion))) invalid2("\u4E0A\u4F20\u7248\u672C\u56DE\u6267\u65E0\u6548");
+  if (operationId(p.pushId) !== metadata.pushId) invalid2("\u4E0A\u4F20\u56DE\u6267 ID \u4E0E\u5143\u6570\u636E\u4E0D\u5339\u914D");
+  return { pushId: metadata.pushId, uploadVersion: p.uploadVersion, status: p.status, metadata, reviewIds: selectedReviewIds(p.reviewIds), failure: p.failure ?? null };
+}
+function parseProductRelease(value) {
+  const r = record(value);
+  if (r.mode !== "with_buddy" && r.mode !== "products_only") invalid2("\u53D1\u5E03\u6A21\u5F0F\u65E0\u6548");
+  if (!["accepted", "activating", "active", "failed", "cancelled"].includes(String(r.status))) invalid2("\u53D1\u5E03\u64CD\u4F5C\u72B6\u6001\u65E0\u6548");
+  if (typeof r.buddyVersion !== "string" || !r.buddyVersion.trim() || /[\u0000-\u001f\u007f]/u.test(r.buddyVersion)) invalid2("\u53D1\u5E03\u7248\u672C\u65E0\u6548");
+  return { releaseId: operationId(r.releaseId), mode: r.mode, buddyVersion: r.buddyVersion, reviewIds: selectedReviewIds(r.reviewIds), status: r.status, ...r.failure === void 0 ? {} : { failure: r.failure } };
+}
+var CloudOperationError = class extends CloudLifecycleError {
+  constructor(code2, message, details, push, release) {
+    super(code2, message, details);
+    this.push = push;
+    this.release = release;
+  }
+  push;
+  release;
+};
+function sameReviewIds(a, b) {
+  return [...a].sort().join("\0") === [...b].sort().join("\0");
+}
+function samePushMetadata(a, b) {
+  return a.pushId === b.pushId && a.commit === b.commit && a.sourceSha256 === b.sourceSha256 && JSON.stringify([...a.productReviews].sort((x, y) => x.productId.localeCompare(y.productId))) === JSON.stringify([...b.productReviews].sort((x, y) => x.productId.localeCompare(y.productId)));
+}
+
+// packages/cli-core/src/cloud/operation-store.ts
+import { createHash as createHash9, randomUUID as randomUUID8 } from "node:crypto";
+import { mkdir as mkdir9, readFile as readFile19, rename as rename10, writeFile as writeFile8, chmod } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join20 } from "node:path";
+var OperationStore = class {
+  constructor(identity, base = join20(homedir4(), ".cache", "buddy-cli", "operations")) {
+    this.identity = identity;
+    this.directory = join20(base, createHash9("sha256").update(JSON.stringify(identity)).digest("hex"));
+  }
+  identity;
+  directory;
+  async ready() {
+    await mkdir9(this.directory, { recursive: true, mode: 448 });
+    await chmod(this.directory, 448);
+  }
+  path(id, suffix = "json") {
+    return join20(this.directory, `${operationId(id)}.${suffix}`);
+  }
+  async create(record3, bytes) {
+    await this.ready();
+    if (record3.kind === "push") {
+      if (!bytes || createHash9("sha256").update(bytes).digest("hex") !== record3.metadata.sourceSha256) throw new CloudLifecycleError("INVALID_REQUEST", "\u4FDD\u5B58\u4E0A\u4F20\u8BB0\u5F55\u65F6\u5305\u5185\u5BB9\u6821\u9A8C\u5931\u8D25");
+      await writeFile8(this.path(record3.id, "tar.gz"), bytes, { flag: "wx", mode: 384 });
+    }
+    await writeFile8(this.path(record3.id), JSON.stringify({ identity: this.identity, operation: record3 }), { flag: "wx", mode: 384 });
+  }
+  async save(record3) {
+    const prior = await this.read(record3.id, record3.kind);
+    const input = (r) => r.kind === "push" ? r.metadata : r.kind === "release" ? r.request : { version: r.version, reviews: r.reviews };
+    if (JSON.stringify(input(prior)) !== JSON.stringify(input(record3))) throw new CloudLifecycleError("INVALID_REQUEST", "\u6062\u590D\u8BB0\u5F55\u7684\u539F\u59CB\u8BF7\u6C42\u4E0D\u80FD\u66F4\u6539");
+    const temporary = this.path(`${record3.id}_${randomUUID8()}`);
+    await writeFile8(temporary, JSON.stringify({ identity: this.identity, operation: record3 }), { flag: "wx", mode: 384 });
+    await rename10(temporary, this.path(record3.id));
+  }
+  async read(id, kind) {
+    try {
+      const value = JSON.parse(await readFile19(this.path(id), "utf8"));
+      const r = value.operation;
+      if (JSON.stringify(value.identity) !== JSON.stringify(this.identity) || r.kind !== kind || r.id !== id) throw new Error("identity mismatch");
+      if (r.kind === "push") {
+        parsePushMetadata(r.metadata);
+        if (r.metadata.pushId !== id) throw new Error("push mismatch");
+        if (r.receipt) parsePackagePush(r.receipt);
+      }
+      if (r.kind === "release") {
+        parseProductRelease({ ...r.request, status: "accepted" });
+        if (r.request.releaseId !== id) throw new Error("release mismatch");
+        if (r.receipt) parseProductRelease(r.receipt);
+      }
+      if (r.kind === "submission") {
+        if (typeof r.version !== "string" || !r.version.trim() || typeof r.confirmed !== "boolean" || r.reviews.length === 0) throw new Error("submission invalid");
+        parsePushMetadata({ pushId: id, commit: "validate", sourceSha256: "0".repeat(64), productReviews: r.reviews });
+      }
+      return r;
+    } catch {
+      throw new CloudLifecycleError("INVALID_REQUEST", `\u627E\u4E0D\u5230\u5F53\u524D\u5E73\u53F0\u3001\u8D26\u53F7\u548C\u642D\u5B50\u7684\u6709\u6548 ${kind} \u6062\u590D\u8BB0\u5F55\uFF1A${id}\uFF1B\u4E0D\u80FD\u66F4\u6362\u5185\u5BB9\u540E\u91CD\u7528\u6B64 ID`);
+    }
+  }
+  async archive(record3) {
+    try {
+      const bytes = await readFile19(this.path(record3.id, "tar.gz"));
+      if (createHash9("sha256").update(bytes).digest("hex") !== record3.metadata.sourceSha256) throw new Error("hash mismatch");
+      return { ...record3.bundle, mediaType: "application/gzip", bytes };
+    } catch {
+      throw new CloudLifecycleError("INVALID_REQUEST", "\u6062\u590D\u7528\u7684\u539F\u59CB\u4EE3\u7801\u5305\u7F3A\u5931\u6216\u88AB\u4FEE\u6539\uFF1B\u4E3A\u907F\u514D\u5185\u5BB9\u6F02\u79FB\uFF0C\u5DF2\u505C\u6B62\u91CD\u8BD5");
+    }
+  }
+};
+
+// packages/cli-core/src/commands/product-lifecycle.ts
+var PRODUCT_HELP = {
+  push: `\u7528\u6CD5: buddy-cli push --commit <\u6539\u52A8\u8BF4\u660E> [--product <\u5546\u54C1 ID> ...] [--directory <\u76EE\u5F55>]
+      buddy-cli push --resume <pushId> | --status <pushId> [--directory <\u76EE\u5F55>]
+\u4E0A\u4F20\u4EE3\u7801\u5E76\u63D0\u4EA4\u660E\u786E\u9009\u4E2D\u7684\u5546\u54C1\uFF1B\u4E0D\u6307\u5B9A --product \u53EA\u4E0A\u4F20\u4EE3\u7801\u3002\u4E0D\u4F1A\u81EA\u52A8\u53D1\u5E03\u3002
+\u5546\u54C1 ID \u793A\u4F8B\uFF1Aprd_12345678\uFF1B\u5DF2\u6709 ps_ \u5546\u54C1 ID \u7EE7\u7EED\u517C\u5BB9\u3002
+\u9996\u6B21\u4E0A\u4F20\u5FC5\u987B\u5B89\u88C5 npm latest \u6700\u65B0\u7A33\u5B9A Runtime \u7684\u51C6\u786E\u7248\u672C\uFF1B\u91CD\u8BD5\u56FA\u5B9A\u4F7F\u7528\u539F\u59CB\u5305\u3001\u8349\u7A3F\u7248\u672C\u548C\u5BA1\u6838 ID\u3002
+\u7F51\u7EDC\u7ED3\u679C\u672A\u77E5\u65F6\u8BF7\u4F7F\u7528\u8F93\u51FA\u7684 --resume\uFF1B--status \u53EA\u67E5\u8BE2\u3002\u4E0D\u8981\u91CD\u65B0\u4E0A\u4F20\u3002`,
+  products: `\u7528\u6CD5: buddy-cli products submit --version <\u5DF2\u4E0A\u4F20\u6216\u5F53\u524D\u53D1\u5E03\u7248\u672C> --product <\u5546\u54C1 ID> [--product <\u5546\u54C1 ID> ...] [--directory <\u76EE\u5F55>]
+      buddy-cli products submit --resume <submissionId> [--directory <\u76EE\u5F55>]
+\u7528\u4E8E\u5DF2\u4E0A\u4F20\u7248\u672C\u8865\u63D0\u5546\u54C1\uFF1B\u6B63\u5E38 push --product \u5DF2\u81EA\u52A8\u63D0\u5BA1\uFF0C\u65E0\u9700\u91CD\u590D\u6267\u884C\u3002
+\u5546\u54C1 ID \u793A\u4F8B\uFF1Aprd_12345678\uFF1B\u5DF2\u6709 ps_ \u5546\u54C1 ID \u7EE7\u7EED\u517C\u5BB9\u3002
+\u6062\u590D\u4F7F\u7528\u9996\u6B21\u6301\u4E45\u4FDD\u5B58\u7684\u5546\u54C1\u96C6\u5408\u3001\u5BA1\u6838 ID \u548C\u8349\u7A3F\u7248\u672C\u3002`,
+  release: `\u7528\u6CD5: buddy-cli release (--from-push <pushId> | --from-submission <submissionId>) [--products-only] [--directory <\u76EE\u5F55>]
+      buddy-cli release --version <\u7248\u672C> --code-only [--directory <\u76EE\u5F55>]
+      buddy-cli release (--resume | --status | --retry | --cancel) <releaseId> [--directory <\u76EE\u5F55>]
+\u53D1\u5E03\u53EA\u91C7\u7528\u6307\u5B9A\u6210\u529F\u56DE\u6267\u4E2D\u7684\u5BA1\u6838\u96C6\u5408\uFF1B\u5546\u54C1\u5931\u8D25\u4E0D\u4F1A\u81EA\u52A8\u964D\u7EA7\u4E3A\u7EAF\u4EE3\u7801\u53D1\u5E03\u3002
+\u9ED8\u8BA4\u968F\u642D\u5B50\u7248\u672C\u4E00\u8D77\u53D1\u5E03\uFF1B--products-only \u53EA\u6FC0\u6D3B\u5546\u54C1\u5E76\u6838\u5BF9\u5F53\u524D\u7EBF\u4E0A\u7248\u672C\u3002
+\u4EC5 active \u8868\u793A\u5DF2\u751F\u6548\uFF1Baccepted/activating \u8BF7\u7528 --status \u67E5\u8BE2\u3002`
+};
+function parse2(command, args) {
+  if (command === "products") {
+    if (args[0] !== "submit") throw new CloudCommandUsageError(PRODUCT_HELP.products);
+    args = args.slice(1);
+  }
+  const values = /* @__PURE__ */ new Map();
+  const products = [];
+  const allowed = command === "push" ? ["--commit", "--resume", "--status", "--product"] : command === "products" ? ["--version", "--resume", "--product"] : ["--from-push", "--from-submission", "--version", "--code-only", "--products-only", "--resume", "--status", "--retry", "--cancel"];
+  for (let i = 0; i < args.length; i++) {
+    const flag2 = args[i];
+    if (flag2 !== "--directory" && !allowed.includes(flag2)) throw new CloudCommandUsageError(`\u672A\u77E5\u53C2\u6570 ${flag2}`);
+    if (flag2 !== "--product" && values.has(flag2)) throw new CloudCommandUsageError(`${flag2} \u4E0D\u80FD\u91CD\u590D`);
+    if (["--code-only", "--products-only"].includes(flag2)) {
+      values.set(flag2, "true");
+      continue;
+    }
+    const value = args[++i];
+    if (!value?.trim() || value.startsWith("--") || /[\u0000-\u001f\u007f]/u.test(value)) throw new CloudCommandUsageError(`${flag2} \u7F3A\u5C11\u6709\u6548\u503C`);
+    if (flag2 === "--product") {
+      if (!isProductId(value) || products.includes(value)) throw new CloudCommandUsageError("\u5546\u54C1 ID \u65E0\u6548\u6216\u91CD\u590D");
+      products.push(value);
+    } else values.set(flag2, value.trim());
+  }
+  if (products.length > 10) throw new CloudCommandUsageError("\u4E00\u6B21\u6700\u591A\u9009\u62E9 10 \u4E2A\u5546\u54C1");
+  const recovery = ["--resume", "--status", "--retry", "--cancel"].filter((f) => values.has(f));
+  if (recovery.length && (recovery.length !== 1 || products.length || [...values.keys()].some((f) => f !== "--directory" && !recovery.includes(f)))) throw new CloudCommandUsageError("\u6062\u590D\u6216\u67E5\u8BE2\u547D\u4EE4\u4E0D\u80FD\u540C\u65F6\u66F4\u6539\u539F\u59CB\u8BF7\u6C42");
+  return { values, products };
+}
+function required(value) {
+  if (!value) throw new CloudCommandUsageError("\u5E73\u53F0 Adapter \u5C1A\u672A\u652F\u6301\u5546\u54C1\u4E0A\u4F20\u548C\u53D1\u5E03\u534F\u8BAE\uFF0C\u8BF7\u5347\u7EA7 Adapter");
+  return value;
+}
+function responseError(message) {
+  throw new CloudLifecycleError("PLATFORM_RESPONSE_INVALID", message);
+}
+async function selection(client, id, products, io) {
+  const reviews = [];
+  const labels = [];
+  for (const productId of products) {
+    const product = await required(client.getProductForSubmission).call(client, { id, productId });
+    if (product.productId !== productId || product.buddyId !== id || !Number.isSafeInteger(product.draftVersion) || product.draftVersion < 1) responseError("\u5546\u54C1\u8EAB\u4EFD\u6216\u8349\u7A3F\u7248\u672C\u65E0\u6548");
+    reviews.push({ productId, reviewId: `pr_${randomUUID9()}`, expectedDraftVersion: product.draftVersion });
+    labels.push({ productId, name: product.name });
+    io.write(`\u9009\u62E9\u5546\u54C1\uFF1A${product.name ?? productId}\uFF08${productId}\uFF09\uFF0C\u8349\u7A3F\u7248\u672C ${product.draftVersion}`);
+  }
+  return { reviews, labels };
+}
+function confirmPush(record3, push) {
+  if (!samePushMetadata(record3.metadata, push.metadata) || push.pushId !== record3.id) responseError("\u670D\u52A1\u5668\u4E0A\u4F20\u56DE\u6267\u4E0E\u539F\u59CB\u8BF7\u6C42\u4E0D\u4E00\u81F4");
+  if (push.status === "completed" && (!push.uploadVersion || !sameReviewIds(push.reviewIds, record3.metadata.productReviews.map((r) => r.reviewId)))) responseError("\u670D\u52A1\u5668\u672A\u786E\u8BA4\u5B8C\u6574\u5546\u54C1\u5BA1\u6838\u96C6\u5408");
+}
+function failureMessage(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const detail = value;
+  const code2 = typeof detail.code === "string" ? detail.code : void 0;
+  const message = typeof detail.message === "string" ? detail.message : void 0;
+  return [code2, message].filter(Boolean).join(" \xB7 ") || void 0;
+}
+function showPush(io, push) {
+  io.write(`\u4E0A\u4F20\u7F16\u53F7\uFF1A${push.pushId}`);
+  if (push.uploadVersion) io.write(`\u4E0A\u4F20\u7248\u672C\uFF1A${push.uploadVersion}`);
+  io.write(`\u4E0A\u4F20\u72B6\u6001\uFF1A${push.status}`);
+  if (failureMessage(push.failure)) io.writeError(`\u539F\u56E0\uFF1A${failureMessage(push.failure)}`);
+  if (push.reviewIds.length) io.write(`\u5546\u54C1\u5BA1\u6838\u7F16\u53F7\uFF1A${push.reviewIds.join(", ")}`);
+  if (push.status === "completed") {
+    io.write(`\u672C\u6B21 push \u4E0D\u4F1A\u53D1\u5E03\u642D\u5B50\uFF1B\u786E\u8BA4\u4EE3\u7801\u53CA\u6240\u9009\u5546\u54C1\u5BA1\u6838\u7ED3\u679C\u540E\u4F7F\u7528 buddy-cli release --from-push ${push.pushId}\u3002`);
+    return 0;
+  }
+  if (push.status === "product_reviews_failed") io.writeError(`\u4EE3\u7801\u5305\u5DF2\u4FDD\u5B58\uFF0C\u5546\u54C1\u672A\u5B8C\u6574\u63D0\u5BA1\u3002\u4FEE\u6B63\u5546\u54C1\u540E\u4F7F\u7528 products submit --version ${push.uploadVersion} --product <\u5546\u54C1 ID> \u8865\u63D0\uFF1B\u7EAF\u4EE3\u7801\u53D1\u5E03\u987B\u660E\u786E --code-only\u3002`);
+  else io.writeError(`\u4E0A\u4F20\u672A\u5B8C\u6210\uFF0C\u4F7F\u7528 buddy-cli push --resume ${push.pushId} \u6062\u590D\u539F\u8BF7\u6C42\u3002`);
+  return 1;
+}
+async function executePush(record3, sourceBundle, store, client, id, io, options) {
+  try {
+    const receipt = await client.pushPackage({ id, commit: record3.metadata.commit, metadata: record3.metadata, sourceBundle });
+    const push = required(receipt.push);
+    confirmPush(record3, push);
+    await store.save({ ...record3, receipt: push });
+    let exitCode = showPush(io, push);
+    io.write(`commit\uFF1A${receipt.commit}`);
+    io.write(`\u5BA1\u6838\u72B6\u6001\uFF1A${{ auditing: "\u5BA1\u6838\u4E2D", approved: "\u5DF2\u901A\u8FC7", rejected: "\u672A\u901A\u8FC7" }[receipt.auditStatus]}`);
+    if (receipt.buildStatus && client.getPackageBuild && exitCode === 0) {
+      let build = { buildStatus: receipt.buildStatus, buildError: receipt.buildError ?? null };
+      const deadline = Date.now() + (options.buildWaitMs ?? 6e4);
+      try {
+        while (build.buildStatus === "building" && Date.now() < deadline) {
+          await delay3(Math.min(options.buildPollMs ?? 2e3, Math.max(1, deadline - Date.now())), void 0, { signal: options.signal });
+          build = await client.getPackageBuild({ id, version: receipt.version });
+        }
+        io.write(`\u6784\u5EFA\uFF1A${{ building: "\u6784\u5EFA\u4E2D", ready: "\u6784\u5EFA\u5B8C\u6210", failed: "\u6784\u5EFA\u5931\u8D25" }[build.buildStatus]}${build.buildError ? ` \xB7 ${build.buildError}` : ""}`);
+        if (build.buildStatus === "failed") exitCode = 1;
+        if (build.buildStatus === "building") io.write("\u6784\u5EFA\u4ECD\u5728\u8FDB\u884C\uFF0C\u7A0D\u540E\u8FD0\u884C buddy-cli status \u67E5\u8BE2\uFF1B\u4E0D\u8981\u91CD\u590D\u4E0A\u4F20\u3002");
+      } catch (cause) {
+        io.writeError(`\u4EE3\u7801\u5DF2\u4E0A\u4F20\uFF0C\u4F46\u6784\u5EFA\u72B6\u6001\u5C1A\u672A\u786E\u8BA4\uFF1A${cause instanceof Error ? cause.message : "\u7F51\u7EDC\u9519\u8BEF"}\u3002\u7528 buddy-cli status \u91CD\u67E5\uFF0C\u4E0D\u8981\u91CD\u590D\u4E0A\u4F20\u3002`);
+        return { exitCode: 1, buddyId: id, version: receipt.version };
+      }
+    }
+    return { exitCode, buddyId: id, version: receipt.version };
+  } catch (cause) {
+    if (cause instanceof CloudOperationError && cause.push) {
+      confirmPush(record3, cause.push);
+      await store.save({ ...record3, receipt: cause.push });
+      showPush(io, cause.push);
+    }
+    io.writeError(`\u4E0A\u4F20\u7ED3\u679C\u9700\u786E\u8BA4\u3002\u6062\u590D\u547D\u4EE4\uFF1Abuddy-cli push --resume ${record3.id}`);
+    throw cause;
+  }
+}
+function matchRelease(request, release) {
+  if (request.releaseId !== release.releaseId || request.mode !== release.mode || request.buddyVersion !== release.buddyVersion || !sameReviewIds(request.reviewIds, release.reviewIds)) responseError("\u53D1\u5E03\u56DE\u6267\u4E0E\u56FA\u5B9A\u8BF7\u6C42\u4E0D\u4E00\u81F4");
+}
+function showRelease(io, release) {
+  io.write(`\u53D1\u5E03\u7F16\u53F7\uFF1A${release.releaseId}`);
+  io.write(`\u53D1\u5E03\u72B6\u6001\uFF1A${release.status}`);
+  io.write(`\u76EE\u6807\u7248\u672C\uFF1A${release.buddyVersion}`);
+  if (failureMessage(release.failure)) io.writeError(`\u539F\u56E0\uFF1A${failureMessage(release.failure)}`);
+  if (release.status === "active") {
+    io.write("\u53D1\u5E03\u5DF2\u751F\u6548\u3002");
+    return 0;
+  }
+  if (release.status === "failed") io.writeError(`\u53D1\u5E03\u672A\u751F\u6548\u3002\u4FEE\u6B63\u539F\u56E0\u540E buddy-cli release --retry ${release.releaseId}\uFF1B\u653E\u5F03\u5219 --cancel ${release.releaseId}\u3002`);
+  else if (release.status === "cancelled") io.write("\u8BE5\u53D1\u5E03\u5DF2\u53D6\u6D88\u3002");
+  else io.write(`\u53D1\u5E03\u4ECD\u5728\u5904\u7406\uFF0C\u8BF7\u8FD0\u884C buddy-cli release --status ${release.releaseId} \u786E\u8BA4\u662F\u5426\u751F\u6548\u3002`);
+  return 1;
+}
+async function runProductLifecycle(command, args, io, options) {
+  if (args.length === 1 && ["--help", "-h"].includes(args[0]) || command === "products" && args.length === 2 && args[0] === "submit" && args[1] === "--help") {
+    io.write(PRODUCT_HELP[command]);
+    return { exitCode: 0 };
+  }
+  const p = parse2(command, args);
+  const v = p.values;
+  if (options.mode === "local-mock") throw new CloudCommandUsageError("\u672C\u5730\u6A21\u62DF\u6A21\u5F0F\u4E0D\u4F1A\u4F2A\u9020\u6B63\u5F0F push \u6216\u53D1\u5E03\uFF0C\u8BF7\u8FDE\u63A5\u771F\u5B9E MLB Server");
+  const freshPush = command === "push" && !v.has("--resume") && !v.has("--status");
+  const root = await (options.resolveProjectRoot ?? (freshPush ? requireBuddyAgentProjectRoot : requireBuddyProjectRoot))(resolve15(options.cwd ?? process.cwd(), v.get("--directory") ?? "."));
+  const platform = resolvePlatformUrl({ env: options.runtimeUpdate?.env });
+  await checkProjectGateway(root, platform);
+  const config = freshPush ? await (options.readConfig ?? readBuddyConfig)(root) : await (options.readManifest ?? readBuddyProjectManifest)(root);
+  const id = config.buddyId;
+  if (!id) throw new CloudCommandUsageError("\u5F53\u524D\u9879\u76EE\u7F3A\u5C11\u5E73\u53F0\u751F\u6210\u7684 buddyId\uFF0C\u8BF7\u5148\u8FD0\u884C buddy-cli init");
+  const client = required(options.client);
+  const session = required(options.session);
+  let commit = v.get("--commit");
+  if (freshPush && !commit) {
+    if (!io.canPrompt || !io.input) throw new CloudCommandUsageError("\u7F3A\u5C11 --commit\uFF1B\u8BF7\u8BF4\u660E\u672C\u6B21\u63D0\u4EA4\u5BA1\u6838\u7684\u6539\u52A8\u5185\u5BB9");
+    while (!commit) commit = (await io.input("\u8BF7\u8BF4\u660E\u672C\u6B21\u63D0\u4EA4\u5BA1\u6838\u7684\u6539\u52A8\u5185\u5BB9")).trim();
+  }
+  if (commit && (commit.length > 2e3 || /[\u0000-\u001f\u007f]/u.test(commit))) throw new CloudCommandUsageError("--commit \u987B\u4E0D\u8D85\u8FC7 2000 \u5B57\u4E14\u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26");
+  const runtime = freshPush ? await requireProjectRuntime(root, { ...options.runtimeUpdate, signal: options.signal }) : void 0;
+  const token = await session.token({ signal: options.signal });
+  const store = new OperationStore({ platform: platform.toString(), subject: token.subject, buddyId: id }, options.operationCacheDirectory);
+  if (command === "push") {
+    const statusId = v.get("--status");
+    if (statusId) {
+      const push = await required(client.getPackagePush).call(client, { id, pushId: statusId });
+      if (push.pushId !== statusId) responseError("\u4E0A\u4F20\u7F16\u53F7\u4E0D\u5339\u914D");
+      return { exitCode: showPush(io, push), buddyId: id, ...push.uploadVersion ? { version: push.uploadVersion } : {} };
+    }
+    const resume = v.get("--resume");
+    if (resume) {
+      const record5 = await store.read(resume, "push");
+      return executePush(record5, await store.archive(record5), store, client, id, io, options);
+    }
+    const bundle = await required(options.preparePush)(root, config, runtime);
+    for (const warning2 of bundle.warnings ?? []) io.writeError(`\u6253\u5305\u63D0\u793A [${warning2.code}]\uFF1A${warning2.message}`);
+    const chosen = await selection(client, id, p.products, io);
+    const pushId = `pu_${randomUUID9()}`;
+    const { bytes, ...bundleInfo } = bundle;
+    const record4 = { kind: "push", id: pushId, metadata: { pushId, commit, sourceSha256: createHash10("sha256").update(bytes).digest("hex"), productReviews: chosen.reviews }, bundle: bundleInfo, products: chosen.labels };
+    await store.create(record4, bytes);
+    io.write(`\u6062\u590D\u7F16\u53F7\uFF1A${pushId}`);
+    return executePush(record4, bundle, store, client, id, io, options);
+  }
+  if (command === "products") {
+    let record4;
+    if (v.has("--resume")) record4 = await store.read(v.get("--resume"), "submission");
+    else {
+      const version = v.get("--version");
+      if (!version || !p.products.length) throw new CloudCommandUsageError(PRODUCT_HELP.products);
+      const chosen = await selection(client, id, p.products, io);
+      record4 = { kind: "submission", id: `sub_${randomUUID9()}`, version, reviews: chosen.reviews, confirmed: false };
+      await store.create(record4);
+    }
+    io.write(`\u5546\u54C1\u63D0\u4EA4\u7F16\u53F7\uFF1A${record4.id}`);
+    try {
+      const receipt = await required(client.submitPackageProducts).call(client, { id, version: record4.version, reviews: record4.reviews });
+      if (!sameReviewIds(receipt.reviewIds, record4.reviews.map((r) => r.reviewId))) responseError("\u5E73\u53F0\u672A\u786E\u8BA4\u5B8C\u6574\u5546\u54C1\u5BA1\u6838\u96C6\u5408");
+      await store.save({ ...record4, confirmed: true });
+      io.write(`\u5546\u54C1\u5DF2\u63D0\u4EA4\u5BA1\u6838\uFF1A${receipt.reviewIds.join(", ")}`);
+      io.write(`\u5BA1\u6838\u901A\u8FC7\u540E\uFF1Abuddy-cli release --from-submission ${record4.id}`);
+      return { exitCode: 0, buddyId: id, version: record4.version };
+    } catch (cause) {
+      io.writeError(`\u4FDD\u7559\u539F\u8BF7\u6C42\u91CD\u8BD5\uFF1Abuddy-cli products submit --resume ${record4.id}`);
+      throw cause;
+    }
+  }
+  const action = ["--resume", "--status", "--retry", "--cancel"].find((f) => v.has(f));
+  let record3;
+  if (action) {
+    const releaseId = v.get(action);
+    if (action === "--status") {
+      const release = await required(client.getProductRelease).call(client, { id, releaseId });
+      if (release.releaseId !== releaseId) responseError("\u53D1\u5E03\u7F16\u53F7\u4E0D\u5339\u914D");
+      return { exitCode: showRelease(io, release), buddyId: id, version: release.buddyVersion };
+    }
+    record3 = await store.read(releaseId, "release");
+  } else {
+    const sources = ["--from-push", "--from-submission", "--version"].filter((f) => v.has(f));
+    if (sources.length !== 1 || v.has("--code-only") !== v.has("--version") || v.has("--code-only") && v.has("--products-only")) throw new CloudCommandUsageError(PRODUCT_HELP.release);
+    let version;
+    let reviewIds;
+    if (v.has("--from-push")) {
+      const pushRecord = await store.read(v.get("--from-push"), "push");
+      const receipt = await required(client.getPackagePush).call(client, { id, pushId: pushRecord.id });
+      confirmPush(pushRecord, receipt);
+      await store.save({ ...pushRecord, receipt });
+      if (receipt.status !== "completed" || !receipt.uploadVersion) throw new CloudCommandUsageError("\u6307\u5B9A\u4E0A\u4F20\u5C1A\u672A\u5B8C\u6574\u63D0\u5BA1\uFF0C\u4E0D\u80FD\u81EA\u52A8\u7701\u7565\u5931\u8D25\u5546\u54C1\uFF1B\u8BF7\u8865\u63D0\u6216\u660E\u786E --version <\u7248\u672C> --code-only");
+      version = receipt.uploadVersion;
+      reviewIds = receipt.reviewIds;
+    } else if (v.has("--from-submission")) {
+      const submission = await store.read(v.get("--from-submission"), "submission");
+      if (!submission.confirmed) throw new CloudCommandUsageError(`\u8865\u63D0\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5148 products submit --resume ${submission.id}`);
+      version = submission.version;
+      reviewIds = submission.reviews.map((r) => r.reviewId);
+    } else {
+      version = v.get("--version");
+      reviewIds = [];
+    }
+    if (v.has("--products-only")) {
+      if (!reviewIds.length) throw new CloudCommandUsageError("--products-only \u9700\u8981\u660E\u786E\u7684\u5546\u54C1\u5BA1\u6838\u96C6\u5408");
+      const buddy2 = await client.getBuddy({ id });
+      if (buddy2.id !== id || !buddy2.released || buddy2.version !== version) throw new CloudCommandUsageError("\u4EC5\u5546\u54C1\u53D1\u5E03\u8981\u6C42\u56DE\u6267\u7248\u672C\u4E0E\u5F53\u524D\u5DF2\u53D1\u5E03\u642D\u5B50\u7248\u672C\u4E00\u81F4");
+    }
+    const releaseId = `rel_${randomUUID9()}`;
+    record3 = { kind: "release", id: releaseId, request: { releaseId, mode: v.has("--products-only") ? "products_only" : "with_buddy", buddyVersion: version, reviewIds } };
+    await store.create(record3);
+  }
+  io.write(`\u6062\u590D\u7F16\u53F7\uFF1A${record3.id}`);
+  try {
+    const receipt = action === "--retry" ? await required(client.retryProductRelease).call(client, { id, releaseId: record3.id }) : action === "--cancel" ? await required(client.cancelProductRelease).call(client, { id, releaseId: record3.id }) : await required(client.createProductRelease).call(client, { id, release: record3.request });
+    matchRelease(record3.request, receipt);
+    await store.save({ ...record3, receipt });
+    return { exitCode: showRelease(io, receipt), buddyId: id, version: receipt.buddyVersion };
+  } catch (cause) {
+    if (cause instanceof CloudOperationError && cause.release) {
+      matchRelease(record3.request, cause.release);
+      await store.save({ ...record3, receipt: cause.release });
+      showRelease(io, cause.release);
+    }
+    io.writeError(`\u53D1\u5E03\u7ED3\u679C\u9700\u786E\u8BA4\uFF1Abuddy-cli release --status ${record3.id}\uFF1B\u539F\u8BF7\u6C42\u6062\u590D\uFF1Abuddy-cli release --resume ${record3.id}`);
+    throw cause;
+  }
+}
+
 // packages/cli-core/src/push/errors.ts
 var PushPreflightError = class extends Error {
   code;
@@ -5319,13 +5737,13 @@ var PushPreflightError = class extends Error {
 };
 
 // packages/cli-core/src/commands/cloud.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 
 // packages/cli-core/src/cloud/auth.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // packages/cli-core/src/cloud/validation.ts
-function record(value, path = "request") {
+function record2(value, path = "request") {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return invalidRequest(`${path} \u5FC5\u987B\u662F\u5BF9\u8C61`);
   }
@@ -5335,12 +5753,12 @@ function record(value, path = "request") {
   }
   return value;
 }
-function exactKeys(value, required, optional = [], path = "request") {
-  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+function exactKeys(value, required2, optional = [], path = "request") {
+  const allowed = /* @__PURE__ */ new Set([...required2, ...optional]);
   for (const key of Object.keys(value)) {
     if (!allowed.has(key)) invalidRequest(`${path} \u5305\u542B\u672A\u77E5\u5B57\u6BB5 ${key}`);
   }
-  for (const key of required) {
+  for (const key of required2) {
     if (!Object.hasOwn(value, key)) invalidRequest(`${path} \u7F3A\u5C11\u5B57\u6BB5 ${key}`);
   }
 }
@@ -5390,7 +5808,7 @@ var CloudAuthenticator = class {
     this.#adapter = adapter;
     this.#store = store;
     this.#now = options.now ?? Date.now;
-    this.#createState = options.createState ?? randomUUID8;
+    this.#createState = options.createState ?? randomUUID10;
     this.#minimumValidityMs = options.minimumValidityMs ?? 3e4;
     if (!Number.isSafeInteger(this.#minimumValidityMs) || this.#minimumValidityMs < 0) {
       throw new TypeError("minimumValidityMs must be a non-negative safe integer");
@@ -5442,7 +5860,7 @@ var CloudAuthenticator = class {
       state: state2,
       ...signal === void 0 ? {} : { signal }
     }));
-    const resultRecord = record(result, "browser login result");
+    const resultRecord = record2(result, "browser login result");
     exactKeys(resultRecord, ["state", "token"], [], "browser login result");
     if (resultRecord.state !== state2) {
       throw new CloudLifecycleError(
@@ -5460,7 +5878,7 @@ var CloudAuthenticator = class {
 };
 function validateToken2(value) {
   try {
-    const input = record(value, "cloud token");
+    const input = record2(value, "cloud token");
     exactKeys(input, ["accessToken", "subject", "expiresAt"], [], "cloud token");
     const accessToken = safeString(input.accessToken, "cloud token accessToken", {
       min: 16,
@@ -5538,6 +5956,7 @@ var EcsSessionMigrationStore = class {
 };
 
 // packages/cli-core/src/cloud/http-client.ts
+import { createHash as createHash11 } from "node:crypto";
 var MAX_RESPONSE_BYTES = 1024 * 1024;
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_UPLOAD_TIMEOUT_MS = 5 * 6e4;
@@ -5548,17 +5967,17 @@ function positiveTimeout(value, fallback, name) {
 }
 function object3(value, path) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw invalid2(`${path} \u5FC5\u987B\u662F\u5BF9\u8C61`);
+    throw invalid3(`${path} \u5FC5\u987B\u662F\u5BF9\u8C61`);
   }
   return value;
 }
-function invalid2(message) {
+function invalid3(message) {
   return new CloudLifecycleError("PLATFORM_RESPONSE_INVALID", message);
 }
 function safeText(value, path, allowNewlines = false, allowEmpty = false) {
-  if (typeof value !== "string" || !allowEmpty && !value.trim()) throw invalid2(`${path} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+  if (typeof value !== "string" || !allowEmpty && !value.trim()) throw invalid3(`${path} \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
   const invalidControl = allowNewlines ? /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u : /[\u0000-\u001f\u007f]/u;
-  if (invalidControl.test(value)) throw invalid2(`${path} \u5305\u542B\u975E\u6CD5\u63A7\u5236\u5B57\u7B26`);
+  if (invalidControl.test(value)) throw invalid3(`${path} \u5305\u542B\u975E\u6CD5\u63A7\u5236\u5B57\u7B26`);
   return value;
 }
 function optionalText(value, path, allowNewlines = false) {
@@ -5580,29 +5999,29 @@ function meta(value, path) {
   });
 }
 function flag(value, path) {
-  if (typeof value !== "boolean") throw invalid2(`${path} \u5FC5\u987B\u662F boolean`);
+  if (typeof value !== "boolean") throw invalid3(`${path} \u5FC5\u987B\u662F boolean`);
   return value;
 }
 function timestamp(value, path) {
-  if (!Number.isSafeInteger(value) || value < 0) throw invalid2(`${path} \u5FC5\u987B\u662F\u975E\u8D1F\u6BEB\u79D2\u65F6\u95F4\u6233`);
+  if (!Number.isSafeInteger(value) || value < 0) throw invalid3(`${path} \u5FC5\u987B\u662F\u975E\u8D1F\u6BEB\u79D2\u65F6\u95F4\u6233`);
   return value;
 }
 function nullableText(value, path) {
   return value === null ? null : safeText(value, path);
 }
 function nonNegativeInteger(value, path) {
-  if (!Number.isSafeInteger(value) || value < 0) throw invalid2(`${path} \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570`);
+  if (!Number.isSafeInteger(value) || value < 0) throw invalid3(`${path} \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570`);
   return value;
 }
 function auditStatus(value, path) {
   if (value !== "auditing" && value !== "approved" && value !== "rejected") {
-    throw invalid2(`${path} \u5FC5\u987B\u662F auditing\u3001approved \u6216 rejected`);
+    throw invalid3(`${path} \u5FC5\u987B\u662F auditing\u3001approved \u6216 rejected`);
   }
   return value;
 }
 function parseBuild(value) {
   const source = object3(value, "build");
-  if (!["building", "ready", "failed"].includes(String(source.buildStatus))) throw invalid2("\u6784\u5EFA\u72B6\u6001\u65E0\u6548");
+  if (!["building", "ready", "failed"].includes(String(source.buildStatus))) throw invalid3("\u6784\u5EFA\u72B6\u6001\u65E0\u6548");
   return {
     buildStatus: source.buildStatus,
     buildError: source.buildError == null ? null : safeText(source.buildError, "build.buildError")
@@ -5652,7 +6071,7 @@ async function boundedJson(response) {
       total += item.value.byteLength;
       if (total > MAX_RESPONSE_BYTES) {
         void reader.cancel().catch(() => void 0);
-        throw invalid2("\u5E73\u53F0\u54CD\u5E94\u8D85\u8FC7 1 MiB");
+        throw invalid3("\u5E73\u53F0\u54CD\u5E94\u8D85\u8FC7 1 MiB");
       }
       chunks.push(item.value);
     }
@@ -5668,17 +6087,17 @@ async function boundedJson(response) {
   try {
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   } catch {
-    throw invalid2("\u5E73\u53F0\u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON");
+    throw invalid3("\u5E73\u53F0\u54CD\u5E94\u4E0D\u662F\u6709\u6548 JSON");
   }
 }
 function serverError(response, body) {
   const source = typeof body === "object" && body !== null && !Array.isArray(body) ? body : void 0;
   const message = typeof source?.error === "string" && source.error.trim() ? source.error.slice(0, 8 * 1024) : `\u5E73\u53F0\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${response.status}\uFF09`;
   const code2 = response.status === 401 ? "AUTH_TOKEN_EXPIRED" : response.status === 404 ? "APP_NOT_FOUND" : response.status >= 500 ? "PLATFORM_UNAVAILABLE" : "INVALID_REQUEST";
-  return new CloudLifecycleError(code2, message, {
+  return new CloudOperationError(code2, message, {
     httpStatus: response.status,
     retryable: response.status === 408 || response.status === 429 || response.status >= 500
-  });
+  }, source?.push === void 0 ? void 0 : parsePackagePush(source.push), source?.release === void 0 ? void 0 : parseProductRelease(source.release));
 }
 var HttpDeveloperPlatformClient = class {
   #baseUrl;
@@ -5739,7 +6158,7 @@ var HttpDeveloperPlatformClient = class {
     const mediaType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
     if (mediaType !== "application/json") {
       await response.body?.cancel().catch(() => void 0);
-      throw invalid2(`\u5E73\u53F0\u54CD\u5E94 Content-Type \u65E0\u6548\uFF08HTTP ${response.status}\uFF09`);
+      throw invalid3(`\u5E73\u53F0\u54CD\u5E94 Content-Type \u65E0\u6548\uFF08HTTP ${response.status}\uFF09`);
     }
     const payload = await boundedJson(response);
     if (!response.ok) throw serverError(response, payload);
@@ -5764,7 +6183,7 @@ var HttpDeveloperPlatformClient = class {
   }
   async listBuddies() {
     const source = object3(await this.#request("/cli/buddies", "GET"), "response");
-    if (!Array.isArray(source.buddies)) throw invalid2("response.buddies \u5FC5\u987B\u662F\u6570\u7EC4");
+    if (!Array.isArray(source.buddies)) throw invalid3("response.buddies \u5FC5\u987B\u662F\u6570\u7EC4");
     return Object.freeze({
       buddies: Object.freeze(source.buddies.map((item) => buddy(item, false)))
     });
@@ -5784,7 +6203,7 @@ var HttpDeveloperPlatformClient = class {
       `/cli/buddies/${encodeURIComponent(request.id)}/packages${suffix}`,
       "GET"
     ), "response");
-    if (!Array.isArray(source.items)) throw invalid2("response.items \u5FC5\u987B\u662F\u6570\u7EC4");
+    if (!Array.isArray(source.items)) throw invalid3("response.items \u5FC5\u987B\u662F\u6570\u7EC4");
     return Object.freeze({
       total: nonNegativeInteger(source.total, "response.total"),
       page: nonNegativeInteger(source.page, "response.page"),
@@ -5802,37 +6221,82 @@ var HttpDeveloperPlatformClient = class {
       throw new CloudLifecycleError("INVALID_REQUEST", "\u63D0\u4EA4\u5305\u4E0D\u80FD\u4E3A\u7A7A");
     }
     const query = new URLSearchParams({ commit });
+    const form = request.metadata ? new FormData() : void 0;
+    if (form && request.metadata) {
+      if (request.metadata.commit !== commit || request.metadata.sourceSha256 !== createHash11("sha256").update(request.sourceBundle.bytes).digest("hex")) throw new CloudLifecycleError("INVALID_REQUEST", "\u4FDD\u5B58\u7684\u4E0A\u4F20\u5143\u6570\u636E\u4E0E\u7A0B\u5E8F\u5305\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u52FF\u66F4\u6362\u6062\u590D\u5305");
+      form.set("metadata", JSON.stringify(request.metadata));
+      form.set("archive", new Blob([new Uint8Array(request.sourceBundle.bytes)], { type: "application/gzip" }), "archive.tar.gz");
+    }
     const source = object3(await this.#request(
-      `/cli/buddies/${encodeURIComponent(request.id)}/packages/push?${query.toString()}`,
+      `/cli/buddies/${encodeURIComponent(request.id)}/packages/push${form ? "" : `?${query.toString()}`}`,
       "POST",
       {
-        binary: request.sourceBundle.bytes,
-        mediaType: request.sourceBundle.mediaType,
+        ...form ? { form } : { binary: request.sourceBundle.bytes, mediaType: request.sourceBundle.mediaType },
         timeoutMs: this.#uploadTimeoutMs
       }
     ), "response");
+    const push = request.metadata ? parsePackagePush(source.push) : void 0;
+    if (push && request.metadata && !samePushMetadata(push.metadata, request.metadata)) throw invalid3("\u5E73\u53F0\u4E0A\u4F20\u56DE\u6267\u4E0E\u56FA\u5B9A\u8BF7\u6C42\u4E0D\u5339\u914D");
     return Object.freeze({
       version: safeText(source.version, "response.version"),
       commit: safeText(source.commit, "response.commit"),
       size: nonNegativeInteger(source.size, "response.size"),
       auditStatus: auditStatus(source.auditStatus, "response.auditStatus"),
-      ...source.buildStatus === void 0 ? {} : parseBuild(source)
+      ...source.buildStatus === void 0 ? {} : parseBuild(source),
+      ...push ? { push, reviewIds: selectedReviewIds(source.reviewIds) } : {}
     });
   }
+  async getProductForSubmission(request) {
+    const response = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/products/${encodeURIComponent(request.productId)}`, "GET"), "response");
+    const p = object3(response.product, "product"), draft = object3(p.draft, "product.draft"), declaration = object3(draft.declaration, "product.draft.declaration");
+    if (p.productId !== request.productId || p.buddyId !== request.id) throw invalid3("\u5546\u54C1\u5F52\u5C5E\u4E0E\u8BF7\u6C42\u4E0D\u5339\u914D");
+    const draftVersion = nonNegativeInteger(p.draftVersion, "product.draftVersion");
+    if (draftVersion < 1) throw invalid3("\u5546\u54C1\u8349\u7A3F\u7248\u672C\u65E0\u6548");
+    return { productId: request.productId, buddyId: request.id, draftVersion, name: declaration.name == null ? null : safeText(declaration.name, "product.name", false, true) };
+  }
+  async getPackagePush(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/packages/pushes/${encodeURIComponent(request.pushId)}`, "GET"), "response");
+    const push = parsePackagePush(source.push);
+    if (push.pushId !== request.pushId) throw invalid3("\u4E0A\u4F20\u56DE\u6267 ID \u4E0D\u5339\u914D");
+    return push;
+  }
+  async submitPackageProducts(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/packages/${encodeURIComponent(request.version)}/product-reviews`, "POST", { json: { reviews: request.reviews } }), "response");
+    return { reviewIds: selectedReviewIds(source.reviewIds) };
+  }
+  async createProductRelease(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/product-releases`, "POST", { json: request.release }), "response");
+    return parseProductRelease(source.release);
+  }
+  async getProductRelease(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/product-releases/${encodeURIComponent(request.releaseId)}`, "GET"), "response");
+    const release = parseProductRelease(source.release);
+    if (release.releaseId !== request.releaseId) throw invalid3("\u53D1\u5E03\u56DE\u6267 ID \u4E0D\u5339\u914D");
+    return release;
+  }
+  async retryProductRelease(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/product-releases/${encodeURIComponent(request.releaseId)}/retry`, "POST"), "response");
+    return parseProductRelease(source.release);
+  }
+  async cancelProductRelease(request) {
+    const source = object3(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/product-releases/${encodeURIComponent(request.releaseId)}/cancel`, "POST"), "response");
+    return parseProductRelease(source.release);
+  }
   async getPackageBuild(request) {
     return parseBuild(await this.#request(`/cli/buddies/${encodeURIComponent(request.id)}/packages/${encodeURIComponent(request.version)}/build`, "GET"));
   }
   async logout(accessToken) {
     const source = object3(await this.#request("/cli/auth/logout", "POST", { accessToken }), "response");
-    if (source.ok !== true) throw invalid2("response.ok \u5FC5\u987B\u662F true");
+    if (source.ok !== true) throw invalid3("response.ok \u5FC5\u987B\u662F true");
   }
 };
 
 // packages/cli-core/src/cloud/mock-client.ts
-import { createHash as createHash9, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash12, randomBytes as randomBytes3 } from "node:crypto";
 var MockDeveloperPlatformClient = class {
   #now;
   #buddies = /* @__PURE__ */ new Map();
+  #pushes = /* @__PURE__ */ new Map();
   #packages = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.#now = options.now ?? Date.now;
@@ -5857,7 +6321,7 @@ var MockDeveloperPlatformClient = class {
     const current = this.#require(request.id);
     validateBuddyMetaUpdate(request.meta);
     const onlyAvatar = Object.keys(request.meta).every((key) => key === "avatar");
-    const avatar = request.avatar ? `/media/avatar-${request.id}.webp?v=${createHash9("sha256").update(request.avatar.bytes).digest("hex").slice(0, 16)}` : request.meta.avatar === null ? null : current.meta?.avatar ?? null;
+    const avatar = request.avatar ? `/media/avatar-${request.id}.webp?v=${createHash12("sha256").update(request.avatar.bytes).digest("hex").slice(0, 16)}` : request.meta.avatar === null ? null : current.meta?.avatar ?? null;
     const next = this.#value({ ...current, meta: { ...onlyAvatar ? current.meta : request.meta, avatar }, updatedAt: this.#now() });
     this.#buddies.set(request.id, next);
     return structuredClone(next);
@@ -5894,6 +6358,8 @@ var MockDeveloperPlatformClient = class {
       throw new CloudLifecycleError("INVALID_REQUEST", "commit \u4E0D\u80FD\u4E3A\u7A7A");
     }
     const current = this.#require(request.id);
+    const existing = request.metadata && this.#pushes.get(request.metadata.pushId);
+    if (existing) return { version: existing.uploadVersion, commit: existing.metadata.commit, size: request.sourceBundle.bytes.byteLength, auditStatus: "auditing", push: structuredClone(existing), reviewIds: existing.reviewIds };
     const pushedAt = this.#now();
     const version = mockVersion(pushedAt);
     const versions = this.#packages.get(request.id) ?? [];
@@ -5906,12 +6372,20 @@ var MockDeveloperPlatformClient = class {
       version,
       commit: request.commit,
       size: request.sourceBundle.bytes.byteLength,
-      auditStatus: "auditing"
+      auditStatus: "auditing",
+      ...request.metadata ? { push: { pushId: request.metadata.pushId, uploadVersion: version, status: "completed", metadata: request.metadata, reviewIds: request.metadata.productReviews.map((r) => r.reviewId), failure: null }, reviewIds: request.metadata.productReviews.map((r) => r.reviewId) } : {}
     });
+    if (receipt.push) this.#pushes.set(receipt.push.pushId, receipt.push);
     versions.unshift(Object.freeze({ ...receipt, auditNote: null }));
     this.#packages.set(request.id, versions);
     return receipt;
   }
+  async getPackagePush(request) {
+    this.#require(request.id);
+    const push = this.#pushes.get(request.pushId);
+    if (!push) throw new CloudLifecycleError("APP_NOT_FOUND", "\u4E0A\u4F20\u8BB0\u5F55\u4E0D\u5B58\u5728");
+    return structuredClone(push);
+  }
   async logout(_accessToken) {
   }
   #require(id) {
@@ -5933,20 +6407,12 @@ function mockVersion(now) {
 }
 
 // packages/cli-core/src/commands/cloud.ts
-var CloudCommandUsageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CloudCommandUsageError";
-  }
-};
 var HELP = Object.freeze({
   login: "\u7528\u6CD5: buddy-cli login",
   logout: "\u7528\u6CD5: buddy-cli logout",
-  push: `\u7528\u6CD5: buddy-cli push [--directory <\u9879\u76EE\u76EE\u5F55>] [--commit <\u672C\u6B21\u6539\u52A8\u8BF4\u660E>]
---directory \u9ED8\u8BA4\u5F53\u524D\u5DE5\u7A0B\uFF1B--commit \u662F\u4E0A\u4F20\u8BF4\u660E\uFF0C\u4E0D\u4F1A\u521B\u5EFA Git commit\uFF0C\u975E\u4EA4\u4E92\u8C03\u7528\u5FC5\u987B\u63D0\u4F9B\u3002
-\u5DE5\u7A0B\u5FC5\u987B\u5B89\u88C5 npm \u6700\u65B0\u7A33\u5B9A\u7248 Runtime\uFF1B\u7248\u672C\u4E0D\u4E00\u81F4\u6216\u67E5\u8BE2\u5931\u8D25\u65F6\u7981\u6B62\u4E0A\u4F20\u3002
-\u4E0A\u4F20\u540E\u663E\u793A\u5BA1\u6838\u53CA\u6784\u5EFA\u72B6\u6001\uFF1B\u6784\u5EFA\u672A\u5B8C\u6210\u7528 status \u91CD\u67E5\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u53D1\u5E03\u3002
-\u793A\u4F8B: buddy-cli push --commit "\u8C03\u6574\u56DE\u590D\u65B9\u5F0F"`,
+  push: PRODUCT_HELP.push,
+  products: PRODUCT_HELP.products,
+  release: PRODUCT_HELP.release,
   status: "\u7528\u6CD5: buddy-cli status [--directory <\u9879\u76EE\u76EE\u5F55>]",
   meta: `\u7528\u6CD5: buddy-cli meta [--directory <\u9879\u76EE\u76EE\u5F55> | --buddy-id <\u642D\u5B50 ID>]
       buddy-cli meta update [--name <\u540D\u79F0>] [--tagline <\u4E00\u53E5\u8BDD\u4ECB\u7ECD>] [--intro <\u5B8C\u6574\u4ECB\u7ECD>] [--avatar <\u56FE\u7247\u6587\u4EF6>] [--directory <\u9879\u76EE\u76EE\u5F55> | --buddy-id <\u642D\u5B50 ID>]
@@ -5962,7 +6428,7 @@ meta \u53EA\u67E5\u770B\u4E91\u7AEF\u8D44\u6599\uFF1Bmeta update \u81F3\u5C11\u6
 --file \u63A5\u53D7\u672C\u5730\u9759\u6001 PNG\u3001JPEG\u3001WebP \u56FE\u7247\uFF0C\u6700\u5927 5 MiB\uFF1BServer \u81EA\u52A8\u5904\u7406\u5E76\u751F\u6210\u5730\u5740\u3002
 \u9700\u8981\u5F53\u524D\u8D26\u53F7\u62E5\u6709\u8BE5\u642D\u5B50\uFF0C\u547D\u4EE4\u6267\u884C\u540E\u7ACB\u5373\u66F4\u65B0\u4E91\u7AEF\u8D44\u6599\u3002`
 });
-function parse2(args, command) {
+function parse3(args, command) {
   const values = /* @__PURE__ */ new Map();
   let help = false;
   const update = command === "meta" && args[0] === "update";
@@ -5993,26 +6459,6 @@ function parse2(args, command) {
   }
   return { values, help, update };
 }
-function validCommit(value) {
-  const commit = value.trim();
-  if (!commit) throw new CloudCommandUsageError("--commit \u4E0D\u80FD\u4E3A\u7A7A");
-  if (/[\u0000-\u001f\u007f]/u.test(commit)) {
-    throw new CloudCommandUsageError("--commit \u4E0D\u80FD\u5305\u542B\u975E\u6CD5\u63A7\u5236\u5B57\u7B26");
-  }
-  return commit;
-}
-async function pushCommit(parsed, io) {
-  const provided = parsed.values.get("--commit");
-  if (provided !== void 0) return validCommit(provided);
-  if (!io.canPrompt || io.input === void 0) {
-    throw new CloudCommandUsageError("\u7F3A\u5C11 --commit\uFF1B\u8BF7\u8BF4\u660E\u672C\u6B21\u63D0\u4EA4\u5BA1\u6838\u7684\u6539\u52A8\u5185\u5BB9");
-  }
-  while (true) {
-    const answer = await io.input("\u8BF7\u8BF4\u660E\u672C\u6B21\u63D0\u4EA4\u5BA1\u6838\u7684\u6539\u52A8\u5185\u5BB9");
-    if (answer.trim()) return validCommit(answer);
-    io.writeError("\u8BF7\u8F93\u5165\u975E\u7A7A\u7684 commit\u3002");
-  }
-}
 function dependencies(options) {
   if (!options.session || !options.client) {
     throw new CloudCommandUsageError("\u5F53\u524D CLI Host \u5C1A\u672A\u914D\u7F6E\u642D\u642D\u8D26\u53F7\u548C\u5F00\u53D1\u8005\u5E73\u53F0 Adapter");
@@ -6020,7 +6466,7 @@ function dependencies(options) {
   return { session: options.session, client: options.client };
 }
 function requestedDirectory(options, parsed) {
-  return resolve15(options.cwd ?? process.cwd(), parsed.values.get("--directory") ?? ".");
+  return resolve16(options.cwd ?? process.cwd(), parsed.values.get("--directory") ?? ".");
 }
 function auditLabel(status) {
   if (status === "auditing") return "\u5BA1\u6838\u4E2D";
@@ -6074,49 +6520,6 @@ async function runLogout(io, options) {
   io.write("\u5DF2\u9000\u51FA\u642D\u642D\u5F00\u53D1\u8005\u8D26\u53F7\uFF0C\u5E76\u6E05\u9664\u672C\u673A\u767B\u5F55\u72B6\u6001\u3002");
   return { exitCode: 0 };
 }
-async function runPush(parsed, io, options) {
-  const root = await (options.resolveProjectRoot ?? requireBuddyAgentProjectRoot)(requestedDirectory(options, parsed));
-  await checkProjectGateway(root, resolvePlatformUrl({ env: options.runtimeUpdate?.env }));
-  const config = await (options.readConfig ?? readBuddyConfig)(root);
-  const commit = await pushCommit(parsed, io);
-  if (!config.buddyId) throw new CloudCommandUsageError("\u5F53\u524D\u9879\u76EE\u7F3A\u5C11\u5E73\u53F0\u751F\u6210\u7684 buddyId\uFF0C\u8BF7\u5148\u8FD0\u884C buddy-cli init");
-  if (options.mode === "local-mock") {
-    throw new CloudCommandUsageError("\u672C\u5730\u6A21\u62DF\u6A21\u5F0F\u4E0D\u4F1A\u4F2A\u9020\u6B63\u5F0F push\uFF0C\u8BF7\u8FDE\u63A5\u771F\u5B9E MLB Server");
-  }
-  if (!options.preparePush) throw new CloudCommandUsageError("push \u6253\u5305 Adapter \u5C1A\u672A\u914D\u7F6E");
-  const { session, client } = dependencies(options);
-  const expectedRuntime = await requireProjectRuntime(root, { ...options.runtimeUpdate, signal: options.signal });
-  await session.token({ signal: options.signal });
-  const sourceBundle = await options.preparePush(root, config, expectedRuntime);
-  for (const warning2 of sourceBundle.warnings ?? []) {
-    io.writeError(`\u6253\u5305\u63D0\u793A [${warning2.code}]\uFF1A${warning2.message}`);
-  }
-  const receipt = await client.pushPackage({ id: config.buddyId, commit, sourceBundle });
-  io.write(`\u5DF2\u63D0\u4EA4\u5BA1\u6838\uFF1A${config.buddyId}`);
-  io.write(`\u5F85\u5BA1\u6838\u7248\u672C\uFF1A${receipt.version}`);
-  io.write(`commit\uFF1A${receipt.commit}`);
-  io.write(`\u5BA1\u6838\u72B6\u6001\uFF1A${auditLabel(receipt.auditStatus)}`);
-  io.write(`\u4E0A\u4F20\u5927\u5C0F\uFF1A${receipt.size} bytes`);
-  io.write("\u672C\u6B21 push \u63D0\u4EA4\u4EE3\u7801\u5E76\u89E6\u53D1\u5E73\u53F0\u6784\u5EFA\uFF0C\u4E0D\u4F1A\u53D1\u5E03 Agent\uFF1B\u6784\u5EFA\u5B8C\u6210\u540E\u4ECD\u9700\u5728\u540E\u53F0\u624B\u52A8\u53D1\u5E03\u3002");
-  if (receipt.buildStatus && client.getPackageBuild) {
-    io.write(`\u6784\u5EFA\uFF1A${buildLabel(receipt.buildStatus)}`);
-    const deadline = Date.now() + (options.buildWaitMs ?? 6e4);
-    let build = { buildStatus: receipt.buildStatus, buildError: receipt.buildError ?? null };
-    try {
-      while (build.buildStatus === "building" && Date.now() < deadline) {
-        await delay3(Math.min(options.buildPollMs ?? 2e3, Math.max(1, deadline - Date.now())), void 0, { signal: options.signal });
-        build = await client.getPackageBuild({ id: config.buddyId, version: receipt.version });
-      }
-      io.write(`\u6784\u5EFA\uFF1A${buildLabel(build.buildStatus)}${build.buildError ? ` \xB7 ${build.buildError}` : ""}`);
-      if (build.buildStatus === "failed") return { exitCode: 1, buddyId: config.buddyId, version: receipt.version };
-      if (build.buildStatus === "building") io.write("\u6784\u5EFA\u4ECD\u5728\u8FDB\u884C\uFF0C\u7A0D\u540E\u8FD0\u884C buddy-cli status \u67E5\u8BE2\uFF1B\u4E0D\u8981\u91CD\u590D\u4E0A\u4F20\u3002");
-    } catch (cause) {
-      io.writeError(`\u4EE3\u7801\u5DF2\u4E0A\u4F20\uFF0C\u4F46\u6784\u5EFA\u72B6\u6001\u5C1A\u672A\u786E\u8BA4\uFF1A${cause instanceof Error ? cause.message : String(cause)}\u3002\u7528 buddy-cli status \u91CD\u67E5\uFF0C\u4E0D\u8981\u91CD\u590D\u4E0A\u4F20\u3002`);
-      return { exitCode: 1, buddyId: config.buddyId, version: receipt.version };
-    }
-  }
-  return { exitCode: 0, buddyId: config.buddyId, version: receipt.version };
-}
 function printMeta(io, buddy2) {
   io.write(`\u642D\u5B50\uFF1A${buddy2.meta?.name ?? "\u672A\u586B\u5199\u540D\u79F0"}\uFF08${buddy2.id}\uFF09`);
   io.write(`\u4E00\u53E5\u8BDD\u4ECB\u7ECD\uFF1A${buddy2.meta?.tagline || "\u672A\u586B\u5199"}`);
@@ -6151,7 +6554,7 @@ async function runMeta(parsed, io, options, legacyAvatar = false) {
   }
   let upload;
   try {
-    upload = file ? await readBuddyAvatarFile(resolve15(options.cwd ?? process.cwd(), file)) : void 0;
+    upload = file ? await readBuddyAvatarFile(resolve16(options.cwd ?? process.cwd(), file)) : void 0;
   } catch (error2) {
     throw new CloudCommandUsageError(error2 instanceof Error ? error2.message : "\u65E0\u6CD5\u8BFB\u53D6\u5934\u50CF\u56FE\u7247");
   }
@@ -6193,7 +6596,8 @@ async function runMeta(parsed, io, options, legacyAvatar = false) {
 }
 async function runCloudCommand(command, args, io, options = {}) {
   try {
-    const parsed = parse2(args, command);
+    if (command === "push" || command === "products" || command === "release") return await runProductLifecycle(command, args, io, options);
+    const parsed = parse3(args, command);
     if (parsed.help) {
       io.write(HELP[command]);
       return { exitCode: 0 };
@@ -6206,7 +6610,6 @@ async function runCloudCommand(command, args, io, options = {}) {
       return { exitCode: 0 };
     }
     if (command === "logout") return await runLogout(io, options);
-    if (command === "push") return await runPush(parsed, io, options);
     if (command === "meta" || command === "avatar") return await runMeta(parsed, io, options, command === "avatar");
     const root = await (options.resolveProjectRoot ?? requireBuddyProjectRoot)(requestedDirectory(options, parsed));
     await checkProjectGateway(root, resolvePlatformUrl({ env: options.runtimeUpdate?.env }));
@@ -6238,6 +6641,10 @@ async function runCloudCommand(command, args, io, options = {}) {
         exitCode: cause instanceof CloudCommandUsageError || cause instanceof BuddyProjectContextError ? 2 : 1
       };
     }
+    if (["push", "products", "release"].includes(command)) {
+      io.writeError(`buddy-cli: ${cause instanceof Error ? cause.message : "\u64CD\u4F5C\u672A\u5B8C\u6210\uFF0C\u8BF7\u6309\u8F93\u51FA\u7F16\u53F7\u67E5\u8BE2\u6216\u6062\u590D"}`);
+      return { exitCode: 1 };
+    }
     throw cause;
   }
 }
@@ -6245,7 +6652,7 @@ var CLOUD_COMMAND_HELP = HELP;
 
 // packages/cli-core/src/migration/index.ts
 import { lstat as lstat12, open as open5, readdir as readdir6, realpath as realpath7, stat } from "node:fs/promises";
-import { extname, isAbsolute as isAbsolute3, join as join20, relative, resolve as resolve16, sep, win32 as win322 } from "node:path";
+import { extname, isAbsolute as isAbsolute3, join as join21, relative, resolve as resolve17, sep, win32 as win322 } from "node:path";
 var DEFAULT_SKILL_SCAN_LIMITS = Object.freeze({
   maxFiles: 128,
   maxFileBytes: 256 * 1024,
@@ -6398,7 +6805,7 @@ async function existingProjectRoot(value) {
     return rejectScan("SKILL_PROJECT_ROOT_INVALID", ".", "projectRoot \u5FC5\u987B\u6307\u5411\u4E00\u4E2A\u5DF2\u6709\u9879\u76EE\u76EE\u5F55\u3002");
   }
   try {
-    const root = await realpath7(resolve16(value));
+    const root = await realpath7(resolve17(value));
     if (!(await stat(root)).isDirectory()) {
       return rejectScan("SKILL_PROJECT_ROOT_INVALID", ".", "projectRoot \u5FC5\u987B\u6307\u5411\u4E00\u4E2A\u5DF2\u6709\u9879\u76EE\u76EE\u5F55\u3002");
     }
@@ -6414,7 +6821,7 @@ async function existingProjectRoot(value) {
   }
 }
 async function existingSkillRoot(projectRoot, skillPath) {
-  const candidate = skillPath === "." ? projectRoot : join20(projectRoot, ...skillPath.split("/"));
+  const candidate = skillPath === "." ? projectRoot : join21(projectRoot, ...skillPath.split("/"));
   try {
     await lstat12(candidate);
   } catch (cause) {
@@ -6451,7 +6858,7 @@ async function existingSkillRoot(projectRoot, skillPath) {
 }
 async function assertEntrypoint(context) {
   const entryPath = reportChild(context.skillPath, "SKILL.md");
-  const candidate = join20(context.skillRoot, "SKILL.md");
+  const candidate = join21(context.skillRoot, "SKILL.md");
   try {
     await lstat12(candidate);
     const target = await realpath7(candidate);
@@ -6555,7 +6962,7 @@ async function walkDirectory(actualDirectory, reportDirectory, ancestors, contex
   }
   for (const entry2 of entries) {
     const childReportPath = reportChild(reportDirectory, entry2.name);
-    const childPath = join20(directory, entry2.name);
+    const childPath = join21(directory, entry2.name);
     let target;
     try {
       target = await realpath7(childPath);
@@ -7009,9 +7416,9 @@ async function scanExternalSkillPortability(options) {
 }
 
 // packages/cli-core/src/push/preflight.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { lstat as lstat13, open as open6, readdir as readdir7, realpath as realpath8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join21, relative as relative2, resolve as resolve17, sep as sep2, win32 as win323 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join22, relative as relative2, resolve as resolve18, sep as sep2, win32 as win323 } from "node:path";
 var MEBIBYTE = 1024 * 1024;
 var DEFAULT_PUSH_MANIFEST_LIMITS = Object.freeze({
   maxFiles: 1e4,
@@ -7095,7 +7502,7 @@ function error(options) {
   throw new PushPreflightError(options);
 }
 function sha256(value) {
-  return `sha256:${createHash10("sha256").update(value).digest("hex")}`;
+  return `sha256:${createHash13("sha256").update(value).digest("hex")}`;
 }
 function positiveLimit(value, name, hardMaximum) {
   if (!Number.isSafeInteger(value) || value < 1 || value > hardMaximum) {
@@ -7185,7 +7592,7 @@ function normalizeBookletPath(value) {
   return normalized;
 }
 async function canonicalProjectRoot(projectRoot) {
-  const absolute = resolve17(projectRoot);
+  const absolute = resolve18(projectRoot);
   let entry2;
   try {
     entry2 = await lstat13(absolute);
@@ -7216,7 +7623,7 @@ async function canonicalProjectRoot(projectRoot) {
   }
 }
 async function captureConfigWithinLimit(projectRoot, maxFileBytes, filename) {
-  const path = join21(projectRoot, filename);
+  const path = join22(projectRoot, filename);
   let entry2;
   try {
     entry2 = await lstat13(path);
@@ -7341,7 +7748,7 @@ async function hashRegularFile(options) {
         message: `\u751F\u6210\u6E05\u5355\u65F6\u6587\u4EF6\u53D1\u751F\u53D8\u5316\uFF1A${options.portablePath}`
       });
     }
-    const hash3 = createHash10("sha256");
+    const hash3 = createHash13("sha256");
     const captured = [];
     const buffer = Buffer.allocUnsafe(READ_BUFFER_BYTES);
     let bytes = 0;
@@ -7419,7 +7826,7 @@ async function createManifest(options) {
         sensitiveEntriesExcluded += 1;
         continue;
       }
-      const absolutePath = join21(directory, name);
+      const absolutePath = join22(directory, name);
       let entry2;
       try {
         entry2 = await lstat13(absolutePath);
@@ -7673,7 +8080,7 @@ async function assertCapturedConfigStable(options) {
   }
   let current;
   try {
-    const path = join21(options.projectRoot, options.filename);
+    const path = join22(options.projectRoot, options.filename);
     const entry2 = await lstat13(path);
     if (!entry2.isFile() || entry2.isSymbolicLink()) {
       error({
@@ -7719,7 +8126,7 @@ async function createPushPreflight(options) {
   parseCapturedProject(initialAgentEntry);
   let initialDataEntry;
   try {
-    await lstat13(join21(projectRoot, DATA_ACCESS_FILENAME));
+    await lstat13(join22(projectRoot, DATA_ACCESS_FILENAME));
     initialDataEntry = await captureConfigWithinLimit(projectRoot, limits.maxFileBytes, DATA_ACCESS_FILENAME);
   } catch (cause) {
     if (cause.code !== "ENOENT") throw cause;
@@ -7820,16 +8227,16 @@ async function createPushPreflight(options) {
 }
 
 // packages/cli-core/src/push/bundle.ts
-import { createHash as createHash11 } from "node:crypto";
-import { lstat as lstat14, readFile as readFile19, realpath as realpath9 } from "node:fs/promises";
-import { join as join22, relative as relative3, sep as sep3, win32 as win324 } from "node:path";
+import { createHash as createHash14 } from "node:crypto";
+import { lstat as lstat14, readFile as readFile20, realpath as realpath9 } from "node:fs/promises";
+import { join as join23, relative as relative3, sep as sep3, win32 as win324 } from "node:path";
 import { Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
 import { pack } from "tar-stream";
 var MEDIA_TYPE = "application/gzip";
 function digest3(bytes) {
-  return `sha256:${createHash11("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash14("sha256").update(bytes).digest("hex")}`;
 }
 function changed(path, message, cause) {
   throw new PushPreflightError({
@@ -7844,7 +8251,7 @@ function inside(root, target) {
   return path === "" || path !== ".." && !path.startsWith(`..${sep3}`) && !path.startsWith("/") && !win324.isAbsolute(path);
 }
 async function capture(root, file) {
-  const absolute = join22(root, ...file.path.split("/"));
+  const absolute = join23(root, ...file.path.split("/"));
   try {
     const entry2 = await lstat14(absolute);
     if (!entry2.isFile() || entry2.isSymbolicLink() || entry2.size !== file.bytes) {
@@ -7852,7 +8259,7 @@ async function capture(root, file) {
     }
     const canonical = await realpath9(absolute);
     if (!inside(root, canonical)) changed(file.path, `\u63D0\u4EA4\u6587\u4EF6\u8D8A\u8FC7\u9879\u76EE\u6839\u76EE\u5F55\uFF1A${file.path}`);
-    const contents = await readFile19(absolute);
+    const contents = await readFile20(absolute);
     if (contents.byteLength !== file.bytes || digest3(contents) !== file.digest) {
       changed(file.path, `\u63D0\u4EA4\u524D\u6587\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316\uFF1A${file.path}`);
     }
@@ -7878,7 +8285,7 @@ async function createPushSourceBundle(plan) {
     schemaVersion: "1",
     files: files.map((file) => ({ path: file.path, bytes: file.bytes, digest: file.digest }))
   });
-  const calculatedBundleDigest = `sha256:${createHash11("sha256").update(`buddy-push-bundle-v1\0${descriptor}`).digest("hex")}`;
+  const calculatedBundleDigest = `sha256:${createHash14("sha256").update(`buddy-push-bundle-v1\0${descriptor}`).digest("hex")}`;
   if (calculatedBundleDigest !== plan.bundleDigest) {
     changed(plan.projectRoot, "\u63D0\u4EA4\u6E05\u5355\u8EAB\u4EFD\u5728\u6253\u5305\u524D\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C push");
   }
@@ -7979,7 +8386,7 @@ async function resolveApplicationDraft(name, tagline, intro, requestedBuddyId, o
     confirmMeta: args.confirmMeta,
     avatarSkill: { version: args.avatarSkillVersion, signal: options.cloud?.signal },
     requestedBuddyId,
-    cwd: resolve18(options.cwd ?? process.cwd()),
+    cwd: resolve19(options.cwd ?? process.cwd()),
     client: platformDependencies(options).client,
     io
   });
@@ -8143,7 +8550,7 @@ function defaultProjectDirectory(name) {
   return `./${folder2}`;
 }
 async function initializeProjectRoute(route, args, io, options, application) {
-  const cwd = resolve18(options.cwd ?? process.cwd());
+  const cwd = resolve19(options.cwd ?? process.cwd());
   const { name, tagline, intro } = application;
   const directoryInput = await textAnswer(
     io,
@@ -8152,7 +8559,7 @@ async function initializeProjectRoute(route, args, io, options, application) {
     "\u9879\u76EE\u76EE\u5F55\uFF08\u7A7A\u76EE\u5F55\u6216\u5DF2\u6709\u642D\u642D\u5DE5\u7A0B\uFF09",
     defaultProjectDirectory(name)
   );
-  const rootDirectory = resolve18(cwd, directoryInput);
+  const rootDirectory = resolve19(cwd, directoryInput);
   await assertInitializableBuddyTarget(rootDirectory);
   const initializationTarget = { directory: rootDirectory, kind: "new" };
   let initializationPlan = options.initializeProject ? void 0 : await planBuddyProjectInitialization(initializationTarget);
@@ -8198,7 +8605,7 @@ async function initializeProjectRoute(route, args, io, options, application) {
 }
 async function runRoute(route, args, io, options) {
   if (!io.canPrompt) assertNonInteractiveProjectArguments(route, args);
-  const cwd = resolve18(options.cwd ?? process.cwd());
+  const cwd = resolve19(options.cwd ?? process.cwd());
   const name = await textAnswer(io, args.name, "--name", "\u642D\u5B50\u540D\u79F0", void 0, BUDDY_PROFILE_TEXT_LIMITS.name);
   const tagline = await textAnswer(
     io,
@@ -8226,7 +8633,7 @@ async function runRoute(route, args, io, options) {
     "\u9879\u76EE\u76EE\u5F55",
     defaultProjectDirectory(name)
   );
-  const rootDirectory = resolve18(cwd, directoryInput);
+  const rootDirectory = resolve19(cwd, directoryInput);
   await assertInitializableBuddyTarget(rootDirectory);
   let plan = await planBuddyDraftInitialization(rootDirectory);
   const existingBuddyId = plan.existingManifest?.buddyId;
@@ -8262,11 +8669,11 @@ async function runRoute(route, args, io, options) {
   return { ...result, route: "create", draft, buddyId };
 }
 async function resumeProjectArguments(args, cwd, options, io) {
-  const root = resolve18(cwd, args.directory?.trim() || ".");
+  const root = resolve19(cwd, args.directory?.trim() || ".");
   await assertInitializableBuddyTarget(root);
   let entry2;
   try {
-    entry2 = await lstat15(join23(root, "package.json"));
+    entry2 = await lstat15(join24(root, "package.json"));
   } catch (cause) {
     if (cause.code === "ENOENT") {
       const draft = await readMetaDraft(root);
@@ -8307,7 +8714,7 @@ async function runBuddyCli(args, io, options = {}) {
   try {
     const [command, ...rest] = args;
     if (!command) {
-      const cwd = resolve18(options.cwd ?? process.cwd());
+      const cwd = resolve19(options.cwd ?? process.cwd());
       let projectRoot;
       try {
         projectRoot = await findBuddyProjectRoot(cwd);
@@ -8357,7 +8764,7 @@ async function runBuddyCli(args, io, options = {}) {
         ...options.dev
       });
     }
-    if (command === "login" || command === "logout" || command === "push" || command === "status" || command === "meta" || command === "avatar") {
+    if (command === "login" || command === "logout" || command === "push" || command === "products" || command === "release" || command === "status" || command === "meta" || command === "avatar") {
       return await runCloudCommand(command, rest, io, {
         cwd: options.cwd,
         runtimeUpdate: options.runtimeCatalog,
@@ -8372,13 +8779,13 @@ async function runBuddyCli(args, io, options = {}) {
       }
       let route = routeFromMode(parsed.mode);
       if (route === void 0 && !io.canPrompt) requireModeForNonInteractive();
-      const cwd = resolve18(options.cwd ?? process.cwd());
+      const cwd = resolve19(options.cwd ?? process.cwd());
       await assertInitializableBuddyTarget(cwd);
       if (parsed.directory !== void 0) {
         if (!parsed.directory.trim()) throw new CliUsageError("--directory \u4E0D\u80FD\u4E3A\u7A7A");
-        await assertInitializableBuddyTarget(resolve18(cwd, parsed.directory));
+        await assertInitializableBuddyTarget(resolve19(cwd, parsed.directory));
       }
-      await checkProjectGateway(resolve18(cwd, parsed.directory ?? "."), resolvePlatformUrl({ env: options.runtimeCatalog?.env }));
+      await checkProjectGateway(resolve19(cwd, parsed.directory ?? "."), resolvePlatformUrl({ env: options.runtimeCatalog?.env }));
       await authenticate(options);
       await resumeProjectArguments(parsed, cwd, options, io);
       route ??= routeFromMode(parsed.mode);
@@ -8492,6 +8899,7 @@ export {
   CloudAuthenticator,
   CloudCommandUsageError,
   CloudLifecycleError,
+  CloudOperationError,
   DEFAULT_DEVELOPER_WEB_URL,
   DEFAULT_MLB_TEST_URL,
   DEFAULT_PUSH_MANIFEST_LIMITS,