draftgo-cli 3.0.1 → 3.0.33

package/src/commands/verifyUi.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const log = require('../logger');
+
+const UI_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less', '.html', '.htm', '.jsx', '.tsx', '.vue', '.svelte']);
+
+function isUiFile(file) {
+  const normalized = String(file || '').replace(/\\/g, '/').toLowerCase();
+  const ext = path.extname(normalized);
+  if (UI_EXTENSIONS.has(ext)) return true;
+  if (!['.js', '.ts'].includes(ext)) return false;
+  return /(^|\/)(frontend|web|ui|components|pages|views|client)(\/|$)/.test(normalized)
+    || /(^|\/)(app|main|client)\.(js|ts)$/.test(normalized)
+    || normalized.startsWith('.draftgo/pages/')
+    || normalized.startsWith('.draftgo/navigations/');
+}
+
+function gitChangedFiles(projectDir) {
+  const r = spawnSync('git', ['status', '--porcelain=v1', '--untracked-files=all'], {
+    cwd: projectDir,
+    encoding: 'utf8',
+    shell: false,
+  });
+  if (r.error || r.status !== 0) return null;
+  return String(r.stdout || '').split(/\r?\n/).filter(Boolean).map((line) => {
+    const raw = line.slice(3).trim();
+    const renamed = raw.includes(' -> ') ? raw.split(' -> ').pop() : raw;
+    return renamed.replace(/^"|"$/g, '');
+  });
+}
+
+function decideMobileCheck(projectDir, mode) {
+  if (mode === 'always') return { run: true, reason: 'mobile-check=always' };
+  if (mode === 'never') return { run: false, reason: 'mobile-check=never' };
+  const changed = gitChangedFiles(projectDir);
+  if (changed === null || changed.length === 0) {
+    return { run: true, reason: '无法从 Git diff 确认影响范围，执行单视口 smoke check' };
+  }
+  const uiFiles = changed.filter(isUiFile);
+  if (!uiFiles.length) return { run: false, reason: '本次变更未涉及页面、样式或前端组件' };
+  return { run: true, reason: `检测到 ${uiFiles.length} 个 UI 文件变更` };
+}
+
+function numberFlag(value, fallback, min, max) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(min, Math.min(max, Math.round(n))) : fallback;
+}
+
+function executableCandidates() {
+  if (process.platform === 'win32') {
+    const roots = [process.env.PROGRAMFILES, process.env['PROGRAMFILES(X86)'], process.env.LOCALAPPDATA].filter(Boolean);
+    const rels = [
+      ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+      ['Google', 'Chrome', 'Application', 'chrome.exe'],
+      ['Chromium', 'Application', 'chrome.exe'],
+    ];
+    return roots.flatMap((root) => rels.map((parts) => path.join(root, ...parts)));
+  }
+  if (process.platform === 'darwin') {
+    return [
+      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+      '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    ];
+  }
+  return ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/microsoft-edge', '/usr/bin/chromium', '/usr/bin/chromium-browser'];
+}
+
+async function launchBrowser(chromium, requested) {
+  const attempts = [];
+  if (requested && requested !== 'chromium') attempts.push({ channel: requested });
+  for (const executablePath of executableCandidates().filter((candidate) => fs.existsSync(candidate))) {
+    attempts.push({ executablePath });
+  }
+  if (!requested || requested === 'chromium') attempts.push({});
+  for (const channel of ['msedge', 'chrome']) {
+    if (!attempts.some((a) => a.channel === channel)) attempts.push({ channel });
+  }
+
+  let lastError = null;
+  for (const options of attempts) {
+    try {
+      return await chromium.launch({ headless: true, ...options });
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw new Error(`未找到可用的 Chromium/Chrome/Edge。${lastError ? ` ${lastError.message.split('\n')[0]}` : ''}`);
+}
+
+async function verifyUi(projectDir, positional, flags = {}) {
+  const url = String(flags.url || positional[0] || '').trim();
+  if (!/^https?:\/\//i.test(url)) {
+    log.err('用法：draftgo verify-ui <http://localhost:port/path>');
+    return 1;
+  }
+
+  const mode = String(flags['mobile-check'] || 'auto').toLowerCase();
+  if (!['auto', 'always', 'never'].includes(mode)) {
+    log.err('--mobile-check 只支持 auto、always、never。');
+    return 1;
+  }
+  const decision = decideMobileCheck(projectDir, mode);
+  if (!decision.run) {
+    log.ok(`跳过 UI smoke check：${decision.reason}`);
+    return 0;
+  }
+
+  let chromium;
+  try {
+    ({ chromium } = require('playwright-core'));
+  } catch {
+    log.err('缺少 playwright-core，请重新安装或升级 draftgo-cli。');
+    return 1;
+  }
+
+  const width = numberFlag(flags.width, 390, 240, 3840);
+  const height = numberFlag(flags.height, 844, 320, 2160);
+  const waitMs = numberFlag(flags['wait-ms'], 500, 0, 10000);
+  const screenshotMode = String(flags.screenshot || 'on-failure').toLowerCase();
+  if (!['on-failure', 'always', 'never'].includes(screenshotMode)) {
+    log.err('--screenshot 只支持 on-failure、always、never。');
+    return 1;
+  }
+
+  let browser;
+  try {
+    browser = await launchBrowser(chromium, flags.browser && String(flags.browser));
+    const page = await browser.newPage({ viewport: { width, height } });
+    const consoleErrors = [];
+    const pageErrors = [];
+    page.on('console', (msg) => { if (msg.type() === 'error') consoleErrors.push(msg.text()); });
+    page.on('pageerror', (err) => pageErrors.push(err.message));
+
+    const response = await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+    if (waitMs) await page.waitForTimeout(waitMs);
+    const state = await page.evaluate(() => {
+      const body = document.body;
+      const root = document.documentElement;
+      return {
+        title: document.title,
+        bodyTextLength: body ? (body.innerText || '').trim().length : 0,
+        bodyHeight: body ? body.getBoundingClientRect().height : 0,
+        hasVisibleMedia: body ? Array.from(body.querySelectorAll('img,svg,canvas,video,iframe,input,button')).some((element) => {
+          const rect = element.getBoundingClientRect();
+          return rect.width > 1 && rect.height > 1;
+        }) : false,
+        horizontalOverflow: root.scrollWidth > window.innerWidth + 1,
+        scrollWidth: root.scrollWidth,
+        viewportWidth: window.innerWidth,
+      };
+    });
+
+    const issues = [];
+    if (response && response.status() >= 400) issues.push(`页面返回 HTTP ${response.status()}`);
+    if (!state.bodyHeight || (!state.bodyTextLength && !state.hasVisibleMedia)) issues.push('页面疑似空白');
+    if (state.horizontalOverflow) issues.push(`页面横向溢出：scrollWidth=${state.scrollWidth}, viewport=${state.viewportWidth}`);
+    if (consoleErrors.length) issues.push(`console error ${consoleErrors.length} 条`);
+    if (pageErrors.length) issues.push(`page error ${pageErrors.length} 条`);
+    if (flags.selector) {
+      const visible = await page.locator(String(flags.selector)).first().isVisible().catch(() => false);
+      if (!visible) issues.push(`关键元素不可见：${flags.selector}`);
+    }
+
+    const shouldScreenshot = screenshotMode === 'always' || (screenshotMode === 'on-failure' && issues.length > 0);
+    let screenshotPath = null;
+    if (shouldScreenshot) {
+      const dir = path.join(projectDir, '.draftgo', 'artifacts');
+      fs.mkdirSync(dir, { recursive: true });
+      screenshotPath = path.join(dir, `ui-check-${process.pid}-${Date.now()}.png`);
+      await page.screenshot({ path: screenshotPath, fullPage: true });
+    }
+
+    if (issues.length) {
+      issues.forEach((issue) => log.err(issue));
+      if (consoleErrors.length) consoleErrors.slice(0, 5).forEach((msg) => log.dim(`  console: ${msg}`));
+      if (pageErrors.length) pageErrors.slice(0, 5).forEach((msg) => log.dim(`  page: ${msg}`));
+      if (screenshotPath) log.info(`失败截图：${screenshotPath}`);
+      return 1;
+    }
+
+    log.ok(`UI smoke check 通过：${width}x${height}，${decision.reason}`);
+    if (screenshotPath) log.info(`截图：${screenshotPath}`);
+    return 0;
+  } catch (err) {
+    log.err(`UI smoke check 失败：${err.message}`);
+    return 1;
+  } finally {
+    if (browser) await browser.close().catch(() => {});
+  }
+}
+
+module.exports = verifyUi;
+module.exports.decideMobileCheck = decideMobileCheck;
+module.exports.gitChangedFiles = gitChangedFiles;
+module.exports.isUiFile = isUiFile;

package/src/index.js

@@ -2,10 +2,17 @@
 
 const path = require('path');
 const { parse } = require('./cli');
+const { resolveCommand } = require('./commandRegistry');
 const log = require('./logger');
 
 async function run(argv) {
-  const { command, positional, flags } = parse(argv);
+  const { command, positional, flags, errors } = parse(argv);
+
+  if (errors.length) {
+    for (const error of errors) log.err(error);
+    require('./commands/help')();
+    return 1;
+  }
 
   // --version / --help shortcuts
   if (flags.version || flags.v || command === 'version') {
@@ -22,51 +29,11 @@ async function run(argv) {
     : process.cwd();
 
   try {
-    switch (command) {
-      case 'init':
-        return await require('./commands/init')(projectDir, positional, flags);
-      case 'update':
-      case 'upgrade':
-        return await require('./commands/update')(projectDir, positional, flags);
-      case 'uninstall':
-      case 'remove':
-        return await require('./commands/uninstall')(projectDir, positional, flags);
-      case 'status':
-        return require('./commands/status')(projectDir);
-      case 'doctor':
-        return await require('./commands/doctor')(projectDir, flags);
-      case 'map':
-        return require('./commands/map')(projectDir, flags);
-      case 'check':
-        return require('./commands/check')(projectDir, flags);
-      case 'dev':
-      case 'build':
-        return require('./commands/projectScript')(projectDir, command, flags);
-      case 'new':
-        return require('./commands/new')(projectDir, positional, flags);
-      case 'delete':
-      case 'del':
-      case 'rm':
-        return await require('./commands/delete')(projectDir, positional, flags);
-      case 'pull':
-      case 'push':
-        return require('./commands/sync')(projectDir, command, positional, flags);
-      case 'local':
-        return require('./commands/local')(projectDir, positional, flags);
-      case 'list-targets':
-      case 'targets':
-        return require('./commands/listTargets')();
-      case 'local-dev':
-      case 'localdev':
-        return await require('./commands/localDev')(projectDir, positional, flags);
-      case 'connect':
-      case 'login':
-        return await require('./commands/connect')(projectDir, positional, flags);
-      default:
-        log.err(`未知命令：${command}`);
-        require('./commands/help')();
-        return 1;
-    }
+    const definition = resolveCommand(command);
+    if (definition) return await definition.run(projectDir, positional, flags);
+    log.err(`未知命令：${command}`);
+    require('./commands/help')();
+    return 1;
   } catch (e) {
     log.err(e.message || String(e));
     if (process.env.DEBUG) console.error(e.stack);

package/src/localdev/compose.js

@@ -1,29 +1,5 @@
 'use strict';
 
-// Generate a docker-compose.yaml for the local-dev DraftGo stack.
-//
-// Stored *inside the project* at:
-//   <project>/.draftgo/docker/
-//     ├── docker-compose.yaml
-//     ├── .env                # random secrets, kept across re-runs
-//     └── data/               # bind-mounted volumes
-//
-// Each project gets its own stack — no cross-project sharing — so multiple
-// DraftGo projects can run in parallel without container/volume collisions.
-//
-// Stack composition is dynamic:
-//   - Always: the `app` service (cabinai/draftgo:latest)
-//   - Optional: `mysql` service (omitted when user wires up an existing MySQL)
-//   - Optional: `redis` service (omitted when user wires up an existing Redis)
-// The app talks to in-stack services by service-name, and to host services via
-// `host.docker.internal` (works on Windows/macOS natively; `host-gateway` extra
-// host is added so it also works on Linux).
-//
-// Container naming: every service gets an explicit `container_name:` derived
-// from the user-supplied compose project name, so the actual containers are
-// named `<projectName>` / `<projectName>-mysql` / `<projectName>-redis`
-// instead of compose's default `<projectName>-<service>-1`.
-
 const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs');
@@ -33,225 +9,100 @@ function stackDir(projectDir) { return path.join(projectDir, '.draftgo', 'docker
 function composePath(projectDir) { return path.join(stackDir(projectDir), 'docker-compose.yaml'); }
 function envPath(projectDir) { return path.join(stackDir(projectDir), '.env'); }
 
-function randomAlnum(len) {
-  // URL-safe alphanumeric (no ambiguous shell metachars).
-  const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-  const bytes = crypto.randomBytes(len);
-  let out = '';
-  for (let i = 0; i < len; i++) out += charset[bytes[i] % charset.length];
-  return out;
-}
-
-function randomHex(bytes) {
-  return crypto.randomBytes(bytes).toString('hex');
-}
+function randomHex(bytes) { return crypto.randomBytes(bytes).toString('hex'); }
 
 function readEnv(projectDir) {
-  // Parse existing .env into a flat object so we can preserve previously
-  // generated secrets across re-runs of the wizard.
   if (!exists(envPath(projectDir))) return {};
   const out = {};
   for (const line of readText(envPath(projectDir)).split(/\r?\n/)) {
-    const m = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
-    if (m) out[m[1]] = m[2];
+    const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (match) out[match[1]] = match[2];
   }
   return out;
 }
 
 function writeEnv(projectDir, env) {
-  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
-  writeText(envPath(projectDir), lines.join('\n') + '\n');
+  writeText(envPath(projectDir), `${Object.entries(env).map(([key, value]) => `${key}=${value}`).join('\n')}\n`);
 }
 
-// Compose project names must match [a-z0-9][a-z0-9_-]*.
-// Trim/normalise user input so we never write an invalid compose file.
 function sanitizeProjectName(raw, fallback = 'draftgo') {
-  let v = String(raw || '').trim().toLowerCase();
-  v = v.replace(/[^a-z0-9_-]/g, '-').replace(/^[-_]+/, '');
-  return v || fallback;
+  const value = String(raw || '').trim().toLowerCase().replace(/[^a-z0-9_-]/g, '-').replace(/^[-_]+/, '');
+  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;
 }
 
-// `opts`:
-//   projectName:    docker compose project name (also drives container_name)
-//   appPort:        host port for the app (default 3000)
-//   mysql:          { useContainer, host, port, user, password, database }
-//   redis:          { useContainer, host, port, password }
 function generate(projectDir, opts) {
   const root = stackDir(projectDir);
   ensureDir(root);
   const env = readEnv(projectDir);
   const projectName = sanitizeProjectName(opts.projectName, 'draftgo');
+  const database = opts.mysql.database;
+  const milvus = opts.milvus || { host: '127.0.0.1', port: 19530, username: '', password: '' };
 
-  const appPort = Number(opts.appPort || 3000);
-  env.APP_PORT = String(appPort);
+  env.APP_PORT = String(opts.appPort || 3000);
   env.SECRET_KEY = env.SECRET_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.MILVUS_ADDRESS = `${dockerHost(milvus.host)}:${milvus.port}`;
+  env.MILVUS_USERNAME = milvus.username || '';
+  env.MILVUS_PASSWORD = milvus.password || '';
+  env.MILVUS_DATABASE = 'default';
+  env.MILVUS_COLLECTION_PREFIX = database;
 
-  const services = {};
-  const dependsOn = [];
-
-  // ── MySQL ────────────────────────────────────────────────────────────
-  let dbUrl;
-  if (opts.mysql.useContainer) {
-    env.MYSQL_ROOT_PASSWORD = env.MYSQL_ROOT_PASSWORD || randomAlnum(24);
-    env.MYSQL_DATABASE = opts.mysql.database || env.MYSQL_DATABASE || 'draftgo';
-    env.MYSQL_USER = opts.mysql.user || env.MYSQL_USER || 'draftgo';
-    env.MYSQL_PASSWORD = env.MYSQL_PASSWORD || randomAlnum(24);
-    services.mysql = [
-      '  mysql:',
-      '    image: mysql:8.0',
-      `    container_name: ${projectName}-mysql`,
-      '    restart: unless-stopped',
-      '    logging:',
-      '      driver: json-file',
-      '      options:',
-      '        max-size: "10m"',
-      '        max-file: "3"',
-      '    environment:',
-      '      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}',
-      '      MYSQL_DATABASE: ${MYSQL_DATABASE}',
-      '      MYSQL_USER: ${MYSQL_USER}',
-      '      MYSQL_PASSWORD: ${MYSQL_PASSWORD}',
-      '    command:',
-      '      - --character-set-server=utf8mb4',
-      '      - --collation-server=utf8mb4_unicode_ci',
-      '    volumes:',
-      '      - ./data/mysql:/var/lib/mysql',
-      '    healthcheck:',
-      '      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}"]',
-      '      interval: 10s',
-      '      timeout: 5s',
-      '      retries: 12',
-      '      start_period: 30s',
-    ].join('\n');
-    dependsOn.push(['mysql', 'service_healthy']);
-    dbUrl = 'mysql+pymysql://${MYSQL_USER}:${MYSQL_PASSWORD}@mysql:3306/${MYSQL_DATABASE}';
-  } else {
-    const u = encodeURIComponent(opts.mysql.user);
-    const p = encodeURIComponent(opts.mysql.password);
-    const host = opts.mysql.host === 'localhost' || opts.mysql.host === '127.0.0.1'
-      ? 'host.docker.internal'
-      : opts.mysql.host;
-    dbUrl = `mysql+pymysql://${u}:${p}@${host}:${opts.mysql.port}/${opts.mysql.database}`;
-  }
-
-  // ── Redis ────────────────────────────────────────────────────────────
-  let redisHost, redisPort, redisPass;
-  if (opts.redis.useContainer) {
-    env.REDIS_PASSWORD = env.REDIS_PASSWORD || randomAlnum(24);
-    services.redis = [
-      '  redis:',
-      '    image: redis:7-alpine',
-      `    container_name: ${projectName}-redis`,
-      '    restart: unless-stopped',
-      '    logging:',
-      '      driver: json-file',
-      '      options:',
-      '        max-size: "10m"',
-      '        max-file: "3"',
-      '    command: ["redis-server", "--requirepass", "${REDIS_PASSWORD}", "--appendonly", "yes"]',
-      '    volumes:',
-      '      - ./data/redis:/data',
-      '    healthcheck:',
-      '      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]',
-      '      interval: 10s',
-      '      timeout: 3s',
-      '      retries: 10',
-      '      start_period: 10s',
-    ].join('\n');
-    dependsOn.push(['redis', 'service_healthy']);
-    redisHost = 'redis';
-    redisPort = '6379';
-    redisPass = '${REDIS_PASSWORD}';
-  } else {
-    redisHost = (opts.redis.host === 'localhost' || opts.redis.host === '127.0.0.1')
-      ? 'host.docker.internal'
-      : opts.redis.host;
-    redisPort = String(opts.redis.port);
-    redisPass = opts.redis.password || '';
-  }
-
-  // ── App ──────────────────────────────────────────────────────────────
-  const appLines = [
+  const yaml = [
+    '# Generated by draftgo-cli. Shared MySQL, Redis, and Milvus stay on the host.',
+    `name: ${projectName}`,
+    'services:',
     '  app:',
     '    image: cabinai/draftgo:latest',
     `    container_name: ${projectName}`,
     '    restart: unless-stopped',
-    '    logging:',
-    '      driver: json-file',
-    '      options:',
-    '        max-size: "10m"',
-    '        max-file: "3"',
-    `    ports:`,
-    `      - "${appPort}:3000"`,
+    '    ports:',
+    '      - "${APP_PORT}:3000"',
     '    environment:',
     '      APP_HOST: 0.0.0.0',
     '      APP_PORT: "3000"',
-    `      PUBLIC_BASE_URL: http://localhost:${appPort}`,
-    '      DATABASE_TYPE: mysql',
-    `      DATABASE_URL: "${dbUrl}"`,
+    '      PUBLIC_BASE_URL: http://localhost:${APP_PORT}',
+    '      DATABASE_URL: ${DATABASE_URL}',
     '      SECRET_KEY: ${SECRET_KEY}',
-    `      REDIS_HOST: ${redisHost}`,
-    `      REDIS_PORT: "${redisPort}"`,
+    '      REDIS_HOST: ${REDIS_HOST}',
+    '      REDIS_PORT: ${REDIS_PORT}',
+    '      REDIS_PASSWORD: ${REDIS_PASSWORD}',
     '      REDIS_DB: "0"',
-    `      REDIS_PASSWORD: "${redisPass}"`,
-    '      LOG_DIR: /app/backend/logs',
-    '      LOG_FILE_NAME: app.log',
-    '      LOG_LEVEL: INFO',
-    '      LOG_MAX_BYTES: "5242880"',
-    '      LOG_BACKUP_COUNT: "5"',
-    '      LOG_TO_CONSOLE: "true"',
-    '      LOG_CONSOLE_JSON: "true"',
-    '      LOG_UVICORN_ACCESS: "true"',
-    '      LOG_RUNTIME_HEARTBEAT_INTERVAL_SECONDS: "300"',
-    '      UPLOAD_PROVIDER: local',
-    '      UPLOAD_MAX_SIZE: "10485760"',
+    '      REDIS_KEY_PREFIX: ${REDIS_KEY_PREFIX}',
+    '      MILVUS_ADDRESS: ${MILVUS_ADDRESS}',
+    '      MILVUS_USERNAME: ${MILVUS_USERNAME}',
+    '      MILVUS_PASSWORD: ${MILVUS_PASSWORD}',
+    '      MILVUS_DATABASE: ${MILVUS_DATABASE}',
+    '      MILVUS_COLLECTION_PREFIX: ${MILVUS_COLLECTION_PREFIX}',
     '      LOCAL_UPLOAD_DIR: /app/backend/storage/uploads',
-    '      UPLOAD_URL_PREFIX: /uploads',
     '    volumes:',
     '      - ./data/uploads:/app/backend/storage/uploads',
     '      - ./data/logs:/app/backend/logs',
     '      - ./data/db:/app/backend/db',
     '    extra_hosts:',
     '      - "host.docker.internal:host-gateway"',
-  ];
-  if (dependsOn.length > 0) {
-    appLines.push('    depends_on:');
-    for (const [name, cond] of dependsOn) {
-      appLines.push(`      ${name}:`);
-      appLines.push(`        condition: ${cond}`);
-    }
-  }
-  services.app = appLines.join('\n');
-
-  const order = ['app', 'mysql', 'redis'].filter((k) => services[k]);
-  const yaml = [
-    '# Auto-generated by draftgo-cli (local-dev wizard).',
-    '# Secrets live in the sibling .env file. Re-running the wizard preserves them.',
-    `name: ${projectName}`,
-    'services:',
-    ...order.map((k) => services[k]),
     '',
   ].join('\n');
-
   writeText(composePath(projectDir), yaml);
   writeEnv(projectDir, env);
-
-  // Pre-create bind-mount dirs so the Docker daemon does not create them as root on Linux.
-  for (const sub of ['data/uploads', 'data/logs', 'data/db', 'data/mysql', 'data/redis']) {
-    try { fs.mkdirSync(path.join(root, sub), { recursive: true }); } catch {}
+  for (const subdir of ['data/uploads', 'data/logs', 'data/db']) {
+    try { fs.mkdirSync(path.join(root, subdir), { recursive: true }); } catch {}
   }
-
-  return {
-    dir: root,
-    composeFile: composePath(projectDir),
-    envFile: envPath(projectDir),
-    projectName,
-    env,
-  };
+  return { dir: root, composeFile: composePath(projectDir), envFile: envPath(projectDir), projectName, env };
 }
 
 module.exports = {
   stackDir, composePath, envPath,
-  generate, sanitizeProjectName,
-  randomAlnum, randomHex,
+  generate, sanitizeProjectName, defaultRedisKeyPrefix, randomHex,
 };