@dreamor/atlas-cli 0.7.0

package/dist/adapters/atlas/commands/update.js

@@ -0,0 +1,106 @@
+import { fileURLToPath } from 'url';
+import { isJsonMode, jsonOk, log } from '../util/output.js';
+import { AtlasError } from '../util/errors.js';
+import { ATLAS_VERSION } from '../util/version.js';
+/**
+ * 检测当前是否通过 npm 全局包安装运行。
+ * 判断依据：import.meta.url 解析后的真实路径是否在 node_modules/@dreamor/atlas-cli 下。
+ * - 命中 → 提示用户用 `npm update -g @dreamor/atlas-cli` 升级
+ * - 未命中 → 独立二进制/Bun/开发模式，提示去 GitHub Releases 升级
+ */
+function detectInstallMode() {
+    try {
+        const url = new URL(import.meta.url);
+        const path = fileURLToPath(url);
+        return /node_modules[\\/]@dreamor[\\/]atlas-cli/.test(path) ? 'npm' : 'other';
+    }
+    catch {
+        return 'other';
+    }
+}
+export function detectPlatform() {
+    const osMap = {
+        darwin: 'darwin',
+        linux: 'linux',
+        win32: 'windows',
+    };
+    const archMap = {
+        arm64: 'arm64',
+        x64: 'x64',
+    };
+    const os = osMap[process.platform];
+    const arch = archMap[process.arch];
+    if (!os || !arch)
+        return null;
+    return { os, arch };
+}
+export function stripV(v) {
+    return v.replace(/^v/, '');
+}
+export function compareVersions(a, b) {
+    // 预处理：去除 prerelease 后缀（如 -rc.1、-beta），纯 semver 比较
+    const clean = (v) => v.replace(/-.*$/, '');
+    const pa = clean(a).split('.').map(Number);
+    const pb = clean(b).split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    // 语义相同：a 有 prerelease 后缀（如 0.6.1-rc.1）→ a < b（跳过升级）
+    if (a !== clean(a) && b === clean(b))
+        return -1;
+    if (a === clean(a) && b !== clean(b))
+        return 1;
+    return 0;
+}
+export async function updateCmd(opts) {
+    if (process.env.ATLAS_DISABLE_UPDATE === '1') {
+        log('更新已被 ATLAS_DISABLE_UPDATE 禁用');
+        if (opts.json || isJsonMode()) {
+            jsonOk({ disabled: true });
+        }
+        return;
+    }
+    // npm 分发后，自更新交给 npm/yarn/pnpm 管理；CLI 不再下载二进制。
+    // 说明：原 GitHub Release 下载 + SHA256 校验 + 原子写入逻辑由 npm registry 取代，
+    // 维持这个命令只是为了给已有用户一个清晰引导，而不是让他们卡在过期入口。
+    const installMode = detectInstallMode();
+    const npmCmd = 'npm update -g @dreamor/atlas-cli';
+    if (installMode === 'npm') {
+        log(`当前版本 ${ATLAS_VERSION}`);
+        log('通过 npm 安装的 atlas 由 npm registry 管理升级，请运行:');
+        log(`  ${npmCmd}`);
+        log('');
+        log('指定的 NPM_TOKEN 拥有 Publish 权限时，npm 会从 registry 自动拉取最新版。');
+        if (opts.json || isJsonMode()) {
+            jsonOk({
+                mode: 'npm',
+                current: ATLAS_VERSION,
+                updateCommand: npmCmd,
+            });
+        }
+        return;
+    }
+    // 非 npm 安装（独立二进制/Bun/源码开发模式）
+    log(`当前版本 ${ATLAS_VERSION}`);
+    log('当前以非 npm 方式运行，自更新已禁用。');
+    log('推荐迁移到 npm 安装：');
+    log('  npm i -g @dreamor/atlas-cli');
+    log('随后通过 `npm update -g @dreamor/atlas-cli` 升级。');
+    if (opts.json || isJsonMode()) {
+        jsonOk({
+            mode: 'other',
+            current: ATLAS_VERSION,
+            migrationCommand: 'npm i -g @dreamor/atlas-cli',
+            updateCommand: npmCmd,
+        });
+    }
+}
+// 保留 throw 以便旧调用点不会报错（改造后独立函数已无调用者）
+export function _unreachableCheck() {
+    throw new AtlasError('update.ts 内部: 不应到达', 'UPDATE_ERROR');
+}

