draftgo-cli 4.0.25 → 4.0.26

package/src/commands/map.js

@@ -7,15 +7,18 @@ 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({
   pages: 'pages',
   navigations: 'navigations',
   docs: 'docs/articles',
-  custom_services: 'custom_services',
 });
 const DEFAULT_REMOTE_RESOURCE_TYPES = Object.freeze(Object.values(REMOTE_RESOURCE_TYPES));
+const LIST_OPERATIONS = Object.freeze({
+  pages: 'listPage',
+  navigations: 'listNavigation',
+  'docs/articles': 'listDocAdminArticle',
+});
 
 function itemsFrom(value) {
   if (Array.isArray(value)) return value;
@@ -46,8 +49,79 @@ function reportedTotal(value) {
   return Number.isInteger(total) && total >= 0 ? total : null;
 }
 
+function registryCursor(operationID, page) {
+  return Buffer.from(JSON.stringify({ operation_id: operationID, page }), 'utf8').toString('base64url');
+}
+
+function registryPageFromCursor(cursor, operationID) {
+  if (cursor == null || cursor === '') return 1;
+  try {
+    const value = JSON.parse(Buffer.from(String(cursor), 'base64url').toString('utf8'));
+    if (value && value.operation_id === operationID && Number.isSafeInteger(value.page) && value.page > 1) {
+      return value.page;
+    }
+  } catch { /* Report one stable CLI error below. */ }
+  throw new Error(`Map --cursor is not valid for Registry operation ${operationID}.`);
+}
+
+function queryProperties(operation) {
+  const schema = operation && operation.input_schema;
+  const query = schema && schema.properties && schema.properties.query;
+  return query && query.properties && typeof query.properties === 'object' ? query.properties : {};
+}
+
+function registryQuery(operation, operationID, flags) {
+  const properties = queryProperties(operation);
+  const query = {};
+  const limit = positiveLimit(flags.limit);
+  const cursor = flags.cursor == null ? '' : String(flags.cursor);
+  if (Object.prototype.hasOwnProperty.call(properties, 'cursor')) {
+    if (cursor) query.cursor = cursor;
+    if (Object.prototype.hasOwnProperty.call(properties, 'limit')) query.limit = limit;
+  } else if (Object.prototype.hasOwnProperty.call(properties, 'page')
+      && Object.prototype.hasOwnProperty.call(properties, 'page_size')) {
+    query.page = registryPageFromCursor(cursor, operationID);
+    query.page_size = limit;
+  } else if (cursor) {
+    throw new Error(`${operationID} does not expose a paginated Registry contract.`);
+  }
+
+  const search = flags.route != null ? normalizeRoute(flags.route)
+    : flags.title != null ? String(flags.title) : '';
+  if (search) {
+    const key = flags.route != null && Object.prototype.hasOwnProperty.call(properties, 'route')
+      ? 'route'
+      : ['search', 'q', 'query'].find((candidate) => Object.prototype.hasOwnProperty.call(properties, candidate));
+    if (key) query[key] = search;
+  }
+  return query;
+}
+
+function registryPagination(payload, operationID, query, returned) {
+  const serverCursor = nextCursor(payload);
+  if (serverCursor != null && serverCursor !== '') {
+    return {
+      next_cursor: String(serverCursor),
+      has_more: true,
+      total: reportedTotal(payload),
+    };
+  }
+  if (claimsMorePages(payload)) {
+    throw new Error(`${operationID} reported more pages without a cursor.`);
+  }
+  const total = reportedTotal(payload);
+  const page = Number(query.page);
+  const pageSize = Number(query.page_size);
+  const hasMore = Number.isSafeInteger(page) && Number.isSafeInteger(pageSize)
+    && (total != null ? page * pageSize < total : returned === pageSize);
+  return {
+    next_cursor: hasMore ? registryCursor(operationID, page + 1) : null,
+    has_more: hasMore,
+    total,
+  };
+}
+
 function normalizeMapResourceType(value) {
-  if (require('./customService').isServiceType(value)) return 'custom_services';
   return REMOTE_RESOURCE_TYPES[canonicalResourceType(value)];
 }
 
@@ -84,7 +158,6 @@ function resourceMatches(resource, flags = {}) {
 
 function resourceKey(resource) {
   const type = resourceType(resource);
-  if (type === 'custom_services') return `custom_services:${resource.resource_id}`;
   return `${canonicalResourceType(type)}:${resource.resource_id}`;
 }
 
@@ -130,6 +203,41 @@ async function listMapResources(session, resourceTypes, flags, options = {}) {
   };
 }
 
+async function listRegistryResources(projectDir, config, session, resourceTypes, flags = {}) {
+  const { registryRevision, descriptionForRevision } = require('./api');
+  if (flags.cursor != null && flags.cursor !== '' && resourceTypes.length !== 1) {
+    throw new Error('Map --cursor requires exactly one --type.');
+  }
+  const groups = await allWithAbort(resourceTypes.map((type) => async (options) => {
+    const operationID = LIST_OPERATIONS[type];
+    const revision = await registryRevision(session, operationID);
+    const description = await descriptionForRevision(projectDir, config, session, operationID, revision);
+    const operation = description.operation || {};
+    const query = registryQuery(operation, operationID, flags);
+    const invoke = {
+      operation_id: operationID,
+      registry_revision: revision,
+    };
+    if (Object.keys(query).length) invoke.query = query;
+    const payload = await callStructured(session, TOOL_NAMES.apiCall, invoke, options);
+    const response = payload && payload.response !== undefined ? payload.response
+      : payload && payload.data !== undefined ? payload.data : payload;
+    const responseItems = itemsFrom(response);
+    const resources = responseItems
+      .map((item) => ({ ...item, resource_type: type, resource_id: String(item.resource_id ?? item.id) }))
+      .filter((item) => item.resource_id && item.resource_id !== 'undefined')
+      .filter((item) => resourceMatches(item, flags));
+    return {
+      resources,
+      pagination: registryPagination(response, operationID, query, responseItems.length),
+    };
+  }));
+  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();
@@ -161,43 +269,40 @@ async function listRemoteResources(session, resourceTypes = DEFAULT_REMOTE_RESOU
   return groups.flat();
 }
 
-function checkoutChanged(entry) {
-  if (entry.resource_type === 'custom_services') {
-    return ['local_modified', 'diverged', 'committed_unrecorded'].includes(entry.state);
-  }
-  return entry.local_hash !== null && entry.local_hash !== entry.base_hash;
-}
+function checkoutChanged(entry) { return entry.local_hash !== null && entry.local_hash !== entry.base_hash; }
 
 async function mapCommand(projectDir, flags = {}) {
   const resourceTypes = requestedResourceTypes(flags);
   const config = loadProjectConfig(projectDir);
   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);
+  let session;
+  let remote;
+  try {
+    session = await openToolSession(config, [searching ? TOOL_NAMES.resourceSearch : TOOL_NAMES.resourceList]);
+    remote = await listMapResources(session, resourceTypes, flags);
+  } catch (error) {
+    if (!error || error.code !== 'MCP_TOOL_UNAVAILABLE') throw error;
+    session = await openToolSession(config, [TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall]);
+    remote = await listRegistryResources(projectDir, config, 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.filter((entry) => 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, {
+      const contentStatus = await inspectRemoteCheckouts(projectDir, {
         config,
         client: session.client,
         tools: session.tools,
         signal: options.signal,
-        entries: contentEntries,
-      }), customServices.inspectRemote(projectDir, { config, signal: options.signal, ids: serviceIds })]);
-      return [...contentStatus, ...serviceStatus].map((entry) => ({
+        entries: statusEntries,
+      });
+      return contentStatus.map((entry) => ({
         ...entry,
         exists: entry.local_hash !== null,
         current_hash: entry.local_hash,
@@ -248,6 +353,11 @@ async function mapCommand(projectDir, flags = {}) {
   log.title('draftgo map');
   log.info(`Remote resources returned: ${resources.length}`);
   for (const [type, count] of [...counts.entries()].sort()) log.plain(`  ${type}: ${count}`);
+  if (!flags.summary) {
+    for (const resource of resources) {
+      log.plain(`  ${resourceType(resource)} ${resource.resource_id}: ${resource.title || '-'} route=${resource.route || '-'} code=${resource.code || '-'} slug=${resource.slug || '-'}`);
+    }
+  }
   log.info(`Local checkouts: ${checkouts.length}`);
   if (flags.summary) {
     for (const [state, count] of [...checkoutStates.entries()].sort()) log.plain(`  ${state}: ${count}`);
@@ -273,8 +383,13 @@ module.exports.requestedResourceTypes = requestedResourceTypes;
 module.exports.listRemoteResources = listRemoteResources;
 module.exports.listRemoteResourcePage = listRemoteResourcePage;
 module.exports.listMapResources = listMapResources;
+module.exports.listRegistryResources = listRegistryResources;
 module.exports.normalizeRoute = normalizeRoute;
 module.exports.resourceMatches = resourceMatches;
 module.exports.positiveLimit = positiveLimit;
 module.exports.reportedTotal = reportedTotal;
+module.exports.registryCursor = registryCursor;
+module.exports.registryPageFromCursor = registryPageFromCursor;
+module.exports.registryQuery = registryQuery;
+module.exports.registryPagination = registryPagination;
 module.exports.checkoutChanged = checkoutChanged;

package/src/commands/reconcile.js

@@ -6,23 +6,9 @@ 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|custom-services> <id...>');
+    log.err('Usage: draftgo reconcile <pages|nav|docs> <id...>');
     return 1;
   }
-  if (require('./customService').isServiceType(resourceType)) {
-    const services = require('../customServices');
-    const states = await services.inspectRemote(projectDir);
-    const results = [];
-    for (const id of ids) {
-      const state = states.find((entry) => String(entry.resource_id) === String(id));
-      if (!state || state.state !== 'committed_unrecorded') throw new Error(`custom_services ${id} cannot be reconciled from state ${state?.state || 'missing'}.`);
-      await services.checkout(projectDir, [id], { force: true });
-      results.push({ resource_type: 'custom_services', resource_id: String(id), base_revision: state.remote_revision });
-    }
-    if (flags.output === 'json') console.log(JSON.stringify(results, null, 2));
-    else results.forEach((result) => log.ok(`Reconciled custom_services ${result.resource_id} -> ${result.base_revision}`));
-    return 0;
-  }
   const results = await reconcileResources(projectDir, resourceType, ids);
   if (flags.output === 'json') console.log(JSON.stringify(results, null, 2));
   else for (const result of results) {

package/src/commands/role.js

@@ -3,9 +3,8 @@
 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',
+  permissions: 'listPermissions',
   list: 'listRoles',
   create: 'createRole',
   get: 'getRole',

package/src/commands/status.js

@@ -5,30 +5,19 @@ 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) {
+function findField(value, keys) {
   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']) {
+      for (const key of keys) if (candidate[key] != null) return candidate[key];
+      for (const key of ['operation_registry', 'registry', 'response', 'data', 'value']) {
         const nested = asObject(candidate[key]);
         if (Object.keys(nested).length) next.push(nested);
       }
@@ -48,30 +37,15 @@ async function connectionDiagnostic(projectDir, options = {}) {
 
   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);
+    const session = await openToolSession(config, [TOOL_NAMES.apiSearch], { timeoutMs: options.timeoutMs });
+    const catalog = await callStructured(session, TOOL_NAMES.apiSearch, {
+      query: 'system', limit: 1,
+    }, { timeoutMs: options.timeoutMs });
     diagnostic.connected = true;
-    diagnostic.server_version = project.version || null;
+    diagnostic.server_version = asObject(session.initialized.serverInfo).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' });
+    diagnostic.registry_revision = findField(catalog, ['registry_revision']) || null;
+    diagnostic.health = 'healthy';
     return diagnostic;
   } catch (error) {
     diagnostic.error = error && error.message || String(error);
@@ -104,9 +78,7 @@ async function status(projectDir, _positional = [], flags = {}) {
   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}`);
+    log.info(`Registry revision：${connection.registry_revision || '-'}`);
   } else {
     log.warn(`连接健康：${connection.health}`);
     if (connection.error) log.dim(`  ${connection.error}`);
@@ -122,5 +94,5 @@ async function status(projectDir, _positional = [], flags = {}) {
 }
 
 module.exports = status;
-module.exports.scopeFrom = scopeFrom;
+module.exports.findField = findField;
 module.exports.connectionDiagnostic = connectionDiagnostic;

package/src/commands/verify.js

@@ -128,18 +128,23 @@ async function verifyPageComponents(projectDir, selected) {
 async function verify(projectDir, positional = [], flags = {}) {
   let selected;
   let remoteMode;
+  let visual;
+  const url = String(flags.url || '').trim();
   try {
     selected = resources(positional);
     remoteMode = flags.remote ? 'always' : 'never';
+    visual = visualRequest(flags, url);
+    if (flags.output === 'json' && visual.run) throw new Error('Visual verification does not support --output json; run the explicit visual check separately.');
   } catch (error) {
     log.err(error.message);
     return 1;
   }
 
-  log.title('draftgo verify');
-  try { await verifyPageComponents(projectDir, selected); }
+  if (flags.output !== 'json') log.title('draftgo verify');
+  try { if (flags.remote) await verifyPageComponents(projectDir, selected); }
   catch (error) { log.err(error.message); return 1; }
   const checkCode = await check(projectDir, [], {
+    output: flags.output,
     strict: flags.strict,
     remote: remoteMode === 'always',
     resourceKeys: selected.length
@@ -148,13 +153,9 @@ async function verify(projectDir, positional = [], flags = {}) {
   });
   if (checkCode !== 0) return checkCode;
 
-  const url = String(flags.url || '').trim();
-  let visual;
-  try { visual = visualRequest(flags, url); }
-  catch (error) { log.err(error.message); return 1; }
   if (!visual.run) {
     if (url) log.warn('--url was provided without --screenshot always or --ui always; visual verification was skipped.');
-    log.ok('Unified verification passed (UI skipped).');
+    if (flags.output !== 'json') log.ok('Local verification passed; browser and business interactions were not tested.');
     return 0;
   }
   let targets;

package/src/commands/worklog.js

@@ -13,7 +13,7 @@ const {
 } = require('../worklog');
 
 function printUsage() {
-  log.err('Usage: draftgo work start|add|start-item|complete|show|list <value>');
+  log.err('Usage: draftgo work start|add|start-item|wait|complete|show|list <value>');
 }
 
 function output(flags, value) {
@@ -27,7 +27,12 @@ function latestReference(blocks) {
 
 function resultFor(blocks, reference) {
   const resolved = resolveReference(blocks, reference);
-  return { date: resolved.block.date, ...resolved.entry };
+  return { date: resolved.block.date, ...resolved.entry, status: visibleStatus(resolved.entry.status) };
+}
+
+function visibleStatus(status) { return status === 'pending' ? 'waiting' : status; }
+function visibleBlocks(blocks) {
+  return blocks.map(block => ({ ...block, entries: block.entries.map(entry => ({ ...entry, status: visibleStatus(entry.status) })) }));
 }
 
 function add(projectDir, positional, flags, status) {
@@ -61,14 +66,14 @@ function change(projectDir, positional, flags, status) {
 }
 
 function show(projectDir, flags) {
-  const blocks = readWorklog(projectDir);
+  const blocks = visibleBlocks(readWorklog(projectDir));
   output(flags, { path: worklogPath(projectDir), blocks });
   if (flags.output !== 'json') console.log(renderWorklog(blocks) || 'Worklog is empty.');
   return 0;
 }
 
 function list(projectDir, flags) {
-  const blocks = readWorklog(projectDir);
+  const blocks = visibleBlocks(readWorklog(projectDir));
   const items = blocks.flatMap((block) => block.entries.map((entry) => ({ date: block.date, ...entry })));
   output(flags, { path: worklogPath(projectDir), items });
   if (flags.output !== 'json') items.forEach((item) => log.info(`${item.date}#${item.number} [${item.status}] ${item.title}`));
@@ -78,7 +83,8 @@ function list(projectDir, flags) {
 async function worklog(projectDir, positional = [], flags = {}) {
   const operation = positional[0] || 'show';
   if (operation === 'start') return add(projectDir, positional.slice(1), flags, 'active');
-  if (operation === 'add') return add(projectDir, positional.slice(1), flags, 'pending');
+  if (operation === 'add') return add(projectDir, positional.slice(1), flags, 'waiting');
+  if (operation === 'wait') return change(projectDir, positional.slice(1), flags, 'waiting');
   if (operation === 'start-item' || operation === 'start_item') return change(projectDir, positional.slice(1), flags, 'active');
   if (operation === 'complete' || operation === 'done') return change(projectDir, positional.slice(1), flags, 'completed');
   if (operation === 'show') return show(projectDir, flags);

package/src/contractCompatibility.js

@@ -21,7 +21,8 @@ function isHardContractIncompatibility(error) {
 
 function isDangerousOperation(contract) {
   const operation = contract && contract.operation || contract || {};
-  return operation.destructive === true || String(operation.risk || '').toLowerCase() === 'high';
+  const risk = String(operation.risk || '').toLowerCase();
+  return operation.destructive === true || risk === 'high' || risk === 'critical';
 }
 
 function canonicalValue(value) {
@@ -36,9 +37,15 @@ function sameOperationContract(left, right) {
   return JSON.stringify(canonicalValue(leftOperation)) === JSON.stringify(canonicalValue(rightOperation));
 }
 
+function canRetryAfterContractChange(left, right) {
+  const operation = right && right.operation || right || {};
+  const method = String(operation.method || '').toUpperCase();
+  return method === 'GET' || method === 'HEAD' || sameOperationContract(left, right);
+}
+
 function incompatibleOperationError(operationId, error) {
   const wrapped = new Error(
-    `DraftGo CLI and server contracts are incompatible for dangerous operation ${operationId}; `
+    `DraftGo CLI and server contracts are incompatible for operation ${operationId}; `
     + 'the call was blocked before retry. Upgrade DraftGo CLI, then describe and confirm the operation again.',
   );
   wrapped.code = 'CLI_CONTRACT_INCOMPATIBLE';
@@ -53,5 +60,6 @@ module.exports = {
   isHardContractIncompatibility,
   isDangerousOperation,
   sameOperationContract,
+  canRetryAfterContractChange,
   incompatibleOperationError,
 };

package/src/localRuntime/compose.js

@@ -23,6 +23,7 @@ function readEnv(projectDir) {
 
 function writeEnv(projectDir, env) {
   writeText(envPath(projectDir), `${Object.entries(env).map(([key, value]) => `${key}=${value}`).join('\n')}\n`);
+  fs.chmodSync(envPath(projectDir), 0o600);
 }
 
 function sanitizeProjectName(raw, fallback = 'draftgo') {
@@ -30,76 +31,89 @@ function sanitizeProjectName(raw, fallback = 'draftgo') {
   return value || fallback;
 }
 
-function defaultRedisKeyPrefix(projectName, mysql) {
-  return (mysql && mysql.database) || projectName;
-}
-
 function dockerHost(host) {
   return host === 'localhost' || host === '127.0.0.1' ? 'host.docker.internal' : host;
 }
 
 function generate(projectDir, opts) {
   const root = stackDir(projectDir);
+  if (exists(composePath(projectDir)) && readText(composePath(projectDir)).includes('./data/storage:/app/data/storage')) {
+    throw new Error('Existing runtime uses legacy storage. Back up and migrate its data to the final DraftGo /app/data layout before regenerating Compose; existing files were preserved.');
+  }
   ensureDir(root);
   const env = readEnv(projectDir);
   const projectName = sanitizeProjectName(opts.projectName, 'draftgo');
   const database = opts.mysql.database;
   const qdrant = opts.qdrant || { host: '127.0.0.1', port: 26333, apiKey: '' };
 
-  env.APP_PORT = String(opts.appPort || 3000);
+  env.APP_PORT = String(opts.appPort || 7777);
   env.SECRET_KEY = env.SECRET_KEY || randomHex(32);
+  env.SYSTEM_CONFIG_MASTER_KEY = env.SYSTEM_CONFIG_MASTER_KEY || randomHex(32);
   env.DATABASE_URL = `mysql://${encodeURIComponent(opts.mysql.user)}:${encodeURIComponent(opts.mysql.password)}@${dockerHost(opts.mysql.host)}:${opts.mysql.port}/${encodeURIComponent(database)}`;
-  env.REDIS_HOST = dockerHost(opts.redis.host);
-  env.REDIS_PORT = String(opts.redis.port);
-  env.REDIS_PASSWORD = opts.redis.password || '';
-  env.REDIS_KEY_PREFIX = database;
-  env.QDRANT_URL = `http://${dockerHost(qdrant.host)}:${qdrant.port}`;
-  env.QDRANT_API_KEY = qdrant.apiKey || '';
+  env.REDIS_URL = 'redis://redis:6379/0';
+  for (const key of ['REDIS_HOST', 'REDIS_PORT', 'REDIS_PASSWORD', 'REDIS_KEY_PREFIX']) delete env[key];
+  env.QDRANT_URL = qdrant ? `http://${dockerHost(qdrant.host)}:${qdrant.port}` : '';
+  env.QDRANT_API_KEY = qdrant ? (qdrant.apiKey || '') : '';
   env.QDRANT_COLLECTION_PREFIX = database;
 
   const yaml = [
-    '# Generated by draftgo-cli. Shared MySQL, Redis, and Qdrant stay on the host.',
+    '# Generated by draftgo-cli. MySQL and Qdrant are shared; Redis is project-isolated.',
     `name: ${projectName}`,
     'services:',
     '  app:',
-    '    image: cabinai/draftgo:latest',
+    `    image: ${opts.image || 'cabinai/draftgo:latest'}`,
     `    container_name: ${projectName}`,
     '    restart: unless-stopped',
     '    ports:',
     '      - "${APP_PORT}:3000"',
     '    environment:',
+    '      APP_ENV: production',
     '      APP_HOST: 0.0.0.0',
     '      APP_PORT: "3000"',
     '      PUBLIC_BASE_URL: http://localhost:${APP_PORT}',
     '      DATABASE_URL: ${DATABASE_URL}',
     '      SECRET_KEY: ${SECRET_KEY}',
-    '      REDIS_HOST: ${REDIS_HOST}',
-    '      REDIS_PORT: ${REDIS_PORT}',
-    '      REDIS_PASSWORD: ${REDIS_PASSWORD}',
-    '      REDIS_DB: "0"',
-    '      REDIS_KEY_PREFIX: ${REDIS_KEY_PREFIX}',
+    '      SYSTEM_CONFIG_MASTER_KEY: ${SYSTEM_CONFIG_MASTER_KEY}',
+    '      REDIS_URL: ${REDIS_URL}',
     '      QDRANT_URL: ${QDRANT_URL}',
     '      QDRANT_API_KEY: ${QDRANT_API_KEY}',
     '      QDRANT_COLLECTION_PREFIX: ${QDRANT_COLLECTION_PREFIX}',
-    '      LOCAL_UPLOAD_DIR: /app/data/storage/uploads',
-    '      KB_STORAGE_DIR: /app/data/storage/kb',
-    '      DRAFTGO_GO_SERVICE_CACHE_DIR: /app/data/storage/custom-services/cache',
-    '      MCP_TEMP_DIR: /app/data/storage/mcp/tmp',
+    '      FILE_STORAGE_ROOT: /app/data/files',
     '    volumes:',
-    '      - ./data/storage:/app/data/storage',
+    '      - app_data:/app/data',
+    '    healthcheck:',
+    '      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:3000/api/system/health"]',
+    '      interval: 10s',
+    '      timeout: 5s',
+    '      start_period: 10s',
+    '      retries: 6',
+    '    depends_on:',
+    '      redis:',
+    '        condition: service_healthy',
     '    extra_hosts:',
     '      - "host.docker.internal:host-gateway"',
+    '  redis:',
+    '    image: redis:7.4-alpine',
+    '    restart: unless-stopped',
+    '    command: ["redis-server", "--appendonly", "yes"]',
+    '    volumes:',
+    '      - redis_data:/data',
+    '    healthcheck:',
+    '      test: ["CMD", "redis-cli", "ping"]',
+    '      interval: 5s',
+    '      timeout: 5s',
+    '      retries: 20',
+    'volumes:',
+    '  app_data:',
+    '  redis_data:',
     '',
   ].join('\n');
   writeText(composePath(projectDir), yaml);
   writeEnv(projectDir, env);
-  for (const subdir of ['data/storage', 'data/storage/uploads', 'data/storage/kb', 'data/storage/mcp/tmp', 'data/storage/custom-services/cache']) {
-    try { fs.mkdirSync(path.join(root, subdir), { recursive: true }); } catch {}
-  }
   return { dir: root, composeFile: composePath(projectDir), envFile: envPath(projectDir), projectName, env };
 }
 
 module.exports = {
   stackDir, composePath, envPath,
-  generate, sanitizeProjectName, defaultRedisKeyPrefix, randomHex,
+  generate, sanitizeProjectName, randomHex,
 };

package/src/localRuntime/detect.js

@@ -31,9 +31,8 @@ function probeHttpOnce(url, timeoutMs = 2000) {
   return new Promise((resolve) => {
     try {
       const req = http.get(url, { timeout: timeoutMs }, (res) => {
-        // Any HTTP response (including 4xx/5xx) means the app is listening.
-        res.resume();
-        resolve(true);
+        res.resume();
+        resolve(res.statusCode >= 200 && res.statusCode < 300);
       });
       req.on('timeout', () => { req.destroy(); resolve(false); });
       req.on('error', () => resolve(false));
@@ -61,9 +60,10 @@ function tryCmd(cmd, args) {
   }
 }
 
-function detectDocker() {
-  const hasDocker = tryCmd('docker', ['version', '--format', '{{.Client.Version}}']);
-  if (!hasDocker) return { ok: false, reason: 'docker-missing' };
+function detectDocker() {
+  const hasDocker = tryCmd('docker', ['--version']);
+  if (!hasDocker) return { ok: false, reason: 'docker-missing' };
+  if (!tryCmd('docker', ['info', '--format', '{{.ServerVersion}}'])) return { ok: false, reason: 'docker-not-running' };
   // Prefer `docker compose` (plugin); fall back to legacy `docker-compose`.
   if (tryCmd('docker', ['compose', 'version'])) {
     return { ok: true, composeCmd: 'docker', composeArgs: ['compose'] };