draftgo-cli 3.0.56 → 4.0.22

package/src/{localdev → localRuntime}/index.js

@@ -2,11 +2,11 @@
 
 const { spawnSync } = require('child_process');
 const log = require('../logger');
-const { ask, askRequired, askPassword, confirm } = require('../prompt');
+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, probeMilvus, startService } = require('./services');
+const { defaults, portOpen, probeRedis, probeQdrant, startService } = require('./services');
 const { writeProjectConfig } = require('../projectConfig');
 const { appendGitignoreLine } = require('../fsx');
 
@@ -88,30 +88,29 @@ async function planRedis(docker) {
   return conn;
 }
 
-async function promptMilvusConnection() {
+async function promptQdrantConnection() {
   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.');
+    const host = await askRequired('  Qdrant host', { default: '127.0.0.1' });
+    const port = Number(await askRequired('  Qdrant port', { default: '26333' }));
+    const apiKey = await askPassword('  Qdrant API key (empty for none)', { default: '' });
+    const conn = { host, port, apiKey };
+    if (await probeQdrant(conn)) return conn;
+    log.err('  Qdrant REST health check failed. Check the address and API key.');
   }
 }
 
-async function planMilvus(docker) {
-  log.step('Checking Milvus');
-  let conn = { ...defaults.milvus };
+async function planQdrant(docker) {
+  log.step('Checking Qdrant');
+  let conn = { ...defaults.qdrant };
   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.');
+    log.dim('  Qdrant is not running locally; starting the shared local service.');
+    if (!startService(docker, 'qdrant')) throw new Error('Unable to start shared Qdrant.');
   }
-  if (!await probeMilvus(conn)) {
-    log.warn('  Default unauthenticated Milvus health check failed.');
-    conn = await promptMilvusConnection();
+  if (!await probeQdrant(conn)) {
+    log.warn('  Default unauthenticated Qdrant REST health check failed.');
+    conn = await promptQdrantConnection();
   }
-  log.ok(`  Milvus ready: ${conn.host}:${conn.port}`);
+  log.ok(`  Qdrant ready: ${conn.host}:${conn.port}`);
   return conn;
 }
 
@@ -190,17 +189,17 @@ async function runWizard(projectDir, { yes = false, mcpCommands } = {}) {
   const projectName = await pickProjectName();
   const mysql = await planMysql(docker, projectName);
   const redis = await planRedis(docker);
-  const milvus = await planMilvus(docker);
+  const qdrant = await planQdrant(docker);
 
-  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis, milvus });
+  const out = compose.generate(projectDir, { projectName, appPort, mysql, redis, qdrant });
   appendGitignoreLine(projectDir, '.draftgo/docker/');
   if (!composeUp(docker, out.dir) || !await waitForApp(appPort)) return 1;
 
   const url = `http://localhost:${appPort}`;
   let token = '';
   while (token.length < 10) {
-    token = String(await askPassword('Paste a DraftGo system access token (SAT)')).trim();
-    if (token.length < 10) log.err('  Token appears too short. Please try again.');
+    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);

package/src/{localdev → localRuntime}/mysqlClient.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// Lightweight MySQL helper used by the local-dev wizard to validate
+// Lightweight MySQL helper used by the local stack wizard to validate
 // credentials and auto-create the project database when missing.
 //
 // We avoid taking a JS MySQL driver as a dependency. Instead we shell out

package/src/{localdev → localRuntime}/services.js

@@ -1,10 +1,12 @@
 'use strict';
 
-// Shared local dependencies live outside individual projects. Project Compose
+// Shared local runtime 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 http = require('http');
+const https = require('https');
 const { spawnSync } = require('child_process');
 const { ensureDir, writeText } = require('../fsx');
 
@@ -15,14 +17,14 @@ 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: '' },
+  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', 'milvus'));
+  ensureDir(path.join(SERVICES_DIR, 'data', 'qdrant'));
   writeText(MYSQL_INIT_FILE, [
     "GRANT ALL PRIVILEGES ON *.* TO 'draftgo'@'%' WITH GRANT OPTION;",
     'FLUSH PRIVILEGES;',
@@ -66,27 +68,19 @@ function writeServiceFiles() {
     '      interval: 5s',
     '      timeout: 5s',
     '      retries: 20',
-    '  milvus:',
-    '    image: milvusdb/milvus:v2.6.0',
-    '    container_name: draftgo-local-milvus',
+    '  qdrant:',
+    '    image: qdrant/qdrant:v1.19.0',
+    '    container_name: draftgo-local-qdrant',
     '    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"',
+    '      - "127.0.0.1:26333:6333"',
     '    volumes:',
-    '      - ./data/milvus:/var/lib/milvus',
+    '      - ./data/qdrant:/qdrant/storage',
     '    healthcheck:',
-    '      test: ["CMD", "curl", "-f", "http://localhost:9091/healthz"]',
+    '      test: ["CMD-SHELL", "bash -c \':> /dev/tcp/127.0.0.1/6333\'"]',
     '      interval: 10s',
     '      timeout: 5s',
-    '      retries: 18',
+    '      retries: 12',
     '      start_period: 30s',
     '',
   ].join('\n'));
@@ -123,25 +117,22 @@ function probeRedis({ host, port, password = '' }) {
   });
 }
 