package/dist/adapters/atlas/daemon/index.js

@@ -0,0 +1,64 @@
+import { createServer } from 'http';
+import { randomBytes, timingSafeEqual } from 'crypto';
+import { dirname } from 'path';
+import { log } from '../util/output.js';
+import { getDaemonTokenFile } from '../util/paths.js';
+import { secureMkdir, secureWriteFile } from '../util/secure-fs.js';
+import { AtlasError } from '../util/errors.js';
+/** 生成 32 字节 hex token */
+function generateToken() {
+    return randomBytes(32).toString('hex');
+}
+/** 校验 Authorization: Bearer <token>（timingSafeEqual 防时序侧信道） */
+function isAuthorized(req, token) {
+    const auth = req.headers.authorization ?? '';
+    const expected = `Bearer ${token}`;
+    const a = Buffer.from(auth);
+    const b = Buffer.from(expected);
+    // timingSafeEqual 要求两 Buffer 等长；不等长时先比后再返回 false 防止时序泄漏
+    if (a.length !== b.length) {
+        timingSafeEqual(Buffer.alloc(1), Buffer.alloc(1));
+        return false;
+    }
+    return timingSafeEqual(a, b);
+}
+export async function daemonCmd(opts) {
+    const envPort = Number(process.env.ATLAS_DAEMON_PORT);
+    const optsPort = opts.port !== undefined ? Number(opts.port) : NaN;
+    const port = Number.isFinite(optsPort) && optsPort > 0
+        ? optsPort
+        : Number.isFinite(envPort) && envPort > 0
+            ? envPort
+            : 8765;
+    // 生成一次性 token，写入 ~/.atlas/daemon.token（0600）
+    const token = generateToken();
+    const tokenFile = getDaemonTokenFile();
+    await secureMkdir(dirname(tokenFile), { recursive: true });
+    await secureWriteFile(tokenFile, token);
+    log(`Daemon token 已写入 ${tokenFile}`);
+    const server = createServer((req, res) => {
+        // 除 /api/health 外所有端点均需鉴权
+        const isHealth = req.url === '/api/health';
+        if (!isHealth && !isAuthorized(req, token)) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, pid: process.pid }));
+    });
+    await new Promise((resolve, reject) => {
+        server.on('error', (e) => {
+            if (e.code === 'EADDRINUSE') {
+                reject(new AtlasError(`端口 ${port} 已被占用`, 'CONFIG_ERROR'));
+            }
+            else {
+                reject(e);
+            }
+        });
+        server.listen(port, '127.0.0.1', resolve);
+    });
+    log(`守护进程已启动，监听 127.0.0.1:${port}`);
+    // Keep running
+    await new Promise(() => { });
+}

package/dist/adapters/atlas/dict/index.js

@@ -0,0 +1,41 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { getCacheDir, getCacheFile } from '../util/paths.js';
+import { secureMkdir, secureWriteFile } from '../util/secure-fs.js';
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24h
+// Key 只允许字母数字和下划线，防止路径穿越（D6）
+const CACHE_KEY_RE = /^[a-z0-9_-]+$/i;
+export async function getCached(key) {
+    if (!CACHE_KEY_RE.test(key))
+        throw new Error(`非法 cache key: "${key}"`);
+    const filePath = getCacheFile(key);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const entry = JSON.parse(raw);
+        if (Date.now() - entry.fetchedAt > CACHE_TTL)
+            return null;
+        return entry.data;
+    }
+    catch {
+        return null;
+    }
+}
+export async function setCache(key, data) {
+    if (!CACHE_KEY_RE.test(key))
+        throw new Error(`非法 cache key: "${key}"`);
+    const filePath = getCacheFile(key);
+    const cacheDir = getCacheDir();
+    await secureMkdir(cacheDir, { recursive: true });
+    const entry = { data, fetchedAt: Date.now() };
+    await secureWriteFile(filePath, JSON.stringify(entry));
+}
+export async function clearCache() {
+    const { rm } = await import('fs/promises');
+    const cacheDir = getCacheDir();
+    try {
+        await rm(cacheDir, { recursive: true, force: true });
+    }
+    catch { }
+}

package/dist/adapters/atlas/http/client.js

