draftgo-cli 3.0.29 → 3.0.35

package/src/localdev/index.js

@@ -1,281 +1,181 @@
 'use strict';
 
-// Local-dev wizard: spin up a fresh DraftGo stack on the user's machine
-// using Docker, then guide them through finishing setup + generating a
-// Server Access Token (SAT) that powers `.draftgo/config.json`.
-//
-// High-level flow:
-//   1. Verify Docker + compose plugin are available.
-//   2. Decide what to do with MySQL / Redis (existing host service vs container).
-//      For host MySQL: validate creds and auto-create the database if missing.
-//   3. Ask for the app port and the compose project name (container prefix).
-//   4. Generate <project>/.draftgo/docker/{docker-compose.yaml, .env} with
-//      random secrets, gitignore the directory, and `docker compose up -d`.
-//   5. Wait until http://localhost:<port> responds.
-//   6. Print step-by-step browser instructions; prompt user to paste a SAT.
-//   7. Write .draftgo/config.json in the project dir and (optionally) run
-//      draftgo_init.py to pull initial project context.
-
 const { spawnSync } = require('child_process');
 const log = require('../logger');
 const { ask, askRequired, askPassword, confirm } = require('../prompt');
 const { probePort, probeHttp, detectDocker } = require('./detect');
 const compose = require('./compose');
-const { ensureDatabase, describeClient } = require('./mysqlClient');
+const { ensureDatabase, testConnection, describeClient } = require('./mysqlClient');
+const { defaults, portOpen, probeRedis, probeMilvus, startService } = require('./services');
 const { writeProjectConfig, maybeRunInit } = require('../projectConfig');
 const { appendGitignoreLine } = require('../fsx');
 
 const DEFAULT_APP_PORT = 3000;
 