-function probeMilvus({ host, port, username = '', password = '' }) {
+function probeQdrant({ host, port, apiKey = '' }) {
   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));
-      },
-    );
+    const client = String(host || '').startsWith('https://') ? https : http;
+    const hostname = String(host || '').replace(/^https?:\/\//, '');
+    const request = client.get({
+      hostname,
+      port,
+      path: '/healthz',
+      headers: apiKey ? { 'api-key': apiKey } : undefined,
+      timeout: 4000,
+    }, (response) => {
+      response.resume();
+      resolve(response.statusCode >= 200 && response.statusCode < 300);
+    });
+    request.once('timeout', () => { request.destroy(); resolve(false); });
+    request.once('error', () => resolve(false));
   });
 }
 
@@ -158,6 +149,6 @@ module.exports = {
   defaults,
   portOpen,
   probeRedis,
-  probeMilvus,
+  probeQdrant,
   startService,
 };

package/src/mcp/client.js

@@ -184,7 +184,7 @@ class DraftGoMcpClient {
   constructor(config, options = {}) {
     if (!config || typeof config !== 'object') throw new TypeError('DraftGo MCP config is required.');
     const token = String(config.token || config.sat || '').trim();
-    if (!token) throw new Error('DraftGo MCP config is missing SAT.');
+    if (!token) throw new Error('DraftGo MCP config is missing API Key.');
     if (!config.server && !config.mcp_url) throw new Error('DraftGo MCP config is missing server.');
 
     this.config = { ...config, token };
@@ -453,7 +453,7 @@ class DraftGoMcpClient {
     })).filter((entry) => entry.tool);
     const byCanonical = Object.fromEntries(selected.map((entry) => [entry.canonical, entry.tool]));
     const overrideCanonical = safeTools.find((canonical) => toolMatches(firstSafeTool.name, canonical));