@@ -0,0 +1,151 @@
+/**
+ * 斑马云图 HTTP 客户端。
+ *
+ * 变更记录（安全审计）：
+ * - A4：path 校验 → 必须以 / 开头，origin 锁定，防 SSRF
+ * - B2：识别 429 状态码，抛 RATE_LIMITED AtlasError
+ * - B5：token/user/staffId 空串时不设请求头
+ * - D3：可传 ZodSchema 对 data 做运行时校验
+ * - D10：已知业务错误码 → 特定异常
+ */
+import { request } from 'undici';
+import { BanmaApiError, SessionExpiredError, AtlasError } from '../util/errors.js';
+import { readCookies, readBanmaIdentity } from '../auth/session.js';
+/** D10：已知业务错误码 → 异常映射（工厂函数避免单例 stack trace 失准） */
+const KNOWN_BUSINESS_ERRORS = {
+    'TOKEN_INVALID': () => new SessionExpiredError('会话 token 已失效，请重新登录'),
+    'TOKEN_EXPIRED': () => new SessionExpiredError('会话 token 已过期，请重新登录'),
+    'SESSION_EXPIRED': () => new SessionExpiredError('会话已过期，请重新登录'),
+};
+const BANMA_BASE = 'https://banma-yuntu.alibaba-inc.com';
+/**
+ * Banma API HTTP 客户端
+ *
+ * 真实 API 格式: { status, code, errCode, errorMsg, detail, success, data }
+ * - success=true 或 status=1 表示成功
+ * - data 可能为数组或对象
+ * - 200 不一定成功；需检查 success 字段
+ */
+export class HttpClient {
+    baseUrl;
+    baseOrigin;
+    timeout;
+    constructor(opts = {}) {
+        this.baseUrl = (opts.baseUrl ?? BANMA_BASE).replace(/\/+$/, '');
+        this.baseOrigin = new URL(this.baseUrl).origin;
+        this.timeout = opts.timeout ?? 30000;
+    }
+    async buildHeaders() {
+        const cookies = await readCookies();
+        const headers = {
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) atlas-cli',
+            'Referer': 'https://banma-yuntu.alibaba-inc.com/',
+            'Origin': 'https://banma-yuntu.alibaba-inc.com',
+        };
+        if (cookies && cookies.length > 0) {
+            headers['Cookie'] = cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+        }
+        // 斑马的项目权限类 API 强制校验 x-banma-* 头，缺失则判定无身份返回空数据。
+        // token/user/staffId 仅在有有效值时设置（B5）；company-id 始终发送（空串亦可）。
+        const identity = await readBanmaIdentity();
+        if (identity) {
+            if (identity.token) {
+                headers['token'] = identity.token;
+                headers['x-banma-token'] = identity.token;
+            }
+            if (identity.user)
+                headers['x-banma-user'] = identity.user;
+            if (identity.staffId)
+                headers['x-banma-staff-id'] = identity.staffId;
+            headers['x-banma-company-id'] = '';
+        }
+        return headers;
+    }
+    /**
+     * POST 请求。
+     *
+     * 可传可选 schema（ZodSchema），在 API 返回后对 json.data 做运行时校验（D3）。
+     */
+    async post(path, body, schema) {
+        // A4: 校验 path 必须以 / 开头，防止 http://evil.example/x 绕过 baseUrl
+        if (!path.startsWith('/'))
+            throw new AtlasError('path must be relative (start with /)', 'CONFIG_ERROR');
+        const url = new URL(path, this.baseUrl + '/');
+        if (url.origin !== this.baseOrigin)
+            throw new AtlasError('origin mismatch — possible SSRF', 'CONFIG_ERROR');
+        const headers = await this.buildHeaders();
+        const response = await request(url.toString(), {
+            method: 'POST',
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            headersTimeout: this.timeout,
+            bodyTimeout: this.timeout,
+        });
+        return this.parseResponse(response, schema);
+    }
+    async multipartUpload(path, fields, file) {
+        // A4: 校验 path
+        if (!path.startsWith('/'))
+            throw new AtlasError('path must be relative (start with /)', 'CONFIG_ERROR');
+        const url = new URL(path, this.baseUrl + '/');
+        if (url.origin !== this.baseOrigin)
+            throw new AtlasError('origin mismatch — possible SSRF', 'CONFIG_ERROR');
+        const headers = await this.buildHeaders();
+        const boundary = `----FormBoundary${Math.random().toString(36).slice(2)}`;
+        const CRLF = '\r\n';
+        const parts = [];
+        for (const f of fields) {
+            parts.push(Buffer.from(`--${boundary}${CRLF}Content-Disposition: form-data; name="${f.name}"${CRLF}${CRLF}${f.value}${CRLF}`));
+        }
+        parts.push(Buffer.from(`--${boundary}${CRLF}Content-Disposition: form-data; name="${file.name}"; filename="${file.filename}"${CRLF}Content-Type: application/octet-stream${CRLF}${CRLF}`));
+        parts.push(file.buffer);
+        parts.push(Buffer.from(`${CRLF}--${boundary}--${CRLF}`));
+        const response = await request(url.toString(), {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': `multipart/form-data; boundary=${boundary}` },
+            body: Buffer.concat(parts),
+            headersTimeout: this.timeout * 2,
+            bodyTimeout: this.timeout * 2,
+        });
+        return this.parseResponse(response);
+    }
+    async parseResponse(response, schema) {
+        const status = response.statusCode;
+        const text = await response.body.text();
+        if (status === 401 || status === 403) {
+            throw new SessionExpiredError();
+        }
+        // B2: 识别 429 限流
+        if (status === 429) {
+            throw new AtlasError('请求过于频繁（429 限流），请稍后重试', 'RATE_LIMITED');
+        }
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            throw new BanmaApiError('PARSE_ERROR', `Failed to parse: ${text.slice(0, 200)}`);
+        }
+        // D10: 识别业务错误码 → 映射到特定异常
+        if (json.errCode && json.errCode !== 'SUCCESS') {
+            const knownError = KNOWN_BUSINESS_ERRORS[json.errCode];
+            if (knownError)
+                throw knownError();
+        }
+        // Banma API 的 success/status 字段不可靠（空结果也返回 success: false）
+        // 只要 HTTP 2xx 就返回 data，由调用方处理 null
+        if (status >= 200 && status < 300) {
+            if (schema)
+                return schema.parse(json.data);
+            return json.data;
+        }
+        const errCode = json.errCode ?? String(json.code) ?? `HTTP_${status}`;
+        const errMsg = json.errorMsg ?? json.detail ?? `HTTP ${status}`;
+        throw new BanmaApiError(errCode, errMsg, json.detail ?? undefined);
+    }
+}
+export function createClient() {
+    return new HttpClient();
+}

