@flightmaster/dast-cli 1.0.0

package/README.md

@@ -0,0 +1,110 @@
+# @flightmaster/dast-cli
+
+DAST MCP 命令行客户端。固定对接单一 MCP Server（`dast_mcp`），将工具发现与调用封装为简洁命令，方便 AI Agent 集成与本地调试。
+
+默认上游：`https://fly.huoli.com/mcp/dast_mcp`
+
+## 安装
+
+```bash
+npm install -g @flightmaster/dast-cli
+```
+
+本地开发：
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+## 配置
+
+```bash
+export DAST_API_KEY=sk_phone_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+`dast-cli` 使用 MCP 网关的 **PhoneKey** 无状态鉴权（与 huoli-cli 等其它凭证体系不同）：
+
+- 格式：`sk_phone_` + 32 位小写字母或数字
+- 每个请求自动带 `Authorization: Bearer <PhoneKey>`（无需、也不会依赖 `MCP-Session-Id`）
+- Key 可从 [https://dast.133.cn](https://dast.133.cn) 获取；创建时完整串只显示一次
+
+| 变量 | 说明 | 默认值 |
+| :--- | :--- | :--- |
+| `DAST_API_KEY` | **必填**。PhoneKey（`sk_phone_…`） | - |
+| `DAST_MCP_URL` | 自定义 MCP 服务地址 | `https://fly.huoli.com/mcp/dast_mcp` |
+| `DAST_TIMEOUT` | 全局请求超时（毫秒） | `20000` |
+
+### 请求超时
+
+超时指 CLI 等待 MCP 网关 HTTP 响应的最长时间（毫秒），适用于 `list` / `schema` / `info` / `call`。
+
+| 方式 | 作用范围 | 示例 |
+| :--- | :--- | :--- |
+| 默认 | 未配置时 | `20000` |
+| `DAST_TIMEOUT` | 当前 shell / 进程环境 | `export DAST_TIMEOUT=60000` |
+| `-t` / `--timeout` | **仅本次命令** | `dast call <tool> -a '...' -t 60000` |
+
+优先级：命令行 `-t` > 环境变量 `DAST_TIMEOUT` > 默认 `20000`。个别慢工具建议用 `-t` 临时加长，不必改全局环境变量。
+
+## 快速入门
+
+```bash
+# 列出全部工具
+dast list
+
+# 导出 Schema（供 Agent 初始化）
+dast schema
+
+# 查看某个工具的参数说明
+dast info dast_flight_dynamic
+
+# 调用工具
+dast call dast_flight_dynamic -a '{"fnum":"CA1831","date":"2026-09-09"}'
+```
+
+## 命令速查
+
+| 命令 | 说明 |
+| :--- | :--- |
+| `dast list` | 列出 dast_mcp 下全部工具 |
+| `dast schema` | 导出工具 Schema（JSON） |
+| `dast info <tool>` | 查看工具描述与参数 |
+| `dast call <tool> -a '<json>'` | 调用工具；可用 `-t` / `--timeout` 设置超时 |
+
+输出格式：`list` / `call` 支持 `-o json` 或 `-o table`（`call` 默认 json）。
+
+## 退出码
+
+| Exit Code | 名称 | 说明 |
+| :--- | :--- | :--- |
+| `0` | SUCCESS | 成功 |
+| `101` | GATEWAY_ERROR | 网关/网络错误 |
+| `102` | NOT_FOUND | 工具不存在 |
+| `103` | INVALID_ARGS | 参数非法（含 JSON 解析失败） |
+| `104` | UNAUTHORIZED | PhoneKey 认证失败（含网关 JSON-RPC `-32003` AUTH_FAILED） |
+| `105` | TIMEOUT | 超时 |
+| `106` | INTERNAL_ERROR | CLI 内部错误 |
+
+## Agent 集成
+
+1. 启动时执行 `dast schema`，将工具定义注入模型。
+2. 按用户意图选择 tool，用 `dast info <tool>` 核对参数（或直接读 schema）。
+3. 执行 `dast call <tool> -a '<json>'`。
+4. 按 Exit Code 决定重试或修正参数。
+
+安装包时会通过 `postinstall` 尝试把 `skills/SKILL.md` 复制到 Cursor / Claude 等 Agent 的 skills 目录。
+
+## 与 aviation-dast-mcp 的关系
+
+| 包 | 形态 | 场景 |
+| :--- | :--- | :--- |
+| `@flightmaster/aviation-dast-mcp` | stdio MCP bridge | Cursor / Claude 原生 MCP |
+| `@flightmaster/dast-cli` | Shell CLI | Agent Skill、脚本、本地调试 |
+
+二者共用同一上游 `dast_mcp`。
+
+## License
+
+ISC

