draftgo-cli 3.0.29 → 3.0.33

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,232 +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) {
-  const dbName = mysql && mysql.database ? sanitizeProjectName(mysql.database, '') : '';
-  return dbName || projectName;
+  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.REDIS_KEY_PREFIX = env.REDIS_KEY_PREFIX || defaultRedisKeyPrefix(projectName, opts.mysql);
-
-  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 || '';
-  }
+  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;
 
-  // ── 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}"`,
     '      REDIS_KEY_PREFIX: ${REDIS_KEY_PREFIX}',
-    '      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"',
+    '      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, defaultRedisKeyPrefix,
-  randomAlnum, randomHex,
+  generate, sanitizeProjectName, defaultRedisKeyPrefix, randomHex,
 };