package/dist/adapters/atlas/http/index.js

@@ -0,0 +1 @@
+export { HttpClient } from './client.js';

package/dist/adapters/atlas/schema/actual.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+// 实际工时-按团队汇总（API: POST /yuntu-service/manpower/weekly/summaryByTeam.json）
+export const ActualSummaryByTeamSchema = z.object({
+    staffId: z.string(),
+    staffName: z.string(),
+    department: z.string().optional(),
+    departmentName: z.string().optional(),
+    role: z.string().optional(),
+    manpower: z.number(),
+    status: z.enum(['pending', 'approved']).optional(),
+    leadName: z.string().optional(),
+});
+export const ActualSummaryByTeamDataSchema = z.object({
+    summaryByTeam: z.array(ActualSummaryByTeamSchema),
+    mp: z.number().optional(),
+});

package/dist/adapters/atlas/schema/baseline.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+// 基线月明细条目（API: POST /yuntu-service/line/plan/month/select.json）
+export const LinePlanMonthDetailSchema = z.object({
+    projectId: z.string(),
+    projectName: z.string(),
+    departmentId: z.string().optional(),
+    departmentName: z.string().optional(),
+    role: z.string().optional(),
+    manpower: z.number(),
+    month: z.string(),
+    areaCode: z.string().optional(),
+    mpType: z.string().optional(),
+    leadId: z.string().optional(),
+    leadName: z.string().optional(),
+});
+// 实际 API 返回的 data 结构
+export const BaselineMonthDataSchema = z.object({
+    linePlanMonthDetailList: z.array(LinePlanMonthDetailSchema),
+    mp: z.number().optional(),
+});
+// 基线条目列表（API: POST /yuntu-service/line/plan/select.json）
+export const LinePlanSelectDataSchema = z.object({
+    linePlanList: z.array(z.object({
+        id: z.string().optional(),
+        projectId: z.string(),
+        projectName: z.string(),
+        departmentName: z.string().optional(),
+        role: z.string().optional(),
+        manpower: z.number(),
+        month: z.string(),
+        areaCode: z.string().optional(),
+        mpType: z.string().optional(),
+    })),
+});