package/bin/dast

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/index.js');

package/dist/client/gateway.d.ts

@@ -0,0 +1,16 @@
+import type { JsonRpcResponse, ToolsListResult, ToolCallResult } from '../types';
+export declare class GatewayClient {
+    private client;
+    private apiKey;
+    private pendingEnvTimeout;
+    constructor();
+    setTimeout(timeout: number): void;
+    private applyEnvTimeoutIfNeeded;
+    private ensureApiKey;
+    private rpc;
+    /** 列出固定 dast_mcp 服务下的全部工具 */
+    getTools(): Promise<JsonRpcResponse<ToolsListResult>>;
+    /** 调用指定工具；若 MCP 返回 isError，抛出 CliError */
+    callTool(tool: string, args: Record<string, unknown>): Promise<JsonRpcResponse<ToolCallResult>>;
+}
+export declare const gatewayClient: GatewayClient;

package/dist/client/gateway.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatewayClient = exports.GatewayClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("../utils/errors");
+const DEFAULT_MCP_URL = 'https://fly.huoli.com/mcp/dast_mcp';
+const DEFAULT_TIMEOUT_MS = 20000;
+class GatewayClient {
+    constructor() {
+        this.apiKey = (0, errors_1.normalizePhoneKey)(process.env.DAST_API_KEY);
+        this.pendingEnvTimeout = process.env.DAST_TIMEOUT;
+        this.client = axios_1.default.create({
+            baseURL: process.env.DAST_MCP_URL || DEFAULT_MCP_URL,
+            timeout: DEFAULT_TIMEOUT_MS,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json, text/event-stream',
+            },
+        });
+    }
+    setTimeout(timeout) {
+        this.pendingEnvTimeout = undefined;
+        this.client.defaults.timeout = timeout;
+    }
+    applyEnvTimeoutIfNeeded() {
+        if (this.pendingEnvTimeout === undefined) {
+            return;
+        }
+        const raw = this.pendingEnvTimeout;
+        this.pendingEnvTimeout = undefined;
+        this.client.defaults.timeout = (0, errors_1.parseTimeoutMs)(raw, 'DAST_TIMEOUT');
+    }
+    ensureApiKey() {
+        if (!this.apiKey) {
+            throw new errors_1.CliError('未配置 DAST_API_KEY 环境变量（PhoneKey，格式 sk_phone_ + 32 位小写字母或数字）', errors_1.ExitCodes.UNAUTHORIZED);
+        }
+        (0, errors_1.assertPhoneKeyFormat)(this.apiKey);
+    }
+    async rpc(method, params = {}) {
+        this.ensureApiKey();
+        this.applyEnvTimeoutIfNeeded();
+        const { data: response } = await this.client.post('', {
+            jsonrpc: '2.0',
+            id: Date.now(),
+            method,
+            params,
+        }, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (response?.error) {
+            const message = response.error.message || `JSON-RPC error (${response.error.code})`;
+            throw (0, errors_1.mapJsonRpcError)(response.error.code, message);
+        }
+        return response;
+    }
+    /** 列出固定 dast_mcp 服务下的全部工具 */
+    async getTools() {
+        return this.rpc('tools/list', {});
+    }
+    /** 调用指定工具；若 MCP 返回 isError，抛出 CliError */
+    async callTool(tool, args) {
+        const response = await this.rpc('tools/call', {
+            name: tool,
+            arguments: args,
+        });
+        const result = response.result;
+        if (result?.isError) {
+            const text = result.content
+                ?.map((item) => (typeof item.text === 'string' ? item.text : ''))
+                .filter(Boolean)
+                .join('\n');
+            throw new errors_1.CliError(text || '工具调用返回错误 (isError=true)', errors_1.ExitCodes.GATEWAY_ERROR);
+        }
+        return response;
+    }
+}
+exports.GatewayClient = GatewayClient;
+exports.gatewayClient = new GatewayClient();

