draftgo-cli 4.0.24 → 4.0.26

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'] };

package/src/localRuntime/index.js

@@ -1,16 +1,17 @@
 'use strict';
 
 const { spawnSync } = require('child_process');
+const path = require('path');
 const log = require('../logger');
 const { askRequired, askPassword, confirm } = require('../prompt');
 const { probePort, probeHttp, detectDocker } = require('./detect');
 const compose = require('./compose');
 const { ensureDatabase, testConnection, describeClient } = require('./mysqlClient');
-const { defaults, portOpen, probeRedis, probeQdrant, startService } = require('./services');
+const { defaults, portOpen, probeQdrant, startService } = require('./services');
 const { writeProjectConfig } = require('../projectConfig');
-const { appendGitignoreLine } = require('../fsx');
+const { appendGitignoreLine, exists, readText } = require('../fsx');
 
-const DEFAULT_APP_PORT = 3000;
+const DEFAULT_APP_PORT = 7777;
 
 async function promptMysqlConnection() {
   while (true) {
@@ -25,10 +26,11 @@ async function promptMysqlConnection() {
   }
 }
 
-async function ensureProjectDatabase(conn, database) {
+async function ensureProjectDatabase(conn, database, interactive = true) {
   while (true) {
     const result = await ensureDatabase({ ...conn, database }, {
       rootPromptFn: async () => {
+        if (!interactive) return null;
         log.warn(`  ${conn.user} cannot create database ${database}.`);
         if (!await confirm('  Create it with another MySQL account?', { default: true })) return null;
         return {
@@ -39,13 +41,14 @@ async function ensureProjectDatabase(conn, database) {
     });
     if (result.ok) return { ...conn, database };
     log.err(`  Database setup failed: ${(result.detail || result.reason || 'unknown error').split('\n')[0]}`);
+    if (!interactive) throw new Error('Database setup needs credentials. Run `draftgo local setup` in a terminal to continue.');
     const retry = await confirm('  Re-enter MySQL connection settings?', { default: true });
     if (!retry) throw new Error('MySQL database was not prepared.');
     conn = await promptMysqlConnection();
   }
 }
 
-async function planMysql(docker, defaultDatabase) {
+async function planMysql(docker, defaultDatabase, interactive = true) {
   log.step('Checking MySQL');
   let conn = { ...defaults.mysql };
   if (!await portOpen(conn.host, conn.port)) {
@@ -54,40 +57,15 @@ async function planMysql(docker, defaultDatabase) {
   }
   if (!testConnection(conn).ok) {
     log.warn('  Default MySQL credentials were not accepted.');
+    if (!interactive) throw new Error('MySQL needs credentials. Run `draftgo local setup` in a terminal to continue.');
     conn = await promptMysqlConnection();
   }
-  const database = await askRequired('  Project database name', { default: defaultDatabase });
-  const out = await ensureProjectDatabase(conn, database);
+  const database = interactive ? await askRequired('  Project database name', { default: defaultDatabase }) : defaultDatabase;
+  const out = await ensureProjectDatabase(conn, database, interactive);
   log.ok(`  MySQL ready: ${out.host}:${out.port}/${out.database} (${describeClient()})`);
   return out;
 }
 
-async function promptRedisConnection() {
-  while (true) {
-    const host = await askRequired('  Redis host', { default: '127.0.0.1' });
-    const port = Number(await askRequired('  Redis port', { default: '6379' }));
-    const password = await askPassword('  Redis password (empty for none)', { default: '' });
-    const conn = { host, port, password };
-    if (await probeRedis(conn)) return conn;
-    log.err('  Redis PING failed. Check the address and password.');
-  }
-}
-
-async function planRedis(docker) {
-  log.step('Checking Redis');
-  let conn = { ...defaults.redis };
-  if (!await portOpen(conn.host, conn.port)) {
-    log.dim('  Redis is not running locally; starting the shared local service.');
-    if (!startService(docker, 'redis')) throw new Error('Unable to start shared Redis.');
-  }
-  if (!await probeRedis(conn)) {
-    log.warn('  Default passwordless Redis PING failed.');
-    conn = await promptRedisConnection();
-  }
-  log.ok(`  Redis ready: ${conn.host}:${conn.port}`);
-  return conn;
-}
-
 async function promptQdrantConnection() {
   while (true) {
     const host = await askRequired('  Qdrant host', { default: '127.0.0.1' });
@@ -99,7 +77,7 @@ async function promptQdrantConnection() {
   }
 }
 
-async function planQdrant(docker) {
+async function planQdrant(docker, interactive = true) {
   log.step('Checking Qdrant');
   let conn = { ...defaults.qdrant };
   if (!await portOpen(conn.host, conn.port)) {
@@ -108,15 +86,22 @@ async function planQdrant(docker) {
   }
   if (!await probeQdrant(conn)) {
     log.warn('  Default unauthenticated Qdrant REST health check failed.');
+    if (!interactive) throw new Error('Qdrant needs credentials. Run `draftgo local setup` in a terminal to continue.');
     conn = await promptQdrantConnection();
   }
   log.ok(`  Qdrant ready: ${conn.host}:${conn.port}`);
   return conn;
 }
 
-async function pickAppPort() {
+async function pickAppPort(interactive = true) {
+  if (!interactive) {
+    for (let port = DEFAULT_APP_PORT; port < DEFAULT_APP_PORT + 100; port += 1) {
+      if (!await probePort('127.0.0.1', port)) return port;
+    }
+    throw new Error('No free local port found. Run `draftgo local setup` in a terminal to select a port.');
+  }
   const taken = await probePort('127.0.0.1', DEFAULT_APP_PORT);
-  const suggested = taken ? '3001' : String(DEFAULT_APP_PORT);
+  const suggested = String(taken ? DEFAULT_APP_PORT + 1 : DEFAULT_APP_PORT);
   while (true) {
     const port = Number(await askRequired('  DraftGo host port', { default: suggested }));
     if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
@@ -141,7 +126,7 @@ function composeUp(docker, dir) {
 }
 
 async function waitForApp(appPort) {
-  const ok = await probeHttp(`http://127.0.0.1:${appPort}/`, { totalMs: 120000, intervalMs: 2000 });
+  const ok = await probeHttp(`http://127.0.0.1:${appPort}/api/system/health`, { totalMs: 120000, intervalMs: 2000 });
   if (!ok) log.err('  Timed out waiting for DraftGo. Run `draftgo local logs` to inspect the app.');
   return ok;
 }
@@ -174,35 +159,50 @@ async function finishMcpSetup(projectDir, mcpCommands) {
   return setupOk && testOk;
 }
 
-async function runWizard(projectDir, { yes = false, mcpCommands } = {}) {
+async function runWizard(projectDir, { yes = false, mcpCommands, interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !yes, params = {} } = {}) {
   log.title('draftgo local setup');
+  if (!yes && !interactive) throw new Error('Run `draftgo local setup --yes` for unattended setup, or use a terminal for guided setup.');
   if (!yes && !await confirm('Continue with local DraftGo setup?', { default: true })) return 0;
 
   const docker = detectDocker();
   if (!docker.ok) {
     throw new Error(docker.reason === 'compose-missing'
-      ? 'Docker is installed but Docker Compose is unavailable.'
-      : 'Docker is required to start missing local dependencies.');
+      ? 'Install Docker Compose: https://docs.docker.com/compose/install/ then retry `draftgo local setup`.'
+      : docker.reason === 'docker-not-running'
+        ? 'Start Docker Desktop or the Docker daemon, then retry `draftgo local setup`. Installed Skills are preserved.'
+        : 'Install Docker: https://docs.docker.com/get-started/get-docker/ then start it and retry `draftgo local setup`. Installed Skills are preserved.');
   }
 
-  const appPort = await pickAppPort();
-  const projectName = await pickProjectName();
-  const mysql = await planMysql(docker, projectName);
-  const redis = await planRedis(docker);
-  const qdrant = await planQdrant(docker);
+  if (exists(compose.composePath(projectDir))) {
+    if (readText(compose.composePath(projectDir)).includes('./data/storage:/app/data/storage')) {
+      throw new Error('Existing runtime uses legacy storage. Back up and migrate it to final DraftGo before setup; Compose and data were preserved.');
+    }
+    log.dim('  Existing project runtime preserved. Use `draftgo local start` to resume it, then `draftgo connect` to bind your API Key.');
+    return 0;
+  }
+  const appPort = params.appPort || await pickAppPort(interactive);
+  const projectName = params.projectName || (interactive ? await pickProjectName() : compose.sanitizeProjectName(path.basename(projectDir)));
+  const mysql = params.mysql || await planMysql(docker, projectName, interactive);
+  const qdrant = params.qdrant === false ? null : (params.qdrant || await planQdrant(docker, interactive));
 
-  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis, qdrant });
+  const out = compose.generate(projectDir, { projectName, appPort, mysql, qdrant, image: params.image });
   appendGitignoreLine(projectDir, '.draftgo/docker/');
   if (!composeUp(docker, out.dir) || !await waitForApp(appPort)) return 1;
 
   const url = `http://localhost:${appPort}`;
+  log.ok(`DraftGo runtime is ready at ${url}`);
+  log.dim('  Open the site, register or sign in, and obtain your personal API Key.');
+  if (!interactive) {
+    log.dim(`  Connection pending. Run \`draftgo connect --server ${url}\` in a terminal to enter your API Key.`);
+    return 0;
+  }
   let token = '';
   while (token.length < 10) {
     token = String(await askPassword('Paste a DraftGo user API Key')).trim();
     if (token.length < 10) log.err('  API Key appears too short. Please try again.');
   }
   const cfgPath = writeProjectConfig(projectDir, url, token);
-  await finishMcpSetup(projectDir, mcpCommands);
+  if (!await finishMcpSetup(projectDir, mcpCommands)) return 1;
   log.ok(`DraftGo is ready at ${url}`);
   log.dim(`Project config: ${cfgPath}`);
   return 0;

package/src/localRuntime/services.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // Shared local runtime dependencies live outside individual projects. Project Compose
-// files only start DraftGo itself and connect back to these loopback services.
+// files run DraftGo and isolated Redis, then connect back to MySQL and Qdrant.
 const net = require('net');
 const os = require('os');
 const path = require('path');
@@ -16,17 +16,15 @@ const MYSQL_INIT_FILE = path.join(SERVICES_DIR, 'mysql-init.sql');
 
 const defaults = {
   mysql: { host: '127.0.0.1', port: 3306, user: 'draftgo', password: 'draftgo' },
-  redis: { host: '127.0.0.1', port: 6379, password: '' },
   qdrant: { host: '127.0.0.1', port: 26333, apiKey: '' },
 };
 
 function writeServiceFiles() {
   ensureDir(SERVICES_DIR);
   ensureDir(path.join(SERVICES_DIR, 'data', 'mysql'));
-  ensureDir(path.join(SERVICES_DIR, 'data', 'redis'));
   ensureDir(path.join(SERVICES_DIR, 'data', 'qdrant'));
   writeText(MYSQL_INIT_FILE, [
-    "GRANT ALL PRIVILEGES ON *.* TO 'draftgo'@'%' WITH GRANT OPTION;",
+    "GRANT ALL PRIVILEGES ON `draftgo\\_%`.* TO 'draftgo'@'%';",
     'FLUSH PRIVILEGES;',
     '',
   ].join('\n'));
@@ -54,20 +52,6 @@ function writeServiceFiles() {
     '      timeout: 5s',
     '      retries: 24',
     '      start_period: 20s',
-    '  redis:',
-    '    image: redis:7.4-alpine',
-    '    container_name: draftgo-local-redis',
-    '    restart: unless-stopped',
-    '    command: ["redis-server", "--appendonly", "yes"]',
-    '    ports:',
-    '      - "127.0.0.1:6379:6379"',
-    '    volumes:',
-    '      - ./data/redis:/data',
-    '    healthcheck:',
-    '      test: ["CMD", "redis-cli", "ping"]',
-    '      interval: 5s',
-    '      timeout: 5s',
-    '      retries: 20',
     '  qdrant:',
     '    image: qdrant/qdrant:v1.19.0',
     '    container_name: draftgo-local-qdrant',
@@ -97,26 +81,6 @@ function portOpen(host, port, timeoutMs = 800) {
   });
 }
 
-function probeRedis({ host, port, password = '' }) {
-  return new Promise((resolve) => {
-    const socket = net.createConnection({ host, port });
-    let response = '';
-    const finish = (ok) => { socket.destroy(); resolve(ok); };
-    socket.setTimeout(2000);
-    socket.once('connect', () => {
-      const auth = password ? `*2\r\n$4\r\nAUTH\r\n$${Buffer.byteLength(password)}\r\n${password}\r\n` : '';
-      socket.write(`${auth}*1\r\n$4\r\nPING\r\n`);
-    });
-    socket.on('data', (chunk) => {
-      response += chunk.toString('utf8');
-      if (response.includes('+PONG')) finish(true);
-      if (response.includes('-NOAUTH') || response.includes('-WRONGPASS') || response.includes('-ERR')) finish(false);
-    });
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-  });
-}
-
 function probeQdrant({ host, port, apiKey = '' }) {
   return new Promise((resolve) => {
     const client = String(host || '').startsWith('https://') ? https : http;
@@ -148,7 +112,6 @@ module.exports = {
   SERVICES_DIR,
   defaults,
   portOpen,
-  probeRedis,
   probeQdrant,
   startService,
 };