package/dist/adapters/atlas/schema/department.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+// 部门树节点（API: POST /yuntu-service/department/tree/select.json）
+export const DepartmentNodeSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    parentId: z.string().optional(),
+    children: z.lazy(() => z.array(DepartmentNodeSchema)).optional(),
+});
+export const DepartmentTreeDataSchema = z.object({
+    departmentTree: z.array(DepartmentNodeSchema).optional(),
+});

package/dist/adapters/atlas/schema/index.js

@@ -0,0 +1,4 @@
+export * from './baseline.js';
+export * from './actual.js';
+export * from './project.js';
+export * from './department.js';

package/dist/adapters/atlas/schema/project.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+// 项目列表（API: POST /yuntu-service/project/selectHasPermisValidProject.json）
+export const ProjectSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    code: z.string().optional(),
+    status: z.string().optional(),
+    manager: z.string().optional(),
+    mpType: z.string().optional(),
+});
+export const ProjectListDataSchema = z.object({
+    projectList: z.array(ProjectSchema).optional(),
+});

package/dist/adapters/atlas/util/constants.js

@@ -0,0 +1,4 @@
+/** 工作天数每月 */
+export const MANHOURS_PER_MONTH = 22;
+/** 月份解析正则 */
+export const MONTH_PATTERN = /^(\d{4})[-/]?(\d{1,2})$/;

package/dist/adapters/atlas/util/env.js

@@ -0,0 +1,8 @@
+/** 获取 BANMA_PROJECT_ID 环境变量 */
+export function getBanmaProjectId() {
+    return process.env.BANMA_PROJECT_ID;
+}
+/** 是否禁用自动升级 */
+export function isUpdateDisabled() {
+    return process.env.ATLAS_DISABLE_UPDATE === '1';
+}

package/dist/adapters/atlas/util/errors.js

@@ -0,0 +1,45 @@
+import { ZodError } from 'zod';
+export class BanmaApiError extends Error {
+    errCode;
+    errorMsg;
+    requestId;
+    constructor(errCode, errorMsg, requestId) {
+        super(`Banma API error [${errCode}] ${errorMsg}`);
+        this.errCode = errCode;
+        this.errorMsg = errorMsg;
+        this.requestId = requestId;
+        this.name = 'BanmaApiError';
+    }
+}
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+export class SessionExpiredError extends Error {
+    constructor(message = '会话已过期，请重新登录：atlas auth login') {
+        super(message);
+        this.name = 'SessionExpiredError';
+    }
+}
+export class NotImplementedError extends Error {
+    constructor(message = '该功能尚未实现') {
+        super(message);
+        this.name = 'NotImplementedError';
+    }
+}
+export class AtlasError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AtlasError';
+    }
+}
+export function isAtlasError(err) {
+    return err instanceof AtlasError;
+}
+export function isZodError(err) {
+    return err instanceof ZodError;
+}

package/dist/adapters/atlas/util/helpers.js

@@ -0,0 +1,17 @@
+/** 将 人天 ÷ 22 转换为 人月 */
+export function manhoursToManMonth(hours) {
+    const v = typeof hours === 'string' ? parseFloat(hours) : hours;
+    if (isNaN(v) || v < 0)
+        return 0;
+    return Math.round((v / 22) * 100) / 100;
+}
+/** 格式化人力数字 */
+export function fmtManpower(v) {
+    if (v == null || isNaN(v))
+        return '-';
+    return v.toFixed(2);
+}
+/** 安全的 sum */
+export function safeSum(values) {
+    return values.reduce((acc, v) => acc + (v ?? 0), 0);
+}

package/dist/adapters/atlas/util/months.js

