draftgo-cli 3.0.56 → 4.0.22

package/src/commands/local.js

@@ -4,8 +4,8 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const log = require('../logger');
 const { exists } = require('../fsx');
-const { detectDocker } = require('../localdev/detect');
-const { runWizard } = require('../localdev');
+const { detectDocker } = require('../localRuntime/detect');
+const { runWizard } = require('../localRuntime');
 
 function composeFile(projectDir) {
   return path.join(projectDir, '.draftgo', 'docker', 'docker-compose.yaml');
@@ -58,21 +58,17 @@ function local(projectDir, positional, flags = {}) {
   switch (action) {
     case 'setup':
       return runWizard(projectDir, { yes: !!(flags.yes || flags.y) });
-    case 'up':
     case 'start':
       return runCompose(projectDir, ['up', '-d']);
-    case 'down':
     case 'stop':
       return runCompose(projectDir, ['down']);
     case 'logs':
       return runCompose(projectDir, ['logs', ...(positional.slice(1).length ? positional.slice(1) : ['-f', 'app'])]);
     case 'status':
-    case 'ps':
       return runCompose(projectDir, ['ps']);
     default:
       log.err(`未知 local 子命令：${action}`);
       log.dim('  可用：draftgo local setup | start | stop | logs | status');
-      log.dim('  兼容别名：up | down');
       return 1;
   }
 }

package/src/commands/map.js

@@ -1,13 +1,12 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
 const log = require('../logger');
 const { loadProjectConfig } = require('../projectConfig');
 const { canonicalResourceType } = require('../worktree/types');
 const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
 const { allWithAbort } = require('../mcp/parallel');
 const { inspectRemoteCheckouts } = require('../worktree/status');
+const { loadManifest } = require('../worktree/manifest');
 const customServices = require('../customServices');
 
 const REMOTE_RESOURCE_TYPES = Object.freeze({
@@ -42,6 +41,11 @@ function claimsMorePages(value) {
     && (value.has_more === true || value.hasMore === true);
 }
 
+function reportedTotal(value) {
+  const total = value && typeof value === 'object' ? value.total : null;
+  return Number.isInteger(total) && total >= 0 ? total : null;
+}
+
 function normalizeMapResourceType(value) {
   if (require('./customService').isServiceType(value)) return 'custom_services';
   return REMOTE_RESOURCE_TYPES[canonicalResourceType(value)];
@@ -53,6 +57,79 @@ function requestedResourceTypes(flags = {}) {
     : [normalizeMapResourceType(flags.type)];
 }
 
+function normalizeRoute(value) {
+  // DraftGo stores page routes without surrounding slashes. Accept either the
+  // stored form or the browser form users naturally paste into the CLI.
+  return String(value == null ? '' : value).trim().replace(/^\/+|\/+$/g, '');
+}
+
+function positiveLimit(value, fallback = 20) {
+  if (value == null) return fallback;
+  if (!/^\d+$/.test(String(value)) || Number(value) < 1 || Number(value) > 100) {
+    throw new Error('Map --limit must be an integer between 1 and 100.');
+  }
+  return Number(value);
+}
+
+function resourceType(resource) {
+  return resource.resource_type || resource.type || 'unknown';
+}
+
+function resourceMatches(resource, flags = {}) {
+  const route = flags.route == null ? null : normalizeRoute(flags.route);
+  const title = flags.title == null ? null : String(flags.title);
+  return (route == null || normalizeRoute(resource.route) === route)
+    && (title == null || String(resource.title == null ? '' : resource.title) === title);
+}
+
+function resourceKey(resource) {
+  const type = resourceType(resource);
+  if (type === 'custom_services') return `custom_services:${resource.resource_id}`;
+  return `${canonicalResourceType(type)}:${resource.resource_id}`;
+}
+
+function paginationFrom(payload, resourceTypeName) {
+  const cursor = nextCursor(payload);
+  if ((cursor == null || cursor === '') && claimsMorePages(payload)) {
+    throw new Error(`DraftGo resource_list (${resourceTypeName}) reported more pages without a cursor.`);
+  }
+  return {
+    next_cursor: cursor == null || cursor === '' ? null : String(cursor),
+    has_more: claimsMorePages(payload) || (cursor != null && cursor !== ''),
+    total: reportedTotal(payload),
+  };
+}
+
+async function listRemoteResourcePage(session, resourceTypeName, flags = {}, options = {}) {
+  const filtered = flags.route != null || flags.title != null;
+  const args = { resource_type: resourceTypeName, limit: positiveLimit(flags.limit) };
+  if (flags.cursor != null && flags.cursor !== '') args.cursor = String(flags.cursor);
+  if (filtered) {
+    // resource_search narrows the remote candidate set; the strict equality
+    // checks below keep --route/--title deterministic even when search is fuzzy.
+    args.query = flags.route != null ? normalizeRoute(flags.route) : String(flags.title);
+  }
+  const payload = await callStructured(
+    session,
+    filtered ? TOOL_NAMES.resourceSearch : TOOL_NAMES.resourceList,
+    args,
+    options,
+  );
+  return { resources: itemsFrom(payload).filter((resource) => resourceMatches(resource, flags)), pagination: paginationFrom(payload, resourceTypeName) };
+}
+
+async function listMapResources(session, resourceTypes, flags, options = {}) {
+  if (flags.cursor != null && flags.cursor !== '' && resourceTypes.length !== 1) {
+    throw new Error('Map --cursor requires exactly one --type.');
+  }
+  const groups = await allWithAbort(resourceTypes.map((resourceTypeName) =>
+    (queryOptions) => listRemoteResourcePage(session, resourceTypeName, flags, queryOptions)), options);
+  return {
+    resources: groups.flatMap((group) => group.resources),
+    pagination: Object.fromEntries(groups.map((group, index) => [resourceTypes[index], group.pagination])),
+  };
+}
+
 async function listRemoteResourceType(session, resourceType, options = {}) {
   const resources = [];
   const seen = new Set();
@@ -84,11 +161,6 @@ async function listRemoteResources(session, resourceTypes = DEFAULT_REMOTE_RESOU
   return groups.flat();
 }
 
-function legacyCaches(projectDir) {
-  return ['pages', 'navigations', 'docs', 'db_meta', 'custom_scripts', 'aihub', 'roles', 'users', 'system_config']
-    .filter((name) => fs.existsSync(path.join(projectDir, '.draftgo', name, 'index.json')));
-}
-
 function checkoutChanged(entry) {
   if (entry.resource_type === 'custom_services') {
     return ['local_modified', 'diverged', 'committed_unrecorded'].includes(entry.state);
@@ -99,19 +171,32 @@ function checkoutChanged(entry) {
 async function mapCommand(projectDir, flags = {}) {
   const resourceTypes = requestedResourceTypes(flags);
   const config = loadProjectConfig(projectDir);
-  const session = await openToolSession(config, [TOOL_NAMES.projectOverview, TOOL_NAMES.resourceList]);
-  const [remote, checkouts] = await allWithAbort([
-    (options) => allWithAbort([
-      (options) => callStructured(session, TOOL_NAMES.projectOverview, {}, options),
-      (options) => listRemoteResources(session, resourceTypes, options),
-    ], options),
+  const searching = flags.route != null || flags.title != null;
+  const session = await openToolSession(config, [searching ? TOOL_NAMES.resourceSearch : TOOL_NAMES.resourceList]);
+  const remote = await listMapResources(session, resourceTypes, flags);
+  const manifestEntries = Object.values(loadManifest(projectDir).entries);
+  const selected = new Set(remote.resources.map(resourceKey));
+  // A filtered map is a focused inspection, so do not make unrelated local
+  // worktree state dominate its output. The unfiltered command retains the
+  // established full-worktree status behavior.
+  const statusEntries = searching
+    ? manifestEntries.filter((entry) => entry.resource_type === 'custom_services'
+      ? selected.has(`custom_services:${entry.resource_id}`)
+      : selected.has(`${canonicalResourceType(entry.resource_type)}:${entry.resource_id}`))
+    : manifestEntries;
+  const contentEntries = statusEntries.filter((entry) => entry.resource_type !== 'custom_services');
+  const serviceIds = statusEntries
+    .filter((entry) => entry.resource_type === 'custom_services')
+    .map((entry) => entry.resource_id);
+  const checkouts = (await allWithAbort([
     async (options) => {
       const [contentStatus, serviceStatus] = await Promise.all([inspectRemoteCheckouts(projectDir, {
         config,
         client: session.client,
         tools: session.tools,
         signal: options.signal,
-      }), customServices.inspectRemote(projectDir, { config, signal: options.signal })]);
+        entries: contentEntries,
+      }), customServices.inspectRemote(projectDir, { config, signal: options.signal, ids: serviceIds })]);
       return [...contentStatus, ...serviceStatus].map((entry) => ({
         ...entry,
         exists: entry.local_hash !== null,
@@ -119,29 +204,58 @@ async function mapCommand(projectDir, flags = {}) {
         changed: checkoutChanged(entry),
       }));
     },
-  ]);
-  const [overview, resources] = remote;
+  ]))[0];
+  const resources = remote.resources;
+  const counts = new Map();
+  for (const resource of resources) {
+    const type = resourceType(resource);
+    counts.set(type, (counts.get(type) || 0) + 1);
+  }
+  const checkoutStates = new Map();
+  for (const entry of checkouts) {
+    const state = entry.state || (!entry.exists ? 'missing' : entry.changed ? 'modified' : 'clean');
+    checkoutStates.set(state, (checkoutStates.get(state) || 0) + 1);
+  }
   const result = {
     server: config.server,
-    overview,
     resources,
     checkouts,
-    legacy_cache: { ignored: true, detected: legacyCaches(projectDir) },
+    pagination: remote.pagination,
+  };
+
+  const summary = {
+    server: config.server,
+    summary: {
+      resources: {
+        returned: resources.length,
+        matched: resources.length,
+        returned_by_type: Object.fromEntries([...counts.entries()].sort()),
+        // This is the server's fuzzy-search/list candidate count before the
+        // client-side exact route/title check. It is null when not reported.
+        candidate_total_by_type: Object.fromEntries(Object.entries(remote.pagination)
+          .map(([type, page]) => [type, page.total])),
+      },
+      checkouts: { total: checkouts.length, by_state: Object.fromEntries([...checkoutStates.entries()].sort()) },
+      truncated: Object.values(remote.pagination).some((page) => page.has_more),
+      pagination: remote.pagination,
+    },
   };
 
   if (flags.output === 'json') {
-    console.log(JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(flags.summary ? summary : result, null, 2));
     return 0;
   }
   log.title('draftgo map');
-  log.info(`Remote resources: ${resources.length}`);
-  const counts = new Map();
-  for (const resource of resources) {
-    const type = resource.resource_type || resource.type || 'unknown';
-    counts.set(type, (counts.get(type) || 0) + 1);
-  }
+  log.info(`Remote resources returned: ${resources.length}`);
   for (const [type, count] of [...counts.entries()].sort()) log.plain(`  ${type}: ${count}`);
   log.info(`Local checkouts: ${checkouts.length}`);
+  if (flags.summary) {
+    for (const [state, count] of [...checkoutStates.entries()].sort()) log.plain(`  ${state}: ${count}`);
+    for (const [type, page] of Object.entries(remote.pagination)) {
+      if (page.has_more) log.plain(`  ${type}: more results; use --type ${type} --cursor ${page.next_cursor}`);
+    }
+    return 0;
+  }
   for (const entry of checkouts) {
     const state = entry.state || (!entry.exists ? 'missing' : entry.changed ? 'modified' : 'clean');
     log.plain(`  ${entry.resource_type} ${entry.resource_id}: ${state}`
@@ -149,9 +263,6 @@ async function mapCommand(projectDir, flags = {}) {
       + `version=${entry.manifest_version ?? '-'}->${entry.remote_version ?? '-'} `
       + `(${entry.local_path})`);
   }
-  if (result.legacy_cache.detected.length) {
-    log.warn(`Ignored legacy cache indexes: ${result.legacy_cache.detected.join(', ')}`);
-  }
   return 0;
 }
 
@@ -160,4 +271,10 @@ module.exports.itemsFrom = itemsFrom;
 module.exports.normalizeMapResourceType = normalizeMapResourceType;
 module.exports.requestedResourceTypes = requestedResourceTypes;
 module.exports.listRemoteResources = listRemoteResources;
+module.exports.listRemoteResourcePage = listRemoteResourcePage;
+module.exports.listMapResources = listMapResources;
+module.exports.normalizeRoute = normalizeRoute;
+module.exports.resourceMatches = resourceMatches;
+module.exports.positiveLimit = positiveLimit;
+module.exports.reportedTotal = reportedTotal;
 module.exports.checkoutChanged = checkoutChanged;

package/src/commands/mcp.js

@@ -17,7 +17,7 @@ function classifyMcpFailure(error) {
   const message = String(error && error.message || error || '');
   const code = error && error.code;
   const status = error && error.status;
-  if (status === 401 || status === 403) return 'SAT authentication or authorization failed.';
+  if (status === 401 || status === 403) return 'API Key authentication or authorization failed.';
   if (/session|uninitialized|initialize first|not initialized/i.test(message)
       || ['SESSION_EXPIRED', 'MCP_SESSION_EXPIRED', -32002].includes(code)) {
     return 'The MCP session was lost or the server rejected the initialized state; check sticky sessions and service restarts.';
@@ -79,7 +79,7 @@ function status(projectDir, positional = [], flags = {}) {
   let exitCode = 0;
   try {
     const config = loadProjectConfig(projectDir);
-    log.plain(`  project      configured (${config.server}; SAT present)`);
+    log.plain(`  project      configured (${config.server}; API Key present)`);
   } catch (error) {
     log.plain(`  project      not ready (${error.message})`);
     exitCode = 1;

package/src/commands/reconcile.js

@@ -6,7 +6,7 @@ const { reconcileResources } = require('../worktree');
 async function reconcile(projectDir, positional, flags = {}) {
   const [resourceType, ...ids] = positional;
   if (!resourceType || !ids.length) {
-    log.err('Usage: draftgo reconcile <pages|nav|docs> <id...>');
+    log.err('Usage: draftgo reconcile <pages|nav|docs|custom-services> <id...>');
     return 1;
   }
   if (require('./customService').isServiceType(resourceType)) {

package/src/commands/role.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const log = require('../logger');
+const { callOperation } = require('./api');
+
+// Role is a permission template. Use `draftgo grant` to bind it to a subject.
+const OPERATIONS = Object.freeze({
+  permissions: 'listPermissionCatalog',
+  list: 'listRoles',
+  create: 'createRole',
+  get: 'getRole',
+  update: 'updateRole',
+  delete: 'deleteRole',
+});
+
+function operationKey(value) {
+  const action = String(value || 'list').trim().toLowerCase();
+  return OPERATIONS[action] ? action : '';
+}
+
+async function roleCommand(projectDir, positional, flags = {}) {
+  const action = operationKey(positional[0]);
+  if (!action) {
+    log.err('Usage: draftgo role permissions|list|create|get|update|delete [--input <json-file>]');
+    return 1;
+  }
+  return callOperation(projectDir, OPERATIONS[action], flags);
+}
+
+module.exports = roleCommand;
+module.exports.OPERATIONS = OPERATIONS;
+module.exports.operationKey = operationKey;

package/src/commands/space.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const log = require('../logger');
+const { callOperation } = require('./api');
+
+const OPERATIONS = Object.freeze({
+  list: 'listSpaces',
+  create: 'createSpace',
+  get: 'getSpace',
+  update: 'updateSpace',
+  replace: 'replaceSpace',
+  disable: 'deleteSpace',
+  'members.list': 'listWorkspaceMembers',
+  'members.add': 'addWorkspaceMember',
+  'members.get': 'getWorkspaceMember',
+  'members.update': 'updateWorkspaceMember',
+  'members.replace': 'replaceWorkspaceMember',
+  'members.remove': 'removeWorkspaceMember',
+});
+
+function operationKey(parts) {
+  const values = parts.map((part) => String(part || '').trim().toLowerCase()).filter(Boolean);
+  if (values.length === 1) return values[0] === 'delete' ? 'disable' : values[0];
+  if (values.length === 2 && ['member', 'members'].includes(values[0])) {
+    return `members.${values[1] === 'delete' ? 'remove' : values[1]}`;
+  }
+  return '';
+}
+
+async function spaceCommand(projectDir, positional, flags = {}) {
+  const key = operationKey(positional);
+  if (!OPERATIONS[key]) {
+    log.err('Usage: draftgo space list|create|get|update|replace|disable | members list|add|get|update|replace|remove [--input <json-file>]');
+    return 1;
+  }
+  return callOperation(projectDir, OPERATIONS[key], flags);
+}
+
+module.exports = spaceCommand;
+module.exports.OPERATIONS = OPERATIONS;
+module.exports.operationKey = operationKey;

package/src/commands/status.js

@@ -1,23 +1,126 @@
 'use strict';
 
 const log = require('../logger');
-const { all } = require('../installers');
+const { all } = require('../targets');
 const { readInstalledVersion, getPackageVersion } = require('../skill');
+const { loadProjectConfig } = require('../projectConfig');
+const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
+const { normalizeDescription } = require('../apiContractCache');
+const { parseTimeout } = require('../timeout');
+
+const API_KEY_STATUS_OPERATION = 'getCurrentUserAPIKey';
+
+function asObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function scopeFrom(value) {
+  let candidates = [asObject(value)];
+  for (let depth = 0; depth < 4; depth += 1) {
+    const next = [];
+    for (const candidate of candidates) {
+      const type = String(candidate.scope_type || candidate.type || '').trim().toLowerCase();
+      if (type === 'platform') return { scope_type: 'platform', workspace_id: null, space_id: null };
+      if (type === 'space') {
+        return {
+          scope_type: 'space',
+          workspace_id: candidate.workspace_id ?? null,
+          space_id: candidate.space_id ?? null,
+        };
+      }
+      for (const key of ['context', 'scope', 'principal', 'credential', 'authentication', 'response', 'data', 'value']) {
+        const nested = asObject(candidate[key]);
+        if (Object.keys(nested).length) next.push(nested);
+      }
+    }
+    candidates = next;
+  }
+  return null;
+}
+
+async function connectionDiagnostic(projectDir, options = {}) {
+  let config;
+  try {
+    config = loadProjectConfig(projectDir);
+  } catch (error) {
+    return { health: 'not_configured', connected: false, error: error.message };
+  }
+
+  const diagnostic = { health: 'unhealthy', connected: false, server: config.server };
+  try {
+    const session = await openToolSession(config, [
+      TOOL_NAMES.projectOverview, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+    ], { timeoutMs: options.timeoutMs });
+    const overview = await callStructured(session, TOOL_NAMES.projectOverview, {}, { timeoutMs: options.timeoutMs });
+    const project = asObject(asObject(overview).project);
+    diagnostic.connected = true;
+    diagnostic.server_version = project.version || null;
+    diagnostic.protocol_version = session.client.protocolVersion || null;
+    diagnostic.registry_revision = asObject(asObject(overview).operation_registry).registry_revision || null;
+
+    let scope = scopeFrom(overview);
+    if (!scope) {
+      const described = normalizeDescription(await callStructured(
+        session, TOOL_NAMES.apiDescribe, { operation_id: API_KEY_STATUS_OPERATION }, { timeoutMs: options.timeoutMs },
+      ));
+      if (!described) throw new Error('DraftGo API Key status contract is missing revision metadata.');
+      const result = await callStructured(session, TOOL_NAMES.apiCall, {
+        operation_id: API_KEY_STATUS_OPERATION,
+        registry_revision: described.registry_revision,
+      }, { timeoutMs: options.timeoutMs });
+      scope = scopeFrom(asObject(result).response || result);
+    }
+    if (!scope) throw new Error('DraftGo server did not report the current API Key scope.');
+    Object.assign(diagnostic, scope, { health: 'healthy' });
+    return diagnostic;
+  } catch (error) {
+    diagnostic.error = error && error.message || String(error);
+    return diagnostic;
+  }
+}
+
+async function status(projectDir, _positional = [], flags = {}) {
+  const targets = all.map((target) => {
+    const value = target.status(projectDir);
+    return { name: target.name, display_name: target.displayName, installed: value.installed === true };
+  });
+  const connection = await connectionDiagnostic(projectDir, { timeoutMs: parseTimeout(flags.timeout) });
+  const result = {
+    project_dir: projectDir,
+    cli_version: getPackageVersion(),
+    skill_version: readInstalledVersion(projectDir) || null,
+    connection,
+    targets,
+  };
+  if (flags.output === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
 
-function status(projectDir) {
   log.title('draftgo status');
   log.info(`项目目录：${projectDir}`);
-  log.info(`CLI 版本：${getPackageVersion()}`);
-  log.info(`已装 skill 版本：${readInstalledVersion(projectDir) || '（未安装）'}`);
+  log.info(`CLI 版本：${result.cli_version}`);
+  log.info(`已装 skill 版本：${result.skill_version || '（未安装）'}`);
+  log.info(`服务端：${connection.server || '（未连接）'}`);
+  if (connection.health === 'healthy') {
+    log.ok(`连接健康：healthy${connection.server_version ? `（server ${connection.server_version}）` : ''}`);
+    const ids = connection.scope_type === 'space'
+      ? `，workspace_id=${connection.workspace_id ?? '-'}，space_id=${connection.space_id ?? '-'}` : '';
+    log.info(`当前上下文：${connection.scope_type}${ids}`);
+  } else {
+    log.warn(`连接健康：${connection.health}`);
+    if (connection.error) log.dim(`  ${connection.error}`);
+  }
 
   console.log('');
   console.log('AI 工具入口：');
-  for (const t of all) {
-    const st = t.status(projectDir);
-    const mark = st.installed ? log.c.green('✓') : log.c.gray('·');
-    console.log(`  ${mark} ${t.name.padEnd(12)} ${t.displayName}`);
+  for (const target of targets) {
+    const mark = target.installed ? log.c.green('✓') : log.c.gray('·');
+    console.log(`  ${mark} ${target.name.padEnd(12)} ${target.display_name}`);
   }
   return 0;
 }
 
 module.exports = status;
+module.exports.scopeFrom = scopeFrom;
+module.exports.connectionDiagnostic = connectionDiagnostic;

package/src/commands/uninstall.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const log = require('../logger');
-const { all, resolveTargets } = require('../installers');
+const { all, resolveTargets } = require('../targets');
 const { removePath } = require('../fsx');
 const { dgDir } = require('../paths');
 
@@ -38,10 +38,10 @@ async function uninstall(projectDir, positional, flags) {
 
   // Each AI-tool skill directory is self-contained, so per-target uninstall
   // already wiped its content above. Only --purge nukes runtime data under
-  // .draftgo/ (config/changelog/Task/lessons/cache etc.).
+  // .draftgo/ (config/worklog/lessons/cache etc.).
   if (flags.purge) {
     if (removePath(dgDir(projectDir))) {
-      log.warn('已使用 --purge：.draftgo/（含 config/changelog/lessons/Task 等运行时数据）已删除。');
+      log.warn('已使用 --purge：.draftgo/（含 config/worklog/lessons 等运行时数据）已删除。');
     }
   }
 

package/src/commands/update.js

@@ -2,10 +2,11 @@
 
 const { spawnSync } = require('child_process');
 const log = require('../logger');
-const { all, byName, resolveTargets } = require('../installers');
+const { all, byName, resolveTargets } = require('../targets');
 const { ensureRuntime, writeInstalledVersion, readInstalledVersion, getPackageVersion } = require('../skill');
 const { fetchLatestVersion, cmpSemver } = require('../updateCheck');
 const { detectTargets } = require('../detect');
+const { readInstallMarker, installRelease } = require('../releaseInstall');
 
 const REENTRY_FLAG = 'DRAFTGO_UPDATE_REENTERED';
 
@@ -30,19 +31,30 @@ async function updateCliIfNeeded(projectDir, positional, flags) {
     return null;
   }
 
-  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const marker = readInstallMarker();
+  let command = process.platform === 'win32' ? 'draftgo.cmd' : 'draftgo';
   log.step(`更新 draftgo-cli：${current} → ${latest}`);
-  const install = spawnSync(npm, ['install', '-g', `draftgo-cli@${latest}`], { stdio: 'inherit', shell: false });
-  if (install.error) {
-    log.err(`CLI 更新启动失败：${install.error.message}`);
-    return 1;
-  }
-  if (install.status !== 0) {
-    log.err(`npm install 返回码 ${install.status}`);
-    return Number.isInteger(install.status) ? install.status : 1;
+  if (marker) {
+    try {
+      const result = await installRelease(latest, null, marker);
+      command = result.launcher;
+      log.ok(`CLI Release updated to ${latest}`);
+    } catch (error) {
+      log.err(`CLI Release update failed: ${error.message}`);
+      return 1;
+    }
+  } else {
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const install = spawnSync(npm, ['install', '-g', `draftgo-cli@${latest}`], { stdio: 'inherit', shell: false });
+    if (install.error) {
+      log.err(`CLI 更新启动失败：${install.error.message}`);
+      return 1;
+    }
+    if (install.status !== 0) {
+      log.err(`npm install 返回码 ${install.status}`);
+      return Number.isInteger(install.status) ? install.status : 1;
+    }
   }
-
-  const command = process.platform === 'win32' ? 'draftgo.cmd' : 'draftgo';
   const rerun = spawnSync(command, ['update', ...positional, '--project', projectDir, '--skip-update-check'], {
     stdio: 'inherit',
     shell: false,