-function printDockerInstallHelp() {
-  log.err('未检测到可用的 Docker。');
-  log.dim('  请先安装 Docker Desktop / Docker Engine：');
-  log.dim('    Windows / macOS: https://www.docker.com/products/docker-desktop/');
-  log.dim('    Linux:           https://docs.docker.com/engine/install/');
-  log.dim('  安装并启动 Docker 后，重新运行：draftgo local-dev');
+async function promptMysqlConnection() {
+  while (true) {
+    const host = await askRequired('  MySQL host', { default: '127.0.0.1' });
+    const port = Number(await askRequired('  MySQL port', { default: '3306' }));
+    const user = await askRequired('  MySQL user', { default: 'draftgo' });
+    const password = await askPassword('  MySQL password', { default: 'draftgo' });
+    const conn = { host, port, user, password };
+    const result = testConnection(conn);
+    if (result.ok) return conn;
+    log.err(`  MySQL connection failed: ${(result.detail || result.reason || 'unknown error').split('\n')[0]}`);
+  }
 }
 
-// ── MySQL ──────────────────────────────────────────────────────────────────
-
-async function planMysql() {
-  // Returns: { useContainer, host, port, user, password, database }
-  log.step('检查 MySQL');
-  const open = await probePort('127.0.0.1', 3306);
-  if (open) {
-    log.ok('  在 127.0.0.1:3306 发现监听中的服务');
-    const reuse = await confirm('  使用已有的 MySQL？', { default: true });
-    if (reuse) {
-      // Collect credentials and validate them in a loop so the user can
-      // recover from typos / missing database without restarting the wizard.
-      while (true) {
-        const host = await ask('  Host', { default: '127.0.0.1' });
-        const port = await ask('  Port', { default: '3306' });
-        const database = await askRequired('  Database（不存在会尝试自动创建）', { default: 'draftgo' });
-        const user = await askRequired('  User', { default: 'draftgo' });
-        const password = await askPassword('  Password');
-        const conn = { host, port: Number(port), user, password, database };
-
-        const verified = await verifyAndEnsureDatabase(conn);
-        if (verified) return { useContainer: false, ...conn };
-      }
-    }
-  } else {
-    log.dim('  未检测到本地 MySQL，将通过 Docker 容器提供');
+async function ensureProjectDatabase(conn, database) {
+  while (true) {
+    const result = await ensureDatabase({ ...conn, database }, {
+      rootPromptFn: async () => {
+        log.warn(`  ${conn.user} cannot create database ${database}.`);
+        if (!await confirm('  Create it with another MySQL account?', { default: true })) return null;
+        return {
+          user: await askRequired('  MySQL admin user', { default: 'root' }),
+          password: await askPassword('  MySQL admin password'),
+        };
+      },
+    });
+    if (result.ok) return { ...conn, database };
+    log.err(`  Database setup failed: ${(result.detail || result.reason || 'unknown error').split('\n')[0]}`);
+    const retry = await confirm('  Re-enter MySQL connection settings?', { default: true });
+    if (!retry) throw new Error('MySQL database was not prepared.');
+    conn = await promptMysqlConnection();
   }
-  return { useContainer: true };
 }
 
-// Validate user-supplied MySQL credentials, auto-creating the database if
-// missing. Returns true on success. On failure, prints a helpful message and
-// returns false so the caller can re-prompt.
-async function verifyAndEnsureDatabase(conn) {
-  log.step('  验证 MySQL 连接 / 数据库…');
-  log.dim(`    using ${describeClient()}`);
-  const res = await ensureDatabase(conn, {
-    rootPromptFn: async () => {
-      log.warn(`    账号 ${conn.user} 没有创建数据库的权限。`);
-      const ok = await confirm('    用 root 账号自动建库并授权？', { default: true });
-      if (!ok) return null;
-      const rootUser = await ask('    root 用户名', { default: 'root' });
-      const rootPass = await askPassword('    root 密码');
-      return { user: rootUser, password: rootPass };
-    },
-  });
+async function planMysql(docker, defaultDatabase) {
+  log.step('Checking MySQL');
+  let conn = { ...defaults.mysql };
+  if (!await portOpen(conn.host, conn.port)) {
+    log.dim('  MySQL is not running locally; starting the shared local service.');
+    if (!startService(docker, 'mysql')) throw new Error('Unable to start shared MySQL.');
+  }
+  if (!testConnection(conn).ok) {
+    log.warn('  Default MySQL credentials were not accepted.');
+    conn = await promptMysqlConnection();
+  }
+  const database = await askRequired('  Project database name', { default: defaultDatabase });
+  const out = await ensureProjectDatabase(conn, database);
+  log.ok(`  MySQL ready: ${out.host}:${out.port}/${out.database} (${describeClient()})`);
+  return out;
+}
 
-  if (res.ok) {
-    if (res.mode === 'existed')      log.ok(`    数据库 \`${conn.database}\` 已存在，连接正常`);
-    else if (res.mode === 'created') log.ok(`    数据库 \`${conn.database}\` 已自动创建（utf8mb4）`);
-    else                             log.ok(`    数据库 \`${conn.database}\` 已由 root 创建并授权 ${conn.user}`);
-    return true;
+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.');
   }
+}
 
-  switch (res.reason) {
-    case 'no-client':
-      log.warn('    未找到 mysql 客户端，也没有 Docker，跳过数据库自动创建。');
-      log.dim('    请确保数据库已存在，否则首次启动会失败。');
-      return true;
-    case 'auth':
-      log.err('    认证失败：用户名或密码不正确。');
-      break;
-    case 'unreachable':
-      log.err('    无法连接到 MySQL：' + (res.detail || '').split('\n')[0]);
-      break;
-    case 'create-failed':
-      log.err('    建库失败：' + (res.detail || '').split('\n')[0]);
-      break;
-    default:
-      log.err('    校验失败：' + (res.detail || res.reason));
+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.');
   }
-  const retry = await confirm('    是否重新输入？', { default: true });
-  if (!retry) {
-    log.warn('    跳过校验，继续。后续启动若失败请检查 MySQL 配置。');
-    return true;
+  if (!await probeRedis(conn)) {
+    log.warn('  Default passwordless Redis PING failed.');
+    conn = await promptRedisConnection();
   }
-  return false;
+  log.ok(`  Redis ready: ${conn.host}:${conn.port}`);
+  return conn;
 }
 
-// ── Redis ──────────────────────────────────────────────────────────────────
-
-async function planRedis() {
-  log.step('检查 Redis');
-  const open = await probePort('127.0.0.1', 6379);
-  if (open) {
-    log.ok('  在 127.0.0.1:6379 发现监听中的服务');
-    const reuse = await confirm('  使用已有的 Redis？', { default: true });
-    if (reuse) {
-      const host = await ask('  Host', { default: '127.0.0.1' });
-      const port = await ask('  Port', { default: '6379' });
-      const password = await askPassword('  Password（无密码直接回车）', { default: '' });
-      return { useContainer: false, host, port: Number(port), password };
-    }
-  } else {
-    log.dim('  未检测到本地 Redis，将通过 Docker 容器提供');
+async function promptMilvusConnection() {
+  while (true) {
+    const host = await askRequired('  Milvus host', { default: '127.0.0.1' });
+    const port = Number(await askRequired('  Milvus port', { default: '19530' }));
+    const username = await ask('  Milvus username (empty for none)', { default: '' });
+    const password = await askPassword('  Milvus password (empty for none)', { default: '' });
+    const conn = { host, port, username, password };
+    if (await probeMilvus(conn)) return conn;
+    log.err('  Milvus health check failed. Check the address and credentials.');
   }
-  return { useContainer: true };
 }
 
-// ── App port + project name ────────────────────────────────────────────────
+async function planMilvus(docker) {
+  log.step('Checking Milvus');
+  let conn = { ...defaults.milvus };
+  if (!await portOpen(conn.host, conn.port)) {
+    log.dim('  Milvus is not running locally; starting the shared local service.');
+    if (!startService(docker, 'milvus')) throw new Error('Unable to start shared Milvus.');
+  }
+  if (!await probeMilvus(conn)) {
+    log.warn('  Default unauthenticated Milvus health check failed.');
+    conn = await promptMilvusConnection();
+  }
+  log.ok(`  Milvus ready: ${conn.host}:${conn.port}`);
+  return conn;
+}
 
 async function pickAppPort() {
-  // Always let the user pick; default to 3000 unless taken (then suggest 3001).
-  log.step('选择 DraftGo 暴露端口');
-  const taken3000 = await probePort('127.0.0.1', DEFAULT_APP_PORT);
-  let suggested = String(DEFAULT_APP_PORT);
-  if (taken3000) {
-    log.warn(`  ${DEFAULT_APP_PORT} 已被占用，默认改用 3001`);
-    suggested = '3001';
-  }
+  const taken = await probePort('127.0.0.1', DEFAULT_APP_PORT);
+  const suggested = taken ? '3001' : String(DEFAULT_APP_PORT);
   while (true) {
-    const v = await askRequired('  DraftGo 宿主端口', { default: suggested });
-    const n = Number(v);
-    if (!Number.isInteger(n) || n <= 0 || n > 65535) {
-      log.dim('  端口需为 1-65535 的整数');
-      continue;
-    }
-    if (await probePort('127.0.0.1', n)) {
-      const reuse = await confirm(`  ${n} 当前被占用，仍然使用？`, { default: false });
-      if (!reuse) continue;
-    }
-    return n;
+    const port = Number(await askRequired('  DraftGo host port', { default: suggested }));
+    if (!Number.isInteger(port) || port < 1 || port > 65535) continue;
+    if (!await probePort('127.0.0.1', port)) return port;
+    if (await confirm(`  Port ${port} is in use. Use it anyway?`, { default: false })) return port;
   }
 }
 
 async function pickProjectName() {
-  // The compose `name:` field becomes the container prefix (e.g. draftgo-app-1).
-  // Default `draftgo`; users with multiple stacks can pick anything matching
-  // docker-compose's identifier rules.
-  log.step('选择容器名前缀');
   while (true) {
-    const raw = await askRequired('  容器名前缀 (compose project name)', { default: 'draftgo' });
+    const raw = await askRequired('  Project container prefix', { default: 'draftgo' });
     const clean = compose.sanitizeProjectName(raw, '');
-    if (!clean) {
-      log.dim('  名称需以字母/数字开头，可包含字母数字、下划线、连字符');
-      continue;
-    }
-    if (clean !== raw.toLowerCase()) {
-      log.dim(`  已规范化为：${clean}`);
-    }
-    return clean;
+    if (clean) return clean;
   }
 }
 
-// ── Compose lifecycle ──────────────────────────────────────────────────────
-
 function composeUp(docker, dir) {
-  log.step('启动容器（docker compose up -d）…');
-  const args = [...docker.composeArgs, '-f', 'docker-compose.yaml', 'up', '-d'];
-  const r = spawnSync(docker.composeCmd, args, {
-    cwd: dir,
-    stdio: 'inherit',
-    shell: false,
+  const result = spawnSync(docker.composeCmd, [...docker.composeArgs, '-f', 'docker-compose.yaml', 'up', '-d'], {
+    cwd: dir, stdio: 'inherit', shell: false,
   });
-  return r.status === 0;
+  return result.status === 0;
 }
 
 async function waitForApp(appPort) {
-  log.step(`等待 DraftGo 启动 (http://localhost:${appPort}) …`);
   const ok = await probeHttp(`http://127.0.0.1:${appPort}/`, { totalMs: 120000, intervalMs: 2000 });
-  if (!ok) {
-    log.err('  等待超时。可在 .draftgo/docker/ 下运行 `docker compose logs app` 排查。');
-    return false;
-  }
-  log.ok('  DraftGo 已就绪');
-  return true;
+  if (!ok) log.err('  Timed out waiting for DraftGo. Run `draftgo local logs` to inspect the app.');
+  return ok;
 }
 
-// ── Main wizard ────────────────────────────────────────────────────────────
-
 async function runWizard(projectDir, { yes = false } = {}) {
-  log.title('draftgo local-dev — 一键本地部署');
-  log.plain('适用于尚未部署 DraftGo 基座的用户。流程：');
-  log.dim('  1) 检测 / 询问 MySQL、Redis 配置（不存在的库会自动创建）');
-  log.dim('  2) 在 <项目>/.draftgo/docker/ 生成 docker-compose.yaml（密钥随机）');
-  log.dim('  3) docker compose up -d 启动 DraftGo');
-  log.dim('  4) 浏览器完成初始化 → 系统设置生成访问令牌 → 回到这里粘贴');
+  log.title('draftgo local setup');
+  if (!yes && !await confirm('Continue with local DraftGo setup?', { default: true })) return 0;
 
-  if (!yes) {
-    const cont = await confirm('\n是否继续？', { default: true });
-    if (!cont) { log.dim('已取消。'); return 0; }
-  }
-
-  // 1) Docker availability
   const docker = detectDocker();
   if (!docker.ok) {
-    if (docker.reason === 'compose-missing') {
-      log.err('检测到 docker 但缺少 compose 插件。请安装 docker compose v2 或 docker-compose。');
-    } else {
-      printDockerInstallHelp();
-    }
-    return 1;
+    throw new Error(docker.reason === 'compose-missing'
+      ? 'Docker is installed but Docker Compose is unavailable.'
+      : 'Docker is required to start missing local dependencies.');
   }
-  log.ok(`Docker 可用：${docker.composeCmd} ${docker.composeArgs.join(' ')}`.trim());
 
-  // 2) Plan services
-  const mysql = await planMysql();
-  const redis = await planRedis();
   const appPort = await pickAppPort();
   const projectName = await pickProjectName();
+  const mysql = await planMysql(docker, projectName);
+  const redis = await planRedis(docker);
+  const milvus = await planMilvus(docker);
 
-  // 3) Generate compose + .env (random secrets, persisted across re-runs)
-  log.step('生成 docker-compose.yaml');
-  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis });
-  // Keep the stack (secrets + bind-mount data) out of git.
+  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis, milvus });
   appendGitignoreLine(projectDir, '.draftgo/docker/');
-  log.ok(`  写入 ${out.composeFile}`);
-  log.dim(`  密钥保存在 ${out.envFile}（已随机生成，请勿外传，已加入 .gitignore）`);
-  log.dim(`  容器名：${out.projectName} / ${out.projectName}-mysql / ${out.projectName}-redis`);
-
-  // 4) Bring stack up + wait for the app
-  if (!composeUp(docker, out.dir)) {
-    log.err('docker compose 启动失败。请检查上方输出，确认 Docker 已运行。');
-    return 1;
-  }
-  if (!await waitForApp(appPort)) return 1;
+  if (!composeUp(docker, out.dir) || !await waitForApp(appPort)) return 1;
 
-  // 5) Guide user to finish initial setup and mint a SAT
   const url = `http://localhost:${appPort}`;
-  log.title('下一步：在浏览器完成初始化');
-  log.plain(`  1) 打开 ${log.c.cyan(url)}`);
-  log.plain('  2) 按页面提示创建管理员账号 / 完成首次设置');
-  log.plain('  3) 进入「系统设置 → 访问令牌 (SAT)」，生成一个新令牌并复制');
-  log.plain('  4) 回到这里把令牌粘贴下来\n');
-
-  const token = await askRequired('请粘贴访问令牌 (SAT)', {
-    validate: (v) => v.length < 10 ? 'token 看起来太短了，请检查后重试' : '',
+  const token = await askRequired('Paste a DraftGo system access token (SAT)', {
+    validate: (value) => value.length < 10 ? 'Token appears too short.' : '',
   });
-
-  // 6) Persist project config and (optionally) bootstrap local context
   const cfgPath = writeProjectConfig(projectDir, url, token);
-  log.ok(`已写入 ${cfgPath}`);
   maybeRunInit(projectDir, url, token);
-
-  log.title('完成');
-  log.plain(`  - DraftGo:        ${url}`);
-  log.plain(`  - 配置文件:        ${cfgPath}`);
-  log.plain(`  - Compose 项目:    ${out.dir}`);
-  log.plain(`  - 容器名前缀:      ${out.projectName}`);
-  log.dim(`  停止：cd "${out.dir}" && docker compose down`);
-  log.dim(`  升级：cd "${out.dir}" && docker compose pull && docker compose up -d`);
+  log.ok(`DraftGo is ready at ${url}`);
+  log.dim(`Project config: ${cfgPath}`);
   return 0;
 }
 

package/src/localdev/mysqlClient.js

@@ -75,6 +75,15 @@ function runSQL(client, conn, sql) {
   return { ok: r.status === 0, stdout: r.stdout || '', stderr: r.stderr || '', code: r.status };
 }
 
+function testConnection(conn) {
+  const client = pickClient();
+  if (!client) return { ok: false, reason: 'no-client' };
+  const probe = runSQL(client, conn, 'SELECT 1');
+  if (probe.ok) return { ok: true };
+  const why = classifyError(probe.stderr);
+  return { ok: false, reason: why === 'auth' ? 'auth' : 'unreachable', detail: probe.stderr.trim() };
+}
+
 function classifyError(stderr) {
   const s = (stderr || '').toLowerCase();
   if (s.includes('access denied')) return 'auth';
@@ -98,14 +107,8 @@ function escIdent(name) {
 // privilege; it should resolve to `{ user, password }` (or null to abort).
 async function ensureDatabase(conn, { rootPromptFn } = {}) {
   const client = pickClient();
-  if (!client) return { ok: false, reason: 'no-client' };
-
-  // 1) Connectivity + auth probe.
-  const probe = runSQL(client, conn, 'SELECT 1');
-  if (!probe.ok) {
-    const why = classifyError(probe.stderr);
-    return { ok: false, reason: why === 'auth' ? 'auth' : 'unreachable', detail: probe.stderr.trim() };
-  }
+  const connected = testConnection(conn);
+  if (!client || !connected.ok) return connected;
 
   // 2) Does the database already exist?
   const showSQL = `SHOW DATABASES LIKE '${String(conn.database).replace(/'/g, "''")}'`;
@@ -149,4 +152,4 @@ function describeClient() {
   return c.kind === 'native' ? 'native mysql client' : 'docker mysql:8.0';
 }
 
-module.exports = { ensureDatabase, describeClient };
+module.exports = { ensureDatabase, testConnection, describeClient };

package/src/localdev/services.js

@@ -0,0 +1,163 @@
+'use strict';
+
+// Shared local dependencies live outside individual projects. Project Compose
+// files only start DraftGo itself and connect back to these loopback services.
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { ensureDir, writeText } = require('../fsx');
+
+const SERVICES_DIR = path.join(os.homedir(), '.draftgo', 'local-services');
+const COMPOSE_FILE = path.join(SERVICES_DIR, 'docker-compose.yaml');
+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: '' },
+  milvus: { host: '127.0.0.1', port: 19530, username: '', password: '' },
+};
+
+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', 'milvus'));
+  writeText(MYSQL_INIT_FILE, [
+    "GRANT ALL PRIVILEGES ON *.* TO 'draftgo'@'%' WITH GRANT OPTION;",
+    'FLUSH PRIVILEGES;',
+    '',
+  ].join('\n'));
+  writeText(COMPOSE_FILE, [
+    'name: draftgo-local-services',
+    'services:',
+    '  mysql:',
+    '    image: mysql:8.0',
+    '    container_name: draftgo-local-mysql',
+    '    restart: unless-stopped',
+    '    command: ["--character-set-server=utf8mb4", "--collation-server=utf8mb4_unicode_ci"]',
+    '    environment:',
+    '      MYSQL_ROOT_PASSWORD: draftgo',
+    '      MYSQL_DATABASE: draftgo_bootstrap',
+    '      MYSQL_USER: draftgo',
+    '      MYSQL_PASSWORD: draftgo',
+    '    ports:',
+    '      - "127.0.0.1:3306:3306"',
+    '    volumes:',
+    '      - ./data/mysql:/var/lib/mysql',
+    '      - ./mysql-init.sql:/docker-entrypoint-initdb.d/01-grants.sql:ro',
+    '    healthcheck:',
+    '      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-pdraftgo"]',
+    '      interval: 5s',
+    '      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',
+    '  milvus:',
+    '    image: milvusdb/milvus:v2.6.0',
+    '    container_name: draftgo-local-milvus',
+    '    restart: unless-stopped',
+    '    command: ["milvus", "run", "standalone"]',
+    '    security_opt:',
+    '      - seccomp:unconfined',
+    '    environment:',
+    '      DEPLOY_MODE: STANDALONE',
+    '      ETCD_USE_EMBED: "true"',
+    '      ETCD_DATA_DIR: /var/lib/milvus/etcd',
+    '      COMMON_STORAGETYPE: local',
+    '    ports:',
+    '      - "127.0.0.1:19530:19530"',
+    '    volumes:',
+    '      - ./data/milvus:/var/lib/milvus',
+    '    healthcheck:',
+    '      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]',
+    '      interval: 10s',
+    '      timeout: 5s',
+    '      retries: 18',
+    '      start_period: 30s',
+    '',
+  ].join('\n'));
+}
+
+function portOpen(host, port, timeoutMs = 800) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host, port });
+    const finish = (ok) => { socket.destroy(); resolve(ok); };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+  });
+}
+
+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 probeMilvus({ host, port, username = '', password = '' }) {
+  return new Promise((resolve) => {
+    const grpc = require('@grpc/grpc-js');
+    const client = new grpc.Client(`${host}:${port}`, grpc.credentials.createInsecure());
+    const metadata = new grpc.Metadata();
+    if (username || password) metadata.add('authorization', `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`);
+    client.makeUnaryRequest(
+      '/milvus.proto.milvus.MilvusService/CheckHealth',
+      (value) => value,
+      (value) => value,
+      Buffer.alloc(0),
+      metadata,
+      { deadline: Date.now() + 4000 },
+      (err, response) => {
+        client.close();
+        // CheckHealthResponse starts with field 1 (is_healthy) when the server is healthy.
+        resolve(!err && Buffer.isBuffer(response) && response.includes(0x01));
+      },
+    );
+  });
+}
+
+function startService(docker, service) {
+  writeServiceFiles();
+  const result = spawnSync(docker.composeCmd, [
+    ...docker.composeArgs, '-f', COMPOSE_FILE, 'up', '-d', '--wait', service,
+  ], { cwd: SERVICES_DIR, stdio: 'inherit', shell: false });
+  return result.status === 0;
+}
+
+module.exports = {
+  SERVICES_DIR,
+  defaults,
+  portOpen,
+  probeRedis,
+  probeMilvus,
+  startService,
+};

package/src/projectConfig.js

@@ -40,7 +40,7 @@ function maybeRunInit(projectDir, server, token) {
   const py = findPython();
   if (!py) {
     log.dim('  未检测到 Python，跳过自动初始化项目上下文。');
-    log.dim('  安装 Python 3.9+ 后，可让 AI 工具调用其内部 draftgo_init.py 完成初始化。');
+    log.dim('  安装 Python 3.9+ 后运行 `draftgo pull` 获取项目资源。');
     return false;
   }
   const script = findInitScript(projectDir);