@@ -0,0 +1,41 @@
+/**
+ * 月份工具：展开月份范围、格式校验、上限保护。
+ */
+import { ConfigError } from './errors.js';
+import { currentMonthKey } from './time.js';
+/** YYYY-MM 格式正则 */
+const MONTH_RE = /^(\d{4})-(0[1-9]|1[0-2])$/;
+/** 单次查询最大月份数 */
+const MAX_MONTHS = 36;
+/**
+ * 展开月份范围 → YYYY-MM 数组。
+ * - 同时给 from/to：返回闭区间内的所有月份。
+ * - 都不给：返回当前月（单元素数组）。
+ * - 只给一个：按"都给"处理，缺失的那个用当前月补齐的语义由调用方决定（此处不单独支持）。
+ *
+ * 格式校验通过 MONTH_RE；无效格式或范围超过 MAX_MONTHS 抛 ConfigError。
+ */
+export function expandMonths(from, to) {
+    if (!from || !to)
+        return [currentMonthKey()];
+    if (!MONTH_RE.test(from))
+        throw new ConfigError(`月份格式应为 YYYY-MM（如 2026-03），实际: "${from}"`);
+    if (!MONTH_RE.test(to))
+        throw new ConfigError(`月份格式应为 YYYY-MM（如 2026-03），实际: "${to}"`);
+    const [fy, fm] = from.split('-').map(Number);
+    const [ty, tm] = to.split('-').map(Number);
+    const months = [];
+    let y = fy, m = fm;
+    while (y < ty || (y === ty && m <= tm)) {
+        months.push(`${y}-${String(m).padStart(2, '0')}`);
+        m++;
+        if (m > 12) {
+            m = 1;
+            y++;
+        }
+    }
+    if (months.length > MAX_MONTHS) {
+        throw new ConfigError(`月份范围过大: ${months.length} 个月（上限 ${MAX_MONTHS} 个月），请缩小查询范围`);
+    }
+    return months;
+}

package/dist/adapters/atlas/util/output-limit.js

@@ -0,0 +1,20 @@
+import { ConfigError } from './errors.js';
+const MAX_OUTPUT_BYTES_ENV = 'ATLAS_MAX_OUTPUT_BYTES';
+/**
+ * 在写出文件前校验输出字节数上限。
+ *
+ * 读取 ATLAS_MAX_OUTPUT_BYTES（字节数，需为正数）。未设置或非法值时放行；
+ * 超限时抛 ConfigError（退出码 64），供 agent 场景防止生成超大 CSV/JSON 占满磁盘。
+ */
+export function enforceOutputLimit(content) {
+    const raw = process.env[MAX_OUTPUT_BYTES_ENV];
+    if (!raw)
+        return;
+    const limit = Number(raw);
+    if (!Number.isFinite(limit) || limit <= 0)
+        return;
+    const bytes = Buffer.byteLength(content, 'utf-8');
+    if (bytes > limit) {
+        throw new ConfigError(`输出 ${bytes} 字节超过 ATLAS_MAX_OUTPUT_BYTES 上限 ${limit} 字节`);
+    }
+}

package/dist/adapters/atlas/util/output.js

@@ -0,0 +1,67 @@
+import { BanmaApiError, AtlasError, ConfigError, NotImplementedError, SessionExpiredError } from './errors.js';
+export function isJsonMode() {
+    return process.env.ATLAS_OUTPUT === 'json';
+}
+export function isQuietMode() {
+    return process.env.ATLAS_QUIET === '1';
+}
+export function jsonOk(data, meta) {
+    const envelope = { ok: true, data };
+    if (meta)
+        envelope.meta = meta;
+    process.stdout.write(JSON.stringify(envelope) + '\n');
+}
+export function jsonError(code, message) {
+    const envelope = { ok: false, error: { code, message } };
+    process.stdout.write(JSON.stringify(envelope) + '\n');
+}
+export function printError(err, opts) {
+    if (opts?.json && isJsonMode()) {
+        if (err instanceof BanmaApiError) {
+            jsonError(err.errCode, err.errorMsg);
+        }
+        else if (err instanceof AtlasError) {
+            jsonError(err.code, err.message);
+        }
+        else if (err instanceof Error) {
+            jsonError('ERROR', err.message);
+        }
+        else {
+            jsonError('ERROR', String(err));
+        }
+        return;
+    }
+    // Non-JSON error printing
+    if (err instanceof BanmaApiError) {
+        console.error(`Banma API error [${err.errCode}] ${err.errorMsg}`);
+    }
+    else if (err instanceof SessionExpiredError) {
+        console.error(err.message);
+    }
+    else if (err instanceof ConfigError) {
+        console.error(`Config error: ${err.message}`);
+    }
+    else if (err instanceof NotImplementedError) {
+        console.error(err.message);
+    }
+    else if (err instanceof AtlasError) {
+        console.error(`[${err.code}] ${err.message}`);
+    }
+    else if (err instanceof Error) {
+        const debug = process.env.DEBUG === '1';
+        console.error(debug ? err.stack ?? err.message : err.message);
+    }
+    else {
+        console.error(String(err));
+    }
+}
+export function log(msg) {
+    if (!isQuietMode()) {
+        console.error(msg);
+    }
+}
+export function table(data) {
+    if (!isJsonMode()) {
+        console.table(data);
+    }
+}