package/dist/commands/call.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerCallCommand(program: Command): void;

package/dist/commands/call.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCallCommand = registerCallCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const gateway_1 = require("../client/gateway");
+const errors_1 = require("../utils/errors");
+function parseArgsObject(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new errors_1.CliError('参数格式错误，必须是合法的 JSON 字符串', errors_1.ExitCodes.INVALID_ARGS);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new errors_1.CliError('参数必须是 JSON 对象（例如 {"fnum":"CA1831"}）', errors_1.ExitCodes.INVALID_ARGS);
+    }
+    return parsed;
+}
+function registerCallCommand(program) {
+    program
+        .command('call <tool>')
+        .description('调用 dast_mcp 上的指定工具')
+        .requiredOption('-a, --args <json>', 'JSON 格式的参数字符串')
+        .option('-o, --output <format>', '输出格式: json/table', 'json')
+        .action(async (tool, options) => {
+        let parsedArgs;
+        try {
+            parsedArgs = parseArgsObject(options.args);
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error, errors_1.ExitCodes.INVALID_ARGS);
+        }
+        try {
+            const response = await gateway_1.gatewayClient.callTool(tool, parsedArgs);
+            let outputData = response;
+            if (response?.result) {
+                outputData = response.result;
+            }
+            else if (response?.data) {
+                outputData = response.data;
+            }
+            if (options.output === 'json') {
+                console.log(JSON.stringify(outputData, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.green('\n✅ 调用成功\n'));
+                console.log(outputData);
+            }
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error, errors_1.ExitCodes.GATEWAY_ERROR);
+        }
+    });
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerInfoCommand(program: Command): void;

package/dist/commands/info.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInfoCommand = registerInfoCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const gateway_1 = require("../client/gateway");
+const errors_1 = require("../utils/errors");
+function registerInfoCommand(program) {
+    program
+        .command('info <tool>')
+        .alias('desc')
+        .description('查看指定工具的功能说明与参数详情')
+        .action(async (tool) => {
+        try {
+            const response = await gateway_1.gatewayClient.getTools();
+            const tools = response?.result?.tools ?? [];
+            if (tools.length === 0) {
+                throw new errors_1.CliError('未找到可用工具', errors_1.ExitCodes.NOT_FOUND);
+            }
+            const targetTool = tools.find((t) => t.name === tool);
+            if (!targetTool) {
+                throw new errors_1.CliError(`未找到工具 '${tool}'`, errors_1.ExitCodes.NOT_FOUND);
+            }
+            console.log(`\n${chalk_1.default.bold.green(targetTool.name)}`);
+            console.log(`${chalk_1.default.bold('描述:')} ${targetTool.description || '无描述'}`);
+            if (targetTool.inputSchema?.properties) {
+                console.log(`\n${chalk_1.default.bold('参数:')}`);
+                const props = targetTool.inputSchema.properties;
+                const required = targetTool.inputSchema.required || [];
+                for (const [key, value] of Object.entries(props)) {
+                    const isRequired = required.includes(key);
+                    const reqStr = isRequired ? chalk_1.default.red('(必填)') : chalk_1.default.gray('(可选)');
+                    const typeStr = value.type || 'any';
+                    const descStr = value.description || '';
+                    console.log(`  ${chalk_1.default.cyan(key)} ${reqStr}: ${chalk_1.default.yellow(typeStr)} - ${descStr}`);
+                }
+            }
+            else {
+                console.log(`\n${chalk_1.default.bold('参数:')} 无参数`);
+            }
+            console.log();
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error, errors_1.ExitCodes.GATEWAY_ERROR);
+        }
+    });
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerListCommand(program: Command): void;

