@doubao-dev/plugin-cli 0.0.0-stage → 0.0.40-canary-dea0ddc73-20261026073950

package/dist/188.js

@@ -0,0 +1,1691 @@
+import { Command, CommanderError, Option } from "commander";
+import strict from "node:assert/strict";
+import node_crypto, { randomUUID } from "node:crypto";
+import { z } from "zod";
+import node_os, { homedir } from "node:os";
+import node_path, { dirname, join, resolve as external_node_path_resolve } from "node:path";
+import { execFile, spawn } from "node:child_process";
+import node_fs, { existsSync, promises } from "node:fs";
+import { promisify, stripVTControlCharacters } from "node:util";
+import { setTimeout as promises_setTimeout } from "node:timers/promises";
+import { ofetch } from "ofetch";
+import { once } from "node:events";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import ora, { oraPromise } from "ora";
+import { log } from "@clack/prompts";
+import { readJsonSync } from "fs-extra/esm";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function applyPlugins(program, plugins) {
+    const names = new Set();
+    for (const { name } of plugins){
+        strict(name.trim() && !names.has(name), `插件名称为空或重复：${name}`);
+        names.add(name);
+    }
+    const hooks = {
+        addCommand: [],
+        dev: [],
+        modifyPackagePlan: [],
+        afterUpload: []
+    };
+    for (const plugin of plugins)try {
+        const pluginName = plugin.name;
+        await plugin.setup({
+            onAddCommand: (callback)=>{
+                hooks.addCommand.push({
+                    pluginName,
+                    callback
+                });
+            },
+            onDev: (callback)=>{
+                hooks.dev.push({
+                    pluginName,
+                    callback
+                });
+            },
+            onModifyPackagePlan: (callback)=>{
+                hooks.modifyPackagePlan.push({
+                    pluginName,
+                    callback
+                });
+            },
+            onAfterUpload: (callback)=>{
+                hooks.afterUpload.push({
+                    pluginName,
+                    callback
+                });
+            }
+        });
+    } catch (cause) {
+        throw new Error(`[${plugin.name}] 注册失败：${errorMessage(cause)}`, {
+            cause
+        });
+    }
+    for (const hook of hooks.addCommand)await callHook(hook, {
+        program,
+        hooks
+    });
+}
+async function callHook({ pluginName, callback }, ...args) {
+    try {
+        return await callback(...args);
+    } catch (cause) {
+        throw new Error(`[${pluginName}] ${errorMessage(cause)}`, {
+            cause
+        });
+    }
+}
+var package_namespaceObject = /*#__PURE__*/ JSON.parse('{"UU":"@doubao-dev/plugin-cli","rE":"0.0.40-canary-dea0ddc73-20261026073950","h_":"Doubao Plugins CLI"}');
+const runtime = {
+    name: package_namespaceObject.UU,
+    version: package_namespaceObject.rE,
+    description: package_namespaceObject.h_,
+    registry: 'https://registry.npmjs.org',
+    appDev: {
+        name: '@doubao-dev/plugin-app-dev',
+        version: package_namespaceObject.rE,
+        entry: '.'
+    },
+    kit: {
+        name: '@doubao-dev/kit',
+        version: process.env.DBX_KIT_VERSION?.trim() || "0.8.0-rc.2",
+        entry: './sdk'
+    },
+    auth: {
+        baseUrl: 'https://open.doubao.com',
+        verificationUrl: 'https://open.doubao.com/apps-plugin/oauth/device'
+    },
+    apiUrl: 'https://open.doubao.com',
+    deviceApiUrl: 'https://developer.doubao.com',
+    consoleUrl: 'https://open.doubao.com/console/plugins/create'
+};
+const DEFAULT_BASE_URL = 'https://developer.doubao.com';
+const DEFAULT_CLIENT_NAME = 'dbx-cli';
+const DEFAULT_TOKEN_PATH = node_path.join(node_os.homedir(), '.dbx', 'token');
+const LEGACY_TOKEN_PATH = node_path.join(node_os.homedir(), '.doubao', 'token');
+const configured = {};
+function config_resolveOptions(options = {}) {
+    const merged = {
+        ...configured,
+        ...options
+    };
+    const baseUrl = normalizeHttpsBaseUrl(merged.baseUrl ?? DEFAULT_BASE_URL, 'baseUrl');
+    const tokenPath = merged.tokenPath ?? DEFAULT_TOKEN_PATH;
+    return {
+        ...merged,
+        baseUrl,
+        verificationUrl: normalizeHttpsBaseUrl(merged.verificationUrl ?? new URL('/oauth/device', baseUrl).href, 'verificationUrl'),
+        allowedOrigins: normalizeAllowedOrigins(merged.allowedOrigins, baseUrl),
+        tokenPath,
+        legacyTokenPath: merged.tokenPath ? void 0 : LEGACY_TOKEN_PATH,
+        requestHeaders: new Headers(merged.requestHeaders)
+    };
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+function normalizeHttpsBaseUrl(value, label) {
+    let parsed;
+    try {
+        parsed = new URL(trimTrailingSlash(value));
+    } catch  {
+        throw new Error(`${label} 必须是完整的 HTTPS URL`);
+    }
+    if ('https:' !== parsed.protocol) throw new Error(`${label} 必须使用 HTTPS`);
+    return trimTrailingSlash(parsed.toString());
+}
+function normalizeAllowedOrigins(values, baseUrl) {
+    const origins = new Set([
+        new URL(baseUrl).origin
+    ]);
+    for (const value of values ?? []){
+        let parsed;
+        try {
+            parsed = new URL(value);
+        } catch  {
+            throw new Error(`allowedOrigins 中的来源必须是完整的 HTTPS 地址：${value}`);
+        }
+        if ('https:' !== parsed.protocol) throw new Error(`allowedOrigins 中的来源必须使用 HTTPS：${value}`);
+        origins.add(parsed.origin);
+    }
+    return [
+        ...origins
+    ];
+}
+const execFileAsync = promisify(execFile);
+const SERVICE_NAME = 'byted-doubao-open-dbx-cli';
+const LOCAL_STORE_DIR_NAME = 'dbx-cli';
+const MASTER_KEY_FILE = 'master.key';
+const CREDENTIALS_DIR = 'credentials';
+const AUTHORITIES_DIR = 'authorities';
+const LOCAL_STORE_VERSION = 1;
+const LOCAL_STORE_ALGORITHM = 'aes-256-gcm';
+class CredentialStoreError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'CredentialStoreError';
+    }
+}
+class MissingMasterKeyError extends CredentialStoreError {
+    constructor(){
+        super('无法读取本地登录凭证：用于解密凭证的密钥文件 master.key 已丢失。请运行 dbx auth login 重新登录。');
+    }
+}
+function defaultCredentialStore() {
+    const encryptedFileStore = new EncryptedFileCredentialStore();
+    if ('darwin' === process.platform) return new CredentialStoreWithFallback(new MacOSKeychainStore(), encryptedFileStore);
+    if ('linux' === process.platform) return new CredentialStoreWithFallback(new SecretToolStore(), encryptedFileStore);
+    return encryptedFileStore;
+}
+class CredentialStoreWithFallback {
+    constructor(primary, fallback){
+        this.primary = primary;
+        this.fallback = fallback;
+    }
+    async get(account) {
+        if (await this.isFallbackAuthoritative(account)) return this.fallback.get(account);
+        let primaryError;
+        try {
+            const value = await this.primary.get(account);
+            if (value) return value;
+        } catch (error) {
+            primaryError = error;
+        }
+        try {
+            const value = await this.fallback.get(account);
+            if (value) return value;
+        } catch (fallbackError) {
+            if (primaryError) throw new CredentialStoreError(`从系统凭证存储读取登录凭证失败（${credential_store_errorMessage(primaryError)}）；从备用加密文件读取也失败：${credential_store_errorMessage(fallbackError)}`);
+            throw fallbackError;
+        }
+        if (primaryError) throw primaryError instanceof Error ? primaryError : new CredentialStoreError(`从系统凭证存储读取登录凭证失败：${String(primaryError)}`);
+    }
+    async set(account, value) {
+        let primaryError;
+        try {
+            await this.primary.set(account, value);
+        } catch (error) {
+            primaryError = error;
+        }
+        try {
+            await this.fallback.set(account, value);
+        } catch (fallbackError) {
+            if (primaryError) throw new CredentialStoreError(`向系统凭证存储写入登录凭证失败（${credential_store_errorMessage(primaryError)}），写入备用加密文件也失败（${credential_store_errorMessage(fallbackError)}）`);
+            await this.removeStaleFallbackAfterPrimaryWrite(account, fallbackError);
+            throw fallbackError;
+        }
+        if (primaryError) await this.markFallbackAuthoritative(account);
+        else await this.clearFallbackAuthority(account);
+    }
+    async delete(account) {
+        let firstError;
+        try {
+            await this.primary.delete(account);
+        } catch (error) {
+            firstError = error;
+        }
+        try {
+            await this.fallback.delete(account);
+        } catch (error) {
+            if (firstError) throw new CredentialStoreError(`从系统凭证存储删除登录凭证失败（${credential_store_errorMessage(firstError)}），从备用加密文件删除也失败（${credential_store_errorMessage(error)}）`);
+            throw error;
+        }
+        if (firstError) return void await this.markFallbackAuthoritativeOrThrow(account, firstError);
+        await this.clearFallbackAuthority(account);
+    }
+    async isFallbackAuthoritative(account) {
+        return supportsCredentialAuthority(this.fallback) ? this.fallback.isFallbackAuthoritative(account) : false;
+    }
+    async markFallbackAuthoritative(account) {
+        if (supportsCredentialAuthority(this.fallback)) await this.fallback.markFallbackAuthoritative(account);
+    }
+    async markFallbackAuthoritativeOrThrow(account, primaryError) {
+        if (!supportsCredentialAuthority(this.fallback)) throw primaryError instanceof Error ? primaryError : new CredentialStoreError(`系统凭证删除失败，且备用存储无法记录删除状态：${String(primaryError)}`);
+        try {
+            await this.fallback.markFallbackAuthoritative(account);
+        } catch (error) {
+            throw new CredentialStoreError(`系统凭证删除失败（${credential_store_errorMessage(primaryError)}），且无法记录备用凭证删除状态：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async clearFallbackAuthority(account) {
+        if (supportsCredentialAuthority(this.fallback)) await this.fallback.clearFallbackAuthority(account);
+    }
+    async removeStaleFallbackAfterPrimaryWrite(account, fallbackError) {
+        const cleanupErrors = [];
+        try {
+            await this.fallback.delete(account);
+        } catch (error) {
+            cleanupErrors.push(error);
+        }
+        try {
+            await this.clearFallbackAuthority(account);
+        } catch (error) {
+            cleanupErrors.push(error);
+        }
+        if (cleanupErrors.length > 0) throw new CredentialStoreError(`系统凭证已写入，但备用加密文件写入失败（${credential_store_errorMessage(fallbackError)}），且清理旧备用凭证失败：${cleanupErrors.map(credential_store_errorMessage).join('；')}`);
+    }
+}
+class EncryptedFileCredentialStore {
+    constructor(options = {}){
+        this.baseDir = options.baseDir ?? defaultEncryptedCredentialDir();
+    }
+    async get(account) {
+        const filePath = this.credentialFilePath(account);
+        let raw;
+        try {
+            raw = await promises.readFile(filePath, 'utf8');
+        } catch (error) {
+            if (isNodeError(error) && 'ENOENT' === error.code) return;
+            throw new CredentialStoreError(`读取加密凭证文件失败：${credential_store_errorMessage(error)}`);
+        }
+        let record;
+        try {
+            record = JSON.parse(raw);
+        } catch (error) {
+            throw new CredentialStoreError(`加密凭证文件不是有效的 JSON：${credential_store_errorMessage(error)}`);
+        }
+        if (!isEncryptedCredentialRecord(record)) throw new CredentialStoreError('无法读取本地登录凭证：当前 CLI 不支持凭证文件中的格式或字段。');
+        const key = await this.readMasterKey();
+        try {
+            const decipher = node_crypto.createDecipheriv(LOCAL_STORE_ALGORITHM, key, Buffer.from(record.iv, 'base64url'));
+            decipher.setAAD(Buffer.from(associatedData(account), 'utf8'));
+            decipher.setAuthTag(Buffer.from(record.authTag, 'base64url'));
+            const plaintext = Buffer.concat([
+                decipher.update(Buffer.from(record.ciphertext, 'base64url')),
+                decipher.final()
+            ]);
+            return plaintext.toString('utf8');
+        } catch (error) {
+            throw new CredentialStoreError(`解密凭证文件失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async set(account, value) {
+        const key = await this.readOrCreateMasterKey();
+        const iv = node_crypto.randomBytes(12);
+        const cipher = node_crypto.createCipheriv(LOCAL_STORE_ALGORITHM, key, iv);
+        cipher.setAAD(Buffer.from(associatedData(account), 'utf8'));
+        const ciphertext = Buffer.concat([
+            cipher.update(value, 'utf8'),
+            cipher.final()
+        ]);
+        const record = {
+            version: LOCAL_STORE_VERSION,
+            algorithm: LOCAL_STORE_ALGORITHM,
+            iv: iv.toString('base64url'),
+            authTag: cipher.getAuthTag().toString('base64url'),
+            ciphertext: ciphertext.toString('base64url')
+        };
+        await writePrivateFileAtomic(this.credentialFilePath(account), `${JSON.stringify(record, null, 2)}\n`);
+    }
+    async delete(account) {
+        try {
+            await promises.unlink(this.credentialFilePath(account));
+        } catch (error) {
+            if (!isNodeError(error) || 'ENOENT' !== error.code) throw new CredentialStoreError(`删除加密凭证文件失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async isFallbackAuthoritative(account) {
+        try {
+            const raw = await promises.readFile(this.authorityFilePath(account), 'utf8');
+            const parsed = JSON.parse(raw);
+            return 1 === parsed.version && 'fallback' === parsed.authority;
+        } catch (error) {
+            if (isNodeError(error) && 'ENOENT' === error.code) return false;
+            throw new CredentialStoreError(`读取登录凭证权威副本标记失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async markFallbackAuthoritative(account) {
+        const record = {
+            version: 1,
+            authority: 'fallback'
+        };
+        await writePrivateFileAtomic(this.authorityFilePath(account), `${JSON.stringify(record, null, 2)}\n`);
+    }
+    async clearFallbackAuthority(account) {
+        try {
+            await promises.unlink(this.authorityFilePath(account));
+        } catch (error) {
+            if (!isNodeError(error) || 'ENOENT' !== error.code) throw new CredentialStoreError(`清理登录凭证权威副本标记失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    masterKeyPath() {
+        return node_path.join(this.baseDir, MASTER_KEY_FILE);
+    }
+    credentialFilePath(account) {
+        const digest = node_crypto.createHash('sha256').update(account).digest('hex');
+        return node_path.join(this.baseDir, CREDENTIALS_DIR, `${digest}.json`);
+    }
+    authorityFilePath(account) {
+        const digest = node_crypto.createHash('sha256').update(account).digest('hex');
+        return node_path.join(this.baseDir, AUTHORITIES_DIR, `${digest}.json`);
+    }
+    async readMasterKey() {
+        try {
+            return parseMasterKey(await promises.readFile(this.masterKeyPath(), 'utf8'));
+        } catch (error) {
+            if (isNodeError(error) && 'ENOENT' === error.code) throw new MissingMasterKeyError();
+            if (error instanceof CredentialStoreError) throw error;
+            throw new CredentialStoreError(`无法读取用于解密本地登录凭证的密钥文件 master.key：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async readOrCreateMasterKey() {
+        try {
+            return await this.readMasterKey();
+        } catch (error) {
+            if (!(error instanceof MissingMasterKeyError)) throw error;
+        }
+        const key = node_crypto.randomBytes(32);
+        try {
+            const created = await writePrivateFileCreateOnce(this.masterKeyPath(), `${key.toString('base64url')}\n`);
+            return created ? key : this.readMasterKey();
+        } catch (error) {
+            throw new CredentialStoreError(`无法保存用于加密本地登录凭证的密钥文件 master.key：${credential_store_errorMessage(error)}`);
+        }
+    }
+}
+class MacOSKeychainStore {
+    async get(account) {
+        try {
+            const { stdout } = await execFileAsync('security', [
+                'find-generic-password',
+                '-a',
+                account,
+                '-s',
+                SERVICE_NAME,
+                '-w'
+            ]);
+            return String(stdout).replace(/\n$/, '');
+        } catch (error) {
+            if (isMacOSKeychainNotFound(error)) return;
+            throw new CredentialStoreError(`从 macOS 钥匙串读取登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async set(account, value) {
+        try {
+            await execFileAsync('security', [
+                'add-generic-password',
+                '-a',
+                account,
+                '-s',
+                SERVICE_NAME,
+                '-w',
+                value,
+                '-U'
+            ]);
+        } catch (error) {
+            throw new CredentialStoreError(`向 macOS 钥匙串写入登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async delete(account) {
+        try {
+            await execFileAsync('security', [
+                'delete-generic-password',
+                '-a',
+                account,
+                '-s',
+                SERVICE_NAME
+            ]);
+        } catch (error) {
+            if (isMacOSKeychainNotFound(error)) return;
+            throw new CredentialStoreError(`从 macOS 钥匙串删除登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+}
+class SecretToolStore {
+    async get(account) {
+        try {
+            const { stdout } = await execFileAsync('secret-tool', [
+                'lookup',
+                'service',
+                SERVICE_NAME,
+                'account',
+                account
+            ]);
+            return String(stdout).replace(/\n$/, '');
+        } catch (error) {
+            if (isSecretToolNotFound(error)) return;
+            throw new CredentialStoreError(`从 Secret Service 读取登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async set(account, value) {
+        try {
+            await execFileWithInput('secret-tool', [
+                'store',
+                '--label',
+                'Doubao Open CLI 登录凭证',
+                'service',
+                SERVICE_NAME,
+                'account',
+                account
+            ], value);
+        } catch (error) {
+            throw new CredentialStoreError(`向 Secret Service 写入登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+    async delete(account) {
+        try {
+            await execFileAsync('secret-tool', [
+                'clear',
+                'service',
+                SERVICE_NAME,
+                'account',
+                account
+            ]);
+        } catch (error) {
+            if (isSecretToolNotFound(error)) return;
+            throw new CredentialStoreError(`从 Secret Service 删除登录凭证失败：${credential_store_errorMessage(error)}`);
+        }
+    }
+}
+function execFileWithInput(command, args, input) {
+    return new Promise((resolve, reject)=>{
+        const child = spawn(command, args, {
+            stdio: [
+                'pipe',
+                'ignore',
+                'pipe'
+            ]
+        });
+        let stderr = '';
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk)=>{
+            stderr += String(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code)=>{
+            if (0 === code) resolve();
+            else {
+                const error = new Error(stderr.trim() || `${command} 已退出，退出码为 ${code}`);
+                reject(error);
+            }
+        });
+        child.stdin.end(input);
+    });
+}
+async function writePrivateFileAtomic(filePath, payload) {
+    const dir = node_path.dirname(filePath);
+    await promises.mkdir(dir, {
+        recursive: true,
+        mode: 448
+    });
+    if ('win32' !== process.platform) await promises.chmod(dir, 448);
+    const tempPath = node_path.join(dir, `.${node_path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        await promises.writeFile(tempPath, payload, {
+            mode: 384,
+            flag: 'wx'
+        });
+        if ('win32' !== process.platform) await promises.chmod(tempPath, 384);
+        await promises.rename(tempPath, filePath);
+        if ('win32' !== process.platform) await promises.chmod(filePath, 384);
+    } finally{
+        try {
+            await promises.unlink(tempPath);
+        } catch  {}
+    }
+}
+async function writePrivateFileCreateOnce(filePath, payload) {
+    const dir = node_path.dirname(filePath);
+    await promises.mkdir(dir, {
+        recursive: true,
+        mode: 448
+    });
+    if ('win32' !== process.platform) await promises.chmod(dir, 448);
+    const tempPath = node_path.join(dir, `.${node_path.basename(filePath)}.${process.pid}.${Date.now()}.${node_crypto.randomBytes(8).toString('hex')}.tmp`);
+    try {
+        await promises.writeFile(tempPath, payload, {
+            mode: 384,
+            flag: 'wx'
+        });
+        if ('win32' !== process.platform) await promises.chmod(tempPath, 384);
+        try {
+            await promises.link(tempPath, filePath);
+            if ('win32' !== process.platform) await promises.chmod(filePath, 384);
+            return true;
+        } catch (error) {
+            if (isNodeError(error) && 'EEXIST' === error.code) return false;
+            throw error;
+        }
+    } finally{
+        try {
+            await promises.unlink(tempPath);
+        } catch  {}
+    }
+}
+function supportsCredentialAuthority(store) {
+    const candidate = store;
+    return 'function' == typeof candidate.isFallbackAuthoritative && 'function' == typeof candidate.markFallbackAuthoritative && 'function' == typeof candidate.clearFallbackAuthority;
+}
+function parseMasterKey(raw) {
+    const key = Buffer.from(raw.trim(), 'base64url');
+    if (32 !== key.length) throw new CredentialStoreError('无法读取本地登录凭证：密钥文件 master.key 的内容无法解析为 32 字节密钥。');
+    return key;
+}
+function isEncryptedCredentialRecord(value) {
+    if (!value || 'object' != typeof value) return false;
+    const record = value;
+    return record.version === LOCAL_STORE_VERSION && record.algorithm === LOCAL_STORE_ALGORITHM && 'string' == typeof record.iv && 'string' == typeof record.authTag && 'string' == typeof record.ciphertext;
+}
+function associatedData(account) {
+    return `${SERVICE_NAME}:${account}`;
+}
+function defaultEncryptedCredentialDir() {
+    if ('darwin' === process.platform) return node_path.join(node_os.homedir(), 'Library', 'Application Support', LOCAL_STORE_DIR_NAME);
+    if ('win32' === process.platform) return node_path.join(process.env.APPDATA || node_path.join(node_os.homedir(), 'AppData', 'Roaming'), LOCAL_STORE_DIR_NAME);
+    return node_path.join(process.env.XDG_DATA_HOME || node_path.join(node_os.homedir(), '.local', 'share'), LOCAL_STORE_DIR_NAME);
+}
+function isMacOSKeychainNotFound(error) {
+    const code = errorCode(error);
+    const stderr = errorStderr(error);
+    return (1 === code || 44 === code) && (stderr.includes('could not be found') || stderr.includes('The specified item could not be found'));
+}
+function isSecretToolNotFound(error) {
+    const code = errorCode(error);
+    const stderr = errorStderr(error);
+    return 1 === code && (stderr.includes('could not be found') || stderr.includes('No matching items') || '' === stderr.trim());
+}
+function errorCode(error) {
+    return 'object' == typeof error && null !== error && 'code' in error ? error.code : void 0;
+}
+function errorStderr(error) {
+    return 'object' == typeof error && null !== error && 'stderr' in error ? String(error.stderr ?? '') : '';
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function credential_store_errorMessage(error) {
+    if ('object' == typeof error && null !== error && 'stderr' in error) {
+        const stderr = String(error.stderr ?? '').trim();
+        if (stderr) return stderr;
+    }
+    if (error instanceof Error && error.message) return error.message;
+    return String(error);
+}
+class AuthError extends Error {
+    constructor(message, code){
+        super(message);
+        this.code = code;
+        this.name = 'AuthError';
+    }
+}
+class NotLoggedInError extends AuthError {
+    constructor(message = '尚未登录，请运行 dbx auth login 完成登录。'){
+        super(message, 'NOT_LOGGED_IN');
+        this.name = 'NotLoggedInError';
+    }
+}
+class TokenExpiredError extends AuthError {
+    constructor(message = '登录凭证已过期，请运行 dbx auth login 重新登录。'){
+        super(message, 'TOKEN_EXPIRED');
+        this.name = 'TokenExpiredError';
+    }
+}
+class DeviceAuthError extends AuthError {
+    constructor(message, code = 'DEVICE_AUTH_FAILED', options = {}){
+        super(message, code);
+        this.name = 'DeviceAuthError';
+        this.logId = options.logId;
+    }
+}
+function decodeJwtPayload(token) {
+    const part = token.split('.')[1];
+    if (!part) return;
+    try {
+        const json = Buffer.from(part, 'base64url').toString('utf8');
+        const payload = JSON.parse(json);
+        return payload && 'object' == typeof payload ? payload : void 0;
+    } catch  {
+        return;
+    }
+}
+function getUidFromToken(token) {
+    const payload = decodeJwtPayload(token);
+    const uid = payload?.uid ?? payload?.sub;
+    if ('string' == typeof uid && uid.length > 0) return uid;
+    if ('number' == typeof uid && Number.isFinite(uid)) return String(uid);
+}
+const ENV_ACCESS_TOKEN_EXPIRES_AT = 4102444800;
+async function readToken(tokenPath, options = {}) {
+    const envToken = readAccessTokenFromEnv();
+    if (envToken) return {
+        accessToken: envToken,
+        tokenType: 'Bearer',
+        expiresAt: ENV_ACCESS_TOKEN_EXPIRES_AT,
+        baseUrl: options.envTokenBaseUrl ?? ''
+    };
+    const raw = await readTokenFile(tokenPath);
+    if (void 0 === raw) return readLegacyPlaintextToken(tokenPath, options);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch (_error) {
+        return;
+    }
+    if (isStoredTokenMetadata(parsed)) {
+        if (!options.allowExpired && isExpired(parsed)) return void await store_deleteToken(tokenPath, options);
+        const accessToken = await credentialStore(options).get(parsed.credentialAccount);
+        if (!accessToken) throw new CredentialStoreError("已找到登录记录，但登录凭证缺失或无法访问。请在能够访问凭证存储的终端中重新运行 dbx auth login。");
+        return {
+            accessToken,
+            tokenType: parsed.tokenType,
+            expiresAt: parsed.expiresAt,
+            baseUrl: parsed.baseUrl
+        };
+    }
+    if (!isStoredToken(parsed)) return;
+    if (!options.allowExpired && isExpired(parsed)) return void await store_deleteToken(tokenPath, options);
+    await writeToken(tokenPath, parsed, options);
+    return parsed;
+}
+async function writeToken(tokenPath, token, options = {}) {
+    const metadata = {
+        version: 2,
+        storage: 'keychain',
+        credentialAccount: credentialAccountForPath(tokenPath),
+        tokenType: token.tokenType,
+        expiresAt: token.expiresAt,
+        baseUrl: token.baseUrl
+    };
+    await credentialStore(options).set(metadata.credentialAccount, token.accessToken);
+    await promises.mkdir(node_path.dirname(tokenPath), {
+        recursive: true,
+        mode: 448
+    });
+    if ('win32' !== process.platform) await promises.chmod(node_path.dirname(tokenPath), 448);
+    const tempPath = `${tokenPath}.${process.pid}.${Date.now()}.tmp`;
+    await promises.writeFile(tempPath, `${JSON.stringify(metadata, null, 2)}\n`, {
+        mode: 384
+    });
+    if ('win32' !== process.platform) await promises.chmod(tempPath, 384);
+    await promises.rename(tempPath, tokenPath);
+    if ('win32' !== process.platform) await promises.chmod(tokenPath, 384);
+}
+async function store_deleteToken(tokenPath, options = {}) {
+    const raw = await readTokenFile(tokenPath);
+    let account = credentialAccountForPath(tokenPath);
+    if (void 0 !== raw) try {
+        const parsed = JSON.parse(raw);
+        if (isStoredTokenMetadata(parsed)) account = parsed.credentialAccount;
+    } catch  {}
+    await credentialStore(options).delete(account);
+    try {
+        await promises.unlink(tokenPath);
+    } catch (error) {
+        if (!store_isNodeError(error) || 'ENOENT' !== error.code) throw error;
+    }
+}
+function isExpired(token, nowSeconds = Math.floor(Date.now() / 1000)) {
+    return token.expiresAt <= nowSeconds;
+}
+function isStoredToken(value) {
+    if (!value || 'object' != typeof value) return false;
+    const token = value;
+    return 'string' == typeof token.accessToken && token.accessToken.length > 0 && 'string' == typeof token.tokenType && token.tokenType.length > 0 && 'number' == typeof token.expiresAt && Number.isFinite(token.expiresAt) && 'string' == typeof token.baseUrl && token.baseUrl.length > 0;
+}
+function isStoredTokenMetadata(value) {
+    if (!value || 'object' != typeof value) return false;
+    const metadata = value;
+    return 2 === metadata.version && 'keychain' === metadata.storage && 'string' == typeof metadata.credentialAccount && metadata.credentialAccount.length > 0 && 'string' == typeof metadata.tokenType && metadata.tokenType.length > 0 && 'number' == typeof metadata.expiresAt && Number.isFinite(metadata.expiresAt) && 'string' == typeof metadata.baseUrl && metadata.baseUrl.length > 0;
+}
+async function readTokenFile(tokenPath) {
+    try {
+        return await promises.readFile(tokenPath, 'utf8');
+    } catch (error) {
+        store_isNodeError(error) && error.code;
+        return;
+    }
+}
+async function readLegacyPlaintextToken(tokenPath, options) {
+    if (!options.legacyTokenPath || node_path.resolve(options.legacyTokenPath) === node_path.resolve(tokenPath)) return;
+    const raw = await readTokenFile(options.legacyTokenPath);
+    if (void 0 === raw) return;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        return;
+    }
+    if (!isStoredToken(parsed)) return;
+    if (!options.allowExpired && isExpired(parsed)) return void await store_deleteToken(options.legacyTokenPath, options);
+    await writeToken(tokenPath, parsed, options);
+    await store_deleteToken(options.legacyTokenPath, options);
+    return parsed;
+}
+function credentialStore(options) {
+    return options.credentialStore ?? defaultCredentialStore();
+}
+function credentialAccountForPath(tokenPath) {
+    const digest = node_crypto.createHash('sha256').update(node_path.resolve(tokenPath)).digest('hex').slice(0, 32);
+    return `token:${digest}`;
+}
+function readAccessTokenFromEnv() {
+    const value = process.env.DBX_ACCESS_TOKEN?.trim();
+    return value ? value : void 0;
+}
+function store_isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+var types_TokenStatus;
+(function(TokenStatus) {
+    TokenStatus[TokenStatus["Pending"] = 1] = "Pending";
+    TokenStatus[TokenStatus["Authorized"] = 2] = "Authorized";
+    TokenStatus[TokenStatus["Expired"] = 3] = "Expired";
+    TokenStatus[TokenStatus["Invalid"] = 4] = "Invalid";
+    TokenStatus[TokenStatus["SlowDown"] = 5] = "SlowDown";
+})(types_TokenStatus || (types_TokenStatus = {}));
+const ISSUE_DEVICE_CODE_PATH = '/app_developer/oauth/device/code';
+const EXCHANGE_DEVICE_TOKEN_PATH = '/app_developer/oauth/token';
+async function login(options = {}) {
+    const resolved = config_resolveOptions(options);
+    const fetchImpl = resolved.fetch ?? fetch;
+    const device = await requestDeviceCode(fetchImpl, resolved.baseUrl, resolved.requestHeaders);
+    const verificationUrl = buildVerificationUrl(resolved.verificationUrl, device.user_code);
+    resolved.onVerification?.({
+        userCode: device.user_code,
+        verificationUrl,
+        expiresIn: device.expires_in,
+        interval: device.interval
+    });
+    return pollDeviceToken(device.device_code, resolved, Math.max(1, device.interval), 1000 * device.expires_in);
+}
+async function startLogin(options = {}) {
+    const resolved = config_resolveOptions(options);
+    const fetchImpl = resolved.fetch ?? fetch;
+    const device = await requestDeviceCode(fetchImpl, resolved.baseUrl, resolved.requestHeaders);
+    const verificationUrl = buildVerificationUrl(resolved.verificationUrl, device.user_code);
+    resolved.onVerification?.({
+        userCode: device.user_code,
+        verificationUrl,
+        expiresIn: device.expires_in,
+        interval: device.interval
+    });
+    return {
+        userCode: device.user_code,
+        deviceCode: device.device_code,
+        verificationUrl,
+        expiresIn: device.expires_in,
+        interval: device.interval
+    };
+}
+async function completeLogin(deviceCode, options = {}) {
+    return pollDeviceToken(deviceCode, config_resolveOptions(options), 5, 600000);
+}
+async function pollDeviceToken(deviceCode, resolved, initialInterval, expiresInMs) {
+    const fetchImpl = resolved.fetch ?? fetch;
+    const sleep = resolved.sleep ?? promises_setTimeout;
+    let intervalSeconds = initialInterval;
+    const deadline = Date.now() + expiresInMs;
+    while(Date.now() < deadline){
+        await sleep(1000 * intervalSeconds);
+        const token = await requestToken(fetchImpl, resolved.baseUrl, deviceCode, resolved.requestHeaders);
+        resolved.onPoll?.({
+            status: token.status,
+            interval: intervalSeconds
+        });
+        if (token.status === types_TokenStatus.Pending) continue;
+        if (token.status === types_TokenStatus.SlowDown) {
+            intervalSeconds += initialInterval;
+            continue;
+        }
+        if (token.status === types_TokenStatus.Expired) throw new DeviceAuthError('设备授权已过期，请运行 dbx auth login 重新登录。', 'DEVICE_AUTH_EXPIRED');
+        if (token.status === types_TokenStatus.Invalid) throw new DeviceAuthError('设备授权无效，请运行 dbx auth login 重新登录。', 'DEVICE_AUTH_INVALID');
+        if (token.status === types_TokenStatus.Authorized) {
+            if (!token.access_token) throw new DeviceAuthError('无法完成登录：认证服务已确认授权，但未返回 access_token。');
+            const stored = toStoredToken(token, resolved.baseUrl);
+            await writeToken(resolved.tokenPath, stored, {
+                credentialStore: resolved.credentialStore
+            });
+            return {
+                accessToken: stored.accessToken,
+                tokenType: stored.tokenType,
+                expiresAt: stored.expiresAt,
+                baseUrl: stored.baseUrl,
+                uid: getUidFromToken(stored.accessToken),
+                tokenPath: resolved.tokenPath
+            };
+        }
+        throw new DeviceAuthError(`无法完成登录：认证服务返回了无法识别的授权状态 status=${String(token.status)}`);
+    }
+    throw new DeviceAuthError('等待设备授权超时，请运行 dbx auth login 重新发起登录。', 'DEVICE_AUTH_EXPIRED');
+}
+async function requestDeviceCode(fetchImpl, baseUrl, requestHeaders) {
+    const response = await fetchImpl(`${baseUrl}${ISSUE_DEVICE_CODE_PATH}`, {
+        method: 'POST',
+        headers: withJsonHeaders(requestHeaders),
+        body: JSON.stringify({
+            client_name: DEFAULT_CLIENT_NAME
+        })
+    });
+    const data = await readJson(response);
+    const payload = unwrapData(data);
+    if (!payload || !payload.device_code || !payload.user_code || 'number' != typeof payload.expires_in || 'number' != typeof payload.interval) throw new DeviceAuthError(`无法获取登录授权码：认证服务返回的数据缺少必要字段或字段类型不正确（HTTP ${response.status}）：${JSON.stringify(data)}`);
+    return payload;
+}
+async function requestToken(fetchImpl, baseUrl, deviceCode, requestHeaders) {
+    const response = await fetchImpl(`${baseUrl}${EXCHANGE_DEVICE_TOKEN_PATH}`, {
+        method: 'POST',
+        headers: withJsonHeaders(requestHeaders),
+        body: JSON.stringify({
+            device_code: deviceCode
+        })
+    });
+    const data = await readJson(response);
+    const payload = unwrapData(data);
+    if (payload?.access_token) return {
+        status: types_TokenStatus.Authorized,
+        access_token: payload.access_token,
+        token_type: payload.token_type,
+        expires_in: payload.expires_in,
+        expires_at: payload.expires_at
+    };
+    if (!payload || 'number' != typeof payload.status) throw new DeviceAuthError(`无法获取登录凭证：认证服务返回的数据缺少有效的 status 字段（HTTP ${response.status}）：${JSON.stringify(data)}`);
+    return payload;
+}
+async function readJson(response) {
+    const headerLogId = response.headers.get('x-tt-logid') ?? void 0;
+    let data;
+    try {
+        data = await response.json();
+    } catch  {
+        throw new DeviceAuthError(`无法读取登录结果：认证服务返回的内容不是有效的 JSON（HTTP ${response.status}）${formatLogId(headerLogId)}`, 'DEVICE_AUTH_FAILED', {
+            logId: headerLogId
+        });
+    }
+    const bodyLogId = extractLogId(data);
+    const logId = bodyLogId ?? headerLogId;
+    if (!response.ok) throw new DeviceAuthError(`认证服务返回 HTTP ${response.status}：${JSON.stringify(data)}${formatLogId(logId)}`, 'DEVICE_AUTH_FAILED', {
+        logId
+    });
+    const apiError = extractApiError(data);
+    if (apiError) throw new DeviceAuthError(`认证服务出错（错误码 ${apiError.code}）：${apiError.message}${formatLogId(apiError.logId ?? logId)}`, 'DEVICE_AUTH_FAILED', {
+        logId: apiError.logId ?? logId
+    });
+    return data;
+}
+function extractApiError(data) {
+    if (data && 'object' == typeof data) {
+        const d = data;
+        if ('number' == typeof d.code && 0 !== d.code) return {
+            code: d.code,
+            message: 'string' == typeof d.message ? d.message : '未知错误',
+            logId: 'string' == typeof d.log_id ? d.log_id : void 0
+        };
+    }
+    return null;
+}
+function extractLogId(data) {
+    if (!data || 'object' != typeof data) return;
+    const d = data;
+    return 'string' == typeof d.log_id && d.log_id ? d.log_id : void 0;
+}
+function formatLogId(logId) {
+    return logId ? ` [log_id: ${logId}]` : '';
+}
+function unwrapData(data) {
+    if (data && 'object' == typeof data && 'data' in data) return data.data;
+    return data;
+}
+function withJsonHeaders(requestHeaders) {
+    const headers = new Headers(requestHeaders);
+    headers.set('Content-Type', 'application/json');
+    return headers;
+}
+function toStoredToken(response, baseUrl) {
+    const now = Math.floor(Date.now() / 1000);
+    return {
+        accessToken: response.access_token ?? '',
+        tokenType: response.token_type ?? 'Bearer',
+        expiresAt: 'number' == typeof response.expires_at ? response.expires_at : now + (response.expires_in ?? 0),
+        baseUrl
+    };
+}
+function buildVerificationUrl(verificationUrl, userCode) {
+    const url = new URL(verificationUrl);
+    url.searchParams.set('user_code', userCode);
+    return url.toString();
+}
+function getAuthHeaders(input, headers, options = {}) {
+    return resolveAuthHeaders(input, headers, config_resolveOptions(options));
+}
+async function resolveAuthHeaders(input, initHeaders, resolved) {
+    assertAllowedAuthenticatedRequest(input, resolved.allowedOrigins);
+    const token = await readToken(resolved.tokenPath, {
+        allowExpired: true,
+        envTokenBaseUrl: resolved.baseUrl,
+        credentialStore: resolved.credentialStore,
+        legacyTokenPath: resolved.legacyTokenPath
+    });
+    if (!token) throw new NotLoggedInError();
+    if (isExpired(token)) throw new TokenExpiredError();
+    const headers = createMergedHeaders(input, initHeaders);
+    resolved.requestHeaders.forEach((value, key)=>{
+        headers.set(key, value);
+    });
+    headers.set('Authorization', `${token.tokenType || 'Bearer'} ${token.accessToken}`);
+    return headers;
+}
+function createMergedHeaders(input, initHeaders) {
+    const headers = new Headers(input instanceof Request ? input.headers : void 0);
+    new Headers(initHeaders).forEach((value, key)=>{
+        headers.set(key, value);
+    });
+    return headers;
+}
+function assertAllowedAuthenticatedRequest(input, allowedOrigins) {
+    const url = requestUrl(input);
+    if ('https:' !== url.protocol) throw new Error(`携带登录凭证的请求必须使用 HTTPS：${url.toString()}`);
+    if (!allowedOrigins.includes(url.origin)) throw new Error(`无法向不受信任的来源发送 Authorization 请求头：${url.origin}`);
+}
+function requestUrl(input) {
+    try {
+        if ('string' == typeof input) return new URL(input);
+        if (input instanceof URL) return input;
+        return new URL(input.url);
+    } catch  {
+        throw new Error('携带登录凭证的请求必须使用完整的 HTTPS URL');
+    }
+}
+async function whoami(options = {}) {
+    const resolved = config_resolveOptions(options);
+    let token;
+    try {
+        token = await readToken(resolved.tokenPath, {
+            envTokenBaseUrl: resolved.baseUrl,
+            credentialStore: resolved.credentialStore,
+            legacyTokenPath: resolved.legacyTokenPath
+        });
+    } catch (error) {
+        if (error instanceof CredentialStoreError) return {
+            loggedIn: false,
+            tokenPath: resolved.tokenPath,
+            baseUrl: resolved.baseUrl,
+            credentialError: {
+                code: 'CREDENTIAL_STORE_UNAVAILABLE',
+                message: error.message
+            }
+        };
+        throw error;
+    }
+    if (!token) return {
+        loggedIn: false,
+        tokenPath: resolved.tokenPath
+    };
+    const user = await fetchCurrentUser(options.fetch ?? fetch, resolved.baseUrl, token, resolved.requestHeaders);
+    if (!user) return {
+        loggedIn: false,
+        expiresAt: token.expiresAt,
+        tokenPath: resolved.tokenPath,
+        baseUrl: resolved.baseUrl
+    };
+    return {
+        loggedIn: true,
+        uid: user.userId,
+        name: user.name,
+        avatar: user.avatar,
+        expiresAt: token.expiresAt,
+        tokenPath: resolved.tokenPath,
+        baseUrl: resolved.baseUrl
+    };
+}
+async function fetchCurrentUser(fetchImpl, baseUrl, token, requestHeaders) {
+    const headers = new Headers(requestHeaders);
+    headers.set('Authorization', `${token.tokenType || 'Bearer'} ${token.accessToken}`);
+    const response = await fetchImpl(`${baseUrl.replace(/\/+$/, '')}/app_developer/api/user/basic`, {
+        method: 'GET',
+        headers
+    });
+    if (!response.ok) return;
+    const result = await response.json();
+    if (0 !== result.code) return;
+    const userId = toStringId(result.data?.user_id);
+    return {
+        userId,
+        name: result.data?.name,
+        avatar: result.data?.avatar
+    };
+}
+function toStringId(value) {
+    if ('string' == typeof value && value.length > 0) return value;
+    if ('number' == typeof value && Number.isFinite(value)) return String(value);
+}
+const baseURL = `${process.env.DBX_BUILD_API_BASE_URL || runtime.apiUrl}/platform/api/v1`;
+const http_request = ofetch.create({
+    baseURL: baseURL,
+    headers: runtime.apiHeaders,
+    method: 'GET',
+    timeout: 30000,
+    retry: 0,
+    redirect: 'error',
+    responseType: 'json',
+    ignoreResponseError: true,
+    async onRequest ({ request, options }) {
+        const target = 'string' == typeof request ? new URL(request, options.baseURL) : request;
+        options.headers = await getAuthHeaders(target, options.headers, {
+            baseUrl: options.baseURL
+        });
+        if (options.signal && options.timeout) options.signal = AbortSignal.any([
+            options.signal,
+            AbortSignal.timeout(options.timeout)
+        ]);
+    },
+    onResponse ({ response }) {
+        const result = response._data;
+        if (!response.ok || result?.code !== 0) {
+            const message = result?.msg || result?.message || result?.statusText || `接口请求失败（HTTP ${response.status}）`;
+            const details = [];
+            if (response.headers.has('x-tt-logid')) details.push(`请求日志 ID：${response.headers.get('x-tt-logid')}`);
+            throw new Error([
+                message,
+                '',
+                ...details
+            ].join('\n'));
+        }
+        response._data = result.data;
+    }
+});
+async function createDeviceTicket(params, signal) {
+    const data = await http_request(`/app_developer/check_api/apps/${encodeURIComponent(params.appKey)}/debug/ticket`, {
+        baseURL: runtime.deviceApiUrl,
+        method: 'POST',
+        signal,
+        body: {
+            debug_context: JSON.stringify({
+                appletName: params.appKey,
+                appletHost: params.hostUrl,
+                appletType: 0,
+                isSigned: false,
+                isEncrypted: false,
+                defaultDebugTagState: true,
+                wifiConnectUrl: params.wifiConnectUrl,
+                ...params.versionTag ? {
+                    versionTag: params.versionTag
+                } : {}
+            })
+        }
+    });
+    const ticket = z.object({
+        debug_token: z.string().trim().min(1),
+        encrypted_debug_payload: z.string().trim().min(1)
+    }).parse(data);
+    return {
+        debugToken: ticket.debug_token,
+        qrCodeValue: JSON.stringify({
+            action: 'start_real_device_debug',
+            ...ticket
+        })
+    };
+}
+function getAppInfo(params, signal) {
+    return http_request('/devtool/plugin-mini-app-base-info', {
+        query: {
+            ...params
+        },
+        signal
+    });
+}
+function uploadPackage(fileName, packageContent, signal) {
+    return http_request('/devtool/plugin-package-uploads', {
+        method: 'POST',
+        query: {
+            file_name: fileName
+        },
+        headers: {
+            'Content-Type': 'application/zip'
+        },
+        body: packageContent,
+        signal
+    });
+}
+function validateMaterial(params) {
+    return http_request('/devtool/plugin-material-validations', {
+        method: 'POST',
+        body: params
+    });
+}
+function listPluginCategories() {
+    return http_request('/devtool/plugin-categories');
+}
+function getPluginDraft(name) {
+    return http_request('/devtool/plugin-drafts', {
+        query: {
+            name
+        }
+    });
+}
+function upsertPluginDraft(params) {
+    return http_request('/devtool/plugin-drafts', {
+        method: 'POST',
+        body: params
+    });
+}
+function savePluginVersion(params) {
+    return http_request('/devtool/plugin-versions', {
+        method: 'POST',
+        body: params
+    });
+}
+async function listPluginVersions(plugin, signal) {
+    const identity = plugin.id ? {
+        ability_id: plugin.id
+    } : {
+        name: plugin.name
+    };
+    const versions = [];
+    const tokens = new Set();
+    let pageToken;
+    do {
+        signal?.throwIfAborted();
+        const result = await http_request('/devtool/plugin-versions', {
+            query: {
+                ...identity,
+                page_size: 50,
+                page_token: pageToken
+            },
+            signal
+        });
+        versions.push(...result.items ?? []);
+        pageToken = result.page?.next_page_token;
+        if (pageToken && tokens.has(pageToken)) throw new Error('版本列表分页异常，请稍后重试');
+        if (pageToken) tokens.add(pageToken);
+    }while (pageToken);
+    return versions.sort((left, right)=>(right.version ?? '').localeCompare(left.version ?? '', 'en', {
+            numeric: true
+        }));
+}
+function getBuildStatus(params, signal) {
+    return http_request('/devtool/plugin-versions/build-status', {
+        query: {
+            ...params
+        },
+        signal
+    });
+}
+function createPreview(params, signal) {
+    return http_request('/devtool/plugin-previews', {
+        method: 'POST',
+        body: params,
+        signal
+    });
+}
+function updateUserPlugin(params, signal) {
+    return http_request('/devtool/plugin-operations', {
+        method: 'POST',
+        body: params,
+        signal
+    });
+}
+function submitApproval(name, version) {
+    return http_request('/devtool/plugin-approvals/submit', {
+        method: 'POST',
+        body: {
+            name,
+            version
+        }
+    });
+}
+function withdrawApproval(approvalId) {
+    return http_request('/devtool/plugin-approvals/withdraw', {
+        method: 'POST',
+        body: {
+            approval_id: approvalId
+        }
+    });
+}
+const PLUGIN_MANIFEST_FILENAME = 'plugin.json';
+const MCP_CONFIG_FILENAME = 'mcp.json';
+const SKILL_FILENAME = 'SKILL.md';
+const APP_MANIFEST_FILENAME = 'manifest.yaml';
+const DOUBAO_APP_DIRECTORY = 'com.doubao/app';
+const APP_GENERATED_DIRECTORIES = [
+    'dist',
+    'node_modules/.doubao'
+];
+const PROJECT_EXCLUDED_DIRECTORIES = [
+    '.git',
+    '.dbx'
+];
+const PROJECT_EXCLUDED_FILES = [
+    '.gitkeep',
+    '.gitignore',
+    '.DS_Store'
+];
+const TEMPLATES_DIRECTORY = 'templates';
+const STANDARD_TEMPLATE_DIRECTORY = 'standard';
+const TEMPLATE_SUFFIX = '.template';
+const PLUGIN_NAME_PLACEHOLDER = '__PLUGIN_NAME__';
+const PACKAGE_CACHE_DIRECTORY = '.dbx/tools';
+const SKILL_NAME = 'doubao-plugin-cli';
+const APP_SKILL_NAME = 'doubao-plugin-app';
+const PROJECT_SKILL_PATH = `.agents/skills/${SKILL_NAME}`;
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function writeStdout(message) {
+    console.log(stripVTControlCharacters(message));
+}
+function writeStderr(message) {
+    console.error(stripVTControlCharacters(message));
+}
+const terminal_log = isInteractive() ? log : {
+    info: writeStdout,
+    step: writeStdout,
+    success: writeStdout,
+    warn: writeStderr,
+    error: writeStderr
+};
+function resolveEntry(require, spec) {
+    try {
+        const manifestPath = require.resolve(`${spec.name}/package.json`);
+        const manifest = JSON.parse(node_fs.readFileSync(manifestPath, 'utf8'));
+        if (manifest.version !== spec.version) return;
+        const exported = manifest.exports?.[spec.entry];
+        const relativeEntry = 'string' == typeof exported ? exported : exported?.import;
+        if ('string' != typeof relativeEntry || !relativeEntry) return;
+        const entry = node_path.resolve(node_path.dirname(manifestPath), relativeEntry);
+        if (node_fs.existsSync(entry)) return entry;
+    } catch (error) {
+        if ('MODULE_NOT_FOUND' !== error.code) throw error;
+    }
+}
+async function loadPackage(spec, signal, output) {
+    signal.throwIfAborted();
+    const cache = node_path.join(homedir(), PACKAGE_CACHE_DIRECTORY, spec.name, spec.version);
+    const requireCache = createRequire(node_path.join(cache, 'package.json'));
+    let entry = resolveEntry(createRequire(import.meta.url), spec) ?? resolveEntry(requireCache, spec);
+    if (!entry) {
+        node_fs.mkdirSync(node_path.dirname(cache), {
+            recursive: true
+        });
+        const staging = node_fs.mkdtempSync(`${cache}-`);
+        const label = spec.name === runtime.kit.name ? '应用编译与模拟器工具' : '应用开发工具';
+        const progress = output || !isInteractive() ? void 0 : ora({
+            text: ` 正在安装${label}`,
+            stream: process.stdout,
+            discardStdin: false
+        }).start();
+        try {
+            if (!progress) (output?.log ?? terminal_log).info(`正在安装${label}`);
+            const child = spawn('npm', [
+                'install',
+                `${spec.name}@${spec.version}`,
+                '--prefix',
+                staging,
+                '--registry',
+                runtime.registry,
+                '--no-audit',
+                '--no-fund',
+                '--loglevel',
+                'error'
+            ], {
+                stdio: [
+                    'ignore',
+                    'ignore',
+                    'pipe'
+                ],
+                signal
+            });
+            let installError = '';
+            child.stderr.on('data', (data)=>{
+                installError += data.toString();
+            });
+            const [code] = await once(child, 'close');
+            if (0 !== code) throw new Error(`${spec.name} 安装失败，退出码：${code}\n${installError.trim()}`);
+            signal.throwIfAborted();
+            if (!resolveEntry(createRequire(node_path.join(staging, 'package.json')), spec)) throw new Error(`${spec.name} 的版本或入口不正确`);
+            try {
+                node_fs.renameSync(staging, cache);
+            } catch  {
+                if (!resolveEntry(requireCache, spec)) {
+                    node_fs.rmSync(cache, {
+                        recursive: true,
+                        force: true
+                    });
+                    node_fs.renameSync(staging, cache);
+                }
+            }
+            entry = resolveEntry(requireCache, spec);
+            progress?.succeed(` ${label}已安装`);
+        } catch (error) {
+            progress?.fail(signal.aborted ? ` 已取消安装${label}` : ` ${label}安装失败`);
+            signal.throwIfAborted();
+            throw error;
+        } finally{
+            node_fs.rmSync(staging, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
+    signal.throwIfAborted();
+    if (!entry) throw new Error(`${spec.name} 的入口不存在`);
+    return pathToFileURL(entry).href;
+}
+function withProgress(message, action) {
+    if (!isInteractive()) {
+        terminal_log.info(message);
+        return action();
+    }
+    return oraPromise(action, {
+        text: ` ${message}`,
+        successText: ` ${message}完成`,
+        stream: process.stdout,
+        discardStdin: false
+    });
+}
+let installing;
+async function loadAppModule(entry, signal = new AbortController().signal, output) {
+    const main = await (installing ??= loadPackage(runtime.appDev, signal, output));
+    signal.throwIfAborted();
+    const url = '.' === entry ? main : await loadPackage({
+        ...runtime.appDev,
+        entry
+    }, signal, output);
+    return import(url);
+}
+const appPlugin = {
+    name: 'doubao-app',
+    setup (api) {
+        api.onAddCommand(({ program })=>{
+            program.commands.find((command)=>'dev' === command.name()).option('--app', '同时启动应用调试（App）');
+        });
+        api.onDev(()=>[
+                {
+                    name: 'app',
+                    title: '应用调试（App）',
+                    option: 'app',
+                    watch: [
+                        MCP_CONFIG_FILENAME
+                    ],
+                    appliesTo: ({ project })=>Boolean(project.app),
+                    async start (ctx) {
+                        const { startApp } = await loadAppModule('.', ctx.signal, ctx);
+                        ctx.signal.throwIfAborted();
+                        await startApp(ctx, {
+                            kitVersion: runtime.kit.version,
+                            quiet: !ctx.interactive,
+                            loadKit: (output)=>loadPackage(runtime.kit, ctx.signal, output),
+                            queryAppInfo: getAppInfo,
+                            requestTicket: createDeviceTicket,
+                            queryVersions: ()=>listPluginVersions(ctx.project.plugin, ctx.signal)
+                        });
+                    },
+                    async createUI (ctx, onExit) {
+                        const { createAppUI } = await loadAppModule('./ui', ctx.signal);
+                        ctx.signal.throwIfAborted();
+                        return createAppUI({
+                            name: ctx.project.plugin.name,
+                            version: runtime.version,
+                            metadata: {
+                                Kit: runtime.kit.version
+                            },
+                            onExit
+                        });
+                    }
+                }
+            ]);
+        api.onModifyPackagePlan((_ctx, plan)=>({
+                ...plan,
+                exclude: [
+                    ...plan.exclude ?? [],
+                    `${DOUBAO_APP_DIRECTORY}/node_modules`
+                ]
+            }));
+        api.onAfterUpload(async (ctx)=>{
+            if (!ctx.project.app) return;
+            const { version } = await withProgress('保存预览版本', ()=>savePluginVersion({
+                    ...ctx.project.plugin.id ? {
+                        ability_id: ctx.project.plugin.id
+                    } : {
+                        name: ctx.project.plugin.name
+                    },
+                    request_id: randomUUID()
+                }));
+            if (!version) throw new Error('服务端未返回保存的版本号，请到平台草稿页查看。');
+            const { showPreview } = await loadAppModule('./preview');
+            await showPreview(ctx.project, version, {
+                withProgress: withProgress,
+                queryBuildStatus: getBuildStatus,
+                createPreview: createPreview
+            });
+        });
+    }
+};
+function findProjectRoot(cwd) {
+    let root = external_node_path_resolve(cwd);
+    while(!existsSync(join(root, PLUGIN_MANIFEST_FILENAME))){
+        const parent = dirname(root);
+        if (parent === root) throw new Error(`未找到 plugin.json，请在应用插件项目内运行：${cwd}`);
+        root = parent;
+    }
+    return root;
+}
+function findApp(projectRoot) {
+    const root = join(projectRoot, DOUBAO_APP_DIRECTORY);
+    if (existsSync(join(root, APP_MANIFEST_FILENAME)) && findProjectRoot(root) === projectRoot) return {
+        root
+    };
+}
+const projectNameMessage = '项目名称须为 1 至 64 个小写字母、数字、连字符或点号，以字母或数字开头结尾，且不能包含连续连字符或连续点号。';
+const projectNameSchema = z.string().max(64, projectNameMessage).regex(/^(?!.*(?:--|\.\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/, projectNameMessage);
+const versionSchema = z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/, '版本号须为 x.y.z 格式，不能包含前导零');
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const pluginManifestSchema = z.looseObject({
+    $schema: z.string().optional(),
+    name: projectNameSchema,
+    id: z.string().optional(),
+    displayName: z.string().optional(),
+    description: z.string().optional(),
+    extensions: jsonObjectSchema.optional()
+});
+const mcpConfigSchema = z.looseObject({
+    mcpServers: z.record(z.string(), jsonObjectSchema)
+});
+function currentSkillsRoot(packageName = runtime.name) {
+    const source = packageName.replace(/^@/, '').replace(/[\\/]/g, '+');
+    return join(homedir(), '.dbx', 'skills', source, 'current');
+}
+function refreshSkills() {
+    const bundledRoot = external_node_path_resolve(import.meta.dirname, 'skills');
+    if (!__rspack_external_node_fs_1b05aee1.statSync(join(bundledRoot, SKILL_NAME, 'SKILL.md')).isFile()) throw new Error('CLI 安装包中的开发 Skill 不完整，请重新安装 CLI。');
+    replaceDirectoryLink(bundledRoot, currentSkillsRoot());
+}
+async function syncProjectSkill(cwd) {
+    const projectRoot = findProjectRoot(cwd);
+    pluginManifestSchema.parse(readJsonSync(join(projectRoot, 'plugin.json')));
+    const hasApp = Boolean(findApp(projectRoot));
+    const sources = [
+        [
+            SKILL_NAME,
+            currentSkillsRoot()
+        ]
+    ];
+    if (hasApp) {
+        const { skillsRoot } = await loadAppModule('./assets');
+        const appSkillsRoot = currentSkillsRoot(runtime.appDev.name);
+        replaceDirectoryLink(skillsRoot, appSkillsRoot);
+        sources.push([
+            APP_SKILL_NAME,
+            appSkillsRoot
+        ]);
+    }
+    for (const [name, source] of sources){
+        const skillPath = `.agents/skills/${name}`;
+        replaceDirectoryLink(join(source, name), join(projectRoot, skillPath));
+        const ignorePath = join(projectRoot, '.gitignore');
+        const ignore = __rspack_external_node_fs_1b05aee1.existsSync(ignorePath) ? __rspack_external_node_fs_1b05aee1.readFileSync(ignorePath, 'utf8') : '';
+        const pattern = `/${skillPath}`;
+        if (!ignore.split(/\r?\n/).includes(pattern)) appendText(ignorePath, ignore, `${pattern}\n`);
+    }
+    const guidePath = join(projectRoot, 'AGENTS.md');
+    const guide = __rspack_external_node_fs_1b05aee1.existsSync(guidePath) ? __rspack_external_node_fs_1b05aee1.readFileSync(guidePath, 'utf8') : '';
+    if (!guide.includes(`${PROJECT_SKILL_PATH}/SKILL.md`)) {
+        const template = __rspack_external_node_fs_1b05aee1.readFileSync(join(import.meta.dirname, 'templates/standard/AGENTS.md'), 'utf8');
+        appendText(guidePath, guide, template);
+    }
+    const appSkillPath = `.agents/skills/${APP_SKILL_NAME}/SKILL.md`;
+    if (hasApp && !guide.includes(appSkillPath)) appendText(guidePath, __rspack_external_node_fs_1b05aee1.readFileSync(guidePath, 'utf8'), `\n仅开发豆包 App 的 Page、Widget 或 Manifest 时，先阅读 [应用开发 Skill](${appSkillPath})。普通 MCP 和 MCP Apps 不使用 App Manifest。\n`);
+}
+function appendText(path, existing, text) {
+    const separator = existing && !existing.endsWith('\n') ? '\n' : '';
+    __rspack_external_node_fs_1b05aee1.writeFileSync(path, `${existing}${separator}${text}`);
+}
+function replaceDirectoryLink(source, target) {
+    const existing = __rspack_external_node_fs_1b05aee1.lstatSync(target, {
+        throwIfNoEntry: false
+    });
+    if (existing?.isSymbolicLink() && external_node_path_resolve(dirname(target), __rspack_external_node_fs_1b05aee1.readlinkSync(target)) === source) return;
+    if (existing && !existing.isSymbolicLink()) throw new Error(`开发 Skill 路径已存在且不是软链接，请先确认并移走该路径：${target}`);
+    __rspack_external_node_fs_1b05aee1.mkdirSync(dirname(target), {
+        recursive: true
+    });
+    __rspack_external_node_fs_1b05aee1.rmSync(target, {
+        recursive: true,
+        force: true
+    });
+    __rspack_external_node_fs_1b05aee1.symlinkSync(source, target, 'win32' === process.platform ? 'junction' : 'dir');
+}
+const builtinPlugin = {
+    name: 'builtin',
+    setup (api) {
+        api.onAddCommand(({ program, hooks })=>{
+            const cwdOption = new Option('--cwd <path>', '项目根目录').argParser((value)=>external_node_path_resolve(value)).default(process.cwd());
+            program.command('init').description('创建应用插件项目').argument('[name]', '项目名称，同时作为目录名').option('--app', '添加应用前端（App）').option('--no-install-deps', '创建 App 后不安装前端依赖').action(async (name, options)=>{
+                const { runInit } = await import("./command~3.js");
+                return runInit(name, options);
+            });
+            program.command('upload').description('上传应用插件包到开放平台').addOption(cwdOption).option('--version <version>', '应用插件版本，格式为 x.y.z').action(withProject(async (project, options)=>{
+                const { runUpload } = await import("./command~4.js");
+                await runUpload(project, options, hooks);
+            }));
+            program.command('dev').addOption(new Option('--plugin', '仅调试 Skill / MCP').conflicts('app')).option('--no-tui', '使用普通日志，不询问、不显示交互界面或自动发起登录').description('启动本地开发调试，监听目录变化并同步插件开发包').addOption(cwdOption).action(withProject(async (project, options)=>{
+                const { runSession } = await import("./session.js");
+                await runSession(project, options, hooks.dev);
+            }));
+            program.command('uninstall').description('从当前用户卸载插件开发包').addOption(cwdOption).action(withProject(async (project)=>{
+                const { runUninstall } = await import("./uninstall.js");
+                await runUninstall(project);
+            }));
+            program.command('categories').description('查询审核类目，输出包含 category_id 和 name 的 JSON 列表').action(async ()=>{
+                const { runCategories } = await import("./categories.js");
+                await runCategories();
+            });
+            program.command('audit').description('完善应用插件草稿、保存版本并提交审核').option('--input <path>', '审核材料 JSON 文件；相对路径按项目根目录解析，跳过交互提示').addOption(cwdOption).action(withProject(async (project, options)=>{
+                const { runAudit } = await import("./command.js");
+                await runAudit(project, options);
+            }));
+            program.command('cancel-audit').description('取消应用插件提审').addOption(cwdOption).action(withProject(async (project)=>{
+                const { runCancelAudit } = await import("./command~2.js");
+                await runCancelAudit(project);
+            }));
+            program.command('skills').description('配置项目开发 Skill').addOption(cwdOption).action(async ({ cwd })=>{
+                await syncProjectSkill(cwd);
+                terminal_log.success('项目开发 Skill 已配置');
+            });
+            const auth = program.command('auth').description('认证管理');
+            auth.command('login').description('登录').addOption(new Option('--begin', '发起设备授权并显示操作说明').conflicts('complete')).addOption(new Option('--complete <device-code>', '使用指定设备码完成授权').conflicts('begin')).action(async (options)=>{
+                const { runLogin } = await import("./command~1.js");
+                await runLogin(options);
+            });
+            auth.command('status').description('查看登录状态').action(async ()=>{
+                const { runStatus } = await import("./command~1.js");
+                await runStatus();
+            });
+        });
+    }
+};
+function withProject(run) {
+    return async ({ cwd, ...options })=>{
+        const { PluginProject } = await import("./plugin.js");
+        await run(new PluginProject(cwd), options);
+    };
+}
+const platformService = {
+    name: 'platform',
+    title: '插件调试（Skill / MCP）',
+    watch: [
+        "skills",
+        MCP_CONFIG_FILENAME,
+        PLUGIN_MANIFEST_FILENAME
+    ],
+    appliesTo: ()=>true,
+    async start (ctx) {
+        const sync = async ()=>{
+            try {
+                ctx.report({
+                    status: 'pending',
+                    message: '正在打包开发项目'
+                });
+                const content = await ctx.project.pack({
+                    exclude: [
+                        DOUBAO_APP_DIRECTORY
+                    ]
+                });
+                ctx.signal.throwIfAborted();
+                ctx.report({
+                    status: 'pending',
+                    message: '正在上传开发包'
+                });
+                const { package_id } = await uploadPackage(`${ctx.project.plugin.name}-${Date.now()}.zip`, content, ctx.signal);
+                if (!package_id) throw new Error('上传失败：服务端未返回 package_id');
+                ctx.signal.throwIfAborted();
+                ctx.report({
+                    status: 'pending',
+                    message: '正在安装应用插件到当前用户'
+                });
+                await updateUserPlugin({
+                    package_id,
+                    action: 'Install'
+                }, ctx.signal);
+                ctx.report({
+                    status: 'success',
+                    message: '已同步'
+                });
+            } catch (error) {
+                if (!ctx.signal.aborted) {
+                    ctx.report({
+                        status: 'error',
+                        message: '同步失败'
+                    });
+                    ctx.log.error(`平台同步失败：${errorMessage(error)}`);
+                }
+            }
+        };
+        ctx.onFileChange(sync);
+        await sync();
+    }
+};
+const platformPlugin = {
+    name: 'platform',
+    setup (api) {
+        api.onDev(()=>[
+                platformService
+            ]);
+    }
+};
+async function main_main(argv = process.argv, options = {}) {
+    const dbx = new Command().name('dbx').description(runtime.description).version(runtime.version, '-V, --version').enablePositionalOptions().configureOutput({
+        outputError: (message)=>terminal_log.error(message.trimEnd())
+    }).exitOverride();
+    try {
+        await applyPlugins(dbx, [
+            builtinPlugin,
+            platformPlugin,
+            appPlugin,
+            ...options.plugins ?? []
+        ]);
+        dbx.action(()=>dbx.outputHelp());
+        refreshSkills();
+        await dbx.parseAsync(argv);
+    } catch (error) {
+        if (error instanceof CommanderError) {
+            process.exitCode = error.exitCode;
+            return;
+        }
+        terminal_log.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+export { APP_GENERATED_DIRECTORIES, DOUBAO_APP_DIRECTORY, MCP_CONFIG_FILENAME, NotLoggedInError, PLUGIN_MANIFEST_FILENAME, PLUGIN_NAME_PLACEHOLDER, PROJECT_EXCLUDED_DIRECTORIES, PROJECT_EXCLUDED_FILES, SKILL_FILENAME, STANDARD_TEMPLATE_DIRECTORY, TEMPLATES_DIRECTORY, TEMPLATE_SUFFIX, callHook, completeLogin, errorMessage, findApp, findProjectRoot, getPluginDraft, isInteractive, listPluginCategories, listPluginVersions, loadAppModule, loadPackage, login, main_main as main, mcpConfigSchema, pluginManifestSchema, projectNameSchema, runtime, savePluginVersion, startLogin, submitApproval, syncProjectSkill, terminal_log, updateUserPlugin, uploadPackage, upsertPluginDraft, validateMaterial, versionSchema, whoami, withProgress, withdrawApproval };