@heybox/hb-sdk 0.2.0-alpha.0 → 0.2.0-alpha.1

package/dist/cli.cjs

@@ -5030,26 +5030,27 @@ const TEMPLATE_ROOT_CANDIDATES = [
     path.resolve(__dirname, '..', 'templates', TEMPLATE_NAME),
     path.resolve(__dirname, '..', 'src', 'cli', 'templates', TEMPLATE_NAME),
 ];
-const PACKAGE_JSON_CANDIDATES = [
-    path.resolve(__dirname, '..', 'package.json'),
-    path.resolve(__dirname, '..', '..', '..', 'package.json'),
-];
+const PACKAGE_JSON_CANDIDATES$3 = [path.resolve(__dirname, '..', 'package.json'), path.resolve(__dirname, '..', '..', '..', 'package.json')];
 const UNSCOPED_PACKAGE_NAME_PATTERN = /^(?![._])[a-z0-9._-]+$/;
-async function runCreateCommand(projectName) {
-    const targetDir = path.resolve(process.cwd(), projectName);
+async function runCreateCommand(projectName, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const targetDir = path.resolve(cwd, projectName);
     const packageName = readPackageName(projectName, targetDir);
     await assertTargetDirectoryWritable(targetDir);
-    const templateRoot = await resolveTemplateRoot();
+    const templateRoot = await resolveTemplateRoot(options.templateRoots);
     const data = {
         packageName,
         projectName: packageName,
-        sdkVersion: await readCurrentSdkVersion(),
+        sdkVersion: await readCurrentSdkVersion$3(options.packageJsonFiles),
     };
     await renderTemplateDirectory(templateRoot, targetDir, data);
-    printCreateResult(projectName, targetDir);
+    printCreateResult(projectName, targetDir, {
+        console: options.console,
+        cwd,
+    });
 }
 function readPackageName(projectName, targetDir) {
-    if (projectName.trim().startsWith('@') || projectName.split(/[\\/]/).some(segment => segment.startsWith('@'))) {
+    if (projectName.trim().startsWith('@') || projectName.split(/[\\/]/).some((segment) => segment.startsWith('@'))) {
         throw new Error('暂不支持 scoped package name，请使用 my-miniapp 这类普通目录名');
     }
     const packageName = path.basename(targetDir);
@@ -5062,7 +5063,7 @@ function readPackageName(projectName, targetDir) {
     return packageName;
 }
 async function assertTargetDirectoryWritable(targetDir) {
-    if (!(await pathExists(targetDir))) {
+    if (!(await pathExists$3(targetDir))) {
         await fs$2.mkdir(targetDir, { recursive: true });
         return;
     }
@@ -5075,25 +5076,25 @@ async function assertTargetDirectoryWritable(targetDir) {
         throw new Error(`目标目录非空，已拒绝覆盖: ${targetDir}`);
     }
 }
-async function resolveTemplateRoot() {
-    for (const candidate of TEMPLATE_ROOT_CANDIDATES) {
-        if (await pathExists(candidate)) {
+async function resolveTemplateRoot(templateRootCandidates = TEMPLATE_ROOT_CANDIDATES) {
+    for (const candidate of templateRootCandidates) {
+        if (await pathExists$3(candidate)) {
             return candidate;
         }
     }
     throw new Error(`未找到 hb-sdk create 模板: ${TEMPLATE_NAME}。请先执行 @heybox/hb-sdk 的 build:templates。`);
 }
-async function readCurrentSdkVersion() {
-    const packageJsonPath = await resolvePackageJsonPath();
+async function readCurrentSdkVersion$3(packageJsonCandidates = PACKAGE_JSON_CANDIDATES$3) {
+    const packageJsonPath = await resolvePackageJsonPath(packageJsonCandidates);
     const packageJson = JSON.parse(await fs$2.readFile(packageJsonPath, 'utf8'));
     if (typeof packageJson.version !== 'string' || !packageJson.version) {
         throw new Error('未能读取 @heybox/hb-sdk 当前版本号');
     }
     return packageJson.version;
 }
-async function resolvePackageJsonPath() {
-    for (const candidate of PACKAGE_JSON_CANDIDATES) {
-        if (await pathExists(candidate)) {
+async function resolvePackageJsonPath(packageJsonCandidates = PACKAGE_JSON_CANDIDATES$3) {
+    for (const candidate of packageJsonCandidates) {
+        if (await pathExists$3(candidate)) {
             return candidate;
         }
     }
@@ -5124,7 +5125,7 @@ async function renderTemplateDirectory(sourceDir, targetDir, data) {
 function toOutputFileName(fileName) {
     return fileName.endsWith('.ejs') ? fileName.slice(0, -'.ejs'.length) : fileName;
 }
-async function pathExists(filePath) {
+async function pathExists$3(filePath) {
     try {
         await fs$2.access(filePath, fs$3.constants.F_OK);
         return true;
@@ -5133,16 +5134,16 @@ async function pathExists(filePath) {
         return false;
     }
 }
-function printCreateResult(inputPath, targetDir) {
-    const displayPath = path.isAbsolute(inputPath)
-        ? targetDir
-        : path.relative(process.cwd(), targetDir) || '.';
-    console.log(`[hb-sdk] Created mini program template at ${targetDir}`);
-    console.log('');
-    console.log('Next steps:');
-    console.log(`  cd ${quoteShellPath(displayPath)}`);
-    console.log('  npm install');
-    console.log('  npm run dev:mock');
+function printCreateResult(inputPath, targetDir, options) {
+    const output = options.console ?? console;
+    const cwd = options.cwd;
+    const displayPath = path.isAbsolute(inputPath) ? targetDir : path.relative(cwd, targetDir) || '.';
+    output.log(`[hb-sdk] Created mini program template at ${targetDir}`);
+    output.log('');
+    output.log('Next steps:');
+    output.log(`  cd ${quoteShellPath(displayPath)}`);
+    output.log('  npm install');
+    output.log('  npm run dev');
 }
 function quoteShellPath(value) {
     if (!/[\s'"`$\\]/.test(value)) {
@@ -5946,45 +5947,44 @@ function readErrorMessage(error) {
 
 const DEFAULT_APP_PORT = 5173;
 const DEFAULT_MOCK_PORT = 5174;
-const MOCK_HOST_QUERY_PARAM = 'mini_url';
+const MINI_PROGRAM_URL_QUERY_PARAM = 'mini_url';
 const MOCK_NETWORK_PROXY_PATH = '/__hb_sdk_mock_network__';
 const MOCK_NETWORK_PROXY_BODY_LIMIT = 1024 * 1024;
-async function runDevCommand(options) {
-    const projectRoot = findProjectRoot(process.cwd());
+// Shared with Heybox H5 Vite plugins so hb-sdk can own the launch output.
+const MANAGED_DEV_OUTPUT_ENV = 'HEYBOX_DEV_SERVER_MANAGED_OUTPUT';
+const VITE_LOG_LEVEL = 'warn';
+async function runDevCommand(options, runtime = {}) {
+    const output = runtime.console ?? console;
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const openUrl = runtime.openExternalUrl ?? openExternalUrl;
+    const projectRoot = findProjectRoot(runtime.cwd ?? process.cwd());
     const vite = await loadProjectVite(projectRoot);
-    const appServer = await vite.createServer(createViteServerOptions(projectRoot, options));
+    const appServer = await withManagedDevOutputEnv(() => vite.createServer(createViteServerOptions(projectRoot, options)), runtime.env);
     await appServer.listen(options.port ?? DEFAULT_APP_PORT);
-    appServer.printUrls();
-    const appUrl = await resolveViteAppUrl(appServer, options);
+    const appUrl = await resolveViteAppUrl(appServer, options, fetchImpl);
     const closers = [() => appServer.close()];
-    if (!options.mock) {
-        console.log(`\n[hb-sdk] Real environment URL: ${appUrl}`);
-        if (options.open) {
-            void openExternalUrl(appUrl);
-        }
-        installShutdownHandlers(closers);
-        return;
-    }
-    const mockHostRoot = resolveMockHostRoot();
-    const mockServer = createMockHostServer(mockHostRoot);
+    const mockHostRoot = runtime.mockHostRoot ?? resolveMockHostRoot(runtime.mockHostRootCandidates);
+    const mockServer = createMockHostServer(mockHostRoot, { fetchImpl });
     const mockPort = await listenHttpServer(mockServer, {
         host: options.host,
         port: options.mockPort ?? DEFAULT_MOCK_PORT,
-    });
+    }, runtime.getPort ?? getPorts);
     const mockUrl = createMockHostUrl({
         appUrl,
         host: options.host,
         port: mockPort,
     });
-    closers.push(() => new Promise((resolve, reject) => {
-        mockServer.close(error => (error ? reject(error) : resolve()));
+    closers.push(() => new Promise((resolve) => {
+        mockServer.close(() => resolve());
     }));
-    console.log(`[hb-sdk] Mock runtime host: ${mockUrl}`);
-    console.log(`[hb-sdk] Mini program URL: ${appUrl}`);
-    if (options.open) {
-        void openExternalUrl(mockUrl);
+    output.log(`\n[hb-sdk] Mock runtime host is ready`);
+    output.log(`[hb-sdk] Mock runtime host: ${mockUrl}`);
+    output.log(`[hb-sdk] Mini program URL: ${appUrl}`);
+    output.log(`[hb-sdk] Mac APP: use the button in Mock runtime host`);
+    if (options.open !== false) {
+        void openUrl(mockUrl);
     }
-    installShutdownHandlers(closers);
+    installShutdownHandlers(closers, runtime.process ?? process);
 }
 function findProjectRoot(startDir) {
     let current = path.resolve(startDir);
@@ -6019,22 +6019,24 @@ function createViteServerOptions(projectRoot, options) {
     if (configFile) {
         return {
             configFile,
+            logLevel: VITE_LOG_LEVEL,
             server,
         };
     }
     return {
+        logLevel: VITE_LOG_LEVEL,
         root: projectRoot,
         server,
     };
 }
 function resolveProjectViteConfig(projectRoot) {
     const candidates = ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs'];
-    return candidates.map(file => path.join(projectRoot, file)).find(file => fs$3.existsSync(file));
+    return candidates.map((file) => path.join(projectRoot, file)).find((file) => fs$3.existsSync(file));
 }
-async function resolveViteAppUrl(server, options) {
+async function resolveViteAppUrl(server, options, fetchImpl) {
     const candidates = createViteAppUrlCandidates(server, options);
     for (const candidate of candidates) {
-        if (await canReachDocumentUrl(candidate)) {
+        if (await canReachDocumentUrl(candidate, fetchImpl)) {
             return candidate;
         }
     }
@@ -6043,10 +6045,7 @@ async function resolveViteAppUrl(server, options) {
 function createViteAppUrlCandidates(server, options) {
     const localUrl = server.resolvedUrls?.local[0];
     const origin = readViteOrigin(localUrl, options);
-    const candidates = [
-        localUrl,
-        createH5EntryUrl(origin, readViteBase(server, localUrl)),
-    ].filter((url) => Boolean(url));
+    const candidates = [localUrl, createH5EntryUrl(origin, readViteBase(server, localUrl))].filter((url) => Boolean(url));
     return Array.from(new Set(candidates));
 }
 function readViteOrigin(localUrl, options) {
@@ -6081,9 +6080,9 @@ function createH5EntryUrl(origin, base) {
     const pathname = `${ensureTrailingSlash(base)}src/index.html`;
     return new URL(pathname, `${origin}/`).toString();
 }
-async function canReachDocumentUrl(url) {
+async function canReachDocumentUrl(url, fetchImpl) {
     try {
-        const headResponse = await fetch(url, {
+        const headResponse = await fetchImpl(url, {
             method: 'HEAD',
             redirect: 'follow',
         });
@@ -6093,7 +6092,7 @@ async function canReachDocumentUrl(url) {
         if (headResponse.status !== 404 && headResponse.status !== 405) {
             return false;
         }
-        const getResponse = await fetch(url, {
+        const getResponse = await fetchImpl(url, {
             method: 'GET',
             redirect: 'follow',
         });
@@ -6106,24 +6105,25 @@ async function canReachDocumentUrl(url) {
 function ensureTrailingSlash(value) {
     return value.endsWith('/') ? value : `${value}/`;
 }
-function resolveMockHostRoot() {
-    const candidates = [
-        path.resolve(__dirname, 'devtools/mock-host'),
-        path.resolve(__dirname, '../devtools/mock-host'),
-        path.resolve(__dirname, '../../devtools/mock-host'),
-    ];
-    const found = candidates.find(candidate => fs$3.existsSync(path.join(candidate, 'index.html')));
+const MOCK_HOST_ROOT_CANDIDATES = [
+    path.resolve(__dirname, 'devtools/mock-host'),
+    path.resolve(__dirname, '../devtools/mock-host'),
+    path.resolve(__dirname, '../../devtools/mock-host'),
+    path.resolve(__dirname, '../../../devtools/mock-host'),
+];
+function resolveMockHostRoot(candidates = MOCK_HOST_ROOT_CANDIDATES) {
+    const found = candidates.find((candidate) => fs$3.existsSync(path.join(candidate, 'index.html')));
     if (!found) {
         throw new Error(`未找到 hb-sdk mock host 静态产物。请先执行 @heybox/hb-sdk 的 build:mock-host。`);
     }
     return found;
 }
-function createMockHostServer(root) {
+function createMockHostServer(root, runtime) {
     return node_http.createServer(async (request, response) => {
-        const requestUrl = new URL(request.url || '/', 'http://localhost');
+        const requestUrl = new URL(request.url, 'http://localhost');
         const pathname = decodeURIComponent(requestUrl.pathname);
         if (pathname === MOCK_NETWORK_PROXY_PATH) {
-            await handleMockNetworkProxy(request, response);
+            await handleMockNetworkProxy(request, response, runtime.fetchImpl);
             return;
         }
         const targetPath = resolveStaticPath(root, pathname);
@@ -6151,7 +6151,7 @@ function createMockHostServer(root) {
         }
     });
 }
-async function handleMockNetworkProxy(request, response) {
+async function handleMockNetworkProxy(request, response, fetchImpl) {
     if (request.method === 'OPTIONS') {
         writeJsonResponse(response, 204, undefined);
         return;
@@ -6165,27 +6165,25 @@ async function handleMockNetworkProxy(request, response) {
     }
     try {
         const payload = await readJsonRequestBody(request);
-        const result = await requestMockNetwork(payload);
+        const result = await requestMockNetwork(payload, fetchImpl);
         writeJsonResponse(response, 200, result);
     }
     catch (error) {
         writeJsonResponse(response, readMockNetworkErrorStatus(error), toMockNetworkErrorPayload(error));
     }
 }
-async function requestMockNetwork(payload) {
+async function requestMockNetwork(payload, fetchImpl) {
     if (!isRecord$1(payload) || typeof payload.url !== 'string' || !payload.url.trim()) {
         throw createMockNetworkError(400, 'INVALID_NETWORK_REQUEST', 'network.request url 必须是非空字符串');
     }
     const url = createMockNetworkUrl(payload.url, payload.params);
-    const method = typeof payload.method === 'string' && payload.method.trim()
-        ? payload.method.trim().toUpperCase()
-        : 'GET';
+    const method = typeof payload.method === 'string' && payload.method.trim() ? payload.method.trim().toUpperCase() : 'GET';
     const headers = normalizeMockNetworkHeaders(payload.headers);
     const controller = new AbortController();
     const timeout = Number(payload.timeout) > 0 ? Number(payload.timeout) : 10000;
     const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        const response = await fetch(url.toString(), {
+        const response = await fetchImpl(url.toString(), {
             method,
             headers,
             body: createMockNetworkBody(method, payload.data, headers),
@@ -6194,6 +6192,7 @@ async function requestMockNetwork(payload) {
         });
         const contentType = response.headers.get('content-type') || '';
         const text = await response.text();
+        clearTimeout(timer);
         return {
             data: contentType.includes('application/json') ? safeJsonParse(text) : text,
             status: response.status,
@@ -6202,12 +6201,8 @@ async function requestMockNetwork(payload) {
         };
     }
     catch (error) {
-        throw createMockNetworkError(502, 'MOCK_NETWORK_REQUEST_FAILED', error instanceof Error && error.name === 'AbortError'
-            ? `network.request timeout after ${timeout}ms`
-            : readErrorMessage(error));
-    }
-    finally {
         clearTimeout(timer);
+        throw createMockNetworkError(502, 'MOCK_NETWORK_REQUEST_FAILED', error instanceof Error && error.name === 'AbortError' ? `network.request timeout after ${timeout}ms` : readErrorMessage(error));
     }
 }
 function createMockNetworkUrl(input, params) {
@@ -6272,8 +6267,8 @@ function readJsonRequestBody(request) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let size = 0;
-        request.on('data', chunk => {
-            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        request.on('data', (chunk) => {
+            const buffer = Buffer.from(chunk);
             size += buffer.byteLength;
             if (size > MOCK_NETWORK_PROXY_BODY_LIMIT) {
                 reject(createMockNetworkError(413, 'REQUEST_ENTITY_TOO_LARGE', 'mock network proxy request body too large'));
@@ -6283,6 +6278,9 @@ function readJsonRequestBody(request) {
             chunks.push(buffer);
         });
         request.on('error', reject);
+        request.on('aborted', () => {
+            reject('mock network proxy request aborted');
+        });
         request.on('end', () => {
             const rawBody = Buffer.concat(chunks).toString('utf8');
             if (!rawBody.trim()) {
@@ -6323,10 +6321,10 @@ function createMockNetworkError(status, code, message) {
     return error;
 }
 function readMockNetworkErrorStatus(error) {
-    return isRecord$1(error) && typeof error.status === 'number' ? error.status : 500;
+    return isObjectLike(error) && typeof error.status === 'number' ? error.status : 500;
 }
 function toMockNetworkErrorPayload(error) {
-    if (isRecord$1(error) && typeof error.code === 'string' && typeof error.message === 'string') {
+    if (isObjectLike(error) && typeof error.code === 'string' && typeof error.message === 'string') {
         return {
             code: error.code,
             message: error.message,
@@ -6337,6 +6335,9 @@ function toMockNetworkErrorPayload(error) {
         message: readErrorMessage(error),
     };
 }
+function isObjectLike(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null;
+}
 function resolveStaticPath(root, pathname) {
     const safePathname = pathname === '/' ? '/index.html' : pathname;
     const normalizedRoot = path.normalize(root);
@@ -6364,9 +6365,9 @@ function readContentType(filePath) {
     }
     return 'application/octet-stream';
 }
-async function listenHttpServer(server, options) {
+async function listenHttpServer(server, options, getPortImpl) {
     const maxAttempts = 20;
-    const port = await getPorts({
+    const port = await getPortImpl({
         host: options.host,
         port: createPortCandidates(options.port, maxAttempts),
     });
@@ -6387,35 +6388,218 @@ async function listenHttpServer(server, options) {
         server.listen(port, options.host);
     });
     const address = server.address();
-    return typeof address === 'object' && address ? address.port : port;
+    return address.port;
 }
 function createPortCandidates(startPort, count) {
     return Array.from({ length: count }, (_, index) => startPort + index);
 }
 function createMockHostUrl(options) {
     const url = new URL(`http://${toDisplayHost(options.host)}:${options.port}/`);
-    url.searchParams.set(MOCK_HOST_QUERY_PARAM, options.appUrl);
+    url.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM, options.appUrl);
     return url.toString();
 }
+async function withManagedDevOutputEnv(action, env = process.env) {
+    const previous = env[MANAGED_DEV_OUTPUT_ENV];
+    env[MANAGED_DEV_OUTPUT_ENV] = '1';
+    try {
+        return await action();
+    }
+    finally {
+        if (previous === undefined) {
+            delete env[MANAGED_DEV_OUTPUT_ENV];
+        }
+        else {
+            env[MANAGED_DEV_OUTPUT_ENV] = previous;
+        }
+    }
+}
 function toDisplayHost(host) {
     if (!host || host === '0.0.0.0' || host === '::') {
         return 'localhost';
     }
     return host;
 }
-function installShutdownHandlers(closers) {
+function installShutdownHandlers(closers, processLike) {
     const shutdown = async () => {
-        await Promise.allSettled(closers.map(close => close()));
-        process.exit(0);
+        await Promise.allSettled(closers.map((close) => close()));
+        processLike.exit(0);
     };
-    process.once('SIGINT', () => {
+    processLike.once('SIGINT', () => {
         void shutdown();
     });
-    process.once('SIGTERM', () => {
+    processLike.once('SIGTERM', () => {
         void shutdown();
     });
 }
 
+const PACKAGE_NAME$1 = '@heybox/hb-sdk';
+const SKILL_NAME = 'hb-sdk';
+const DEFAULT_SKILL_SOURCE = 'https://open.xiaoheihe.cn/agent-skills/hb-sdk';
+const DEFAULT_REMOTE_INDEX_URL = 'https://open.xiaoheihe.cn/agent-skills/.well-known/agent-skills/index.json';
+const DEFAULT_TIMEOUT_MS$1 = 3000;
+const SKILL_INSTALL_COMMAND = `npx skills add ${DEFAULT_SKILL_SOURCE}`;
+const PACKAGE_JSON_CANDIDATES$2 = [
+    path.resolve(__dirname, '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', '..', 'package.json'),
+];
+async function runDoctorCommand(runtime = {}) {
+    const output = runtime.console ?? console;
+    const result = await getDoctorResult(runtime);
+    printDoctorResult(result, output);
+    printDoctorNextStep(result, output);
+    return result;
+}
+async function getDoctorResult(runtime = {}) {
+    const currentSdkVersion = await readCurrentSdkVersion$2(runtime.packageJsonFiles);
+    const localSkillJsonPath = resolveLocalSkillJsonPath(runtime);
+    let remoteSkill;
+    try {
+        remoteSkill = await fetchRemoteSkill(runtime);
+    }
+    catch {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            status: 'REMOTE_UNAVAILABLE',
+        };
+    }
+    if (remoteSkill?.sdk?.version !== currentSdkVersion) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            remoteSkill,
+            status: 'SDK_MISMATCH',
+        };
+    }
+    const localSkill = await readLocalSkillManifest(localSkillJsonPath);
+    if (!localSkill.exists) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            remoteSkill,
+            status: 'SKILL_MISSING',
+        };
+    }
+    if (!localSkill.manifest ||
+        localSkill.manifest.name !== SKILL_NAME ||
+        localSkill.manifest.skillVersion !== remoteSkill.version ||
+        localSkill.manifest.sdk?.version !== remoteSkill.sdk?.version) {
+        return {
+            currentSdkVersion,
+            localSkillJsonPath,
+            localSkillVersion: localSkill.manifest?.skillVersion,
+            remoteSkill,
+            status: 'SKILL_OUTDATED',
+        };
+    }
+    return {
+        currentSdkVersion,
+        localSkillJsonPath,
+        localSkillVersion: localSkill.manifest.skillVersion,
+        remoteSkill,
+        status: 'OK',
+    };
+}
+function printDoctorResult(result, output) {
+    output.log('[hb-sdk] Doctor');
+    output.log(`SDK version: ${result.currentSdkVersion}`);
+    output.log(`Remote skill: ${result.remoteSkill?.version ? `${result.remoteSkill.version} (sdk ${result.remoteSkill.sdk?.version ?? 'unknown'})` : 'unavailable'}`);
+    output.log(`Local skill: ${result.localSkillVersion ?? 'missing'} (${result.localSkillJsonPath})`);
+    output.log(`Status: ${result.status}`);
+}
+function printDoctorNextStep(result, output) {
+    if (result.status === 'OK') {
+        output.log('[hb-sdk] Skill is up to date.');
+        return;
+    }
+    if (result.status === 'SDK_MISMATCH') {
+        output.log(`[hb-sdk] Current SDK does not match the latest skill metadata. Upgrade with: npm i -D ${PACKAGE_NAME$1}@latest`);
+        output.log(`[hb-sdk] Then install or refresh the skill manually: ${formatSkillInstallCommand(result)}`);
+        return;
+    }
+    if (result.status === 'REMOTE_UNAVAILABLE') {
+        output.log('[hb-sdk] Remote skill metadata is unavailable. Try again later.');
+        output.log(`[hb-sdk] Manual install command: ${SKILL_INSTALL_COMMAND}`);
+        return;
+    }
+    output.log(`[hb-sdk] Install or refresh the skill manually: ${formatSkillInstallCommand(result)}`);
+}
+function formatSkillInstallCommand(result) {
+    return `npx skills add ${result.remoteSkill?.source || DEFAULT_SKILL_SOURCE}`;
+}
+async function fetchRemoteSkill(runtime) {
+    const fetchImpl = runtime.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), runtime.timeoutMs ?? DEFAULT_TIMEOUT_MS$1);
+    try {
+        const response = await fetchImpl(runtime.remoteIndexUrl ?? DEFAULT_REMOTE_INDEX_URL, {
+            headers: {
+                accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`remote skill index returned ${response.status}`);
+        }
+        const index = (await response.json());
+        const skill = index.skills?.find(item => item.name === SKILL_NAME);
+        if (!skill?.version || skill.sdk?.package !== PACKAGE_NAME$1 || !skill.sdk.version) {
+            throw new Error('remote hb-sdk skill metadata is incomplete');
+        }
+        return skill;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readLocalSkillManifest(skillJsonPath) {
+    if (!(await pathExists$2(skillJsonPath))) {
+        return {
+            exists: false,
+        };
+    }
+    try {
+        return {
+            exists: true,
+            manifest: JSON.parse(await fs$2.readFile(skillJsonPath, 'utf8')),
+        };
+    }
+    catch {
+        return {
+            exists: true,
+        };
+    }
+}
+async function readCurrentSdkVersion$2(packageJsonCandidates = PACKAGE_JSON_CANDIDATES$2) {
+    for (const candidate of packageJsonCandidates) {
+        if (!(await pathExists$2(candidate))) {
+            continue;
+        }
+        const packageJson = JSON.parse(await fs$2.readFile(candidate, 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    throw new Error('未能读取 @heybox/hb-sdk 当前版本号');
+}
+function resolveLocalSkillJsonPath(runtime) {
+    if (runtime.localSkillJsonPath) {
+        return runtime.localSkillJsonPath;
+    }
+    const codexHome = runtime.codexHome ?? runtime.env?.CODEX_HOME ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+    return path.join(codexHome, 'skills', SKILL_NAME, 'skill.json');
+}
+async function pathExists$2(filePath) {
+    try {
+        await fs$2.access(filePath, fs$3.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
 const HEYBOX_LOGIN_URL = 'https://login.xiaoheihe.cn/';
 const HEYBOX_CALLBACK_HOST = '127.0.0.1';
 const HEYBOX_CALLBACK_PATH = '/heybox/callback';
@@ -6446,26 +6630,27 @@ async function waitForHeyboxBrowserCallback(options = {}) {
     const expectedState = node_crypto.randomBytes(16).toString('hex');
     const timeoutMs = options.timeoutMs ?? DEFAULT_HEYBOX_CALLBACK_TIMEOUT_MS;
     const openBrowser = options.openBrowser ?? openExternalUrl;
-    let server = null;
     let timer = null;
+    const loginCallback = {};
+    const server = node_http.createServer((request, response) => {
+        try {
+            const requestUrl = new URL(request.url, `http://${HEYBOX_CALLBACK_HOST}`);
+            if (requestUrl.pathname === HEYBOX_CALLBACK_DONE_PATH) {
+                sendBrowserResponse(response, 200, 'Heybox 登录成功，可以回到终端继续。');
+                return;
+            }
+            const callbackPayload = parseHeyboxCallbackUrl(request.url, expectedState);
+            redirectToCleanCallbackPage(response, () => loginCallback.resolve(callbackPayload));
+        }
+        catch (error) {
+            sendBrowserResponse(response, 400, `Heybox 登录失败: ${readErrorMessage(error)}`);
+            loginCallback.reject(error);
+        }
+    });
     try {
         const payload = await new Promise((resolve, reject) => {
-            server = node_http.createServer((request, response) => {
-                try {
-                    const requestUrl = new URL(request.url || '/', `http://${HEYBOX_CALLBACK_HOST}`);
-                    if (requestUrl.pathname === HEYBOX_CALLBACK_DONE_PATH) {
-                        sendBrowserResponse(response, 200, 'Heybox 登录成功，可以回到终端继续。');
-                        return;
-                    }
-                    const callbackPayload = parseHeyboxCallbackUrl(request.url || '', expectedState);
-                    redirectToCleanCallbackPage(response, () => resolve(callbackPayload));
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    sendBrowserResponse(response, 400, `Heybox 登录失败: ${message}`);
-                    reject(error);
-                }
-            });
+            loginCallback.resolve = resolve;
+            loginCallback.reject = reject;
             server.once('error', reject);
             server.listen(0, HEYBOX_CALLBACK_HOST, () => {
                 void handleServerListening(server, expectedState, {
@@ -6488,10 +6673,7 @@ async function waitForHeyboxBrowserCallback(options = {}) {
     }
 }
 async function handleServerListening(server, expectedState, options) {
-    const address = server?.address();
-    if (!address || typeof address === 'string') {
-        throw new Error('无法启动 Heybox 登录回调服务');
-    }
+    const address = server.address();
     const callbackUrl = `http://${HEYBOX_CALLBACK_HOST}:${address.port}${HEYBOX_CALLBACK_PATH}`;
     const loginUrl = createHeyboxLoginUrl(callbackUrl, expectedState);
     options.onLoginUrl?.(loginUrl);
@@ -6519,11 +6701,7 @@ function redirectToCleanCallbackPage(response, onSent) {
     response.end(onSent);
 }
 function closeServer(server) {
-    return new Promise(resolve => {
-        if (!server?.listening) {
-            resolve();
-            return;
-        }
+    return new Promise((resolve) => {
         server.close(() => resolve());
     });
 }
@@ -9436,9 +9614,9 @@ var libExports = /*@__PURE__*/ requireLib();
 var fs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
 const AUTH_CACHE_VERSION = 1;
-const paths = envPaths('hb-sdk', { suffix: '' });
+const paths$1 = envPaths('hb-sdk', { suffix: '' });
 function getAuthCacheFilePath(options = {}) {
-    return options.cacheFile ?? path.join(paths.cache, 'auth.json');
+    return options.cacheFile ?? path.join(paths$1.cache, 'auth.json');
 }
 function createHeyboxAuthSession(payload, options = {}) {
     return {
@@ -9531,105 +9709,402 @@ function isRecord(value) {
     return Object.prototype.toString.call(value) === '[object Object]';
 }
 
-async function loginToHeybox() {
-    const payload = await waitForHeyboxBrowserCallback({
+async function loginToHeybox(options = {}) {
+    const output = options.console ?? console;
+    const waitForBrowserCallback = options.waitForBrowserCallback ?? waitForHeyboxBrowserCallback;
+    const payload = await waitForBrowserCallback({
+        openBrowser: options.openBrowser,
         onLoginUrl(loginUrl) {
-            console.log('Heybox 浏览器登录');
-            console.log(`浏览器入口: ${loginUrl}`);
-            console.log('请在打开的页面完成登录，成功后 hb-sdk 会自动接收登录态。');
+            output.log('Heybox 浏览器登录');
+            output.log(`浏览器入口: ${loginUrl}`);
+            output.log('请在打开的页面完成登录，成功后 hb-sdk 会自动接收登录态。');
         },
         onBrowserOpenResult(opened, loginUrl) {
             if (opened) {
-                console.log('已打开 Heybox 登录页。');
+                output.log('已打开 Heybox 登录页。');
                 return;
             }
-            console.log('当前环境无法直接打开浏览器。');
-            console.log('请打开这个链接完成 Heybox 登录:');
-            console.log(loginUrl);
+            output.log('当前环境无法直接打开浏览器。');
+            output.log('请打开这个链接完成 Heybox 登录:');
+            output.log(loginUrl);
         },
+        timeoutMs: options.timeoutMs,
     });
-    const session = createHeyboxAuthSession(payload);
-    await writeHeyboxAuthSession(session);
-    console.log(`Heybox 登录成功: ${session.heyboxId}`);
-    console.log(`cache: ${getAuthCacheFilePath()}`);
-    console.log('验证: hb-sdk login status');
-}
-async function printLoginStatus() {
-    const status = await readRedactedHeyboxAuthStatus();
+    const session = createHeyboxAuthSession(payload, options);
+    await writeHeyboxAuthSession(session, options);
+    output.log(`Heybox 登录成功: ${session.heyboxId}`);
+    output.log(`cache: ${getAuthCacheFilePath(options)}`);
+    output.log('验证: hb-sdk login status');
+}
+async function printLoginStatus(options = {}) {
+    const output = options.console ?? console;
+    const status = await readRedactedHeyboxAuthStatus(options);
     if (!status.loggedIn) {
-        console.log('Heybox 登录态: 未登录');
-        console.log('下一步: hb-sdk login');
-        console.log(`cache: ${status.cacheFile}`);
+        output.log('Heybox 登录态: 未登录');
+        output.log('下一步: hb-sdk login');
+        output.log(`cache: ${status.cacheFile}`);
         return;
     }
-    console.log('Heybox 登录态: 已登录');
-    console.log(`heyboxId: ${status.heyboxId}`);
-    console.log(`loggedInAt: ${status.loggedInAt}`);
-    console.log(`cache: ${status.cacheFile}`);
+    output.log('Heybox 登录态: 已登录');
+    output.log(`heyboxId: ${status.heyboxId}`);
+    output.log(`loggedInAt: ${status.loggedInAt}`);
+    output.log(`cache: ${status.cacheFile}`);
+}
+async function clearLoginStatus(options = {}) {
+    const output = options.console ?? console;
+    await clearHeyboxAuthSession(options);
+    output.log('已清理 Heybox 登录态');
+    output.log(`cache: ${getAuthCacheFilePath(options)}`);
+}
+
+const PACKAGE_NAME = '@heybox/hb-sdk';
+const UPDATE_CHECK_CACHE_VERSION = 1;
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 1500;
+const UPDATE_CHECK_CACHE_FILE = 'update-check.json';
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}`;
+const paths = envPaths('hb-sdk', { suffix: '' });
+const PACKAGE_JSON_CANDIDATES$1 = [
+    path.resolve(__dirname, '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', '..', 'package.json'),
+];
+async function printUpdateReminder(options = {}) {
+    try {
+        const reminder = await getUpdateReminder(options);
+        if (!reminder) {
+            return;
+        }
+        const output = options.stderr ?? process.stderr;
+        output.write(`${formatUpdateReminder(reminder)}\n`);
+    }
+    catch {
+        // Version checks must never affect the actual hb-sdk command.
+    }
+}
+async function getUpdateReminder(options = {}) {
+    if (isUpdateCheckDisabled(options.env ?? process.env)) {
+        return null;
+    }
+    const now = options.now?.() ?? new Date();
+    const currentVersion = options.currentVersion ?? (await readCurrentSdkVersion$1(options.packageJsonFiles));
+    const cached = await readFreshUpdateCheckCache(getUpdateCheckCacheFilePath(options), now);
+    if (cached) {
+        return createUpdateReminder(currentVersion, cached.latestVersion);
+    }
+    let latestVersion;
+    try {
+        latestVersion = await fetchLatestVersion(options);
+    }
+    catch {
+        await writeUpdateCheckCache({
+            version: UPDATE_CHECK_CACHE_VERSION,
+            checkedAt: now.toISOString(),
+        }, options).catch(() => undefined);
+        return null;
+    }
+    await writeUpdateCheckCache({
+        version: UPDATE_CHECK_CACHE_VERSION,
+        checkedAt: now.toISOString(),
+        latestVersion,
+    }, options).catch(() => undefined);
+    return createUpdateReminder(currentVersion, latestVersion);
+}
+function formatUpdateReminder(reminder) {
+    return `[hb-sdk] New version available: ${reminder.currentVersion} -> ${reminder.latestVersion}. Upgrade with: npm i -D ${PACKAGE_NAME}@latest`;
+}
+function isVersionGreater(version, baseline) {
+    const compared = compareSemver(version, baseline);
+    return compared !== null && compared > 0;
+}
+function createUpdateReminder(currentVersion, latestVersion) {
+    if (!latestVersion || !isVersionGreater(latestVersion, currentVersion)) {
+        return null;
+    }
+    return {
+        currentVersion,
+        latestVersion,
+    };
+}
+function getUpdateCheckCacheFilePath(options = {}) {
+    return options.cacheFile ?? path.join(paths.cache, UPDATE_CHECK_CACHE_FILE);
 }
-async function clearLoginStatus() {
-    await clearHeyboxAuthSession();
-    console.log('已清理 Heybox 登录态');
-    console.log(`cache: ${getAuthCacheFilePath()}`);
+async function readFreshUpdateCheckCache(cacheFile, now) {
+    const cache = await readUpdateCheckCache(cacheFile);
+    if (!cache) {
+        return null;
+    }
+    const checkedAt = Date.parse(cache.checkedAt);
+    if (!Number.isFinite(checkedAt) || now.getTime() - checkedAt >= UPDATE_CHECK_TTL_MS) {
+        return null;
+    }
+    return cache;
+}
+async function readUpdateCheckCache(cacheFile) {
+    if (!(await pathExists$1(cacheFile))) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(await fs$2.readFile(cacheFile, 'utf8'));
+        if (parsed.version !== UPDATE_CHECK_CACHE_VERSION || typeof parsed.checkedAt !== 'string') {
+            return null;
+        }
+        return {
+            version: UPDATE_CHECK_CACHE_VERSION,
+            checkedAt: parsed.checkedAt,
+            ...(typeof parsed.latestVersion === 'string' ? { latestVersion: parsed.latestVersion } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeUpdateCheckCache(cache, options = {}) {
+    const cacheFile = getUpdateCheckCacheFilePath(options);
+    await fs$2.mkdir(path.dirname(cacheFile), { recursive: true });
+    await fs$2.writeFile(cacheFile, JSON.stringify(cache, null, 2), 'utf8');
+}
+async function fetchLatestVersion(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(options.registryUrl ?? NPM_REGISTRY_URL, {
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`npm registry returned ${response.status}`);
+        }
+        const metadata = (await response.json());
+        const latestVersion = metadata['dist-tags']?.latest;
+        if (typeof latestVersion !== 'string' || !latestVersion) {
+            throw new Error('npm registry response missing latest dist-tag');
+        }
+        return latestVersion;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function readCurrentSdkVersion$1(packageJsonCandidates = PACKAGE_JSON_CANDIDATES$1) {
+    for (const candidate of packageJsonCandidates) {
+        if (!(await pathExists$1(candidate))) {
+            continue;
+        }
+        const packageJson = JSON.parse(await fs$2.readFile(candidate, 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    throw new Error('未能读取 @heybox/hb-sdk 当前版本号');
+}
+function isUpdateCheckDisabled(env) {
+    return env.HB_SDK_NO_UPDATE_CHECK === '1' || env.CI === 'true';
+}
+function compareSemver(version, baseline) {
+    const parsedVersion = parseSemver(version);
+    const parsedBaseline = parseSemver(baseline);
+    if (!parsedVersion || !parsedBaseline) {
+        return null;
+    }
+    for (const key of ['major', 'minor', 'patch']) {
+        if (parsedVersion[key] !== parsedBaseline[key]) {
+            return parsedVersion[key] > parsedBaseline[key] ? 1 : -1;
+        }
+    }
+    return comparePrerelease(parsedVersion.prerelease, parsedBaseline.prerelease);
+}
+function parseSemver(version) {
+    const matched = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-.]+))?(?:\+[0-9A-Za-z-.]+)?$/);
+    if (!matched) {
+        return null;
+    }
+    return {
+        major: Number(matched[1]),
+        minor: Number(matched[2]),
+        patch: Number(matched[3]),
+        prerelease: matched[4]?.split('.') ?? [],
+    };
+}
+function comparePrerelease(versionPrerelease, baselinePrerelease) {
+    if (versionPrerelease.length === 0 && baselinePrerelease.length === 0) {
+        return 0;
+    }
+    if (versionPrerelease.length === 0) {
+        return 1;
+    }
+    if (baselinePrerelease.length === 0) {
+        return -1;
+    }
+    const length = Math.max(versionPrerelease.length, baselinePrerelease.length);
+    for (let index = 0; index < length; index += 1) {
+        const left = versionPrerelease[index];
+        const right = baselinePrerelease[index];
+        if (left === undefined) {
+            return -1;
+        }
+        if (right === undefined) {
+            return 1;
+        }
+        const compared = comparePrereleaseIdentifier(left, right);
+        if (compared !== 0) {
+            return compared;
+        }
+    }
+    return 0;
+}
+function comparePrereleaseIdentifier(left, right) {
+    const leftNumeric = isNumericPrereleaseIdentifier(left);
+    const rightNumeric = isNumericPrereleaseIdentifier(right);
+    if (leftNumeric && rightNumeric) {
+        const compared = Number(left) - Number(right);
+        return compared === 0 ? 0 : compared > 0 ? 1 : -1;
+    }
+    if (leftNumeric) {
+        return -1;
+    }
+    if (rightNumeric) {
+        return 1;
+    }
+    if (left === right) {
+        return 0;
+    }
+    return left > right ? 1 : -1;
+}
+function isNumericPrereleaseIdentifier(value) {
+    return /^\d+$/.test(value);
+}
+async function pathExists$1(filePath) {
+    try {
+        await fs$2.access(filePath, fs$3.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+const CLI_VERSION_PLACEHOLDER = ['__HB', 'SDK', 'CLI', 'VERSION__'].join('_');
+const BUILT_CLI_VERSION = '0.2.0-alpha.1';
+const PACKAGE_JSON_CANDIDATES = [
+    path.resolve(__dirname, '..', '..', 'package.json'),
+    path.resolve(__dirname, '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', '..', 'package.json'),
+];
+function getCliVersion(packageJsonCandidates = PACKAGE_JSON_CANDIDATES) {
+    if (BUILT_CLI_VERSION !== CLI_VERSION_PLACEHOLDER) {
+        return BUILT_CLI_VERSION;
+    }
+    return readCurrentSdkVersion(packageJsonCandidates);
+}
+function readCurrentSdkVersion(packageJsonCandidates) {
+    for (const candidate of packageJsonCandidates) {
+        if (!pathExists(candidate)) {
+            continue;
+        }
+        const packageJson = JSON.parse(fs$3.readFileSync(candidate, 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    throw new Error('未能读取 @heybox/hb-sdk 当前版本号');
+}
+function pathExists(filePath) {
+    try {
+        fs$3.accessSync(filePath, fs$3.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 
-main().catch(error => {
-    if (error instanceof CommanderError && error.exitCode === 0) {
-        process.exit(0);
+async function runCli(options = {}) {
+    const processLike = options.process ?? process;
+    try {
+        await createCliProgram(options).parseAsync(options.argv ?? process.argv);
     }
-    if (!(error instanceof CommanderError)) {
-        printError(error);
+    catch (error) {
+        if (error instanceof CommanderError && error.exitCode === 0) {
+            processLike.exit(0);
+            return;
+        }
+        if (!(error instanceof CommanderError)) {
+            (options.printError ?? printError)(error);
+        }
+        processLike.exit(error instanceof CommanderError ? error.exitCode : 1);
     }
-    process.exit(error instanceof CommanderError ? error.exitCode : 1);
-});
-async function main() {
-    await createCliProgram().parseAsync(process.argv);
 }
-function createCliProgram() {
+function createCliProgram(overrides = {}) {
+    const handlers = {
+        clearLoginStatus: clearLoginStatus,
+        loginToHeybox: loginToHeybox,
+        printLoginStatus: printLoginStatus,
+        printUpdateReminder: printUpdateReminder,
+        runCreateCommand: runCreateCommand,
+        runDevCommand: runDevCommand,
+        runDoctorCommand: runDoctorCommand,
+        ...overrides,
+    };
     const program = new Command();
     program
         .name('hb-sdk')
         .description('hb-sdk developer tools')
+        .version(getCliVersion())
         .showHelpAfterError()
         .exitOverride();
     program
         .command('create')
         .description('创建外部小程序项目开发模板')
         .argument('<project-name>', '项目目录名，例如 my-miniapp')
-        .action(async (projectName) => {
-        await runCreateCommand(projectName);
-    });
+        .action(withUpdateReminder(async (projectName) => {
+        await handlers.runCreateCommand(projectName);
+    }, handlers.printUpdateReminder));
     program
         .command('dev')
-        .description('启动当前小程序项目的 Vite dev server')
-        .option('--mock', '启动内置浏览器 mock runtime host', false)
+        .description('启动当前小程序项目的 Vite dev server 和浏览器 mock runtime host')
         .option('--port <port>', 'App dev server 端口', parsePositivePort)
         .option('--mock-port <port>', 'Mock host 端口', parsePositivePort)
         .option('--host <host>', '传给 Vite 和 mock host 的 host')
-        .option('--open', '打开 app URL 或 mock host URL', false)
-        .action(async (options) => {
-        await runDevCommand(options);
+        .option('--no-open', '不自动打开浏览器调试页')
+        .action(withUpdateReminder(async (options) => {
+        await handlers.runDevCommand(options);
+    }, handlers.printUpdateReminder));
+    program
+        .command('doctor')
+        .description('诊断 hb-sdk 本地环境和 Agent Skill 版本')
+        .action(async () => {
+        await handlers.runDoctorCommand();
     });
     const login = program
         .command('login')
         .description('登录 Heybox 并缓存 CLI 登录态')
-        .action(async () => {
-        await loginToHeybox();
-    });
+        .action(withUpdateReminder(async () => {
+        await handlers.loginToHeybox();
+    }, handlers.printUpdateReminder));
     login
         .command('status')
         .description('查看脱敏后的 Heybox 登录态')
-        .action(async () => {
-        await printLoginStatus();
-    });
+        .action(withUpdateReminder(async () => {
+        await handlers.printLoginStatus();
+    }, handlers.printUpdateReminder));
     login
         .command('clear')
         .description('清理 hb-sdk 命名空间中的 Heybox 登录态')
-        .action(async () => {
-        await clearLoginStatus();
-    });
+        .action(withUpdateReminder(async () => {
+        await handlers.clearLoginStatus();
+    }, handlers.printUpdateReminder));
     return program;
 }
+function withUpdateReminder(action, printUpdateReminder) {
+    return async (...args) => {
+        await action(...args);
+        await printUpdateReminder();
+    };
+}
 function parsePositivePort(value) {
     const parsed = Number(value);
     if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -9637,3 +10112,6 @@ function parsePositivePort(value) {
     }
     return parsed;
 }
+
+exports.createCliProgram = createCliProgram;
+exports.runCli = runCli;