package/dist/commands/list.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerListCommand = registerListCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const gateway_1 = require("../client/gateway");
+const formatter_1 = require("../utils/formatter");
+const errors_1 = require("../utils/errors");
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('列出 dast_mcp 服务下的全部可用工具')
+        .option('-o, --output <format>', '输出格式: json/table', 'table')
+        .action(async (options) => {
+        try {
+            const response = await gateway_1.gatewayClient.getTools();
+            const tools = response?.result?.tools ?? [];
+            if (tools.length === 0) {
+                throw new errors_1.CliError('未找到可用工具', errors_1.ExitCodes.NOT_FOUND);
+            }
+            if (options.output === 'json') {
+                console.log(JSON.stringify(tools, null, 2));
+            }
+            else {
+                console.log(chalk_1.default.bold('\n🛠️  DAST MCP 工具列表:\n'));
+                console.log((0, formatter_1.formatToolsTable)(tools));
+                console.log(`\n💡 提示: 运行 ${chalk_1.default.cyan("dast call <tool_name> -a '{}'")} 调用工具。\n`);
+            }
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error, errors_1.ExitCodes.GATEWAY_ERROR);
+        }
+    });
+}

package/dist/commands/schema.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSchemaCommand(program: Command): void;

package/dist/commands/schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSchemaCommand = registerSchemaCommand;
+const gateway_1 = require("../client/gateway");
+const errors_1 = require("../utils/errors");
+function registerSchemaCommand(program) {
+    program
+        .command('schema')
+        .description('导出全部工具的 Schema 定义，供 Agent 或自动化脚本初始化时使用')
+        .action(async () => {
+        try {
+            const response = await gateway_1.gatewayClient.getTools();
+            const tools = response?.result?.tools ?? [];
+            if (tools.length === 0) {
+                throw new errors_1.CliError('未找到可用工具', errors_1.ExitCodes.NOT_FOUND);
+            }
+            console.log(JSON.stringify({ tools }, null, 2));
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error, errors_1.ExitCodes.GATEWAY_ERROR);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const list_1 = require("./commands/list");
+const schema_1 = require("./commands/schema");
+const call_1 = require("./commands/call");
+const info_1 = require("./commands/info");
+const gateway_1 = require("./client/gateway");
+const errors_1 = require("./utils/errors");
+const program = new commander_1.Command();
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('../package.json');
+program
+    .name('dast')
+    .description('DAST MCP CLI — Flight Master aviation data (fixed dast_mcp server)')
+    .version(pkg.version)
+    .option('-t, --timeout <ms>', '设置全局请求超时时间（毫秒）')
+    .addHelpText('after', `
+环境变量:
+  DAST_API_KEY   PhoneKey 鉴权凭证 (必填，格式 sk_phone_ + 32 位小写字母或数字)
+  DAST_MCP_URL   自定义 MCP 服务地址 (默认: https://fly.huoli.com/mcp/dast_mcp)
+  DAST_TIMEOUT   全局请求超时时间，单位毫秒 (默认: 20000)
+
+示例:
+  $ dast list
+  $ dast schema
+  $ dast info dast_flight_dynamic
+  $ dast call dast_flight_dynamic -a '{"fnum":"CA1831","date":"2026-09-09"}'
+  $ dast call dast_flight_dynamic -a '{"fnum":"CA1831","date":"2026-09-09"}' -t 30000
+`);
+program.hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.timeout) {
+        try {
+            gateway_1.gatewayClient.setTimeout((0, errors_1.parseTimeoutMs)(opts.timeout, '-t/--timeout'));
+        }
+        catch (error) {
+            (0, errors_1.handleError)(error);
+        }
+    }
+});
+(0, list_1.registerListCommand)(program);
+(0, schema_1.registerSchemaCommand)(program);
+(0, call_1.registerCallCommand)(program);
+(0, info_1.registerInfoCommand)(program);
+program.parse();

