bailian-cli-core 1.0.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,924 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+import { createHash, createHmac, randomUUID } from "crypto";
+//#region src/errors/codes.ts
+const ExitCode = {
+	SUCCESS: 0,
+	GENERAL: 1,
+	USAGE: 2,
+	AUTH: 3,
+	QUOTA: 4,
+	TIMEOUT: 5,
+	NETWORK: 6,
+	CONTENT_FILTER: 10
+};
+//#endregion
+//#region src/errors/base.ts
+/**
+* Base error class for the Bailian SDK.
+*
+* Carries an `exitCode` (intended for CLI consumers to translate into a
+* process exit code) and an optional `hint` describing how to recover.
+* SDK consumers may ignore `exitCode` and treat instances as ordinary errors.
+*/
+var BailianError = class extends Error {
+	exitCode;
+	hint;
+	constructor(message, exitCode = ExitCode.GENERAL, hint) {
+		super(message);
+		this.name = "BailianError";
+		this.exitCode = exitCode;
+		this.hint = hint;
+	}
+	toJSON() {
+		return { error: {
+			code: this.exitCode,
+			message: this.message,
+			...this.hint ? { hint: this.hint } : {}
+		} };
+	}
+};
+//#endregion
+//#region src/errors/api.ts
+function mapApiError(status, body, _url) {
+	const apiMsg = body.error?.message || body.message || `HTTP ${status}`;
+	const apiCode = body.error?.type || body.code;
+	if (status === 401 || status === 403 || apiCode === "InvalidApiKey" || apiCode === "Unauthorized") return new BailianError(`API key rejected (HTTP ${status}). ${apiMsg}`, ExitCode.AUTH, "Verify your API key is valid and not expired.");
+	if (status === 429 || apiCode === "Throttling" || apiCode === "Throttling.RateQuota" || apiCode === "Throttling.AllocationQuota") return new BailianError(`Rate limit or quota exceeded. ${apiMsg}`, ExitCode.QUOTA, "Wait a moment and retry, or check your account quota.");
+	if (status === 408 || status === 504) return new BailianError(`Request timed out (HTTP ${status}).`, ExitCode.TIMEOUT, "Try increasing the request timeout or retry later.");
+	if (apiCode === "InvalidParameter" || apiCode === "BadRequest") return new BailianError(`Invalid parameter: ${apiMsg}`, ExitCode.USAGE);
+	if (apiCode === "ModelNotFound" || apiCode === "AccessDenied") return new BailianError(`Model access denied or not found: ${apiMsg}`, ExitCode.AUTH, "Verify the model name and that your account has access to it.");
+	if (apiCode === "DataInspectionFailed") return new BailianError(`Content flagged by safety filter: ${apiMsg}`, ExitCode.CONTENT_FILTER);
+	return new BailianError(`API error: ${apiMsg} (HTTP ${status}${apiCode ? `, code: ${apiCode}` : ""})`, ExitCode.GENERAL);
+}
+//#endregion
+//#region src/config/schema.ts
+const REGIONS = {
+	cn: "https://dashscope.aliyuncs.com",
+	us: "https://dashscope-us.aliyuncs.com",
+	intl: "https://dashscope-intl.aliyuncs.com"
+};
+const DOCS_HOSTS = {
+	cn: "https://help.aliyun.com/zh/model-studio",
+	us: "https://help.aliyun.com/zh/model-studio",
+	intl: "https://help.aliyun.com/zh/model-studio"
+};
+const BAILIAN_HOST = "https://bailian.cn-beijing.aliyuncs.com";
+const VALID_REGIONS = new Set([
+	"cn",
+	"us",
+	"intl"
+]);
+const VALID_OUTPUTS = new Set(["text", "json"]);
+function parseConfigFile(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+	const obj = raw;
+	const out = {};
+	if (typeof obj.api_key === "string") out.api_key = obj.api_key;
+	if (typeof obj.region === "string" && VALID_REGIONS.has(obj.region)) out.region = obj.region;
+	if (typeof obj.base_url === "string" && obj.base_url.startsWith("http")) out.base_url = obj.base_url;
+	if (typeof obj.output === "string" && VALID_OUTPUTS.has(obj.output)) out.output = obj.output;
+	if (typeof obj.output_dir === "string" && obj.output_dir.length > 0) out.output_dir = obj.output_dir;
+	if (typeof obj.timeout === "number" && obj.timeout > 0) out.timeout = obj.timeout;
+	if (typeof obj.default_text_model === "string" && obj.default_text_model.length > 0) out.default_text_model = obj.default_text_model;
+	if (typeof obj.default_video_model === "string" && obj.default_video_model.length > 0) out.default_video_model = obj.default_video_model;
+	if (typeof obj.default_image_model === "string" && obj.default_image_model.length > 0) out.default_image_model = obj.default_image_model;
+	if (typeof obj.default_speech_model === "string" && obj.default_speech_model.length > 0) out.default_speech_model = obj.default_speech_model;
+	if (typeof obj.default_omni_model === "string" && obj.default_omni_model.length > 0) out.default_omni_model = obj.default_omni_model;
+	if (typeof obj.access_key_id === "string" && obj.access_key_id.length > 0) out.access_key_id = obj.access_key_id;
+	if (typeof obj.access_key_secret === "string" && obj.access_key_secret.length > 0) out.access_key_secret = obj.access_key_secret;
+	if (typeof obj.workspace_id === "string" && obj.workspace_id.length > 0) out.workspace_id = obj.workspace_id;
+	return out;
+}
+//#endregion
+//#region src/config/paths.ts
+const CONFIG_DIR_NAME = ".bailian";
+function getConfigDir() {
+	if (process.env.BAILIAN_CONFIG_DIR) return process.env.BAILIAN_CONFIG_DIR;
+	return join(homedir(), CONFIG_DIR_NAME);
+}
+function getConfigPath() {
+	return join(getConfigDir(), "config.json");
+}
+function getCredentialsPath() {
+	return join(getConfigDir(), "credentials.json");
+}
+async function ensureConfigDir() {
+	const dir = getConfigDir();
+	await (await import("fs/promises")).mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+}
+//#endregion
+//#region src/output/text.ts
+function formatText(data) {
+	if (data === null || data === void 0) return "";
+	if (typeof data === "string") return data;
+	if (typeof data === "number" || typeof data === "boolean") return String(data);
+	if (Array.isArray(data)) {
+		if (data.length === 0) return "(empty)";
+		if (typeof data[0] === "object" && data[0] !== null) return formatTable(data);
+		return data.map(String).join("\n");
+	}
+	if (typeof data === "object") return formatKeyValue(data);
+	return String(data);
+}
+function formatKeyValue(obj, indent = 0) {
+	const prefix = " ".repeat(indent);
+	const lines = [];
+	for (const [key, value] of Object.entries(obj)) {
+		if (value === null || value === void 0) continue;
+		if (Array.isArray(value)) {
+			lines.push(`${prefix}${key}:`);
+			for (const item of value) if (typeof item === "object" && item !== null) lines.push(`${prefix}  - ${formatKeyValue(item, indent + 4).trimStart()}`);
+			else lines.push(`${prefix}  - ${String(item)}`);
+		} else if (typeof value === "object") {
+			lines.push(`${prefix}${key}:`);
+			lines.push(formatKeyValue(value, indent + 2));
+		} else lines.push(`${prefix}${key}: ${String(value)}`);
+	}
+	return lines.join("\n");
+}
+function formatTable(rows) {
+	if (rows.length === 0) return "(empty)";
+	const keys = Object.keys(rows[0]);
+	const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length)));
+	return [
+		keys.map((k, i) => k.toUpperCase().padEnd(widths[i])).join("  "),
+		widths.map((w) => "-".repeat(w)).join("  "),
+		...rows.map((r) => keys.map((k, i) => String(r[k] ?? "").padEnd(widths[i])).join("  "))
+	].join("\n");
+}
+//#endregion
+//#region src/output/json.ts
+function formatJson(data) {
+	return JSON.stringify(data, null, 2);
+}
+function formatErrorJson(code, message, hint) {
+	return JSON.stringify({ error: {
+		code,
+		message,
+		...hint ? { hint } : {}
+	} }, null, 2);
+}
+//#endregion
+//#region src/output/formatter.ts
+function detectOutputFormat(flagValue) {
+	if (flagValue === "json" || flagValue === "text") return flagValue;
+	if (!process.stdout.isTTY) return "json";
+	return "text";
+}
+function formatOutput(data, format) {
+	switch (format) {
+		case "json": return formatJson(data);
+		case "text": return formatText(data);
+	}
+}
+//#endregion
+//#region src/config/loader.ts
+function readConfigFile() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return {};
+	try {
+		return parseConfigFile(JSON.parse(readFileSync(path, "utf-8")));
+	} catch (err) {
+		const e = err;
+		if (e instanceof SyntaxError || e.message.includes("JSON")) console.warn("Warning: config file is corrupted; using defaults.");
+		return {};
+	}
+}
+async function writeConfigFile(data) {
+	await ensureConfigDir();
+	const path = getConfigPath();
+	const tmp = path + ".tmp";
+	writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+	renameSync(tmp, path);
+}
+function loadConfig(flags) {
+	const file = readConfigFile();
+	const apiKey = flags.apiKey || void 0;
+	const fileApiKey = file.api_key;
+	const explicitRegion = flags.region || process.env.DASHSCOPE_REGION || void 0;
+	const cachedRegion = file.region;
+	const region = explicitRegion || cachedRegion || "cn";
+	const baseUrl = flags.baseUrl || process.env.DASHSCOPE_BASE_URL || file.base_url || REGIONS[region] || REGIONS.cn;
+	const output = detectOutputFormat(flags.output || process.env.DASHSCOPE_OUTPUT || file.output);
+	const envTimeout = process.env.DASHSCOPE_TIMEOUT ? Number(process.env.DASHSCOPE_TIMEOUT) : void 0;
+	const validEnvTimeout = envTimeout !== void 0 && Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : void 0;
+	const timeout = flags.timeout ?? validEnvTimeout ?? file.timeout ?? 300;
+	if (!Number.isFinite(timeout) || timeout <= 0) throw new BailianError("Timeout must be a positive finite number.", ExitCode.USAGE);
+	return {
+		apiKey,
+		fileApiKey,
+		fileRegion: file.region,
+		configPath: getConfigPath(),
+		region,
+		baseUrl,
+		output,
+		outputDir: file.output_dir || void 0,
+		timeout,
+		defaultTextModel: file.default_text_model,
+		defaultVideoModel: file.default_video_model,
+		defaultImageModel: file.default_image_model,
+		defaultSpeechModel: file.default_speech_model,
+		defaultOmniModel: file.default_omni_model,
+		accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID || file.access_key_id || void 0,
+		accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET || file.access_key_secret || void 0,
+		workspaceId: process.env.BAILIAN_WORKSPACE_ID || file.workspace_id || void 0,
+		verbose: flags.verbose || process.env.DASHSCOPE_VERBOSE === "1",
+		quiet: flags.quiet || false,
+		noColor: flags.noColor || process.env.NO_COLOR !== void 0 || !process.stdout.isTTY,
+		yes: flags.yes || false,
+		dryRun: flags.dryRun || false,
+		nonInteractive: flags.nonInteractive || false,
+		async: flags.async || false
+	};
+}
+//#endregion
+//#region src/auth/credentials.ts
+function loadApiKeyFromConfig() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return null;
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const data = JSON.parse(raw);
+		if (typeof data.api_key === "string" && data.api_key.length > 0) return data.api_key;
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function saveApiKeyToConfig(apiKey) {
+	await ensureConfigDir();
+	const path = getConfigPath();
+	let existing = {};
+	try {
+		existing = JSON.parse(readFileSync(path, "utf-8"));
+	} catch {}
+	existing.api_key = apiKey;
+	const tmp = path + ".tmp";
+	writeFileSync(tmp, JSON.stringify(existing, null, 2) + "\n", { mode: 384 });
+	renameSync(tmp, path);
+}
+async function clearApiKey() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return;
+	try {
+		const existing = JSON.parse(readFileSync(path, "utf-8"));
+		delete existing.api_key;
+		const tmp = path + ".tmp";
+		writeFileSync(tmp, JSON.stringify(existing, null, 2) + "\n", { mode: 384 });
+		renameSync(tmp, path);
+	} catch {}
+}
+//#endregion
+//#region src/auth/resolver.ts
+async function resolveCredential(config) {
+	if (config.apiKey) return {
+		token: config.apiKey,
+		method: "api-key",
+		source: "flag"
+	};
+	if (config.fileApiKey) return {
+		token: config.fileApiKey,
+		method: "api-key",
+		source: "config.json"
+	};
+	if (process.env.DASHSCOPE_API_KEY) return {
+		token: process.env.DASHSCOPE_API_KEY,
+		method: "api-key",
+		source: "DASHSCOPE_API_KEY"
+	};
+	throw new BailianError("No credentials found.", ExitCode.AUTH, "Set DASHSCOPE_API_KEY environment variable, pass --api-key, or configure a key.");
+}
+//#endregion
+//#region src/client/ak-sign.ts
+/**
+* Alibaba Cloud V3 Signature (ROA style) for Bailian Cloud API.
+*
+* Used by Knowledge Base Retrieve API which requires AK/SK authentication
+* instead of Bearer token.
+*
+* Reference: https://help.aliyun.com/document_detail/2712195.html
+*/
+function signRequest(cfg) {
+	const method = cfg.method ?? "POST";
+	const dateISO = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+	const nonce = randomUUID();
+	const hashedBody = sha256Hex(cfg.body);
+	const headers = {
+		host: cfg.host,
+		"x-acs-action": cfg.action,
+		"x-acs-version": cfg.version,
+		"x-acs-date": dateISO,
+		"x-acs-signature-nonce": nonce,
+		"x-acs-content-sha256": hashedBody,
+		"content-type": "application/json"
+	};
+	const signedHeaderKeys = Object.keys(headers).filter((k) => k === "host" || k === "content-type" || k.startsWith("x-acs-")).sort();
+	const canonicalHeaders = signedHeaderKeys.map((k) => `${k}:${headers[k]}`).join("\n") + "\n";
+	const signedHeadersStr = signedHeaderKeys.join(";");
+	const canonicalRequest = [
+		method,
+		cfg.pathname,
+		"",
+		canonicalHeaders,
+		signedHeadersStr,
+		hashedBody
+	].join("\n");
+	const algorithm = "ACS3-HMAC-SHA256";
+	const stringToSign = `${algorithm}\n${sha256Hex(canonicalRequest)}`;
+	const signature = hmacSHA256Hex(cfg.accessKeySecret, stringToSign);
+	headers["authorization"] = `${algorithm} Credential=${cfg.accessKeyId},SignedHeaders=${signedHeadersStr},Signature=${signature}`;
+	return headers;
+}
+function sha256Hex(data) {
+	return createHash("sha256").update(data, "utf8").digest("hex");
+}
+function hmacSHA256Hex(key, data) {
+	return createHmac("sha256", key).update(data, "utf8").digest("hex");
+}
+//#endregion
+//#region src/client/endpoints.ts
+function chatEndpoint(baseUrl) {
+	return `${baseUrl}/compatible-mode/v1/chat/completions`;
+}
+function imageEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/services/aigc/image-generation/generation`;
+}
+function imageSyncEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/services/aigc/multimodal-generation/generation`;
+}
+function videoGenerateEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/services/aigc/video-generation/video-synthesis`;
+}
+function taskEndpoint(baseUrl, taskId) {
+	return `${baseUrl}/api/v1/tasks/${taskId}`;
+}
+function appCompletionEndpoint(baseUrl, appId) {
+	return `${baseUrl}/api/v1/apps/${appId}/completion`;
+}
+function memoryAddEndpoint(baseUrl) {
+	return `${baseUrl}/api/v2/apps/memory/add`;
+}
+function memorySearchEndpoint(baseUrl) {
+	return `${baseUrl}/api/v2/apps/memory/memory_nodes/search`;
+}
+function memoryListEndpoint(baseUrl) {
+	return `${baseUrl}/api/v2/apps/memory/memory_nodes`;
+}
+function memoryNodeEndpoint(baseUrl, nodeId) {
+	return `${baseUrl}/api/v2/apps/memory/memory_nodes/${nodeId}`;
+}
+function speechSynthesizeEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/services/audio/tts/SpeechSynthesizer`;
+}
+function speechRecognizeEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/services/audio/asr/transcription`;
+}
+function profileSchemaEndpoint(baseUrl) {
+	return `${baseUrl}/api/v2/apps/memory/profile_schemas`;
+}
+function userProfileEndpoint(baseUrl, schemaId) {
+	return `${baseUrl}/api/v2/apps/memory/profile_schemas/${schemaId}/profiles`;
+}
+function mcpWebSearchEndpoint(baseUrl) {
+	return `${baseUrl}/api/v1/mcps/WebSearch/mcp`;
+}
+//#endregion
+//#region src/client/headers.ts
+/**
+* Shared HTTP request headers for all outgoing requests.
+*
+* Centralises the `x-dashscope-source-config` header so every fetch call
+* (both via the central http client and the bypass paths) uses the
+* same values from a single source of truth.
+*/
+const CHANNEL = "bailian-cli";
+const TAGS = {
+	t1: "public",
+	t2: ""
+};
+const SOURCE_CONFIG = JSON.stringify({
+	channel: CHANNEL,
+	tags: TAGS
+});
+/** Standard tracking headers required on every outbound request. */
+function trackingHeaders() {
+	return { "x-dashscope-source-config": SOURCE_CONFIG };
+}
+//#endregion
+//#region src/client/http.ts
+/**
+* Bailian requires `X-DashScope-OssResourceResolve: enable` on any request whose body
+* references an `oss://` URL (returned by the upload API). Detected automatically here
+* so callers don't need to track it manually.
+*/
+function bodyReferencesOssUrl(body) {
+	if (body == null || typeof body !== "object") return false;
+	if (body instanceof FormData) return false;
+	return JSON.stringify(body).includes("oss://");
+}
+async function request(config, opts) {
+	const isFormData = typeof FormData !== "undefined" && opts.body instanceof FormData;
+	const headers = {
+		"User-Agent": `${config.clientName ?? "bailian-cli-core"}/${config.clientVersion ?? "0.0.0-dev"}`,
+		...trackingHeaders(),
+		...opts.headers
+	};
+	if (!isFormData && !headers["Content-Type"]) headers["Content-Type"] = "application/json";
+	if (opts.async) headers["X-DashScope-Async"] = "enable";
+	if (bodyReferencesOssUrl(opts.body)) headers["X-DashScope-OssResourceResolve"] = "enable";
+	if (!opts.noAuth) {
+		const credential = await resolveCredential(config);
+		headers["Authorization"] = `Bearer ${credential.token}`;
+		if (config.verbose) {
+			console.error(`> ${opts.method ?? "GET"} ${opts.url}`);
+			console.error(`> Auth: ${credential.token.slice(0, 8)}...`);
+			console.error(`> x-dashscope-source-config: ${SOURCE_CONFIG}`);
+		}
+	}
+	const timeoutMs = (opts.timeout ?? config.timeout) * 1e3;
+	const res = await fetch(opts.url, {
+		method: opts.method ?? "GET",
+		headers,
+		body: opts.body ? isFormData ? opts.body : JSON.stringify(opts.body) : void 0,
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+	if (config.verbose) {
+		console.error(`< ${res.status} ${res.statusText}`);
+		const reqId = res.headers.get("x-request-id");
+		if (reqId) console.error(`request_id: ${reqId}`);
+	}
+	if (!res.ok) {
+		let body = {};
+		try {
+			body = await res.json();
+		} catch {}
+		throw mapApiError(res.status, body, opts.url);
+	}
+	return res;
+}
+async function requestJson(config, opts) {
+	const res = await request(config, opts);
+	let data;
+	try {
+		data = await res.json();
+	} catch {
+		throw new BailianError(`API returned non-JSON response (${res.headers.get("content-type") || "unknown type"}). Server may be experiencing issues.`, ExitCode.GENERAL);
+	}
+	if (data.code && typeof data.code === "string" && data.code !== "200" && data.code !== "Success") throw mapApiError(200, { error: {
+		message: data.message,
+		type: data.code
+	} }, opts.url);
+	return data;
+}
+//#endregion
+//#region src/client/mcp.ts
+var McpClient = class {
+	baseUrl;
+	sessionId;
+	nextId = 1;
+	config;
+	authToken;
+	constructor(config, baseUrl) {
+		this.config = config;
+		this.baseUrl = baseUrl;
+	}
+	/**
+	* Initialize the MCP session. Must be called before any other method.
+	*/
+	async initialize() {
+		const credential = await resolveCredential(this.config);
+		this.authToken = credential.token;
+		const result = await this.rpc("initialize", {
+			protocolVersion: "2025-03-26",
+			capabilities: {},
+			clientInfo: {
+				name: this.config.clientName ?? "bailian-cli-core",
+				version: this.config.clientVersion ?? "0.0.0-dev"
+			}
+		});
+		if (this.config.verbose) {
+			console.error(`[MCP] Session initialized: ${this.sessionId ?? "no session"}`);
+			console.error(`[MCP] Server: ${JSON.stringify(result)}`);
+		}
+		await this.notify("notifications/initialized");
+	}
+	/**
+	* List available tools from the MCP server.
+	*/
+	async listTools() {
+		return (await this.rpc("tools/list")).tools || [];
+	}
+	/**
+	* Call a tool on the MCP server.
+	*/
+	async callTool(name, args) {
+		return await this.rpc("tools/call", {
+			name,
+			arguments: args
+		});
+	}
+	async rpc(method, params) {
+		const body = {
+			jsonrpc: "2.0",
+			id: this.nextId++,
+			method,
+			...params ? { params } : {}
+		};
+		const data = await (await this.send(body)).json();
+		if (data.error) throw new BailianError(`MCP error (${data.error.code}): ${data.error.message}`, ExitCode.GENERAL);
+		return data.result;
+	}
+	async notify(method, params) {
+		const body = {
+			jsonrpc: "2.0",
+			method,
+			...params ? { params } : {}
+		};
+		await this.send(body);
+	}
+	async send(body) {
+		const headers = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			"User-Agent": `${this.config.clientName ?? "bailian-cli-core"}/${this.config.clientVersion ?? "0.0.0-dev"}`,
+			...trackingHeaders()
+		};
+		if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
+		if (this.sessionId) headers["Mcp-Session-Id"] = this.sessionId;
+		if (this.config.verbose) {
+			console.error(`> POST ${this.baseUrl}`);
+			console.error(`> Method: ${body.method}`);
+		}
+		const timeoutMs = this.config.timeout * 1e3;
+		const res = await fetch(this.baseUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+		if (this.config.verbose) console.error(`< ${res.status} ${res.statusText}`);
+		const sid = res.headers.get("Mcp-Session-Id") || res.headers.get("mcp-session-id");
+		if (sid) this.sessionId = sid;
+		if (!res.ok) {
+			let errMsg = `MCP request failed: ${res.status} ${res.statusText}`;
+			try {
+				const errBody = await res.text();
+				if (errBody) errMsg += ` - ${errBody.slice(0, 500)}`;
+			} catch {}
+			throw new BailianError(errMsg, ExitCode.GENERAL);
+		}
+		return res;
+	}
+};
+//#endregion
+//#region src/client/stream.ts
+async function* parseSSE(response) {
+	const reader = response.body?.getReader();
+	if (!reader) return;
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			let event = {};
+			for (const line of lines) {
+				if (line === "") {
+					if (event.data !== void 0) yield {
+						data: event.data,
+						event: event.event,
+						id: event.id
+					};
+					event = {};
+					continue;
+				}
+				if (line.startsWith(":")) continue;
+				const colonIndex = line.indexOf(":");
+				if (colonIndex === -1) continue;
+				const field = line.slice(0, colonIndex);
+				const value = line.slice(colonIndex + 1).trimStart();
+				switch (field) {
+					case "data":
+						event.data = event.data !== void 0 ? `${event.data}\n${value}` : value;
+						break;
+					case "event":
+						event.event = value;
+						break;
+					case "id":
+						event.id = value;
+						break;
+				}
+			}
+		}
+		if (buffer.trim() && buffer.includes("data:")) {
+			const colonIndex = buffer.indexOf(":");
+			if (colonIndex !== -1) yield { data: buffer.slice(colonIndex + 1).trimStart() };
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+//#endregion
+//#region src/files/upload.ts
+/**
+* Upload local files to DashScope temporary OSS storage.
+*
+* Returns an `oss://` prefixed URL valid for 48 hours.
+* When using this URL in API calls, the request MUST include:
+*   X-DashScope-OssResourceResolve: enable
+*/
+const UPLOAD_API = `${REGIONS.cn}/api/v1/uploads`;
+/**
+* Step 1: Fetch the upload policy (presigned credentials) from DashScope.
+*/
+async function getUploadPolicy(apiKey, model) {
+	const url = `${UPLOAD_API}?action=getPolicy&model=${encodeURIComponent(model)}`;
+	const res = await fetch(url, {
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json",
+			...trackingHeaders()
+		},
+		signal: AbortSignal.timeout(15e3)
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new BailianError(`Failed to get upload policy (HTTP ${res.status}): ${text}`, ExitCode.GENERAL);
+	}
+	return (await res.json()).data;
+}
+/**
+* Step 2: Upload the file to OSS using the policy.
+*/
+async function uploadToOSS(policy, filePath) {
+	const fileName = basename(filePath);
+	const key = `${policy.upload_dir}/${fileName}`;
+	const fileData = readFileSync(filePath);
+	const form = new FormData();
+	form.append("OSSAccessKeyId", policy.oss_access_key_id);
+	form.append("Signature", policy.signature);
+	form.append("policy", policy.policy);
+	form.append("x-oss-object-acl", policy.x_oss_object_acl);
+	form.append("x-oss-forbid-overwrite", policy.x_oss_forbid_overwrite);
+	form.append("key", key);
+	form.append("success_action_status", "200");
+	form.append("file", new Blob([fileData]), fileName);
+	const res = await fetch(policy.upload_host, {
+		method: "POST",
+		headers: { ...trackingHeaders() },
+		body: form,
+		signal: AbortSignal.timeout(12e4)
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new BailianError(`Failed to upload file to OSS (HTTP ${res.status}): ${text}`, ExitCode.GENERAL);
+	}
+	return `oss://${key}`;
+}
+/**
+* Upload a local file to DashScope temporary storage and return the oss:// URL.
+* The URL is valid for 48 hours.
+*/
+async function uploadFile(opts) {
+	const { apiKey, model, filePath } = opts;
+	if (!existsSync(filePath)) throw new BailianError(`File not found: ${filePath}`, ExitCode.USAGE);
+	if (!statSync(filePath).isFile()) throw new BailianError(`Not a file: ${filePath}`, ExitCode.USAGE);
+	return uploadToOSS(await getUploadPolicy(apiKey, model), filePath);
+}
+/**
+* Check if a string looks like a local file path (not a URL).
+*/
+function isLocalFile(input) {
+	if (input.startsWith("http://") || input.startsWith("https://")) return false;
+	if (input.startsWith("oss://")) return false;
+	if (input.startsWith("data:")) return false;
+	return existsSync(input);
+}
+/**
+* Resolve a file argument: if it's a local path, upload it and return the oss:// URL.
+* If it's already a URL, return as-is.
+*/
+async function resolveFileUrl(input, apiKey, model) {
+	if (!isLocalFile(input)) return input;
+	return uploadFile({
+		apiKey,
+		model,
+		filePath: input
+	});
+}
+//#endregion
+//#region src/types/command.ts
+function defineCommand(spec) {
+	return {
+		name: spec.name,
+		description: spec.description,
+		usage: spec.usage,
+		options: spec.options,
+		examples: spec.examples,
+		apiDocs: spec.apiDocs,
+		execute: spec.run
+	};
+}
+/** Global flags shared by all commands — drives the parser's type resolution. */
+const GLOBAL_OPTIONS = [
+	{
+		flag: "--api-key <key>",
+		description: "API key"
+	},
+	{
+		flag: "--region <region>",
+		description: "API region: cn (default), us, intl"
+	},
+	{
+		flag: "--base-url <url>",
+		description: "API base URL"
+	},
+	{
+		flag: "--output <format>",
+		description: "Output format: text, json"
+	},
+	{
+		flag: "--timeout <seconds>",
+		description: "Request timeout",
+		type: "number"
+	},
+	{
+		flag: "--quiet",
+		description: "Suppress non-essential output"
+	},
+	{
+		flag: "--verbose",
+		description: "Print HTTP request/response details"
+	},
+	{
+		flag: "--no-color",
+		description: "Disable ANSI colors"
+	},
+	{
+		flag: "--dry-run",
+		description: "Dry run mode"
+	},
+	{
+		flag: "--non-interactive",
+		description: "Disable interactive prompts"
+	},
+	{
+		flag: "--concurrent <n>",
+		description: "Run N parallel requests (default: 1)",
+		type: "number"
+	},
+	{
+		flag: "--help",
+		description: "Show help"
+	},
+	{
+		flag: "--version",
+		description: "Print version"
+	}
+];
+//#endregion
+//#region src/utils/filename.ts
+/**
+* 生成文件名前缀
+* @param prefix prompt的前10个字符
+* @param suffix timestamp
+* @returns
+*/
+function sanitizeFilenamePart(input, fallback) {
+	return input.normalize("NFKC").replace(/[\\/:*?"<>|]/g, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || fallback;
+}
+function generateFilename(prefix, prompt) {
+	return `${sanitizeFilenamePart(prefix || "image", "image")}_${sanitizeFilenamePart((prompt || "").substring(0, 20), "untitled")}_${Date.now()}`;
+}
+//#endregion
+//#region src/utils/output-dir.ts
+const DEFAULT_OUTPUT_DIR = () => join(homedir(), "bailian-output");
+/**
+* Resolve the output directory for generated files.
+*
+* Priority:
+* 1. User-specified dir (e.g. --out-dir flag)
+* 2. Config file output_dir
+* 3. Default: ~/bailian-output/
+*
+* Optionally appends a subdirectory (e.g. 'images', 'videos', 'speech').
+* Creates the directory if it doesn't exist.
+*/
+function resolveOutputDir(config, options) {
+	const base = options?.flagDir || config.outputDir || DEFAULT_OUTPUT_DIR();
+	const dir = options?.subDir ? join(base, options.subDir) : base;
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	return dir;
+}
+//#endregion
+//#region src/utils/schema.ts
+/**
+* Parse a CLI flag string (e.g. "--prompt <text>", "--stream") into
+* a parameter name and inferred type.
+*/
+function parseFlag(flag) {
+	const match = flag.match(/^--([a-zA-Z0-9-]+)/);
+	const kebabName = match ? match[1] : "";
+	const name = kebabName.replace(/-([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+	let inferredType = "string";
+	let isArray = false;
+	if (!flag.includes("<") && !flag.includes("[")) inferredType = "boolean";
+	else if (flag.includes("<n>") || flag.includes("<hz>") || flag.includes("<bps>") || flag.includes("<count>")) inferredType = "number";
+	if (flag.toLowerCase().includes("repeatable")) isArray = true;
+	return {
+		name,
+		kebabName,
+		inferredType,
+		isArray
+	};
+}
+function generateToolSchema(cmd) {
+	const schema = {
+		name: `bailian_${cmd.name.replace(/ /g, "_")}`,
+		description: cmd.description,
+		input_schema: {
+			type: "object",
+			properties: {},
+			required: []
+		}
+	};
+	if (cmd.options) for (const opt of cmd.options) {
+		const { name, inferredType, isArray } = parseFlag(opt.flag);
+		if (!name) continue;
+		const explicitType = opt.type;
+		const effectiveType = isArray ? "array" : explicitType ?? inferredType;
+		const propSchema = { description: opt.description };
+		if (effectiveType === "array") {
+			propSchema.type = "array";
+			propSchema.items = { type: "string" };
+		} else propSchema.type = effectiveType;
+		const inputSchema = schema.input_schema;
+		inputSchema.properties[name] = propSchema;
+		if (opt.required) inputSchema.required.push(name);
+	}
+	return schema;
+}
+//#endregion
+//#region src/utils/token.ts
+function maskToken(token) {
+	return token.length > 8 ? `${token.slice(0, 4)}...${token.slice(-4)}` : "***";
+}
+//#endregion
+//#region src/utils/env.ts
+/**
+* Environment detection utilities for bailian-cli.
+*
+* Used to determine whether the CLI is running in an interactive terminal
+* (human user) or in a non-interactive environment (CI, agent, pipe, etc.),
+* so commands can adjust their behavior accordingly.
+*/
+/**
+* Detects whether the current environment is interactive.
+*
+* Returns false when:
+*  - stdout or stdin is not a TTY
+*  - The --non-interactive flag was explicitly set
+*  - The process is running in a known CI environment (CI env var present)
+*
+* Returns true when stdout and stdin are both TTYs and --non-interactive
+* was not passed.
+*/
+function isInteractive(options) {
+	if (options?.nonInteractive === true) return false;
+	if (process.env.CI) return false;
+	return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+/**
+* Detects whether the current process is running in a CI environment.
+*/
+function isCI() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.JENKINS_URL || process.env.TRAVIS || process.env.CIRCLECI);
+}
+//#endregion
+//#region src/utils/object.ts
+/**
+* Generic object-cleaning utilities.
+*/
+/**
+* Remove all keys whose value is `undefined` from a plain object (in-place).
+* Returns the same reference for chaining convenience.
+*
+* ```ts
+* const params = { a: 1, b: undefined };
+* stripUndefined(params); // { a: 1 }
+* ```
+*/
+function stripUndefined(obj) {
+	for (const key of Object.keys(obj)) if (obj[key] === void 0) delete obj[key];
+	return obj;
+}
+//#endregion
+export { BAILIAN_HOST, BailianError, CHANNEL, DOCS_HOSTS, ExitCode, GLOBAL_OPTIONS, McpClient, REGIONS, SOURCE_CONFIG, TAGS, appCompletionEndpoint, chatEndpoint, clearApiKey, defineCommand, detectOutputFormat, ensureConfigDir, formatErrorJson, formatJson, formatKeyValue, formatOutput, formatTable, formatText, generateFilename, generateToolSchema, getConfigDir, getConfigPath, getCredentialsPath, imageEndpoint, imageSyncEndpoint, isCI, isInteractive, isLocalFile, loadApiKeyFromConfig, loadConfig, mapApiError, maskToken, mcpWebSearchEndpoint, memoryAddEndpoint, memoryListEndpoint, memoryNodeEndpoint, memorySearchEndpoint, parseConfigFile, parseSSE, profileSchemaEndpoint, readConfigFile, request, requestJson, resolveCredential, resolveFileUrl, resolveOutputDir, saveApiKeyToConfig, signRequest, speechRecognizeEndpoint, speechSynthesizeEndpoint, stripUndefined, taskEndpoint, trackingHeaders, uploadFile, userProfileEndpoint, videoGenerateEndpoint, writeConfigFile };