@freelog-cli/cli2 0.5.2 → 0.5.3

package/dist/bin/index.js

@@ -9168,11 +9168,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path16) {
-      if (!path16 || typeof path16 !== "string") {
+    function lookup(path19) {
+      if (!path19 || typeof path19 !== "string") {
         return false;
       }
-      var extension2 = extname("x." + path16).toLowerCase().substr(1);
+      var extension2 = extname("x." + path19).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -10287,7 +10287,7 @@ var require_form_data = __commonJS({
     "use strict";
     var CombinedStream = require_combined_stream();
     var util4 = __require("util");
-    var path16 = __require("path");
+    var path19 = __require("path");
     var http3 = __require("http");
     var https2 = __require("https");
     var parseUrl2 = __require("url").parse;
@@ -10418,11 +10418,11 @@ var require_form_data = __commonJS({
     FormData3.prototype._getContentDisposition = function(value, options) {
       var filename;
       if (typeof options.filepath === "string") {
-        filename = path16.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path19.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value && (value.name || value.path)) {
-        filename = path16.basename(options.filename || value && (value.name || value.path));
+        filename = path19.basename(options.filename || value && (value.name || value.path));
       } else if (value && value.readable && hasOwn(value, "httpVersion")) {
-        filename = path16.basename(value.client._httpMessage.path || "");
+        filename = path19.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
         return 'filename="' + escapeHeaderParam(filename) + '"';
@@ -13339,9 +13339,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path16, key, dots) {
-  if (!path16) return key;
-  return path16.concat(key).map(function each(token, i) {
+function renderKey(path19, key, dots) {
+  if (!path19) return key;
+  return path19.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -13427,13 +13427,13 @@ function toFormData(obj, formData, options) {
       return currentValue;
     });
   }
-  function defaultVisitor(value, key, path16) {
+  function defaultVisitor(value, key, path19) {
     let arr = value;
     if (utils_default.isReactNative(formData) && utils_default.isReactNativeBlob(value)) {
-      formData.append(renderKey(path16, key, dots), convertValue(value));
+      formData.append(renderKey(path19, key, dots), convertValue(value));
       return false;
     }
-    if (value && !path16 && typeof value === "object") {
+    if (value && !path19 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = stringifyWithDepthLimit(value, 1);
@@ -13452,7 +13452,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path16, key, dots), convertValue(value));
+    formData.append(renderKey(path19, key, dots), convertValue(value));
     return false;
   }
   const exposedHelpers = Object.assign(predicates, {
@@ -13460,17 +13460,17 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path16, depth = 0) {
+  function build(value, path19, depth = 0) {
     if (utils_default.isUndefined(value)) return;
     throwIfMaxDepthExceeded(depth);
     if (stack.indexOf(value) !== -1) {
-      throw new Error("Circular reference detected in " + path16.join("."));
+      throw new Error("Circular reference detected in " + path19.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
-      const result = !(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path16, exposedHelpers);
+      const result = !(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path19, exposedHelpers);
       if (result === true) {
-        build(el, path16 ? path16.concat(key) : [key], depth + 1);
+        build(el, path19 ? path19.concat(key) : [key], depth + 1);
       }
     });
     stack.pop();
@@ -13682,7 +13682,7 @@ var platform_default = {
 // ../../node_modules/.pnpm/axios@1.19.0/node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams(), {
-    visitor: function(value, key, path16, helpers) {
+    visitor: function(value, key, path19, helpers) {
       if (platform_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -13704,14 +13704,14 @@ function throwIfDepthExceeded(index) {
   }
 }
 function parsePropPath(name) {
-  const path16 = [];
+  const path19 = [];
   const pattern = /[^.[\]]+|\[([^.[\]]*)]/g;
   let match;
   while ((match = pattern.exec(name)) !== null) {
-    throwIfDepthExceeded(path16.length);
-    path16.push(match[0] === "[]" ? "" : match[1] || match[0]);
+    throwIfDepthExceeded(path19.length);
+    path19.push(match[0] === "[]" ? "" : match[1] || match[0]);
   }
-  return path16;
+  return path19;
 }
 function arrayToObject(arr) {
   const obj = {};
@@ -13726,12 +13726,12 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path16, value, target, index) {
+  function buildPath(path19, value, target, index) {
     throwIfDepthExceeded(index);
-    let name = path16[index++];
+    let name = path19[index++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path16.length;
+    const isLast = index >= path19.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -13744,7 +13744,7 @@ function formDataToJSON(formData) {
     if (!utils_default.hasOwnProp(target, name) || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path16, value, target[name], index);
+    const result = buildPath(path19, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -15462,9 +15462,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path16;
+    let path19;
     try {
-      path16 = buildURL(
+      path19 = buildURL(
         parsed.pathname + parsed.search,
         own2("params"),
         own2("paramsSerializer")
@@ -15483,7 +15483,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = Object.assign(/* @__PURE__ */ Object.create(null), {
-      path: path16,
+      path: path19,
       method,
       headers: toByteStringHeaderObject(headers),
       agents: { http: httpAgent, https: httpsAgent },
@@ -15885,14 +15885,14 @@ var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PUR
 var cookies_default = platform_default.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
-    write(name, value, expires, path16, domain, secure, sameSite) {
+    write(name, value, expires, path19, domain, secure, sameSite) {
       if (typeof document === "undefined") return;
       const cookie = [`${name}=${encodeURIComponent(value)}`];
       if (utils_default.isNumber(expires)) {
         cookie.push(`expires=${new Date(expires).toUTCString()}`);
       }
-      if (utils_default.isString(path16)) {
-        cookie.push(`path=${path16}`);
+      if (utils_default.isString(path19)) {
+        cookie.push(`path=${path19}`);
       }
       if (utils_default.isString(domain)) {
         cookie.push(`domain=${domain}`);
@@ -17786,14 +17786,14 @@ function copy(a, s, t2) {
     if (s[m]) t2[m] = s[m];
   });
 }
-function getLastOfPath(object, path16, Empty) {
+function getLastOfPath(object, path19, Empty) {
   function cleanKey(key2) {
     return key2 && key2.indexOf("###") > -1 ? key2.replace(/###/g, ".") : key2;
   }
   function canNotTraverseDeeper() {
     return !object || typeof object === "string";
   }
-  var stack = typeof path16 !== "string" ? [].concat(path16) : path16.split(".");
+  var stack = typeof path19 !== "string" ? [].concat(path19) : path19.split(".");
   while (stack.length > 1) {
     if (canNotTraverseDeeper()) return {};
     var key = cleanKey(stack.shift());
@@ -17810,18 +17810,18 @@ function getLastOfPath(object, path16, Empty) {
     k: cleanKey(stack.shift())
   };
 }
-function setPath(object, path16, newValue) {
-  var _getLastOfPath = getLastOfPath(object, path16, Object), obj = _getLastOfPath.obj, k = _getLastOfPath.k;
+function setPath(object, path19, newValue) {
+  var _getLastOfPath = getLastOfPath(object, path19, Object), obj = _getLastOfPath.obj, k = _getLastOfPath.k;
   obj[k] = newValue;
 }
-function pushPath(object, path16, newValue, concat) {
-  var _getLastOfPath2 = getLastOfPath(object, path16, Object), obj = _getLastOfPath2.obj, k = _getLastOfPath2.k;
+function pushPath(object, path19, newValue, concat) {
+  var _getLastOfPath2 = getLastOfPath(object, path19, Object), obj = _getLastOfPath2.obj, k = _getLastOfPath2.k;
   obj[k] = obj[k] || [];
   if (concat) obj[k] = obj[k].concat(newValue);
   if (!concat) obj[k].push(newValue);
 }
-function getPath(object, path16) {
-  var _getLastOfPath3 = getLastOfPath(object, path16), obj = _getLastOfPath3.obj, k = _getLastOfPath3.k;
+function getPath(object, path19) {
+  var _getLastOfPath3 = getLastOfPath(object, path19), obj = _getLastOfPath3.obj, k = _getLastOfPath3.k;
   if (!obj) return void 0;
   return obj[k];
 }
@@ -17943,11 +17943,11 @@ function _isNativeReflectConstruct() {
     return false;
   }
 }
-function deepFind(obj, path16) {
+function deepFind(obj, path19) {
   var keySeparator = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : ".";
   if (!obj) return void 0;
-  if (obj[path16]) return obj[path16];
-  var paths = path16.split(keySeparator);
+  if (obj[path19]) return obj[path19];
+  var paths = path19.split(keySeparator);
   var current = obj;
   for (var i = 0; i < paths.length; ++i) {
     if (!current) return void 0;
@@ -17965,7 +17965,7 @@ function deepFind(obj, path16) {
       }
       if (mix === void 0) return void 0;
       if (mix === null) return null;
-      if (path16.endsWith(p)) {
+      if (path19.endsWith(p)) {
         if (typeof mix === "string") return mix;
         if (p && typeof mix[p] === "string") return mix[p];
       }
@@ -18022,13 +18022,13 @@ var ResourceStore = (function(_EventEmitter) {
       var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
       var keySeparator = options.keySeparator !== void 0 ? options.keySeparator : this.options.keySeparator;
       var ignoreJSONStructure = options.ignoreJSONStructure !== void 0 ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
-      var path16 = [lng, ns];
-      if (key && typeof key !== "string") path16 = path16.concat(key);
-      if (key && typeof key === "string") path16 = path16.concat(keySeparator ? key.split(keySeparator) : key);
+      var path19 = [lng, ns];
+      if (key && typeof key !== "string") path19 = path19.concat(key);
+      if (key && typeof key === "string") path19 = path19.concat(keySeparator ? key.split(keySeparator) : key);
       if (lng.indexOf(".") > -1) {
-        path16 = lng.split(".");
+        path19 = lng.split(".");
       }
-      var result = getPath(this.data, path16);
+      var result = getPath(this.data, path19);
       if (result || !ignoreJSONStructure || typeof key !== "string") return result;
       return deepFind(this.data && this.data[lng] && this.data[lng][ns], key, keySeparator);
     }
@@ -18040,15 +18040,15 @@ var ResourceStore = (function(_EventEmitter) {
       };
       var keySeparator = this.options.keySeparator;
       if (keySeparator === void 0) keySeparator = ".";
-      var path16 = [lng, ns];
-      if (key) path16 = path16.concat(keySeparator ? key.split(keySeparator) : key);
+      var path19 = [lng, ns];
+      if (key) path19 = path19.concat(keySeparator ? key.split(keySeparator) : key);
       if (lng.indexOf(".") > -1) {
-        path16 = lng.split(".");
+        path19 = lng.split(".");
         value = ns;
-        ns = path16[1];
+        ns = path19[1];
       }
       this.addNamespaces(ns);
-      setPath(this.data, path16, value);
+      setPath(this.data, path19, value);
       if (!options.silent) this.emit("added", lng, ns, key, value);
     }
   }, {
@@ -18070,21 +18070,21 @@ var ResourceStore = (function(_EventEmitter) {
       var options = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {
         silent: false
       };
-      var path16 = [lng, ns];
+      var path19 = [lng, ns];
       if (lng.indexOf(".") > -1) {
-        path16 = lng.split(".");
+        path19 = lng.split(".");
         deep = resources;
         resources = ns;
-        ns = path16[1];
+        ns = path19[1];
       }
       this.addNamespaces(ns);
-      var pack = getPath(this.data, path16) || {};
+      var pack = getPath(this.data, path19) || {};
       if (deep) {
         deepExtend(pack, resources, overwrite);
       } else {
         pack = _objectSpread$1(_objectSpread$1({}, pack), resources);
       }
-      setPath(this.data, path16, pack);
+      setPath(this.data, path19, pack);
       if (!options.silent) this.emit("added", lng, ns, resources);
     }
   }, {
@@ -19078,10 +19078,10 @@ var Interpolator = (function() {
       }
       var handleFormat = function handleFormat2(key) {
         if (key.indexOf(_this.formatSeparator) < 0) {
-          var path16 = getPathWithDefaults(data, defaultData, key);
-          return _this.alwaysFormat ? _this.format(path16, void 0, lng, _objectSpread$3(_objectSpread$3(_objectSpread$3({}, options), data), {}, {
+          var path19 = getPathWithDefaults(data, defaultData, key);
+          return _this.alwaysFormat ? _this.format(path19, void 0, lng, _objectSpread$3(_objectSpread$3(_objectSpread$3({}, options), data), {}, {
             interpolationkey: key
-          })) : path16;
+          })) : path19;
         }
         var p = key.split(_this.formatSeparator);
         var k = p.shift().trim();
@@ -23985,7 +23985,7 @@ function addSharedOptions(command) {
     "--json",
     // i18n: cli.flag.json
     "\u4EE5 JSON \u8F93\u51FA"
-  ).option("--resource <selector>", "\u9009\u62E9\u672C\u5730\u8D44\u6E90\u72B6\u6001\uFF08N.json\u3001\u8D44\u6E90 ID\u3001\u6807\u8BC6\u7B26\u6216\u6807\u9898\uFF09");
+  ).option("--resource <selector>", "\u9009\u62E9\u672C\u5730\u8D44\u6E90\uFF08id:\u3001name:\u3001title:\u3001artifact: \u6216 file:N.json\uFF09");
 }
 function readSharedOptions(command) {
   const raw = command.optsWithGlobals();
@@ -24247,6 +24247,9 @@ function createLogoutCommand() {
 // src/commands/create/create.ts
 import { Command as Command4 } from "commander";
 
+// src/domain/create/create.ts
+import path10 from "path";
+
 // src/local/identity.ts
 import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4 } from "fs";
 import path6 from "path";
@@ -24456,7 +24459,7 @@ var inputFields = {
   name: z2.string().min(1).optional(),
   title: z2.string().min(1).optional(),
   typeCode: z2.string().min(1),
-  filePath: z2.string().min(1).optional(),
+  filePath: z2.string().min(1),
   env: z2.enum(["prod", "test", "dev"]).optional()
 };
 var createSchema = z2.object(inputFields).strict();
@@ -24516,6 +24519,9 @@ function throwZodAsCliError(error2) {
   if (field === "name" || field === "resourceId" || field === "title") {
     throw new CliError("\u7ED1\u5B9A\u8EAB\u4EFD\u5B57\u6BB5\u4E0D\u5B8C\u6574", "IDENTITY_BINDING_INVALID");
   }
+  if (field === "filePath") {
+    throw new CliError("\u6BCF\u4EFD\u8D44\u6E90\u72B6\u6001\u5FC5\u987B\u5173\u8054\u672C\u5730\u4EA7\u7269\u8DEF\u5F84", "IDENTITY_ARTIFACT_REQUIRED");
+  }
   throw new CliError("\u8EAB\u4EFD\u5B57\u6BB5\u65E0\u6548", "IDENTITY_INVALID");
 }
 function toStored(data) {
@@ -24526,7 +24532,7 @@ function toStored(data) {
     ...data.name ? { name: data.name } : {},
     ...data.title ? { title: data.title } : {},
     typeCode: data.typeCode,
-    ...data.filePath ? { filePath: data.filePath } : {},
+    filePath: data.filePath,
     ...data.env === "test" || data.env === "dev" ? { env: data.env } : {}
   };
 }
@@ -24545,7 +24551,7 @@ function toDiskObject(identity) {
     ...identity.name ? { name: identity.name } : {},
     ...identity.title ? { title: identity.title } : {},
     typeCode: identity.typeCode,
-    ...identity.filePath ? { filePath: identity.filePath } : {},
+    filePath: identity.filePath,
     ...identity.env ? { env: identity.env } : {}
   };
 }
@@ -24757,32 +24763,58 @@ function draftSummary(draft) {
   return ["\u5C06\u8986\u76D6\u672C\u5730\u5DE5\u4F5C\u7A3F\uFF1A", `  \u6765\u6E90\uFF1A${source}`, `  \u6587\u4EF6\uFF1A${draft.filename ?? "\u65E0"}  sha1=${sha1}`, `  \u5C5E\u6027 ${(draft.customPropertyDescriptors ?? []).length} / \u4F9D\u8D56 ${(draft.dependencies ?? []).length}`].join("\n");
 }
 
+// src/local/projectPath.ts
+import path8 from "path";
+var defaultError = {
+  code: "FILE_PATH_OUTSIDE_PROJECT",
+  message: "\u8DEF\u5F84\u5FC5\u987B\u843D\u5728\u5F53\u524D\u5DE5\u7A0B\u91CC"
+};
+function normalizeProjectPath(cwd, rawPath, error2 = defaultError) {
+  if (!rawPath.trim() || path8.isAbsolute(rawPath) || path8.win32.isAbsolute(rawPath) || path8.posix.isAbsolute(rawPath)) {
+    throw new CliError(error2.message, error2.code);
+  }
+  const root = path8.resolve(cwd);
+  const resolved = path8.resolve(root, rawPath);
+  const relative = path8.relative(root, resolved);
+  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    throw new CliError(error2.message, error2.code);
+  }
+  return relative.replaceAll("\\", "/");
+}
+
 // src/local/resolve.ts
-function assertNoDuplicate(identities, key) {
+function assertNoDuplicate(cwd, identities, key) {
   const seen = /* @__PURE__ */ new Map();
   for (const identity of identities) {
     const value = identity[key];
     if (!value) continue;
-    const previous = seen.get(value);
+    const comparable = key === "filePath" ? normalizeProjectPath(cwd, value) : value;
+    const previous = seen.get(comparable);
     if (previous !== void 0) {
       throw new CliError(`\u672C\u5730\u72B6\u6001\u51B2\u7A81\uFF1A${previous}.json \u4E0E ${identity.n}.json \u4F7F\u7528\u540C\u4E00 ${key}`, "IDENTITY_CONFLICT");
     }
-    seen.set(value, identity.n);
+    seen.set(comparable, identity.n);
   }
 }
-function matches(identity, selector) {
+function matches(cwd, identity, selector) {
   if (selector.startsWith("file:")) return `${identity.n}.json` === selector.slice(5);
   if (selector.startsWith("id:")) return identity.resourceId === selector.slice(3);
   if (selector.startsWith("name:")) return identity.name === selector.slice(5) || identity.name === selector.slice(5).split("/").pop();
   if (selector.startsWith("title:")) return identity.title === selector.slice(6);
+  if (selector.startsWith("artifact:")) {
+    return normalizeProjectPath(cwd, identity.filePath) === normalizeProjectPath(
+      cwd,
+      selector.slice("artifact:".length)
+    );
+  }
   return `${identity.n}.json` === selector || identity.resourceId === selector || identity.name === selector || identity.title === selector;
 }
 var DRAFT_FILE_RE = /^([1-9]\d*)\.version\.json$/;
 function validateLocalState(cwd) {
   const identities = listIdentities(cwd);
-  assertNoDuplicate(identities, "resourceId");
-  assertNoDuplicate(identities, "name");
-  assertNoDuplicate(identities, "filePath");
+  assertNoDuplicate(cwd, identities, "resourceId");
+  assertNoDuplicate(cwd, identities, "name");
+  assertNoDuplicate(cwd, identities, "filePath");
   const numbers = new Set(identities.map((identity) => identity.n));
   const dir = freelogDir(cwd);
   if (!existsSync7(dir)) return identities;
@@ -24801,7 +24833,7 @@ function resolveIdentity(cwd, selector) {
   const identities = validateLocalState(cwd);
   if (identities.length === 0) {
     throw new CliError(
-      "\u5F53\u524D\u76EE\u5F55\u6CA1\u6709\u8D44\u6E90\u72B6\u6001\u3002\u65B0\u8D44\u6E90\u8BF7\u5148 init \u540E create\uFF1B\u5DF2\u6709\u8D44\u6E90\u8BF7 bind <\u8D44\u6E90 ID|\u6807\u8BC6\u7B26> --artifact <\u8DEF\u5F84>\u3002",
+      "\u5F53\u524D\u76EE\u5F55\u6CA1\u6709\u8D44\u6E90\u72B6\u6001\u3002\u65B0\u8D44\u6E90\u53EF\u76F4\u63A5 create --type <\u53F6\u5B50\u7C7B\u578B> --artifact <\u8DEF\u5F84>\uFF0C\u4E5F\u53EF\u5148 init \u518D create\uFF1B\u5DF2\u6709\u8D44\u6E90\u8BF7 bind <\u8D44\u6E90 ID|\u6807\u8BC6\u7B26> --artifact <\u8DEF\u5F84>\u3002",
       "IDENTITY_NOT_FOUND"
     );
   }
@@ -24809,12 +24841,12 @@ function resolveIdentity(cwd, selector) {
     if (identities.length === 1) return identities[0];
     throw new CliError("\u5F53\u524D\u5DE5\u7A0B\u6709\u591A\u4EFD\u8D44\u6E90\u72B6\u6001\uFF1B\u8BF7\u4F7F\u7528 --resource \u6307\u5B9A\u8D44\u6E90", "IDENTITY_RESOURCE_REQUIRED");
   }
-  const matched = identities.filter((identity) => matches(identity, selector));
+  const matched = identities.filter((identity) => matches(cwd, identity, selector));
   if (matched.length === 1) return matched[0];
   if (matched.length === 0) {
     throw new CliError(`\u627E\u4E0D\u5230\u8D44\u6E90\u9009\u62E9\u5668 ${selector}`, "IDENTITY_RESOURCE_NOT_FOUND");
   }
-  throw new CliError(`\u8D44\u6E90\u9009\u62E9\u5668 ${selector} \u5339\u914D\u591A\u4EFD\u72B6\u6001\uFF1B\u8BF7\u4F7F\u7528 file:\u3001id: \u6216 name:`, "IDENTITY_RESOURCE_AMBIGUOUS");
+  throw new CliError(`\u8D44\u6E90\u9009\u62E9\u5668 ${selector} \u5339\u914D\u591A\u4EFD\u72B6\u6001\uFF1B\u8BF7\u4F7F\u7528 id:\u3001name:\u3001artifact: \u6216 file:`, "IDENTITY_RESOURCE_AMBIGUOUS");
 }
 
 // src/core/tty.ts
@@ -24854,6 +24886,16 @@ async function confirmWrite(preview, yes) {
   }
   return preview;
 }
+async function confirmDestructive(preview, action, yes, interactive = isInteractive(), ask = confirmQuestion) {
+  if (yes) {
+    return true;
+  }
+  if (!interactive) {
+    throw new CliError(`\u6709\u672A\u63D0\u4EA4\u5DE5\u4F5C\u7A3F\uFF1B\u8BF7\u52A0 --yes \u786E\u8BA4${action}`, "DRAFT_DESTRUCTIVE_NEED_YES");
+  }
+  return ask(`${preview}
+\u786E\u8BA4${action}\uFF1F`, false);
+}
 
 // src/domain/create/typePick.ts
 function unwrapList(result) {
@@ -24989,29 +25031,83 @@ function formatTypeList(items) {
   return items.map((item) => `${item.code}	${item.nameChain ?? item.name}`).join("\n");
 }
 
-// src/local/projectPath.ts
-import path8 from "path";
-var defaultError = {
-  code: "FILE_PATH_OUTSIDE_PROJECT",
-  message: "\u8DEF\u5F84\u5FC5\u987B\u843D\u5728\u5F53\u524D\u5DE5\u7A0B\u91CC"
-};
-function normalizeProjectPath(cwd, rawPath, error2 = defaultError) {
-  if (!rawPath.trim() || path8.isAbsolute(rawPath) || path8.win32.isAbsolute(rawPath) || path8.posix.isAbsolute(rawPath)) {
-    throw new CliError(error2.message, error2.code);
+// src/domain/version/zip.ts
+import { createWriteStream, existsSync as existsSync8, readdirSync as readdirSync3, statSync, unlinkSync as unlinkSync5 } from "fs";
+import { tmpdir } from "os";
+import path9 from "path";
+import { finished } from "stream/promises";
+import archiver from "archiver";
+function isThemeOrWidget(typeCode) {
+  return typeCode === "RT001" || typeCode === "RT002";
+}
+function assertArtifactPath(typeCode, filePath) {
+  const stats = existsSync8(filePath) ? statSync(filePath) : void 0;
+  const themeOrWidget = isThemeOrWidget(typeCode);
+  if (stats?.isDirectory() && !themeOrWidget) {
+    throw new CliError("\u4E0D\u652F\u6301\u6587\u4EF6\u5939\uFF0C\u8BF7\u6307\u5B9A\u4E00\u4E2A\u6587\u4EF6\u3002", "FILE_DIRECTORY_UNSUPPORTED");
   }
-  const root = path8.resolve(cwd);
-  const resolved = path8.resolve(root, rawPath);
-  const relative = path8.relative(root, resolved);
-  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
-    throw new CliError(error2.message, error2.code);
+}
+function assertArtifactAnchor(typeCode, filePath) {
+  if (!existsSync8(filePath)) {
+    throw new CliError(`\u672C\u5730\u4EA7\u7269\u4E0D\u5B58\u5728\uFF1A${filePath}`, "ARTIFACT_ANCHOR_MISSING");
+  }
+  const stats = statSync(filePath);
+  assertArtifactPath(typeCode, filePath);
+  if (!isThemeOrWidget(typeCode) && !stats.isFile()) {
+    throw new CliError("\u4E0D\u652F\u6301\u6587\u4EF6\u5939\uFF0C\u8BF7\u6307\u5B9A\u4E00\u4E2A\u6587\u4EF6\u3002", "FILE_DIRECTORY_UNSUPPORTED");
   }
-  return relative.replaceAll("\\", "/");
+}
+async function zipDirectoryContents(dir) {
+  if (!existsSync8(dir) || !statSync(dir).isDirectory()) {
+    throw new CliError(`\u6CA1\u6709\u6784\u5EFA\u4EA7\u7269 ${dir}\uFF0C\u8BF7\u5148\u6784\u5EFA`, "ZIP_MISSING");
+  }
+  if (existsSync8(path9.join(dir, ".freelog"))) {
+    throw new CliError("\u4E0D\u8981\u628A\u5DE5\u7A0B\u6839\u5F53\u4EA7\u7269\u76EE\u5F55\uFF0C\u8BF7\u6307\u5B9A dist \u6216 build\u3002", "ZIP_PROJECT_ROOT");
+  }
+  const entries = readdirSync3(dir);
+  if (entries.length === 0) {
+    throw new CliError("\u6784\u5EFA\u4EA7\u7269\u662F\u7A7A\u7684\uFF0C\u8BF7\u5148\u6784\u5EFA", "ZIP_EMPTY");
+  }
+  const outPath = path9.join(
+    tmpdir(),
+    `freelog-zip-${process.pid}-${Date.now()}.zip`
+  );
+  const output2 = createWriteStream(outPath);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  try {
+    archive.on("error", (error2) => output2.destroy(error2));
+    archive.pipe(output2);
+    for (const entry2 of entries) {
+      const full = path9.join(dir, entry2);
+      const stats = statSync(full);
+      if (stats.isDirectory()) {
+        archive.directory(full, entry2);
+      } else {
+        archive.file(full, { name: entry2 });
+      }
+    }
+    await archive.finalize();
+    await finished(output2);
+    return outPath;
+  } catch (error2) {
+    if (existsSync8(outPath)) {
+      try {
+        unlinkSync5(outPath);
+      } catch {
+      }
+    }
+    throw error2;
+  }
+}
+async function prepareUploadPath(typeCode, filePath) {
+  assertArtifactPath(typeCode, filePath);
+  if (isThemeOrWidget(typeCode) && existsSync8(filePath) && statSync(filePath).isDirectory()) {
+    return zipDirectoryContents(filePath);
+  }
+  return filePath;
 }
 
 // src/domain/create/create.ts
-function isFixedTemplateType(typeCode) {
-  return typeCode === "RT001" || typeCode === "RT002";
-}
 function unwrapData(result) {
   const envelope = result;
   return envelope.data ?? result;
@@ -25093,13 +25189,14 @@ async function assertOwnShellAvailable(input2) {
   );
 }
 function writeCreatedIdentity(input2) {
-  const filePath = input2.file;
+  const filePath = input2.file ?? input2.target?.filePath;
+  if (!filePath) throw new CliError("\u65B0\u8D44\u6E90\u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "CREATE_ARTIFACT_REQUIRED");
   const patch = {
     resourceId: input2.resourceId,
     name: input2.name,
     title: input2.title,
     typeCode: input2.typeCode,
-    ...filePath ? { filePath } : {},
+    filePath,
     env: input2.env
   };
   return input2.target ? updateIdentity(input2.cwd, input2.target.n, patch) : createIdentity(input2.cwd, {
@@ -25108,7 +25205,7 @@ function writeCreatedIdentity(input2) {
     name: input2.name,
     title: input2.title,
     typeCode: input2.typeCode,
-    ...filePath ? { filePath } : {},
+    filePath,
     env: input2.env
   });
 }
@@ -25141,18 +25238,17 @@ async function createResource(input2) {
     if (input2.yes && !input2.type && !target?.typeCode) {
       throw new CliError("--yes \u5728\u6CA1\u6709\u5DE5\u7A0B\u7C7B\u578B\u65F6\u5FC5\u987B\u63D0\u4F9B --type", "CREATE_YES_FLAGS");
     }
-    const targetTypeCode = target?.typeCode;
-    if (!target && isFixedTemplateType(input2.type) && !file) {
-      throw new CliError(
-        input2.type === "RT001" ? "\u5DF2\u6709\u4E3B\u9898\u5DE5\u7A0B\u8BF7\u901A\u8FC7 --artifact \u6307\u5B9A\u6784\u5EFA\u76EE\u5F55" : "\u5DF2\u6709\u63D2\u4EF6\u5DE5\u7A0B\u8BF7\u901A\u8FC7 --artifact \u6307\u5B9A\u6784\u5EFA\u76EE\u5F55",
-        "CREATE_FIXED_TYPE_FILE_REQUIRED"
-      );
+    const artifact = file ?? target?.filePath;
+    if (!artifact) {
+      throw new CliError("\u65B0\u8D44\u6E90\u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "CREATE_ARTIFACT_REQUIRED");
     }
-    if (isFixedTemplateType(targetTypeCode) && input2.type && input2.type !== targetTypeCode) {
+    const targetTypeCode = target?.typeCode;
+    if ((targetTypeCode === "RT001" || targetTypeCode === "RT002") && input2.type && input2.type !== targetTypeCode) {
       throw new CliError("\u4E3B\u9898/\u63D2\u4EF6\u5DE5\u7A0B\u7684\u8D44\u6E90\u7C7B\u578B\u56FA\u5B9A\uFF0C\u4E0D\u80FD\u7528 --type \u6539\u5199", "CREATE_FIXED_TYPE");
     }
     const typeCode = resolveTypeCode(input2.type, target);
     await getTypeInfo(typeCode, input2.apis);
+    assertArtifactAnchor(typeCode, path10.resolve(input2.cwd, artifact));
     await assertOwnShellAvailable({
       authLoginName: auth.loginName,
       authUserId: auth.userId,
@@ -25353,7 +25449,7 @@ function createUpdateCommand() {
 
 // src/commands/policy/apply.ts
 import { readFileSync as readFileSync6 } from "fs";
-import path9 from "path";
+import path11 from "path";
 import { confirm, input } from "@inquirer/prompts";
 import { Command as Command6 } from "commander";
 
@@ -25532,7 +25628,7 @@ async function setPolicy(input2) {
 // src/commands/policy/apply.ts
 function parsePolicy(file) {
   const text = readFileSync6(file, "utf8");
-  if (path9.extname(file).toLowerCase() !== ".json") return { policyText: text };
+  if (path11.extname(file).toLowerCase() !== ".json") return { policyText: text };
   let parsed;
   try {
     parsed = JSON.parse(text);
@@ -25656,14 +25752,18 @@ function createPolicyTemplateCommand() {
 // src/commands/project/bind.ts
 import { Command as Command10 } from "commander";
 
+// src/domain/bind/bind.ts
+import { existsSync as existsSync10 } from "fs";
+
 // src/local/indexFile.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import path12 from "path";
 function normalizeFileKey(filePath) {
-  return filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+  return path12.posix.normalize(filePath.replaceAll("\\", "/")).replace(/^\.\//, "");
 }
 
 // src/domain/bind/bind.ts
+import path13 from "path";
 async function bindResource(input2) {
   assertPlatformAllowed();
   const auth = requireAuth({ cwd: input2.cwd, homeDir: input2.homeDir });
@@ -25672,6 +25772,12 @@ async function bindResource(input2) {
     code: "BIND_FILE_OUTSIDE",
     message: "--artifact \u5FC5\u987B\u843D\u5728\u5F53\u524D\u5DE5\u7A0B\u91CC"
   }) : void 0;
+  if (filePath) {
+    const absolute = path13.resolve(input2.cwd, filePath);
+    if (!existsSync10(absolute)) {
+      throw new CliError(`\u672C\u5730\u4EA7\u7269\u4E0D\u5B58\u5728\uFF1A${absolute}`, "ARTIFACT_ANCHOR_MISSING");
+    }
+  }
   const infoApi2 = input2.apis?.info ?? ((params) => service_API_default.Resource.info(params));
   const info2 = unwrapData2(
     await infoApi2({
@@ -25718,9 +25824,11 @@ async function bindResource(input2) {
     if (byFile && target?.n !== byFile.n) {
       throw new CliError("\u8DEF\u5F84\u5DF2\u88AB\u5360\u7528", "BIND_PATH_TAKEN");
     }
-    if (isThemeOrWidget(typeCode) && !filePath && !target?.filePath) {
-      throw new CliError("\u4E3B\u9898/\u63D2\u4EF6 bind \u65F6\u8BF7\u901A\u8FC7 --artifact \u6307\u5B9A\u6784\u5EFA\u76EE\u5F55", "BIND_FIXED_TYPE_FILE_REQUIRED");
+    const resolvedFilePath = filePath ?? target?.filePath;
+    if (!resolvedFilePath) {
+      throw new CliError("\u65B0\u589E\u672C\u5730\u72B6\u6001\u65F6\u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "BIND_ARTIFACT_REQUIRED");
     }
+    assertArtifactAnchor(typeCode, path13.resolve(input2.cwd, resolvedFilePath));
     const env = getEnv2();
     if (target) {
       const resourceChanged = target.resourceId !== resourceId;
@@ -25736,7 +25844,7 @@ async function bindResource(input2) {
         name,
         title,
         typeCode,
-        filePath: filePath ?? target.filePath,
+        filePath: resolvedFilePath,
         env
       });
       commitLocalTransaction(input2.cwd, [
@@ -25751,7 +25859,7 @@ async function bindResource(input2) {
       name,
       title,
       typeCode,
-      filePath,
+      filePath: resolvedFilePath,
       env
     });
     commitLocalTransaction(input2.cwd, [
@@ -25768,9 +25876,6 @@ function isCollectionSubject(subjectType) {
   const values = Array.isArray(subjectType) ? subjectType : [subjectType];
   return values.some((value) => Number(value) === 4);
 }
-function isThemeOrWidget(typeCode) {
-  return typeCode === "RT001" || typeCode === "RT002";
-}
 
 // src/commands/project/bind.ts
 function createBindCommand() {
@@ -25806,9 +25911,9 @@ import { Command as Command11 } from "commander";
 
 // src/domain/init/scaffold.ts
 import { execFile as execFileCallback } from "child_process";
-import { cpSync, existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync2, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync8, renameSync, rmSync } from "fs";
+import { cpSync, existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync2, mkdtempSync, readdirSync as readdirSync4, readFileSync as readFileSync8, renameSync, rmSync } from "fs";
 import os4 from "os";
-import path11 from "path";
+import path14 from "path";
 import { promisify } from "util";
 
 // src/domain/init/templates.ts
@@ -25834,44 +25939,49 @@ function formatTemplateList(items) {
 
 // src/domain/init/scaffold.ts
 var execFile = promisify(execFileCallback);
-function isFixedTemplateType2(typeCode) {
-  return typeCode === "RT001" || typeCode === "RT002";
-}
 function resolveTargetDir(input2) {
-  return input2.dir ? path11.isAbsolute(input2.dir) ? input2.dir : path11.resolve(input2.cwd, input2.dir) : path11.resolve(input2.cwd);
+  return input2.dir ? path14.isAbsolute(input2.dir) ? input2.dir : path14.resolve(input2.cwd, input2.dir) : path14.resolve(input2.cwd);
 }
 function targetHasOnlyAuthSelector(targetDir) {
-  if (!existsSync9(targetDir)) return false;
+  if (!existsSync11(targetDir)) return false;
   let entries;
   try {
-    entries = readdirSync3(targetDir);
+    entries = readdirSync4(targetDir);
   } catch {
     throw new CliError("\u76EE\u6807\u76EE\u5F55\u4E0D\u53EF\u8BFB\u53D6\uFF0C\u62D2\u7EDD\u8986\u76D6", "INIT_TARGET_NOT_EMPTY");
   }
   if (entries.length === 0) return false;
   if (entries.length !== 1 || entries[0] !== ".freelog") return false;
-  const stateDir = path11.join(targetDir, ".freelog");
-  if (!lstatSync(stateDir).isDirectory() || lstatSync(stateDir).isSymbolicLink()) return false;
-  const stateEntries = readdirSync3(stateDir);
+  const stateDir = path14.join(targetDir, ".freelog");
+  return stateDirHasOnlyAuthSelector(stateDir);
+}
+function stateDirHasOnlyAuthSelector(stateDir) {
+  if (!existsSync11(stateDir) || !lstatSync(stateDir).isDirectory() || lstatSync(stateDir).isSymbolicLink()) return false;
+  const stateEntries = readdirSync4(stateDir);
   if (stateEntries.length !== 1 || stateEntries[0] !== "auth") return false;
-  const auth = lstatSync(path11.join(stateDir, "auth"));
+  const auth = lstatSync(path14.join(stateDir, "auth"));
   return auth.isFile() && !auth.isSymbolicLink();
 }
-function assertInitialTarget(targetDir) {
-  if (!existsSync9(targetDir)) return { targetExisted: false, preserveAuth: false };
-  const entries = readdirSync3(targetDir);
-  if (entries.length === 0) return { targetExisted: true, preserveAuth: false };
-  if (targetHasOnlyAuthSelector(targetDir)) return { targetExisted: true, preserveAuth: true };
+function assertInitialTarget(targetDir, adoptExistingProject) {
+  if (!existsSync11(targetDir)) return { targetExisted: false, preserveAuth: false, adoptExistingProject };
+  const entries = readdirSync4(targetDir);
+  if (entries.length === 0) return { targetExisted: true, preserveAuth: false, adoptExistingProject };
+  if (targetHasOnlyAuthSelector(targetDir)) return { targetExisted: true, preserveAuth: true, adoptExistingProject };
+  if (adoptExistingProject) {
+    const stateDir = path14.join(targetDir, ".freelog");
+    if (!existsSync11(stateDir)) return { targetExisted: true, preserveAuth: false, adoptExistingProject: true };
+    if (stateDirHasOnlyAuthSelector(stateDir)) return { targetExisted: true, preserveAuth: true, adoptExistingProject: true };
+  }
   throw new CliError("\u76EE\u6807\u76EE\u5F55\u4E0D\u662F\u7A7A\u76EE\u5F55\uFF0C\u62D2\u7EDD\u8986\u76D6", "INIT_TARGET_NOT_EMPTY");
 }
 function assertOnlyAuthSelectorStillThere(targetDir) {
-  if (!targetHasOnlyAuthSelector(targetDir)) {
+  if (!stateDirHasOnlyAuthSelector(path14.join(targetDir, ".freelog"))) {
     throw new CliError("\u76EE\u6807\u76EE\u5F55\u5728\u521D\u59CB\u5316\u671F\u95F4\u88AB\u4FEE\u6539\uFF0C\u672A\u8986\u76D6\u672A\u77E5\u6587\u4EF6", "INIT_TARGET_CHANGED");
   }
 }
 function copyDirectoryContents(sourceDir, targetDir) {
-  for (const entry2 of readdirSync3(sourceDir)) {
-    cpSync(path11.join(sourceDir, entry2), path11.join(targetDir, entry2), { recursive: true, errorOnExist: true, force: false });
+  for (const entry2 of readdirSync4(sourceDir)) {
+    cpSync(path14.join(sourceDir, entry2), path14.join(targetDir, entry2), { recursive: true, errorOnExist: true, force: false });
   }
 }
 function parsePackFilename(stdout) {
@@ -25883,8 +25993,8 @@ function parsePackFilename(stdout) {
   throw new CliError("\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25\uFF1Anpm \u672A\u8FD4\u56DE\u5B89\u88C5\u5305", "TEMPLATE_DOWNLOAD_FAILED");
 }
 function validateRemoteTemplate(packageDir, template) {
-  const manifestPath = path11.join(packageDir, "template.manifest.json");
-  const templateDir = path11.join(packageDir, "template");
+  const manifestPath = path14.join(packageDir, "template.manifest.json");
+  const templateDir = path14.join(packageDir, "template");
   let manifest;
   try {
     manifest = JSON.parse(readFileSync8(manifestPath, "utf8"));
@@ -25892,15 +26002,15 @@ function validateRemoteTemplate(packageDir, template) {
     throw new CliError("\u6A21\u677F\u6821\u9A8C\u5931\u8D25\uFF1A\u7F3A\u5C11\u6216\u65E0\u6CD5\u8BFB\u53D6 template.manifest.json", "TEMPLATE_INVALID");
   }
   const tags = Array.isArray(manifest.tags) ? manifest.tags : [];
-  if (manifest.id !== template.id || manifest.npmName !== template.npmName || manifest.version !== template.version || !tags.includes("runtime") || !template.targets.every((target) => tags.includes(target)) || !existsSync9(templateDir)) {
+  if (manifest.id !== template.id || manifest.npmName !== template.npmName || manifest.version !== template.version || !tags.includes("runtime") || !template.targets.every((target) => tags.includes(target)) || !existsSync11(templateDir)) {
     throw new CliError("\u6A21\u677F\u6821\u9A8C\u5931\u8D25\uFF1A\u7EBF\u4E0A\u6A21\u677F\u4E0E\u53D7\u63A7\u6E05\u5355\u4E0D\u4E00\u81F4", "TEMPLATE_INVALID");
   }
   return templateDir;
 }
 async function installRemoteTemplate(input2) {
-  const tempDir = mkdtempSync(path11.join(os4.tmpdir(), "freelog-template-"));
-  const downloadDir = path11.join(tempDir, "download");
-  const extractDir = path11.join(tempDir, "extract");
+  const tempDir = mkdtempSync(path14.join(os4.tmpdir(), "freelog-template-"));
+  const downloadDir = path14.join(tempDir, "download");
+  const extractDir = path14.join(tempDir, "extract");
   mkdirSync2(downloadDir);
   mkdirSync2(extractDir);
   const npm = process.platform === "win32" ? "npm.cmd" : "npm";
@@ -25911,78 +26021,86 @@ async function installRemoteTemplate(input2) {
     } catch {
       throw new CliError(`\u6A21\u677F\u4E0B\u8F7D\u5931\u8D25\uFF1A${input2.template.id}`, "TEMPLATE_DOWNLOAD_FAILED");
     }
-    const archivePath = path11.join(downloadDir, parsePackFilename(stdout));
+    const archivePath = path14.join(downloadDir, parsePackFilename(stdout));
     try {
       await execFile("tar", ["-xzf", archivePath, "-C", extractDir]);
     } catch {
       throw new CliError(`\u6A21\u677F\u89E3\u5305\u5931\u8D25\uFF1A${input2.template.id}`, "TEMPLATE_EXTRACT_FAILED");
     }
-    copyDirectoryContents(validateRemoteTemplate(path11.join(extractDir, "package"), input2.template), input2.targetDir);
+    copyDirectoryContents(validateRemoteTemplate(path14.join(extractDir, "package"), input2.template), input2.targetDir);
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
   }
 }
-function commitStaging(stagingDir, targetDir, targetExisted, preserveAuth) {
+function commitStaging(stagingDir, targetDir, targetExisted, preserveAuth, adoptExistingProject) {
   if (!targetExisted) {
     renameSync(stagingDir, targetDir);
     return;
   }
   if (preserveAuth) {
     assertOnlyAuthSelectorStillThere(targetDir);
+  } else if (adoptExistingProject) {
+    if (existsSync11(path14.join(targetDir, ".freelog"))) {
+      throw new CliError("\u76EE\u6807\u76EE\u5F55\u5728\u521D\u59CB\u5316\u671F\u95F4\u88AB\u4FEE\u6539\uFF0C\u672A\u8986\u76D6\u672A\u77E5\u6587\u4EF6", "INIT_TARGET_CHANGED");
+    }
+    renameSync(path14.join(stagingDir, ".freelog"), path14.join(targetDir, ".freelog"));
+    rmSync(stagingDir, { recursive: true, force: true });
+    return;
   } else {
-    assertInitialTarget(targetDir);
+    assertInitialTarget(targetDir, false);
   }
-  for (const entry2 of readdirSync3(stagingDir)) {
-    const destination = path11.join(targetDir, entry2);
+  for (const entry2 of readdirSync4(stagingDir)) {
+    const destination = path14.join(targetDir, entry2);
     if (preserveAuth && entry2 === ".freelog") {
-      for (const stateEntry of readdirSync3(path11.join(stagingDir, entry2))) {
-        const stateDestination = path11.join(destination, stateEntry);
-        if (existsSync9(stateDestination)) {
+      for (const stateEntry of readdirSync4(path14.join(stagingDir, entry2))) {
+        const stateDestination = path14.join(destination, stateEntry);
+        if (existsSync11(stateDestination)) {
           throw new CliError("\u76EE\u6807\u76EE\u5F55\u5728\u521D\u59CB\u5316\u671F\u95F4\u88AB\u4FEE\u6539\uFF0C\u672A\u8986\u76D6\u672A\u77E5\u6587\u4EF6", "INIT_TARGET_CHANGED");
         }
-        renameSync(path11.join(stagingDir, entry2, stateEntry), stateDestination);
+        renameSync(path14.join(stagingDir, entry2, stateEntry), stateDestination);
       }
-      rmSync(path11.join(stagingDir, entry2), { recursive: true, force: true });
+      rmSync(path14.join(stagingDir, entry2), { recursive: true, force: true });
       continue;
     }
-    if (existsSync9(destination)) {
+    if (existsSync11(destination)) {
       throw new CliError("\u76EE\u6807\u76EE\u5F55\u5728\u521D\u59CB\u5316\u671F\u95F4\u88AB\u4FEE\u6539\uFF0C\u672A\u8986\u76D6\u672A\u77E5\u6587\u4EF6", "INIT_TARGET_CHANGED");
     }
-    renameSync(path11.join(stagingDir, entry2), destination);
+    renameSync(path14.join(stagingDir, entry2), destination);
   }
   rmSync(stagingDir, { recursive: true, force: true });
 }
 async function initProject(input2) {
   const targetDir = resolveTargetDir(input2);
   return withInitLock(targetDir, async () => {
-    const initialTarget = assertInitialTarget(targetDir);
     const shortcut = input2.shortcut;
+    const adoptExistingProject = !shortcut;
+    const initialTarget = assertInitialTarget(targetDir, adoptExistingProject);
     if (shortcut && input2.yes && !input2.template) {
       throw new CliError("init theme / widget \u4F7F\u7528 --yes \u65F6\u5FC5\u987B\u5E26 --template", "INIT_TEMPLATE_REQUIRED");
     }
     if (!shortcut && !input2.typeCode?.trim()) {
       throw new CliError("\u8BF7\u9009\u62E9\u8D44\u6E90\u7C7B\u578B", "INIT_TYPE_REQUIRED");
     }
-    const typeCode = shortcut === "theme" ? "RT001" : shortcut === "widget" ? "RT002" : (await (input2.typeValidator ?? ((code) => getTypeInfo(code, input2.typeApis)))(input2.typeCode)).code;
-    if (!shortcut && isFixedTemplateType2(typeCode)) {
-      throw new CliError(
-        typeCode === "RT001" ? "\u4E3B\u9898\u8BF7\u4F7F\u7528 init theme \u521B\u5EFA\u6A21\u677F\u5DE5\u7A0B" : "\u63D2\u4EF6\u8BF7\u4F7F\u7528 init widget \u521B\u5EFA\u6A21\u677F\u5DE5\u7A0B",
-        "INIT_TEMPLATE_SHORTCUT_REQUIRED"
-      );
+    if (!shortcut && !input2.artifact?.trim()) {
+      throw new CliError("init \u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "INIT_ARTIFACT_REQUIRED");
     }
+    const typeCode = shortcut === "theme" ? "RT001" : shortcut === "widget" ? "RT002" : (await (input2.typeValidator ?? ((code) => getTypeInfo(code, input2.typeApis)))(input2.typeCode)).code;
+    const artifact = shortcut ? "dist" : normalizeProjectPath(targetDir, input2.artifact);
+    if (!shortcut) assertArtifactAnchor(typeCode, path14.resolve(targetDir, artifact));
     const template = shortcut && input2.template ? getTemplate(input2.template, shortcut) : void 0;
     if (shortcut && !template) throw new CliError("\u8BF7\u9009\u62E9\u6A21\u677F", "INIT_TEMPLATE_REQUIRED");
-    const parent = path11.dirname(targetDir);
+    const parent = path14.dirname(targetDir);
     mkdirSync2(parent, { recursive: true });
-    const stagingDir = mkdtempSync(path11.join(parent, `.${path11.basename(targetDir)}.freelog-init-`));
+    const stagingDir = mkdtempSync(path14.join(parent, `.${path14.basename(targetDir)}.freelog-init-`));
     try {
       if (template) await (input2.templateSource ?? installRemoteTemplate)({ template, targetDir: stagingDir });
+      if (shortcut) mkdirSync2(path14.join(stagingDir, artifact), { recursive: true });
       const created = createIdentity(stagingDir, {
         subject: "resource",
         typeCode,
-        ...shortcut ? { filePath: "dist" } : {}
+        filePath: artifact
       });
-      commitStaging(stagingDir, targetDir, initialTarget.targetExisted, initialTarget.preserveAuth);
+      commitStaging(stagingDir, targetDir, initialTarget.targetExisted, initialTarget.preserveAuth, adoptExistingProject);
       return { ...created, n: created.n };
     } catch (error2) {
       rmSync(stagingDir, { recursive: true, force: true });
@@ -26012,9 +26130,18 @@ async function chooseProjectDir(dir) {
   }
   return selected;
 }
+async function chooseArtifact(artifact, yes) {
+  if (artifact?.trim()) return artifact;
+  if (yes || !isInteractive()) {
+    throw new CliError("init \u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "INIT_ARTIFACT_REQUIRED");
+  }
+  const selected = (await askInput2("\u672C\u5730\u4EA7\u7269\u6587\u4EF6\u6216\u6784\u5EFA\u76EE\u5F55")).trim();
+  if (!selected) throw new CliError("init \u5FC5\u987B\u901A\u8FC7 --artifact \u5173\u8054\u672C\u5730\u4EA7\u7269", "INIT_ARTIFACT_REQUIRED");
+  return selected;
+}
 function createInitCommand() {
   const init2 = addSharedOptions(new Command11("init"));
-  init2.description("\u53EA\u5EFA\u672C\u5730\u5355\u8D44\u6E90\u5DE5\u7A0B").argument("[dir]", "\u76EE\u6807\u76EE\u5F55").option("--type <leaf-code>", "\u666E\u901A\u8D44\u6E90\u6700\u7EC8\u53F6\u5B50\u7C7B\u578B").option("--resource-type <leaf-code>", "\u5DF2\u5F03\u7528\uFF1A\u8BF7\u6539\u7528 --type").action(async function(dir, options) {
+  init2.description("\u5EFA\u7ACB\u9996\u4EFD\u672C\u5730\u8D44\u6E90\u72B6\u6001").argument("[dir]", "\u76EE\u6807\u76EE\u5F55").option("--type <leaf-code>", "\u666E\u901A\u8D44\u6E90\u6700\u7EC8\u53F6\u5B50\u7C7B\u578B").option("--artifact <path>", "\u8981\u5173\u8054\u7684\u672C\u5730\u4EA7\u7269\u6587\u4EF6\u6216\u6784\u5EFA\u76EE\u5F55").option("--resource-type <leaf-code>", "\u5DF2\u5F03\u7528\uFF1A\u8BF7\u6539\u7528 --type").action(async function(dir, options) {
     if (options.type && options.resourceType) throw new CliError("--type \u4E0E --resource-type \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528", "INIT_TYPE_CONFLICT");
     if (options.resourceType) console.warn("\u8B66\u544A\uFF1A--resource-type \u5DF2\u5F03\u7528\uFF0C\u8BF7\u6539\u7528 --type");
     const shared = sharedOptions(this);
@@ -26023,7 +26150,14 @@ function createInitCommand() {
     requireAuth({ cwd });
     const selected = options.type ?? options.resourceType;
     const type = selected ? await getTypeInfo(selected) : await chooseLeafType();
-    const created = await initProject({ cwd, dir: targetDir, typeCode: type.code, typeValidator: async () => type, yes: shared.yes });
+    const created = await initProject({
+      cwd,
+      dir: targetDir,
+      typeCode: type.code,
+      typeValidator: async () => type,
+      artifact: await chooseArtifact(options.artifact, shared.yes),
+      yes: shared.yes
+    });
     console.log(`\u5DF2\u521B\u5EFA\u672C\u5730\u8EAB\u4EFD ${created.n}.json`);
   });
   for (const shortcut of ["theme", "widget"]) {
@@ -26705,90 +26839,16 @@ async function submitVersion(input2) {
 
 // src/domain/version/file.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync2, unlinkSync as unlinkSync6 } from "fs";
-import path13 from "path";
-
-// src/domain/version/zip.ts
-import { createWriteStream, existsSync as existsSync10, readdirSync as readdirSync4, statSync, unlinkSync as unlinkSync5 } from "fs";
-import { tmpdir } from "os";
-import path12 from "path";
-import { finished } from "stream/promises";
-import archiver from "archiver";
-function isThemeOrWidget2(typeCode) {
-  return typeCode === "RT001" || typeCode === "RT002";
-}
-function assertArtifactPath(typeCode, filePath) {
-  const stats = existsSync10(filePath) ? statSync(filePath) : void 0;
-  const themeOrWidget = isThemeOrWidget2(typeCode);
-  if (stats?.isDirectory() && !themeOrWidget) {
-    throw new CliError("\u4E0D\u652F\u6301\u6587\u4EF6\u5939\uFF0C\u8BF7\u6307\u5B9A\u4E00\u4E2A\u6587\u4EF6\u3002", "FILE_DIRECTORY_UNSUPPORTED");
-  }
-  if (themeOrWidget && stats?.isFile() && filePath.toLowerCase().endsWith(".zip")) {
-    throw new CliError("\u4E3B\u9898/\u63D2\u4EF6\u8BF7\u6307\u5B9A\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\uFF0C\u4E0D\u8981\u81EA\u5DF1\u6253 zip\u3002", "FILE_THEME_ZIP");
-  }
-  if (themeOrWidget && stats?.isFile()) {
-    throw new CliError("\u4E3B\u9898/\u63D2\u4EF6\u8BF7\u6307\u5B9A\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\uFF0C\u4E0D\u8981\u81EA\u5DF1\u6253 zip\u3002", "FILE_THEME_ZIP");
-  }
-}
-async function zipDirectoryContents(dir) {
-  if (!existsSync10(dir) || !statSync(dir).isDirectory()) {
-    throw new CliError(`\u6CA1\u6709\u6784\u5EFA\u4EA7\u7269 ${dir}\uFF0C\u8BF7\u5148\u6784\u5EFA`, "ZIP_MISSING");
-  }
-  if (existsSync10(path12.join(dir, ".freelog"))) {
-    throw new CliError("\u4E0D\u8981\u628A\u5DE5\u7A0B\u6839\u5F53\u4EA7\u7269\u76EE\u5F55\uFF0C\u8BF7\u6307\u5B9A dist \u6216 build\u3002", "ZIP_PROJECT_ROOT");
-  }
-  const entries = readdirSync4(dir);
-  if (entries.length === 0) {
-    throw new CliError("\u6784\u5EFA\u4EA7\u7269\u662F\u7A7A\u7684\uFF0C\u8BF7\u5148\u6784\u5EFA", "ZIP_EMPTY");
-  }
-  const outPath = path12.join(
-    tmpdir(),
-    `freelog-zip-${process.pid}-${Date.now()}.zip`
-  );
-  const output2 = createWriteStream(outPath);
-  const archive = archiver("zip", { zlib: { level: 9 } });
-  try {
-    archive.on("error", (error2) => output2.destroy(error2));
-    archive.pipe(output2);
-    for (const entry2 of entries) {
-      const full = path12.join(dir, entry2);
-      const stats = statSync(full);
-      if (stats.isDirectory()) {
-        archive.directory(full, entry2);
-      } else {
-        archive.file(full, { name: entry2 });
-      }
-    }
-    await archive.finalize();
-    await finished(output2);
-    return outPath;
-  } catch (error2) {
-    if (existsSync10(outPath)) {
-      try {
-        unlinkSync5(outPath);
-      } catch {
-      }
-    }
-    throw error2;
-  }
-}
-async function prepareUploadPath(typeCode, filePath) {
-  assertArtifactPath(typeCode, filePath);
-  if (isThemeOrWidget2(typeCode) && existsSync10(filePath) && statSync(filePath).isDirectory()) {
-    return zipDirectoryContents(filePath);
-  }
-  return filePath;
-}
-
-// src/domain/version/file.ts
+import { existsSync as existsSync12, readFileSync as readFileSync9, statSync as statSync2, unlinkSync as unlinkSync6 } from "fs";
+import path15 from "path";
 var ANALYZE_TIMEOUT_MS = 12e4;
 var ANALYZE_POLL_INTERVAL_MS = 200;
 function resolveExistingPath(cwd, raw) {
-  if (existsSync11(raw)) {
-    return path13.resolve(raw);
+  if (existsSync12(raw)) {
+    return path15.resolve(raw);
   }
-  const joined = path13.resolve(cwd, raw);
-  if (existsSync11(joined)) {
+  const joined = path15.resolve(cwd, raw);
+  if (existsSync12(joined)) {
     return joined;
   }
   return void 0;
@@ -26847,7 +26907,7 @@ async function uploadIfNew(uploadPath, sha1, typeCode, apis) {
   await upload({ file: readFileSync9(uploadPath), resourceType: typeCode });
 }
 function removeTempZip(uploadPath, localPath) {
-  if (uploadPath === localPath || !existsSync11(uploadPath)) {
+  if (uploadPath === localPath || !existsSync12(uploadPath)) {
     return;
   }
   try {
@@ -26896,12 +26956,12 @@ async function uploadAndAnalyze(input2) {
 async function uploadAndAnalyzeLocked(input2) {
   assertPlatformAllowed();
   const file = input2.file !== void 0 ? normalizeProjectPath(input2.cwd, input2.file) : void 0;
-  const recordedFile = input2.identity.filePath ? normalizeProjectPath(input2.cwd, input2.identity.filePath) : void 0;
+  const recordedFile = normalizeProjectPath(input2.cwd, input2.identity.filePath);
   const identity = recordedFile === input2.identity.filePath ? input2.identity : { ...input2.identity, filePath: recordedFile };
   const localPath = confirmLocalPath(identity, file, input2.yes, input2.cwd);
   const uploadPath = await prepareUploadPath(identity.typeCode, localPath);
   try {
-    const uploaded = { fileSha1: sha1OfFile(uploadPath), filename: path13.basename(uploadPath) };
+    const uploaded = { fileSha1: sha1OfFile(uploadPath), filename: path15.basename(uploadPath) };
     await uploadIfNew(uploadPath, uploaded.fileSha1, identity.typeCode, input2.apis ?? {});
     const analysis = await waitAnalyze(
       uploaded.fileSha1,
@@ -26954,12 +27014,26 @@ async function runCreateVersionLocked(input2) {
     })
   );
   const latestVersion = info2.latestVersion ? String(info2.latestVersion) : void 0;
+  const existingDraft = readDraft(input2.cwd, identity.n);
+  evaluateGates({ latestVersion, draft: input2.reset ? void 0 : existingDraft }, "create-version");
+  const artifact = resolveArtifactPath(input2.cwd, identity, input2.file, input2.artifact);
+  if (!input2.prepare && !input2.yes) {
+    throw new CliError("\u63D0\u4EA4\u8BF7\u52A0 --yes", "CREATE_VERSION_NEED_YES");
+  }
   if (input2.reset) {
+    confirmLocalPath(identity, artifact, input2.yes, input2.cwd);
+  }
+  let draft = existingDraft;
+  if (input2.reset && existingDraft) {
+    if (!input2.confirmReset) {
+      throw new CliError("\u8BF7\u5148\u786E\u8BA4\u4E22\u5F03\u5DE5\u4F5C\u7A3F", "RESET_CONFIRMATION_REQUIRED");
+    }
+    if (!await input2.confirmReset(draftSummary(existingDraft))) {
+      return "\u5DF2\u53D6\u6D88";
+    }
     deleteDraft(input2.cwd, identity.n);
+    draft = void 0;
   }
-  const draft = readDraft(input2.cwd, identity.n);
-  evaluateGates({ latestVersion, draft }, "create-version");
-  const artifact = resolveArtifactPath(input2.cwd, identity, input2.file, input2.artifact);
   if (!draft || input2.prepare || artifact) {
     writeDraft(input2.cwd, identity.n, draft ?? emptyDraft());
   }
@@ -26973,9 +27047,6 @@ async function runCreateVersionLocked(input2) {
     });
     return "\u5DF2\u5907\u7A3F\uFF0C\u672A\u63D0\u4EA4";
   }
-  if (!input2.yes) {
-    throw new CliError("\u63D0\u4EA4\u8BF7\u52A0 --yes", "CREATE_VERSION_NEED_YES");
-  }
   await uploadAndAnalyze({
     cwd: input2.cwd,
     identity,
@@ -27004,6 +27075,11 @@ async function runCreateVersionLocked(input2) {
   return "1.0.0";
 }
 
+// src/commands/version/draftConfirmation.ts
+async function confirmDraftDestruction(input2) {
+  return confirmDestructive(input2.summary, input2.action, input2.yes, isInteractive(), confirmQuestion);
+}
+
 // src/commands/version/create-version.ts
 function createCreateVersionCommand() {
   const command = addSharedOptions(new Command20("create-version"));
@@ -27024,12 +27100,14 @@ function createCreateVersionCommand() {
     "\u672C\u6B21\u4E0A\u4F20\u5E76\u8BB0\u5F55\u7684\u672C\u5730\u6587\u4EF6\u6216\u76EE\u5F55"
   ).action(async function(options) {
     const shared = readSharedOptions(this);
+    const cwd = resolveCwd(shared.cwd);
     const result = await runCreateVersion({
-      cwd: resolveCwd(shared.cwd),
+      cwd,
       file: shared.file,
       artifact: options.artifact,
       prepare: options.prepare,
       reset: options.reset,
+      confirmReset: options.reset ? (summary) => confirmDraftDestruction({ summary, yes: shared.yes, action: "\u4E22\u5F03\u5DE5\u4F5C\u7A3F\u5E76\u91CD\u7F6E\u9996\u7248" }) : void 0,
       yes: shared.yes
     });
     console.log(result);
@@ -27442,15 +27520,23 @@ function registerDraftDescription(draft) {
 import { Command as Command23 } from "commander";
 
 // src/domain/version/draftDiscard.ts
-function draftDiscard(cwd, file) {
-  return withProjectLock(cwd, () => draftDiscardLocked(cwd, file), "version-draft-discard");
+async function draftDiscard(cwd, file, confirmed = false, confirm4) {
+  return withProjectLock(cwd, () => draftDiscardLocked(cwd, file, confirmed, confirm4), "version-draft-discard");
 }
-function draftDiscardLocked(cwd, file) {
+async function draftDiscardLocked(cwd, file, confirmed, confirm4) {
   const identity = resolveIdentity(cwd, file);
   const draft = readDraft(cwd, identity.n);
   if (!draft) {
     return "\u6CA1\u6709\u5DE5\u4F5C\u7A3F";
   }
+  if (!confirmed) {
+    if (!confirm4) {
+      throw new CliError("\u8BF7\u5148\u786E\u8BA4\u4E22\u5F03\u5DE5\u4F5C\u7A3F", "DRAFT_DISCARD_CONFIRMATION_REQUIRED");
+    }
+    if (!await confirm4(draftSummary(draft))) {
+      return "\u5DF2\u53D6\u6D88";
+    }
+  }
   deleteDraft(cwd, identity.n);
   return "\u5DF2\u4E22\u6389\u5DE5\u4F5C\u7A3F";
 }
@@ -27477,17 +27563,6 @@ async function draftPullLocked(input2) {
   if (!want) {
     throw new CliError("\u8FD8\u6CA1\u6709\u53D1\u884C\u7248\u672C\uFF0C\u8BF7\u5148 create-version", "GATE_USE_CREATE");
   }
-  if (existing) {
-    const summary = draftSummary(existing);
-    if (!input2.yes && existing.fromVersion === want) {
-      return `${summary}
-\u7A3F\u5DF2\u6765\u81EA ${want}\uFF0C\u672A\u8986\u76D6`;
-    }
-    if (!input2.yes) {
-      return `${summary}
-\u672A\u8986\u76D6`;
-    }
-  }
   const versionInfoApi = input2.apis?.resourceVersionInfo1 ?? ((params) => service_API_default.Resource.resourceVersionInfo1(params));
   const versionInfo = unwrapData2(
     await versionInfoApi({
@@ -27499,6 +27574,17 @@ async function draftPullLocked(input2) {
   if (!pulledSha) {
     throw new CliError("\u6CA1\u6709\u8FD9\u4E2A\u7248\u672C", "DRAFT_VERSION_MISSING");
   }
+  if (existing && !input2.yes) {
+    const summary = draftSummary(existing);
+    if (!input2.confirmOverwrite) {
+      return existing.fromVersion === want ? `${summary}
+\u7A3F\u5DF2\u6765\u81EA ${want}\uFF0C\u672A\u8986\u76D6` : `${summary}
+\u672A\u8986\u76D6`;
+    }
+    if (!await input2.confirmOverwrite(summary, want)) {
+      return "\u5DF2\u53D6\u6D88";
+    }
+  }
   writeDraft(input2.cwd, identity.n, {
     fromVersion: want,
     fileSha1: pulledSha,
@@ -27533,20 +27619,36 @@ function createVersionDraftCommand() {
     "\u5DF2\u53D1\u53F7"
   ).action(async function(options) {
     const shared = readSharedOptions(this);
+    const cwd = resolveCwd(shared.cwd);
     const text = await draftPull({
-      cwd: resolveCwd(shared.cwd),
+      cwd,
       file: shared.file,
       version: options.version,
-      yes: shared.yes
+      yes: shared.yes,
+      confirmOverwrite: (summary, version) => confirmDraftDestruction({
+        summary,
+        yes: shared.yes,
+        action: `\u7528\u7EBF\u4E0A\u7248\u672C ${version} \u8986\u76D6\u672C\u5730\u5DE5\u4F5C\u7A3F`
+      })
     });
     console.log(text);
   });
   addSharedOptions(draft.command("discard")).description(
     // i18n: cli.command.version.draft.discard.description
     "\u4E22\u6389\u5DE5\u4F5C\u7A3F"
-  ).action(function() {
+  ).action(async function() {
     const shared = readSharedOptions(this);
-    console.log(draftDiscard(resolveCwd(shared.cwd), shared.file));
+    const cwd = resolveCwd(shared.cwd);
+    console.log(await draftDiscard(
+      cwd,
+      shared.file,
+      shared.yes,
+      (summary) => confirmDraftDestruction({
+        summary,
+        yes: shared.yes,
+        action: "\u4E22\u5F03\u5DE5\u4F5C\u7A3F"
+      })
+    ));
   });
   return draft;
 }
@@ -27791,6 +27893,7 @@ function createVersionOptionCommand() {
 import { Command as Command25 } from "commander";
 
 // src/domain/version/setPath.ts
+import path16 from "path";
 function setIdentityFilePath(cwd, input2) {
   return withProjectLock(cwd, () => {
     const artifact = input2.artifact !== void 0 ? normalizeProjectPath(cwd, input2.artifact) : void 0;
@@ -27798,6 +27901,7 @@ function setIdentityFilePath(cwd, input2) {
       throw new CliError("\u8BF7\u63D0\u4F9B --artifact", "SET_ARTIFACT_REQUIRED");
     }
     const identity = resolveIdentity(cwd, input2.file);
+    assertArtifactAnchor(identity.typeCode, path16.resolve(cwd, artifact));
     const updated = prepareIdentityUpdate(cwd, identity.n, { filePath: artifact });
     commitLocalTransaction(cwd, [
       { path: identityFilePath(cwd, updated.n), content: serializeIdentity(updated) }
@@ -27932,13 +28036,40 @@ async function runUpdateVersionLocked(input2) {
     })
   );
   const latestVersion = info2.latestVersion ? String(info2.latestVersion) : void 0;
+  const existingDraft = readDraft(input2.cwd, identity.n);
+  const source = input2.reuseVersion ?? latestVersion;
+  evaluateGates({ latestVersion, draft: input2.reset ? void 0 : existingDraft, reuseVersion: input2.reuseVersion }, "update-version");
+  const artifact = resolveArtifactPath(input2.cwd, identity, input2.file, input2.artifact);
+  if (!input2.reset && input2.yes && existingDraft?.fromVersion && source && existingDraft.fromVersion !== source) {
+    throw new CliError(
+      `\u7A3F\u6765\u81EA ${existingDraft.fromVersion}\u3001\u5E95\u662F ${source}\u3002\u8BF7 version draft pull \u6216 --reuse-version`,
+      "UPDATE_VERSION_MISMATCH"
+    );
+  }
+  const next = resolveNextVersion(latestVersion, input2.version, input2.bump);
+  if (!semver2.gt(next, latestVersion)) {
+    throw new CliError(
+      `\u7EBF\u4E0A\u5DF2\u7ECF\u662F ${latestVersion}\uFF0C\u4E0D\u80FD\u53D1 ${next}`,
+      "UPDATE_VERSION_NOT_GREATER"
+    );
+  }
+  if (!input2.yes) {
+    throw new CliError("\u63D0\u4EA4\u8BF7\u52A0 --yes", "UPDATE_VERSION_NEED_YES");
+  }
   if (input2.reset) {
+    confirmLocalPath(identity, artifact, input2.yes, input2.cwd);
+  }
+  let draft = existingDraft;
+  if (input2.reset && existingDraft) {
+    if (!input2.confirmReset) {
+      throw new CliError("\u8BF7\u5148\u786E\u8BA4\u4E22\u5F03\u5DE5\u4F5C\u7A3F", "RESET_CONFIRMATION_REQUIRED");
+    }
+    if (!await input2.confirmReset(draftSummary(existingDraft))) {
+      return "\u5DF2\u53D6\u6D88";
+    }
     deleteDraft(input2.cwd, identity.n);
+    draft = void 0;
   }
-  let draft = readDraft(input2.cwd, identity.n);
-  const source = input2.reuseVersion ?? latestVersion;
-  evaluateGates({ latestVersion, draft, reuseVersion: input2.reuseVersion }, "update-version");
-  const artifact = resolveArtifactPath(input2.cwd, identity, input2.file, input2.artifact);
   if (input2.yes && draft && !draft.fromVersion && input2.reuseVersion === void 0) {
     throw new CliError("\u8BF7\u5148 version draft pull --yes", "UPDATE_VERSION_FIRST_DRAFT");
   }
@@ -27958,16 +28089,6 @@ async function runUpdateVersionLocked(input2) {
       "UPDATE_VERSION_MISMATCH"
     );
   }
-  const next = resolveNextVersion(latestVersion, input2.version, input2.bump);
-  if (!semver2.gt(next, latestVersion)) {
-    throw new CliError(
-      `\u7EBF\u4E0A\u5DF2\u7ECF\u662F ${latestVersion}\uFF0C\u4E0D\u80FD\u53D1 ${next}`,
-      "UPDATE_VERSION_NOT_GREATER"
-    );
-  }
-  if (!input2.yes) {
-    throw new CliError("\u63D0\u4EA4\u8BF7\u52A0 --yes", "UPDATE_VERSION_NEED_YES");
-  }
   await uploadAndAnalyze({
     cwd: input2.cwd,
     identity,
@@ -28044,14 +28165,16 @@ function createUpdateVersionCommand() {
     "\u672C\u6B21\u4E0A\u4F20\u5E76\u8BB0\u5F55\u7684\u672C\u5730\u6587\u4EF6\u6216\u76EE\u5F55"
   ).action(async function(options) {
     const shared = readSharedOptions(this);
+    const cwd = resolveCwd(shared.cwd);
     const result = await runUpdateVersion({
-      cwd: resolveCwd(shared.cwd),
+      cwd,
       file: shared.file,
       artifact: options.artifact,
       version: options.version,
       bump: options.bump,
       reuseVersion: options.reuseVersion,
       reset: options.reset,
+      confirmReset: options.reset ? (summary) => confirmDraftDestruction({ summary, yes: shared.yes, action: "\u4E22\u5F03\u5DE5\u4F5C\u7A3F\u5E76\u91CD\u7F6E\u66F4\u65B0\u7248\u672C" }) : void 0,
       yes: shared.yes
     });
     console.log(result);
@@ -28112,25 +28235,25 @@ function createSubCommands() {
 }
 
 // src/core/usageDocs.ts
-import { existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path17 from "path";
 import { fileURLToPath } from "url";
 function usageDocsPath() {
-  const moduleDir = path14.dirname(fileURLToPath(import.meta.url));
-  const bundledPath = path14.resolve(moduleDir, "../docs/README.md");
-  if (existsSync12(bundledPath)) {
+  const moduleDir = path17.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path17.resolve(moduleDir, "../docs/README.md");
+  if (existsSync13(bundledPath)) {
     return bundledPath;
   }
-  return path14.resolve(moduleDir, "../../../../docs/\u4E00\u671F/\u4EA7\u54C1\u65B9\u6848/\u4F7F\u7528/README.md");
+  return path17.resolve(moduleDir, "../../../../docs/\u4E00\u671F/\u4EA7\u54C1\u65B9\u6848/\u4F7F\u7528/README.md");
 }
 
 // src/core/packageVersion.ts
 import { readFileSync as readFileSync10 } from "fs";
-import path15 from "path";
+import path18 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function packageVersion() {
-  const moduleDir = path15.dirname(fileURLToPath2(import.meta.url));
-  const packageJson = path15.resolve(moduleDir, "../..", "package.json");
+  const moduleDir = path18.dirname(fileURLToPath2(import.meta.url));
+  const packageJson = path18.resolve(moduleDir, "../..", "package.json");
   const value = JSON.parse(readFileSync10(packageJson, "utf8"));
   return typeof value.version === "string" ? value.version : "unknown";
 }
@@ -28202,7 +28325,20 @@ function resourceChoiceLabel(cwd, identity) {
   ].join("  ");
 }
 function resourceSelectorExamples(identities) {
-  return identities.map((identity) => `file:${identity.n}.json\uFF08${identity.title ?? "\u672A\u540C\u6B65\u6807\u9898"}\uFF1B${identity.name ?? "\u672A\u7ED1\u5B9A"}\uFF1B${identity.resourceId ?? "\u672A\u7ED1\u5B9A"}\uFF09`).join("\u3001");
+  const titleCounts = /* @__PURE__ */ new Map();
+  for (const identity of identities) {
+    if (identity.title) titleCounts.set(identity.title, (titleCounts.get(identity.title) ?? 0) + 1);
+  }
+  return identities.map((identity) => {
+    const selectors = [
+      ...identity.resourceId ? [`id:${identity.resourceId}`] : [],
+      ...identity.name ? [`name:${identity.name}`] : [],
+      ...identity.title && titleCounts.get(identity.title) === 1 ? [`title:${identity.title}`] : [],
+      `artifact:${identity.filePath}`,
+      `file:${identity.n}.json`
+    ];
+    return selectors.join(" | ");
+  }).join("\uFF1B");
 }
 function isResourceFreeCommand(command) {
   let current = command;