package/dist/scripts/auto-install-skill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/auto-install-skill.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const AGENT_DIRECTORIES = [
+    path_1.default.join(os_1.default.homedir(), '.cursor', 'skills'),
+    path_1.default.join(os_1.default.homedir(), '.trae', 'skills'),
+    path_1.default.join(os_1.default.homedir(), '.claude', 'skills'),
+    path_1.default.join(os_1.default.homedir(), '.agents', 'skills'),
+];
+const SKILL_NAME = 'dast-mcp';
+const SOURCE_SKILL_PATH = path_1.default.join(__dirname, '..', '..', 'skills', 'SKILL.md');
+function installSkill() {
+    console.log('📦 正在为支持的 AI Agent 自动安装 dast-mcp 技能...');
+    if (!fs_1.default.existsSync(SOURCE_SKILL_PATH)) {
+        console.warn(`⚠️ 警告: 找不到源技能文件: ${SOURCE_SKILL_PATH}`);
+        return;
+    }
+    let installedCount = 0;
+    let attemptedCount = 0;
+    AGENT_DIRECTORIES.forEach((agentDir) => {
+        const baseAgentDir = path_1.default.dirname(agentDir);
+        if (fs_1.default.existsSync(baseAgentDir)) {
+            attemptedCount++;
+            try {
+                if (!fs_1.default.existsSync(agentDir)) {
+                    fs_1.default.mkdirSync(agentDir, { recursive: true });
+                }
+                const targetSkillDir = path_1.default.join(agentDir, SKILL_NAME);
+                if (!fs_1.default.existsSync(targetSkillDir)) {
+                    fs_1.default.mkdirSync(targetSkillDir, { recursive: true });
+                }
+                const targetSkillPath = path_1.default.join(targetSkillDir, 'SKILL.md');
+                fs_1.default.copyFileSync(SOURCE_SKILL_PATH, targetSkillPath);
+                console.log(`✅ 成功将技能安装到: ${targetSkillPath}`);
+                installedCount++;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.error(`❌ 安装技能到 ${agentDir} 失败 (可能是权限不足): ${message}`);
+            }
+        }
+    });
+    if (attemptedCount === 0) {
+        console.log('ℹ️ 未检测到支持的 AI Agent 目录，跳过自动安装。');
+    }
+    else if (installedCount === 0) {
+        console.log('⚠️ 已检测到 Agent 目录，但技能安装均失败，请检查权限后手动复制 skills/SKILL.md。');
+    }
+    else {
+        console.log('🎉 技能安装完成！你的 AI Agent 现在可以直接使用自然语言调用 DAST MCP 服务了。');
+    }
+}
+installSkill();

package/dist/types/index.d.ts