-    const defaultPlan = hasDiagnosticOverrides ? [{
+    let defaultPlan = hasDiagnosticOverrides ? [{
       label: overrideCanonical,
       canonical: overrideCanonical,
       tool: firstSafeTool,
@@ -473,6 +473,15 @@ class DraftGoMcpClient {
         args: { resource_type: 'db_meta', limit: 100 },
       },
     ];
+    const spaceScope = options.scopeType === 'space' && Number(options.spaceId) > 0
+      ? { scope_type: 'space', space_id: Number(options.spaceId) }
+      : {};
+    if (!hasDiagnosticOverrides && !spaceScope.scope_type) {
+      defaultPlan = defaultPlan.filter(entry => entry.label !== 'resource:docs/articles');
+    }
+    for (const entry of defaultPlan) {
+      if (entry.label === 'resource:docs/articles') entry.args = { ...entry.args, ...spaceScope };
+    }
     const runPlan = (plan, startIndex = 0) => allWithAbort(plan.map((entry, offset) =>
       async (queryOptions) => {
         if (typeof options.onStage === 'function') options.onStage(`tools/call:${entry.label}`, 'started');

package/src/mcp/protocol.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const DEFAULT_PROTOCOL_VERSION = '2025-06-18';
+const DEFAULT_PROTOCOL_VERSION = '2026-07-28';
 
 class McpHttpError extends Error {
   constructor(message, { status = 0, rpc = null, code = null } = {}) {
@@ -34,7 +34,7 @@ function endpointFor(config) {
     ...((config.mcp_allowed_origins || []).map((value) => new URL(value).origin)),
   ]);
   if (!allowedOrigins.has(endpoint.origin)) {
-    throw new McpHttpError('DraftGo MCP endpoint origin is not allowlisted; refusing to send the SAT.');
+    throw new McpHttpError('DraftGo MCP endpoint origin is not allowlisted; refusing to send the API Key.');
   }
   return endpoint.toString();
 }

package/src/mcp/tools.js

@@ -35,6 +35,19 @@ async function openToolSession(config, expected = [], options = {}) {
   return { client, tools, names };
 }
 
+function configuredScope(config, description = null) {
+  const operation = description && (description.operation || description) || {};
+  if (String(operation.ownership_mode || '').toLowerCase() === 'platform_only') return {};
+  const supported = Array.isArray(operation.supported_scopes)
+    ? operation.supported_scopes.map(value => String(value).toLowerCase()) : [];
+  const needsSpace = String(operation.ownership_mode || '').toLowerCase() === 'workspace_required'
+    && supported.length > 0 && !supported.includes('platform');
+  if (config && config.scope_type === 'space' && Number(config.space_id) > 0 && (needsSpace || supported.includes('space'))) {
+    return { scope_type: 'space', space_id: Number(config.space_id) };
+  }
+  return {};
+}
+
 async function callStructured(session, expectedName, args = {}, options = {}) {
   const name = session.names[expectedName] || expectedName;
   const result = await session.client.toolsCall(name, args, options);
@@ -44,4 +57,4 @@ async function callStructured(session, expectedName, args = {}, options = {}) {
     : data;
 }
 
-module.exports = { TOOL_NAMES, openToolSession, callStructured };
+module.exports = { TOOL_NAMES, openToolSession, callStructured, configuredScope };

package/src/platforms.js

@@ -94,6 +94,15 @@ const platforms = [
     signals: ['.gemini', 'GEMINI.md'],
     frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
   },
+  {
+    name: 'pi',
+    displayName: 'Pi',
+    mainFile: '.agents/skills/draftgo/SKILL.md',
+    assetDir: '.agents/skills/draftgo',
+    skillDir: '.agents/skills/draftgo',
+    signals: ['.agents/skills', '.pi'],
+    frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
+  },
 ];
 
 const byName = Object.fromEntries(platforms.map((p) => [p.name, p]));

package/src/projectConfig.js

@@ -9,6 +9,8 @@ const IGNORE_ENTRIES = [
   '.draftgo/token',
   '.draftgo/worktree/',
   '.draftgo/conflicts/',
+	'.draftgo/api-contract-cache.json',
+	'.draftgo/api-contract-cache.json.lock',
 ];
 
 function parseHttpUrl(raw) {
@@ -93,16 +95,18 @@ function writePrivateJson(file, value) {
 
 function writeProjectConfig(projectDir, server, token, options = {}) {
   const normalizedServer = normalizeServer(server);
-  const sat = String(token || '').trim();
+  const apiKey = String(token || '').trim();
   if (!normalizedServer) throw new Error('DraftGo server is required.');
-  if (!sat) throw new Error('DraftGo SAT is required.');
+  if (!apiKey) throw new Error('DraftGo API Key is required.');
   const existing = readExisting(projectDir);
   const config = {
     ...existing,
     server: normalizedServer,
-    token: sat,
+    token: apiKey,
     auto_push: existing.auto_push === true,
   };
+  if (options.scope_type) config.scope_type = String(options.scope_type).trim().toLowerCase();
+  if (options.space_id) config.space_id = Number(options.space_id);
   if (options.mcp_url) config.mcp_url = normalizeMcpEndpoint(options.mcp_url);
   else delete config.mcp_url;
   const file = configPath(projectDir);
@@ -119,7 +123,7 @@ function loadProjectConfig(projectDir, { requireToken = true } = {}) {
   const mcpUrl = config.mcp_url ? normalizeMcpEndpoint(config.mcp_url) : '';
   const token = String(config.token || config.sat || '').trim();
   if (!server) throw new Error('DraftGo project config is missing server.');
-  if (requireToken && !token) throw new Error('DraftGo project config is missing SAT.');
+  if (requireToken && !token) throw new Error('DraftGo project config is missing API Key.');
   const result = { ...config, server, token, path: file };
   if (mcpUrl) result.mcp_url = mcpUrl;
   else delete result.mcp_url;

package/src/releaseInstall.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { PACKAGE_ROOT } = require('./paths');
+
+const MARKER = '.draftgo-install.json';
+const REPO = process.env.DRAFTGO_REPO || 'draftgo/draftgo-cli';
+const BASE_URL = process.env.DRAFTGO_INSTALL_BASE_URL || 'https://draftgo.cn/draftgo-cli';
+const MIRROR = process.env.DRAFTGO_GITHUB_MIRROR || `https://ghproxy.net/https://github.com/${REPO}/releases/download`;
+
+function readInstallMarker() {
+  try {
+    const marker = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, MARKER), 'utf8'));
+    if (!marker.installRoot || !marker.binDir) return null;
+    return { installRoot: path.resolve(marker.installRoot), binDir: path.resolve(marker.binDir) };
+  } catch { return null; }
+}
+
+function download(url, output, timeoutMs = 15000, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(new Error('Too many download redirects.'));
+    const parsed = new URL(url);
+    const transport = parsed.protocol === 'http:' ? http : https;
+    const req = transport.get(parsed, { timeout: timeoutMs, headers: { 'user-agent': 'draftgo-cli' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        return resolve(download(new URL(res.headers.location, parsed).toString(), output, timeoutMs, redirects + 1));
+      }
+      if (res.statusCode !== 200) { res.resume(); return reject(new Error(`HTTP ${res.statusCode}`)); }
+      const stream = fs.createWriteStream(output, { flags: 'wx' });
+      stream.on('error', reject);
+      res.on('error', reject);
+      stream.on('finish', () => stream.close(() => resolve(url)));
+      res.pipe(stream);
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('Download timed out.')));
+  });
+}
+
+async function downloadFirst(urls, output) {
+  const errors = [];
+  for (const url of urls) {
+    try { return { url: await download(url, output), output }; }
+    catch (error) { errors.push(`${url}: ${error.message}`); try { fs.rmSync(output, { force: true }); } catch {} }
+  }
+  throw new Error(`Unable to download DraftGo release.\n${errors.join('\n')}`);
+}
+
+function hashFile(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function writeLauncher(binDir, packageDir) {
+  fs.mkdirSync(binDir, { recursive: true });
+  if (process.platform === 'win32') {
+    const launcher = path.join(binDir, 'draftgo.cmd');
+    fs.writeFileSync(launcher, `@echo off\r\nnode "${path.join(packageDir, 'bin', 'draftgo.js')}" %*\r\n`, 'ascii');
+    return launcher;
+  }
+  const launcher = path.join(binDir, 'draftgo');
+  fs.writeFileSync(launcher, `#!/usr/bin/env sh\nexec node "${path.join(packageDir, 'bin', 'draftgo.js')}" "$@"\n`, { mode: 0o755 });
+  fs.chmodSync(launcher, 0o755);
+  return launcher;
+}
+
+async function installRelease(version, expectedSha, marker = readInstallMarker()) {
+  if (!marker) return null;
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(String(version))) throw new Error('Invalid release version.');
+  fs.mkdirSync(marker.installRoot, { recursive: true });
+  const tempDir = fs.mkdtempSync(path.join(marker.installRoot, '.update-'));
+  const archive = path.join(tempDir, `draftgo-cli-${version}.tgz`);
+  const asset = path.basename(archive);
+  const urls = [`${BASE_URL}/${asset}`, `${MIRROR}/v${version}/${asset}`, `https://github.com/${REPO}/releases/download/v${version}/${asset}`];
+  try {
+    const downloaded = await downloadFirst(urls, archive);
+    let checksum = expectedSha;
+    if (!checksum) {
+      const checksumFile = path.join(tempDir, `${asset}.sha256`);
+      await download(`${downloaded.url}.sha256`, checksumFile);
+      checksum = fs.readFileSync(checksumFile, 'utf8').trim().split(/\s+/)[0];
+    }
+    if (!/^[0-9a-f]{64}$/i.test(String(checksum)) || hashFile(archive).toLowerCase() !== checksum.toLowerCase()) {
+      throw new Error('DraftGo archive checksum mismatch.');
+    }
+    const staged = path.join(tempDir, 'package');
+    fs.mkdirSync(staged);
+    const extract = spawnSync('tar', ['-xzf', archive, '-C', staged, '--strip-components=1'], { encoding: 'utf8', shell: false });
+    if (extract.error || extract.status !== 0) throw new Error(extract.error ? extract.error.message : (extract.stderr || 'Unable to extract DraftGo release.'));
+    const installedVersion = JSON.parse(fs.readFileSync(path.join(staged, 'package.json'), 'utf8')).version;
+    if (installedVersion !== version) throw new Error(`Release version mismatch: expected ${version}, received ${installedVersion}.`);
+    fs.writeFileSync(path.join(staged, MARKER), JSON.stringify(marker, null, 2) + '\n');
+    const destination = path.join(marker.installRoot, version);
+    if (fs.existsSync(destination)) fs.rmSync(destination, { recursive: true, force: true });
+    fs.renameSync(staged, destination);
+    return { launcher: writeLauncher(marker.binDir, destination), destination };
+  } finally { fs.rmSync(tempDir, { recursive: true, force: true }); }
+}
+
+module.exports = { MARKER, readInstallMarker, installRelease, hashFile, writeLauncher };

package/src/{installers/index.js → targets.js}

@@ -1,11 +1,9 @@
 'use strict';
 
-// Thin compatibility layer over src/platforms.js + src/skill.js.
-// Each "installer" is just a platform descriptor exposing install/uninstall/
-// status methods that delegate to the generic renderer.
+// Public Skill target registry backed by shared platform descriptors.
 
-const { platforms } = require('../platforms');
-const skill = require('../skill');
+const { platforms } = require('./platforms');
+const skill = require('./skill');
 
 function makeInstaller(p) {
   return {

package/src/updateCheck.js

@@ -1,14 +1,20 @@
 'use strict';
 
-// Fetch the latest draftgo-cli version from the npm registry.
+// Fetch the latest draftgo-cli version from the DraftGo release endpoint.
 // Results are cached for 24 hours so update stays fast and deterministic.
 
+const http = require('http');
 const https = require('https');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const REGISTRY_URL = 'https://registry.npmjs.org/draftgo-cli/latest';
+const REPO = process.env.DRAFTGO_REPO || 'draftgo/draftgo-cli';
+const RELEASE_BASE_URL = process.env.DRAFTGO_INSTALL_BASE_URL || 'https://draftgo.cn/draftgo-cli';
+const RELEASE_URLS = [
+  `${RELEASE_BASE_URL}/latest.json`,
+  `https://api.github.com/repos/${REPO}/releases/latest`,
+];
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const CACHE_FILE = path.join(os.homedir(), '.draftgo-cli', 'update-check.json');
 
@@ -32,40 +38,54 @@ function writeCache(version) {
   }
 }
 
-function fetchLatestVersion(timeoutMs = 3000, opts = {}) {
-  if (!opts.force) {
-    const cached = readCache();
-    if (cached) return Promise.resolve(cached);
-  }
+function requestVersion(url, timeoutMs, redirects = 0) {
   return new Promise((resolve) => {
+    if (redirects > 5) return resolve(null);
+    let parsed;
+    try { parsed = new URL(url); } catch { return resolve(null); }
+    const transport = parsed.protocol === 'http:' ? http : https;
     let req;
     try {
-      req = https.get(
-        REGISTRY_URL,
-        { timeout: timeoutMs, headers: { accept: 'application/json' } },
-        (res) => {
-          if (res.statusCode !== 200) { res.resume(); return resolve(null); }
-          let body = '';
-          res.setEncoding('utf8');
-          res.on('data', (c) => { body += c; });
-          res.on('end', () => {
-              try {
-                const version = JSON.parse(body).version || null;
-                if (version) writeCache(version);
-                resolve(version);
-              }
-            catch { resolve(null); }
-          });
+      req = transport.get(parsed, {
+        timeout: timeoutMs,
+        headers: { accept: 'application/json', 'user-agent': 'draftgo-cli' },
+      }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume();
+          return resolve(requestVersion(new URL(res.headers.location, parsed).toString(), timeoutMs, redirects + 1));
         }
-      );
-    } catch {
-      return resolve(null);
-    }
+        if (res.statusCode !== 200) { res.resume(); return resolve(null); }
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          body += chunk;
+          if (body.length > 64 * 1024) req.destroy();
+        });
+        res.on('end', () => {
+          try {
+            const payload = JSON.parse(body);
+            resolve(payload.version || String(payload.tag_name || '').replace(/^v/, '') || null);
+          } catch { resolve(null); }
+        });
+      });
+    } catch { return resolve(null); }
     req.on('error', () => resolve(null));
     req.on('timeout', () => { req.destroy(); resolve(null); });
   });
 }
 
+async function fetchLatestVersion(timeoutMs = 3000, opts = {}) {
+  if (!opts.force) {
+    const cached = readCache();
+    if (cached) return Promise.resolve(cached);
+  }
+  for (const url of RELEASE_URLS) {
+    const version = await requestVersion(url, timeoutMs);
+    if (version) { writeCache(version); return version; }
+  }
+  return null;
+}
+
 // Compare 'a.b.c' ignoring prerelease tags. Returns 1 / 0 / -1.
 function cmpSemver(a, b) {
   const pa = String(a).split('-')[0].split('.').map((x) => Number(x) || 0);
@@ -77,4 +97,4 @@ function cmpSemver(a, b) {
   return 0;
 }
 
-module.exports = { fetchLatestVersion, cmpSemver, readCache, CACHE_TTL_MS };
+module.exports = { fetchLatestVersion, cmpSemver, readCache, requestVersion, CACHE_TTL_MS };