@@ -0,0 +1,37 @@
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: {
+        type?: string;
+        properties?: Record<string, {
+            type?: string;
+            description?: string;
+            [key: string]: unknown;
+        }>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc?: string;
+    id?: number | string;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    data?: unknown;
+}
+export interface ToolsListResult {
+    tools: McpTool[];
+}
+export interface ToolCallResult {
+    content?: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+    [key: string]: unknown;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/errors.d.ts

@@ -0,0 +1,37 @@
+export declare const ExitCodes: {
+    readonly SUCCESS: 0;
+    readonly GATEWAY_ERROR: 101;
+    readonly NOT_FOUND: 102;
+    readonly INVALID_ARGS: 103;
+    readonly UNAUTHORIZED: 104;
+    readonly TIMEOUT: 105;
+    readonly INTERNAL_ERROR: 106;
+};
+export type ExitCode = (typeof ExitCodes)[keyof typeof ExitCodes];
+/** PhoneKey: sk_phone_ + 32 lowercase letters or digits (mcp-gateway PhoneKey). */
+export declare const PHONE_KEY_PATTERN: RegExp;
+export declare class CliError extends Error {
+    readonly exitCode: ExitCode;
+    constructor(message: string, exitCode?: ExitCode);
+}
+/**
+ * Trim whitespace and strip a redundant `Bearer ` prefix if the user pasted the full header value.
+ */
+export declare function normalizePhoneKey(raw: string | undefined): string | undefined;
+export declare function assertPhoneKeyFormat(key: string): void;
+export declare function parseTimeoutMs(value: string, label: string): number;
+/**
+ * Map JSON-RPC errors from the PhoneKey MCP gateway.
+ * PhoneKey auth failures are typically HTTP 200 + jsonrpc error code -32003 (AUTH_FAILED).
+ */
+export declare function mapJsonRpcError(code: number | undefined, message: string): CliError;
+export declare function resolveError(error: unknown): {
+    message: string;
+    exitCode: ExitCode;
+};
+/**
+ * Print error and exit.
+ * Prefer CliError / axios-derived exit codes. Optional fallbackExitCode
+ * only applies to generic Error instances without a mapped code.
+ */
+export declare function handleError(error: unknown, fallbackExitCode?: ExitCode): never;

package/dist/utils/errors.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = exports.PHONE_KEY_PATTERN = exports.ExitCodes = void 0;
+exports.normalizePhoneKey = normalizePhoneKey;
+exports.assertPhoneKeyFormat = assertPhoneKeyFormat;
+exports.parseTimeoutMs = parseTimeoutMs;
+exports.mapJsonRpcError = mapJsonRpcError;
+exports.resolveError = resolveError;
+exports.handleError = handleError;
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+exports.ExitCodes = {
+    SUCCESS: 0,
+    GATEWAY_ERROR: 101,
+    NOT_FOUND: 102,
+    INVALID_ARGS: 103,
+    UNAUTHORIZED: 104,
+    TIMEOUT: 105,
+    INTERNAL_ERROR: 106,
+};
+/** PhoneKey: sk_phone_ + 32 lowercase letters or digits (mcp-gateway PhoneKey). */
+exports.PHONE_KEY_PATTERN = /^sk_phone_[a-z0-9]{32}$/;
+class CliError extends Error {
+    constructor(message, exitCode = exports.ExitCodes.INTERNAL_ERROR) {
+        super(message);
+        this.name = 'CliError';
+        this.exitCode = exitCode;
+    }
+}
+exports.CliError = CliError;
+/**
+ * Trim whitespace and strip a redundant `Bearer ` prefix if the user pasted the full header value.
+ */
+function normalizePhoneKey(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    let key = raw.trim();
+    if (!key) {
+        return undefined;
+    }
+    if (/^bearer\s+/i.test(key)) {
+        key = key.replace(/^bearer\s+/i, '').trim();
+    }
+    return key || undefined;
+}
+function assertPhoneKeyFormat(key) {
+    if (!exports.PHONE_KEY_PATTERN.test(key)) {
+        throw new CliError('DAST_API_KEY 须为 PhoneKey：sk_phone_ + 32 位小写字母或数字（不要加 Bearer 前缀）', exports.ExitCodes.INVALID_ARGS);
+    }
+}
+function parseTimeoutMs(value, label) {
+    const asNumber = Number(value);
+    if (!Number.isFinite(asNumber) || !Number.isInteger(asNumber) || asNumber <= 0) {
+        throw new CliError(`${label} 无效，必须是正整数毫秒数`, exports.ExitCodes.INVALID_ARGS);
+    }
+    return asNumber;
+}
+function extractAxiosMessage(error) {
+    if (!axios_1.default.isAxiosError(error)) {
+        return undefined;
+    }
+    const data = error.response?.data;
+    if (typeof data === 'string' && data.trim()) {
+        return data.trim();
+    }
+    if (data && typeof data === 'object') {
+        const record = data;
+        const rpcError = record.error;
+        if (rpcError && typeof rpcError === 'object') {
+            const message = rpcError.message;
+            if (typeof message === 'string' && message) {
+                return message;
+            }
+        }
+        if (typeof record.message === 'string' && record.message) {
+            return record.message;
+        }
+    }
+    return error.message;
+}
+function isRateLimitMessage(message) {
+    return /rate.?limit|限流|过于频繁|too many requests|qps/i.test(message);
+}
+function isPhoneKeyAuthMessage(message) {
+    return /phone\s*key|phonekey|sk_phone_|api key|unauthorized|认证|鉴权|未授权|invalid.*key|missing.*key|key.*无效|无效.*或不存在/i.test(message);
+}
+/**
+ * Map JSON-RPC errors from the PhoneKey MCP gateway.
+ * PhoneKey auth failures are typically HTTP 200 + jsonrpc error code -32003 (AUTH_FAILED).
+ */
+function mapJsonRpcError(code, message) {
+    const lower = message.toLowerCase();
+    if (isRateLimitMessage(message)) {
+        return new CliError(message, exports.ExitCodes.GATEWAY_ERROR);
+    }
+    // Guide: PhoneKey errors (48001–48009) surface as JSON-RPC -32003 AUTH_FAILED
+    if (code === -32003 || isPhoneKeyAuthMessage(message)) {
+        return new CliError(message, exports.ExitCodes.UNAUTHORIZED);
+    }
+    if (code === -32602 || /invalid params|参数非法|参数错误/i.test(lower)) {
+        return new CliError(message, exports.ExitCodes.INVALID_ARGS);
+    }
+    if (/not found|未找到|unknown tool|tool .* not/i.test(lower)) {
+        return new CliError(message, exports.ExitCodes.NOT_FOUND);
+    }
+    if (/timeout|超时/i.test(lower)) {
+        return new CliError(message, exports.ExitCodes.TIMEOUT);
+    }
+    return new CliError(message, exports.ExitCodes.GATEWAY_ERROR);
+}
+function resolveError(error) {
+    if (error instanceof CliError) {
+        return { message: error.message, exitCode: error.exitCode };
+    }
+    if (axios_1.default.isAxiosError(error)) {
+        if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT' || error.code === 'ERR_CANCELED') {
+            return {
+                message: `请求超时: ${error.message}`,
+                exitCode: exports.ExitCodes.TIMEOUT,
+            };
+        }
+        const status = error.response?.status;
+        const detail = extractAxiosMessage(error);
+        if (status === 401 || status === 403) {
+            return {
+                message: detail || 'PhoneKey 认证失败，请检查 DAST_API_KEY（sk_phone_…）是否正确',
+                exitCode: exports.ExitCodes.UNAUTHORIZED,
+            };
+        }
+        if (detail && isRateLimitMessage(detail)) {
+            return { message: detail, exitCode: exports.ExitCodes.GATEWAY_ERROR };
+        }
+        if (detail && isPhoneKeyAuthMessage(detail)) {
+            return { message: detail, exitCode: exports.ExitCodes.UNAUTHORIZED };
+        }
+        return {
+            message: detail || error.message || '网关请求失败',
+            exitCode: exports.ExitCodes.GATEWAY_ERROR,
+        };
+    }
+    if (error instanceof Error && error.message) {
+        if (/DAST_API_KEY|PhoneKey/i.test(error.message)) {
+            return { message: error.message, exitCode: exports.ExitCodes.UNAUTHORIZED };
+        }
+        return { message: error.message, exitCode: exports.ExitCodes.INTERNAL_ERROR };
+    }
+    return { message: 'An unknown error occurred.', exitCode: exports.ExitCodes.INTERNAL_ERROR };
+}
+/**
+ * Print error and exit.
+ * Prefer CliError / axios-derived exit codes. Optional fallbackExitCode
+ * only applies to generic Error instances without a mapped code.
+ */
+function handleError(error, fallbackExitCode) {
+    const resolved = resolveError(error);
+    const useResolved = error instanceof CliError ||
+        axios_1.default.isAxiosError(error) ||
+        (error instanceof Error && /DAST_API_KEY|PhoneKey/i.test(error.message));
+    const exitCode = useResolved ? resolved.exitCode : (fallbackExitCode ?? resolved.exitCode);
+    console.error(chalk_1.default.red(`Error: ${resolved.message}`));
+    if (!(error instanceof Error) && error !== undefined && error !== null) {
+        console.error(error);
+    }
+    process.exit(exitCode);
+}

package/dist/utils/formatter.d.ts

@@ -0,0 +1,2 @@
+import type { McpTool } from '../types';
+export declare function formatToolsTable(tools: McpTool[]): string;

package/dist/utils/formatter.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToolsTable = formatToolsTable;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+function formatToolsTable(tools) {
+    const table = new cli_table3_1.default({
+        head: [chalk_1.default.cyan('Tool Name'), chalk_1.default.cyan('Description')],
+        style: { head: [], border: [] },
+        colWidths: [30, 70],
+        wordWrap: true,
+    });
+    tools.forEach((tool) => {
+        table.push([tool.name, tool.description || '-']);
+    });
+    return table.toString();
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@flightmaster/dast-cli",
+  "version": "1.0.0",
+  "mcpName": "io.github.flight-master-dast/dast-cli",
+  "description": "DAST MCP CLI — fixed single-server client for Flight Master aviation data",
+  "main": "dist/index.js",
+  "bin": {
+    "dast": "./bin/dast"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "skills",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && chmod 755 bin/dast",
+    "start": "ts-node src/index.ts",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node -e \"try{require('./dist/scripts/auto-install-skill.js')}catch(e){if(e.code!=='MODULE_NOT_FOUND')throw e}\""
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cli",
+    "command-line",
+    "dast",
+    "flight",
+    "flights",
+    "aviation",
+    "airport",
+    "weather",
+    "delay",
+    "travel",
+    "flightmaster",
+    "agent",
+    "gateway"
+  ],
+  "author": "DAST",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "axios": "^1.14.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/skills/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: dast-mcp
+description: DAST 航空数据助手 - 教 AI 通过 dast CLI 发现并调用固定的 dast_mcp 服务（航班动态、航线、舒适度、延误概率、天气、飞行轨迹等）。
+version: 1.0.0
+metadata: {"openclaw": {"emoji": "✈️", "category": "travel", "tags": ["DAST", "航班", "航空数据", "MCP"], "requires": {"bins": ["dast"]}, "env": {"DAST_API_KEY": {"type": "string", "description": "DAST PhoneKey（sk_phone_ + 32 位小写字母或数字）", "required": true}}}}
+---
+
+# DAST 航空数据助手 (dast MCP Agent)
+
+当用户向你询问任何与 **航班动态、航线班次、舒适度、延误概率、机场天气、飞行轨迹** 等相关的需求时，你**必须**使用本地的 `dast` 命令行工具来获取数据并帮助用户完成任务。
+
+本 CLI 固定对接单一 MCP Server（`dast_mcp`），使用 **PhoneKey** 无状态鉴权（`Authorization: Bearer sk_phone_…`），无需先选择 server，也不依赖 session。
+
+## 核心工作流（严格遵守）：
+
+### 第一步：查阅工具说明书 (Schema)
+你不知道当前有哪些工具以及参数规则，必须先执行：
+```bash
+dast schema
+```
+仔细阅读返回的 JSON，特别是每个工具的 `inputSchema`（`type`、`description`、`required`）。
+
+如只需确认某一个工具，可执行：
+```bash
+dast info <toolName>
+```
+（例如: `dast info dast_flight_dynamic`）
+
+### 第二步：调用工具并返回结果 (Call)
+根据 schema 构造 JSON 参数，执行：
+```bash
+dast call <toolName> -a '<json_string>'
+```
+（例如: `dast call dast_flight_dynamic -a '{"fnum":"CA1831","date":"2026-09-09"}'`）
+
+提取返回的核心业务数据，整理成易读自然语言展示给用户。
+
+可选：`dast list -o json` 可快速查看工具名称与描述（不含完整 schema）。
+
+---
+
+## ⚠️ 重要注意事项：
+
+1. **绝不瞎猜参数**：调用前必须通过 `schema` 或 `info` 确认参数名。若返回参数错误，重新查阅 schema 后修正。
+2. **JSON 转义**：在 Linux/Mac 终端中，务必用单引号 `' '` 包裹 `-a` 后的整个 JSON 字符串。
+3. **认证前置**：执行任何命令前，确保存在环境变量 `DAST_API_KEY`，且值为 PhoneKey（`sk_phone_` + 32 位小写字母或数字，不要带 `Bearer ` 前缀）；若没有或格式不对，请要求用户从 dast 平台重新提供。
+4. **日期与三字码**：多数工具需要 `YYYY-MM-DD` 日期和机场三字码（如 PEK、CAN）；城市名需先转换为机场码。
+5. **退出码**：鉴权失败为 `104`；参数非法为 `103`；网关/限流等为 `101`。按退出码决定是换 Key、改参数还是重试。