@fastgpt-plugin/cli 0.2.0-alpha.1 → 0.2.0-alpha.3

package/README.en.md

@@ -46,6 +46,8 @@ fastgpt-plugin dev --no-interactive \
   --connect "fpg_dbg_..."
 ```
 
+After `--connect` starts and connects successfully, it overwrites the persisted connection key in local `config.json`, so later `fastgpt-plugin dev` runs can reuse it. In the TUI, press `c` to enter and save a new connection key. Stop the session with `Ctrl+C`; press `Ctrl+C` again to force exit.
+
 When passing a raw connection key, set `FASTGPT_PLUGIN_DEBUG_CONNECT_URL`, or set `FASTGPT_PLUGIN_SERVER_URL` so the CLI can request `/api/plugin/debug-sessions/connection-key:exchange`. Full connect links remain supported for compatibility. The exchange result returns the gateway WSS endpoint, `debug:tmbId:{tmbId}` source, and scoped connect token. The CLI does not need `CONNECTION_GATEWAY_AUTH_TOKEN` or `JWT_SECRET`.
 
 When no plugin directories are passed, `dev` auto-discovers plugins from the current directory. If the current directory has `index.ts`, it is used as the plugin entry; otherwise, the CLI scans one level of child directories for `index.ts`. You can still pass multiple plugin directories explicitly.

package/README.md

@@ -46,6 +46,8 @@ fastgpt-plugin dev --no-interactive \
   --connect "fpg_dbg_..."
 ```
 
+`--connect` 启动并成功连接后会覆盖本地持久配置 `config.json` 里的 connection key，后续 `fastgpt-plugin dev` 可直接复用该配置。TUI 运行中按 `c` 可以重新输入并保存 connection key；停止会话使用 `Ctrl+C`，再次按 `Ctrl+C` 强制退出。
+
 使用裸 connection key 时，需要设置 `FASTGPT_PLUGIN_DEBUG_CONNECT_URL`，或设置 `FASTGPT_PLUGIN_SERVER_URL` 让 CLI 默认请求 `/api/plugin/debug-sessions/connection-key:exchange`。兼容场景仍可传入完整 connect link。exchange 结果会返回 gateway WSS 地址、`debug:tmbId:{tmbId}` source 和 scoped connect token。CLI 不需要 `CONNECTION_GATEWAY_AUTH_TOKEN` 或 `JWT_SECRET`。
 
 `dev` 未传插件目录时会自动探测当前目录：如果当前目录有 `index.ts`，则把当前目录作为插件；否则扫描当前目录下一层子目录中的 `index.ts`。也可以手动传入多个插件目录。

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { registerHooks, stripTypeScriptTypes } from "node:module";
+import { createRequire, registerHooks, stripTypeScriptTypes } from "node:module";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -526,7 +526,7 @@ var CheckCommand = class extends BaseCommand {
 //#endregion
 //#region package.json
 var name = "@fastgpt-plugin/cli";
-var version = "0.2.0-alpha.1";
+var version = "0.2.0-alpha.3";
 
 //#endregion
 //#region src/constants.ts
@@ -686,6 +686,40 @@ var CreateCommand = class extends BaseCommand {
 	}
 };
 
+//#endregion
+//#region ../../packages/domain/src/value-objects/plugin-debug-session.vo.ts
+const PLUGIN_DEBUG_SOURCE_KIND = "debug";
+const PLUGIN_DEBUG_SESSION_SOURCE_TMB_ID_KEY = "tmbId";
+const PLUGIN_DEBUG_SOURCE_PREFIX = `${PLUGIN_DEBUG_SOURCE_KIND}:`;
+const PLUGIN_DEBUG_SESSION_SOURCE_FORMAT = `${PLUGIN_DEBUG_SOURCE_KIND}:${PLUGIN_DEBUG_SESSION_SOURCE_TMB_ID_KEY}:{tmbId}`;
+const PluginDebugSessionIdSchema = z.string().min(1);
+const PluginDebugSessionTmbIdSchema = z.string().min(1);
+const PluginDebugSessionSourceSchema = z.string().min(1).refine((source) => parsePluginDebugSessionSource(source) !== null, { message: "Invalid plugin debug session source" });
+const PluginDebugSessionStatusSchema = z.enum([
+	"enabled",
+	"connected",
+	"disconnected",
+	"revoked"
+]);
+const PluginDebugSessionSchema = z.object({
+	tmbId: PluginDebugSessionTmbIdSchema,
+	source: PluginDebugSessionSourceSchema,
+	status: PluginDebugSessionStatusSchema,
+	enabled: z.boolean(),
+	keyId: z.string().min(1),
+	connectionKeyHash: z.string().min(1),
+	connectionKey: z.string().min(1).optional(),
+	createdAt: z.number().int().positive(),
+	updatedAt: z.number().int().positive(),
+	refreshedAt: z.number().int().positive().optional(),
+	revokedAt: z.number().int().positive().optional()
+});
+function parsePluginDebugSessionSource(source) {
+	const parts = source.split(":");
+	if (parts.length !== 3 || parts[0] !== PLUGIN_DEBUG_SOURCE_KIND || parts[1] !== PLUGIN_DEBUG_SESSION_SOURCE_TMB_ID_KEY || !parts[2]) return null;
+	return { tmbId: parts[2] };
+}
+
 //#endregion
 //#region src/debug/discover.ts
 const IGNORED_DIRS = new Set([
@@ -777,6 +811,12 @@ const ConnectionGatewayWsHeartbeatMessageSchema = z.object({
 	type: z.literal("heartbeat"),
 	ts: z.number().int().positive()
 });
+const ConnectionGatewayWsMetadataMessageSchema = z.object({
+	protocol: ConnectionGatewayWsProtocolSchema,
+	type: z.literal("metadata"),
+	requestId: z.string().min(1).optional(),
+	metadata: z.record(z.string(), z.unknown())
+});
 const ConnectionGatewayWsErrorMessageSchema = z.object({
 	protocol: ConnectionGatewayWsProtocolSchema,
 	type: z.literal("error"),
@@ -793,7 +833,8 @@ const ConnectionGatewayWsBoundMessageSchema = z.object({
 const ConnectionGatewayWsClientMessageSchema = z.discriminatedUnion("type", [
 	ConnectionGatewayWsBindMessageSchema,
 	ConnectionGatewayWsEnvelopeMessageSchema,
-	ConnectionGatewayWsHeartbeatMessageSchema
+	ConnectionGatewayWsHeartbeatMessageSchema,
+	ConnectionGatewayWsMetadataMessageSchema
 ]);
 const ConnectionGatewayWsServerMessageSchema = z.discriminatedUnion("type", [
 	ConnectionGatewayWsBoundMessageSchema,
@@ -997,7 +1038,11 @@ const RESOLVE_EXTENSIONS = [
 	".cjs",
 	".json"
 ];
+const TRANSFORM_PROBE_SOURCE = "const __fastgptPluginTransformProbe__: number = 1;";
 let hooksRegistered = false;
+let transformModeSupported;
+let cachedTypeScriptCompiler;
+const localRequire = createRequire(import.meta.url);
 function ensureDebugImportHooks() {
 	if (hooksRegistered) return;
 	hooksRegistered = true;
@@ -1021,15 +1066,90 @@ function ensureDebugImportHooks() {
 			if (SOURCE_EXTENSIONS.includes(ext)) return {
 				format: "module",
 				shortCircuit: true,
-				source: stripTypeScriptTypes(fs$1.readFileSync(fileURLToPath(parsed), "utf-8"), {
-					mode: "transform",
-					sourceMap: false
+				source: compileTypeScriptModuleSource(fs$1.readFileSync(fileURLToPath(parsed), "utf-8"), {
+					filePath: fileURLToPath(parsed),
+					workspaceRoot
 				})
 			};
 			return nextLoad(url, context);
 		}
 	});
 }
+function compileTypeScriptModuleSource(sourceText, { filePath, workspaceRoot, stripTypeScriptTypesFn = stripTypeScriptTypes, typeScriptCompiler }) {
+	if (supportsTransformMode(stripTypeScriptTypesFn)) try {
+		return stripTypeScriptTypesFn(sourceText, {
+			mode: "transform",
+			sourceMap: false
+		});
+	} catch {}
+	return transpileTypeScriptModuleSource(sourceText, {
+		filePath,
+		workspaceRoot,
+		typeScriptCompiler
+	});
+}
+function supportsTransformMode(stripTypeScriptTypesFn) {
+	if (stripTypeScriptTypesFn === stripTypeScriptTypes) {
+		if (transformModeSupported !== void 0) return transformModeSupported;
+		transformModeSupported = canTransformTypeScript(stripTypeScriptTypesFn);
+		return transformModeSupported;
+	}
+	return canTransformTypeScript(stripTypeScriptTypesFn);
+}
+function canTransformTypeScript(stripTypeScriptTypesFn) {
+	try {
+		stripTypeScriptTypesFn(TRANSFORM_PROBE_SOURCE, {
+			mode: "transform",
+			sourceMap: false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function transpileTypeScriptModuleSource(sourceText, { filePath, workspaceRoot, typeScriptCompiler }) {
+	const compiler = typeScriptCompiler ?? loadTypeScriptCompiler(filePath, workspaceRoot);
+	const transpiled = compiler.transpileModule(sourceText, {
+		fileName: filePath,
+		reportDiagnostics: true,
+		compilerOptions: {
+			module: compiler.ModuleKind.ESNext,
+			target: compiler.ScriptTarget.ES2022,
+			moduleResolution: compiler.ModuleResolutionKind.Bundler,
+			jsx: compiler.JsxEmit.ReactJSX,
+			sourceMap: false,
+			inlineSourceMap: false,
+			inlineSources: false,
+			isolatedModules: true,
+			esModuleInterop: true,
+			allowImportingTsExtensions: true,
+			verbatimModuleSyntax: true
+		}
+	});
+	const errors = transpiled.diagnostics?.filter((diagnostic) => diagnostic.category === compiler.DiagnosticCategory.Error) ?? [];
+	if (errors.length > 0) {
+		const formatted = errors.map((diagnostic) => formatDiagnosticMessage(compiler, diagnostic)).join("\n");
+		throw new Error(`Failed to transpile TypeScript debug module: ${filePath}\n${formatted}`);
+	}
+	return transpiled.outputText;
+}
+function loadTypeScriptCompiler(filePath, workspaceRoot) {
+	if (cachedTypeScriptCompiler) return cachedTypeScriptCompiler;
+	const resolvePaths = [
+		path.dirname(filePath),
+		process.cwd(),
+		workspaceRoot,
+		path.dirname(fileURLToPath(import.meta.url))
+	].filter((value) => Boolean(value));
+	cachedTypeScriptCompiler = localRequire(localRequire.resolve("typescript", { paths: resolvePaths }));
+	return cachedTypeScriptCompiler;
+}
+function formatDiagnosticMessage(compiler, diagnostic) {
+	const message = compiler.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+	if (!diagnostic.file || diagnostic.start === void 0) return message;
+	const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+	return `${line + 1}:${character + 1} ${message}`;
+}
 function resolveSpecifier({ specifier, parentURL, workspaceRoot }) {
 	if (specifier.startsWith("node:")) return null;
 	if (specifier.startsWith("file:")) return toFileURL(resolveExistingPath(fileURLToPath(new URL(specifier))));
@@ -1191,9 +1311,188 @@ const InvokeMethodEnumSchema = z.enum([
 ]);
 const InvokeMethodEnum = InvokeMethodEnumSchema.enum;
 
+//#endregion
+//#region ../../packages/domain/src/value-objects/error.vo.ts
+const DEFAULT_INTERNAL_REASON = {
+	en: "Internal Server Error",
+	"zh-CN": "服务器内部错误"
+};
+var RegisteredError = class extends Error {
+	code;
+	reason;
+	httpStatus;
+	telemetryKind;
+	visibility;
+	severity;
+	data;
+	constructor(definition, options = {}) {
+		super(options.message ?? definition.message, { cause: normalizeErrorCause(options.cause) });
+		this.name = "RegisteredError";
+		this.code = definition.code;
+		this.reason = options.reason ?? definition.reason;
+		this.httpStatus = definition.httpStatus ?? 500;
+		this.telemetryKind = definition.telemetryKind;
+		this.visibility = definition.visibility ?? "public";
+		this.severity = definition.severity ?? "expected";
+		this.data = options.data;
+	}
+};
+function createReasonError(reason, options = {}) {
+	const cause = normalizeErrorCause(options.cause);
+	const error = cause === void 0 ? new Error(reason.en) : new Error(reason.en, { cause });
+	return Object.assign(error, { reason });
+}
+function normalizeToError(error, fallbackMessage = "Unknown error") {
+	if (error instanceof Error) return error;
+	if (typeof error === "string") return new Error(error);
+	if (isI18nString(error)) return createReasonError(error);
+	if (isResultFailureLike(error)) {
+		const reason = isI18nString(error.reason) ? error.reason : void 0;
+		const cause = normalizeToError(error.error, reason?.en ?? fallbackMessage);
+		if (reason && isSameI18nString(reason, getErrorReason(cause))) return cause;
+		return reason ? createReasonError(reason, { cause }) : new Error(fallbackMessage, { cause });
+	}
+	return new Error(getUnknownErrorMessage(error, fallbackMessage), { cause: error });
+}
+function getErrorReason(error, fallback) {
+	if (error instanceof RegisteredError) return error.visibility === "internal" ? DEFAULT_INTERNAL_REASON : error.reason;
+	if (isI18nString(error)) return error;
+	const record = isRecord(error) ? error : void 0;
+	if (record && isI18nString(record.reason)) return record.reason;
+	if (record && isI18nString(record.error)) return record.error;
+	if (fallback) return fallback;
+	if (error instanceof Error) return {
+		en: error.message,
+		"zh-CN": error.message
+	};
+	if (typeof error === "string") return {
+		en: error,
+		"zh-CN": error
+	};
+	return DEFAULT_INTERNAL_REASON;
+}
+function serializeError(error, options) {
+	return serializeErrorInner(error, {
+		includeStack: options?.includeStack ?? false,
+		depth: 0,
+		seen: /* @__PURE__ */ new WeakSet()
+	});
+}
+function normalizeErrorCause(cause) {
+	if (cause === void 0 || cause instanceof Error) return cause;
+	if (typeof cause === "string") return new Error(cause);
+	if (isI18nString(cause)) return createReasonError(cause);
+	if (isResultFailureLike(cause)) return normalizeToError(cause);
+	return cause;
+}
+function serializeErrorInner(error, state) {
+	if (state.depth > 5) return {
+		name: "Error",
+		message: "Error cause depth exceeded"
+	};
+	if (error instanceof RegisteredError) return {
+		name: error.name,
+		code: error.code,
+		message: error.message,
+		reason: error.reason,
+		httpStatus: error.httpStatus,
+		telemetryKind: error.telemetryKind,
+		visibility: error.visibility,
+		data: error.data,
+		...state.includeStack && error.stack !== void 0 ? { stack: error.stack } : {},
+		...error.cause !== void 0 ? { cause: serializeErrorInner(error.cause, nextSerializeState(state, error)) } : {}
+	};
+	if (error instanceof Error) {
+		const reason = getI18nStringField(error, "reason");
+		return {
+			name: error.name,
+			code: getStringField(error, "code"),
+			message: error.message,
+			...reason !== void 0 ? { reason } : {},
+			data: getUnknownField(error, "data"),
+			...state.includeStack && error.stack !== void 0 ? { stack: error.stack } : {},
+			...error.cause !== void 0 ? { cause: serializeErrorInner(error.cause, nextSerializeState(state, error)) } : {}
+		};
+	}
+	if (typeof error === "string") return {
+		name: "Error",
+		message: error
+	};
+	return {
+		name: "Error",
+		message: getUnknownErrorMessage(error, "Unknown error")
+	};
+}
+function nextSerializeState(state, error) {
+	if (state.seen.has(error)) return {
+		...state,
+		depth: 6
+	};
+	state.seen.add(error);
+	return {
+		...state,
+		depth: state.depth + 1
+	};
+}
+function getUnknownErrorMessage(error, fallback) {
+	if (error === null || error === void 0) return fallback;
+	if (isRecord(error)) {
+		const message = error.message ?? error.msg;
+		if (typeof message === "string" && message.length > 0) return message;
+	}
+	return String(error);
+}
+function getStringField(error, field) {
+	const value = error[field];
+	return typeof value === "string" ? value : void 0;
+}
+function getI18nStringField(error, field) {
+	const value = error[field];
+	return isI18nString(value) ? value : void 0;
+}
+function getUnknownField(error, field) {
+	return error[field];
+}
+function isI18nString(value) {
+	return isRecord(value) && typeof value.en === "string" && (value["zh-CN"] === void 0 || typeof value["zh-CN"] === "string") && (value["zh-Hant"] === void 0 || typeof value["zh-Hant"] === "string");
+}
+function isSameI18nString(left, right) {
+	return left.en === right.en && left["zh-CN"] === right["zh-CN"] && left["zh-Hant"] === right["zh-Hant"];
+}
+function isRecord(value) {
+	return Boolean(value && typeof value === "object");
+}
+function isResultFailureLike(value) {
+	return isRecord(value) && "error" in value && ("reason" in value || isRecord(value.error));
+}
+
 //#endregion
 //#region ../../packages/domain/src/value-objects/result.vo.ts
 const successResult = (data) => [data, null];
+function failureResult(reasonOrFailure, error) {
+	if (isResultFailure(reasonOrFailure)) return [null, toResultFailure(reasonOrFailure.reason, reasonOrFailure.error, reasonOrFailure)];
+	if (reasonOrFailure instanceof Error) return [null, toResultFailure(getErrorReason(reasonOrFailure), reasonOrFailure)];
+	return [null, toResultFailure(reasonOrFailure, error === void 0 ? createReasonError(reasonOrFailure) : createLegacyFailureError(reasonOrFailure, error))];
+}
+function isResultFailure(value) {
+	return Boolean(value && typeof value === "object" && "reason" in value && "error" in value);
+}
+function createLegacyFailureError(reason, cause) {
+	return createReasonError(reason, { cause: normalizeToError(cause, reason.en) });
+}
+function toResultFailure(reason, error, existing) {
+	const serialized = serializeError(error);
+	const code = existing?.code ?? serialized.code;
+	const message = existing?.message ?? serialized.message;
+	const data = existing && "data" in existing ? existing.data : serialized.data;
+	return {
+		reason,
+		error,
+		...code !== void 0 ? { code } : {},
+		...message !== void 0 ? { message } : {},
+		...data !== void 0 ? { data } : {}
+	};
+}
 
 //#endregion
 //#region ../../packages/domain/src/value-objects/stream.vo.ts
@@ -1690,7 +1989,7 @@ function createIncomingStream({ source, streamName, streamId, traceId, meta }) {
 	};
 }
 function toStreamData(source) {
-	if (isStreamDataLike$1(source)) return source;
+	if (isStreamDataLike$2(source)) return source;
 	const output = StreamData.create();
 	(async () => {
 		try {
@@ -1702,7 +2001,7 @@ function toStreamData(source) {
 	})();
 	return output;
 }
-function isStreamDataLike$1(source) {
+function isStreamDataLike$2(source) {
 	return source instanceof StreamData || typeof source === "object" && source !== null && typeof source.values === "function" && typeof source.consume === "function";
 }
 
@@ -1737,7 +2036,7 @@ async function loadDebugSession({ entryDir, uploadDir }) {
 		else process.env.RUNTIME_MODE = previousRuntimeMode;
 	}
 }
-async function runDebugTool({ runtime, snapshot, toolId, input, secrets, systemVar }) {
+async function runDebugTool({ runtime, snapshot, toolId, input, secrets, systemVar, traceId }) {
 	const targetTool = pickTargetTool(snapshot, toolId);
 	const mergedSystemVar = createDebugSystemVar(snapshot, targetTool.id, systemVar);
 	const response = await runtime.invokePlugin("run", {
@@ -1745,7 +2044,7 @@ async function runDebugTool({ runtime, snapshot, toolId, input, secrets, systemV
 		systemVar: mergedSystemVar,
 		...snapshot.isToolSet ? { childId: targetTool.id } : {},
 		...secrets ? { secrets } : {}
-	}, { traceId: randomUUID() });
+	}, { traceId: traceId ?? randomUUID() });
 	if (!response.output) throw new Error("调试运行未返回输出流。");
 	const streamMessages = [];
 	let finalResponse;
@@ -1805,7 +2104,7 @@ function createDebugSnapshot(tool, location) {
 		author: getOptionalString(userManifest.author),
 		tags: toStringArray(userManifest.tags),
 		permissions: toStringArray(userManifest.permission),
-		secretSchema: ensurePlainObject(secretSchema),
+		secretSchema: ensurePlainObject$1(secretSchema),
 		isToolSet: children.length > 0,
 		tools
 	};
@@ -1818,8 +2117,8 @@ function createSingleToolSnapshot(tool, userManifest) {
 		name: pickLocalizedText(userManifest.name),
 		description: pickLocalizedText(userManifest.description),
 		toolDescription: pickToolDescription(getOptionalString(userManifest.toolDescription), userManifest.description),
-		inputSchema: ensurePlainObject(z.toJSONSchema(handler.inputSchema)),
-		outputSchema: ensurePlainObject(z.toJSONSchema(handler.outputSchema))
+		inputSchema: ensurePlainObject$1(z.toJSONSchema(handler.inputSchema)),
+		outputSchema: ensurePlainObject$1(z.toJSONSchema(handler.outputSchema))
 	};
 }
 function createChildToolSnapshot(tool, child) {
@@ -1830,8 +2129,8 @@ function createChildToolSnapshot(tool, child) {
 		name: pickLocalizedText(child.name),
 		description: pickLocalizedText(child.description),
 		toolDescription: pickToolDescription(child.toolDescription, child.description),
-		inputSchema: ensurePlainObject(z.toJSONSchema(handler.inputSchema)),
-		outputSchema: ensurePlainObject(z.toJSONSchema(handler.outputSchema))
+		inputSchema: ensurePlainObject$1(z.toJSONSchema(handler.inputSchema)),
+		outputSchema: ensurePlainObject$1(z.toJSONSchema(handler.outputSchema))
 	};
 }
 function pickTargetTool(snapshot, toolId) {
@@ -1843,10 +2142,10 @@ function pickTargetTool(snapshot, toolId) {
 }
 function createVirtualHostHandler(uploadDir) {
 	return async ({ method, args, input }) => {
-		const invokeArgs = ensurePlainObject(args);
+		const invokeArgs = ensurePlainObject$1(args);
 		switch (method) {
 			case InvokeMethodEnum.uploadFile: {
-				const buffer = await readSourceToBuffer(input);
+				const buffer = await readSourceToBuffer$1(input);
 				const fileName = sanitizeFileName(typeof invokeArgs.fileName === "string" && invokeArgs.fileName.trim().length > 0 ? invokeArgs.fileName : "debug-upload.bin");
 				const contentType = typeof invokeArgs.contentType === "string" && invokeArgs.contentType.trim().length > 0 ? invokeArgs.contentType : "application/octet-stream";
 				const saveDir = path.resolve(uploadDir);
@@ -1866,17 +2165,17 @@ function createVirtualHostHandler(uploadDir) {
 		}
 	};
 }
-async function readSourceToBuffer(source) {
+async function readSourceToBuffer$1(source) {
 	if (!source) return Buffer.alloc(0);
 	const chunks = [];
-	const iterable = isStreamDataLike(source) ? source.values() : source;
-	for await (const chunk of iterable) chunks.push(toBuffer(chunk));
+	const iterable = isStreamDataLike$1(source) ? source.values() : source;
+	for await (const chunk of iterable) chunks.push(toBuffer$1(chunk));
 	return Buffer.concat(chunks);
 }
-function isStreamDataLike(source) {
+function isStreamDataLike$1(source) {
 	return source instanceof StreamData || typeof source === "object" && source !== null && typeof source.values === "function" && typeof source.consume === "function";
 }
-function toBuffer(value) {
+function toBuffer$1(value) {
 	if (Buffer.isBuffer(value)) return value;
 	if (value instanceof Uint8Array) return Buffer.from(value);
 	if (typeof value === "string") return Buffer.from(value);
@@ -1914,7 +2213,7 @@ function toStringArray(value) {
 	const items = value.filter((item) => typeof item === "string");
 	return items.length > 0 ? items : void 0;
 }
-function ensurePlainObject(value) {
+function ensurePlainObject$1(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function sanitizeFileName(fileName) {
@@ -1945,6 +2244,8 @@ async function assertPathExists(targetPath, message) {
 
 //#endregion
 //#region src/debug/gateway.ts
+const GATEWAY_DUPLICATE_CONNECTION_CODE = "connection_gateway.session_already_bound";
+const GATEWAY_HEARTBEAT_INTERVAL_MS = 5e3;
 async function connectDebugGateway({ targets, options, onLog }) {
 	if (targets.length === 0) throw new Error("Gateway debug targets cannot be empty");
 	if (options.reconnect) return connectReconnectingDebugGateway({
@@ -1963,19 +2264,32 @@ async function connectReconnectingDebugGateway({ targets, options, onLog }) {
 	let current = null;
 	let currentSession = null;
 	let latestTargets = targets;
+	let hasAttemptedConnection = false;
+	let currentOptions = options;
+	const resolveReconnectOptions = options.resolveReconnectOptions;
 	const intervalMs = Math.max(100, options.reconnectIntervalMs ?? 2e3);
 	const closedPromise = (async () => {
 		while (!closed) {
 			try {
+				const attemptOptions = hasAttemptedConnection && resolveReconnectOptions ? await resolveReconnectOptions() : currentOptions;
+				hasAttemptedConnection = true;
+				currentOptions = {
+					...attemptOptions,
+					resolveReconnectOptions
+				};
 				current = await connectSingleDebugGateway({
 					targets: latestTargets,
-					options,
+					options: currentOptions,
 					onLog
 				});
 				currentSession = current.session;
 				await current.closed;
 			} catch (error) {
 				if (closed) return;
+				if (isDuplicateConnectionError(error)) {
+					closed = true;
+					throw error;
+				}
 				onLog?.(`Connection Gateway 调试通道断开: ${formatErrorMessage(error)}`);
 			} finally {
 				current = null;
@@ -1994,6 +2308,9 @@ async function connectReconnectingDebugGateway({ targets, options, onLog }) {
 			latestTargets = targets;
 			current?.updateTargets(targets);
 		},
+		reconnect() {
+			current?.close();
+		},
 		close() {
 			closed = true;
 			current?.close();
@@ -2006,6 +2323,7 @@ async function connectSingleDebugGateway({ targets, options, onLog }) {
 	let targetsByPluginId = createTargetsByPluginId(targets);
 	let closed = false;
 	let session = null;
+	let stopHeartbeat = () => void 0;
 	let boundResolve;
 	let boundReject;
 	const bound = new Promise((resolve, reject) => {
@@ -2015,6 +2333,7 @@ async function connectSingleDebugGateway({ targets, options, onLog }) {
 	const closedPromise = new Promise((resolve) => {
 		socket.addEventListener("close", () => {
 			closed = true;
+			stopHeartbeat();
 			resolve();
 		});
 		socket.addEventListener("error", () => {
@@ -2030,7 +2349,7 @@ async function connectSingleDebugGateway({ targets, options, onLog }) {
 		}
 		if (message.type === "heartbeat") return;
 		if (message.type === "error") {
-			const error = new Error(message.message);
+			const error = createGatewayError(message.code, message.message);
 			if (!session) boundReject(error);
 			onLog?.(`Connection Gateway 错误: ${message.code} ${message.message}`);
 			return;
@@ -2063,19 +2382,56 @@ async function connectSingleDebugGateway({ targets, options, onLog }) {
 		throw error;
 	});
 	const boundSession = await bound;
+	stopHeartbeat = startGatewayHeartbeat(socket);
 	onLog?.(`已连接 Connection Gateway session: ${boundSession.id}`);
 	return {
 		session: boundSession,
 		updateTargets(targets) {
 			targetsByPluginId = createTargetsByPluginId(targets);
+			updateGatewayMetadata({
+				socket,
+				targets,
+				options,
+				onLog
+			});
 			onLog?.(`已热更新本地调试插件: ${targets.map((target) => target.snapshot.pluginId).join(", ")}`);
 		},
 		close() {
-			if (!closed) socket.close();
+			if (!closed) {
+				stopHeartbeat();
+				socket.close();
+			}
 		},
 		closed: closedPromise
 	};
 }
+async function updateGatewayMetadata({ socket, targets, options, onLog }) {
+	try {
+		await sendMessage(socket, {
+			protocol: "connection-gateway.ws.v1",
+			type: "metadata",
+			requestId: randomUUID(),
+			metadata: makePluginDebugMetadata(targets, options.source)
+		});
+	} catch (error) {
+		onLog?.(`Connection Gateway metadata 更新失败: ${formatErrorMessage(error)}`);
+	}
+}
+function startGatewayHeartbeat(socket) {
+	const timer = setInterval(() => {
+		sendMessage(socket, {
+			protocol: "connection-gateway.ws.v1",
+			type: "heartbeat",
+			ts: Date.now()
+		}).catch(() => {
+			socket.close();
+		});
+	}, GATEWAY_HEARTBEAT_INTERVAL_MS);
+	if (typeof timer === "object" && timer && "unref" in timer) timer.unref();
+	return () => {
+		clearInterval(timer);
+	};
+}
 function createTargetsByPluginId(targets) {
 	return new Map(targets.map((target) => [target.snapshot.pluginId, target]));
 }
@@ -2088,6 +2444,7 @@ async function handleGatewayEnvelope({ socket, session, targetsByPluginId, envel
 	if (!pluginId) throw new Error("Gateway debug request missing pluginId");
 	const target = targetsByPluginId.get(pluginId);
 	if (!target) throw new Error(`Gateway debug target not found: ${source} ${pluginId}`);
+	const traceId = envelope.traceId ?? requiredRequestId(envelope);
 	onLog?.(`收到远程调试请求: ${source} ${pluginId} ${envelope.requestId ?? "-"}`);
 	await sendEnvelope(socket, {
 		protocol: "connection-gateway.v1",
@@ -2101,15 +2458,21 @@ async function handleGatewayEnvelope({ socket, session, targetsByPluginId, envel
 		createdAt: Date.now(),
 		payload: { kind: "plugin-debug.accepted" }
 	});
-	const result = await runDebugTool({
-		runtime: target.runtime,
-		snapshot: target.snapshot,
-		toolId: request.payload.childId,
-		input: request.payload.input,
-		secrets: request.payload.secrets,
-		systemVar: request.payload.systemVar
-	});
-	for (const message of result.streamMessages) await sendStreamChunk(socket, session, envelope, message);
+	target.invokeBridge?.bind(traceId, { invokeToken: request.payload.systemVar.invokeToken });
+	try {
+		const result = await runDebugTool({
+			runtime: target.runtime,
+			snapshot: target.snapshot,
+			toolId: request.payload.childId,
+			input: request.payload.input,
+			secrets: request.payload.secrets,
+			systemVar: request.payload.systemVar,
+			traceId
+		});
+		for (const message of result.streamMessages) await sendStreamChunk(socket, session, envelope, message);
+	} finally {
+		target.invokeBridge?.release(traceId);
+	}
 	await sendEnvelope(socket, {
 		protocol: "connection-gateway.v1",
 		sessionId: session.id,
@@ -2212,11 +2575,245 @@ function delay(ms) {
 function formatErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+function createGatewayError(code, message) {
+	const error = new Error(message);
+	Object.assign(error, { code });
+	return error;
+}
+function isDuplicateConnectionError(error) {
+	return error instanceof Error && ("code" in error ? error.code === GATEWAY_DUPLICATE_CONNECTION_CODE : false);
+}
 function parseWsServerMessage(data) {
 	const text = typeof data === "string" ? data : data instanceof ArrayBuffer ? Buffer.from(data).toString("utf8") : ArrayBuffer.isView(data) ? Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8") : String(data);
 	return ConnectionGatewayWsServerMessageSchema.parse(JSON.parse(text));
 }
 
+//#endregion
+//#region ../../packages/infrastructure/src/plugin/invoke/invoke.impl.ts
+var InvokeManager = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async getWecomCorpToken() {
+		const [result, responseErr] = await this.requestFastGPT({
+			path: "/api/proApi/support/wecom/getCorpToken",
+			init: { method: "GET" },
+			failureReason: {
+				en: "Get wecom corp token failed",
+				"zh-CN": "获取企业微信企业令牌失败"
+			},
+			invalidJsonReason: {
+				en: "Invalid wecom corp token output",
+				"zh-CN": "获取企业微信企业令牌返回数据格式错误"
+			}
+		});
+		if (responseErr) return failureResult(responseErr);
+		return successResult(result);
+	}
+	async userInfo() {
+		const [result, responseErr] = await this.requestFastGPT({
+			path: "/api/invoke/userInfo",
+			init: { method: "GET" },
+			failureReason: {
+				en: "Invoke user info failed",
+				"zh-CN": "反向调用用户信息失败"
+			},
+			invalidJsonReason: {
+				en: "Invalid invoke user info output",
+				"zh-CN": "反向调用用户信息返回数据格式错误"
+			}
+		});
+		if (responseErr) return failureResult(responseErr);
+		try {
+			return successResult(InvokeUserInfoOutputSchema.parse(result));
+		} catch (error) {
+			return failureResult({
+				en: "Invalid invoke user info output",
+				"zh-CN": "反向调用用户信息返回数据格式错误"
+			}, error);
+		}
+	}
+	async uploadFile(input) {
+		let request;
+		try {
+			request = await this.buildUploadFileRequest(input);
+		} catch (error) {
+			return failureResult({
+				en: "Invoke upload file failed",
+				"zh-CN": "反向调用上传文件失败"
+			}, error);
+		}
+		const [result, responseErr] = await this.requestFastGPT({
+			path: "/api/invoke/fileUpload",
+			init: {
+				method: "POST",
+				body: request.formData
+			},
+			failureReason: {
+				en: "Invoke upload file failed",
+				"zh-CN": "反向调用上传文件失败"
+			},
+			invalidJsonReason: {
+				en: "Invalid invoke upload file output",
+				"zh-CN": "反向调用上传文件返回数据格式错误"
+			}
+		});
+		if (responseErr) return failureResult(responseErr);
+		try {
+			return successResult(InvokeUploadFileOutputSchema.parse({ accessURL: result.url }));
+		} catch (error) {
+			return failureResult({
+				en: "Invalid invoke upload file output",
+				"zh-CN": "反向调用上传文件返回数据格式错误"
+			}, error);
+		}
+	}
+	buildUrl(path) {
+		return new URL(path, this.deps.fastgptBaseUrl).toString();
+	}
+	async buildUploadFileRequest(input) {
+		const formData = new FormData();
+		const fileBuffer = await this.toBuffer(input.file);
+		const fileName = input.fileName ?? randomUUID();
+		const contentType = input.contentType ?? "application/octet-stream";
+		const blobPart = new Uint8Array(fileBuffer.byteLength);
+		blobPart.set(fileBuffer);
+		formData.append("file", new Blob([blobPart], { type: contentType }), fileName);
+		if (input.fileName) formData.append("fileName", input.fileName);
+		if (input.contentType) formData.append("contentType", input.contentType);
+		return {
+			formData,
+			meta: {
+				fileName,
+				contentType
+			}
+		};
+	}
+	async toBuffer(file) {
+		if (Buffer.isBuffer(file)) return file;
+		if (file instanceof Readable$1) {
+			const chunks = [];
+			for await (const chunk of file) chunks.push(this.toBufferChunk(chunk));
+			return Buffer.concat(chunks);
+		}
+		return Buffer.from(file);
+	}
+	toBufferChunk(chunk) {
+		if (Buffer.isBuffer(chunk)) return chunk;
+		if (chunk instanceof Uint8Array) return Buffer.from(chunk);
+		if (chunk instanceof ArrayBuffer) return Buffer.from(chunk);
+		if (ArrayBuffer.isView(chunk)) return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		if (typeof chunk === "string") return Buffer.from(chunk);
+		if (typeof chunk === "number") return Buffer.from([chunk]);
+		if (this.isSerializedBufferChunk(chunk)) return Buffer.from(chunk.data);
+		throw new TypeError(`Unsupported upload file stream chunk type: ${Object.prototype.toString.call(chunk)}`);
+	}
+	isSerializedBufferChunk(value) {
+		return this.isRecord(value) && value.type === "Buffer" && Array.isArray(value.data) && value.data.every((item) => Number.isInteger(item) && Number.isSafeInteger(item) && item >= 0 && item <= 255);
+	}
+	async requestFastGPT({ path, init, failureReason, invalidJsonReason }) {
+		const headers = new Headers(init?.headers);
+		headers.set("Authorization", `Bearer ${this.deps.token}`);
+		let response;
+		try {
+			response = await fetch(this.buildUrl(path), {
+				...init,
+				headers
+			});
+		} catch (error) {
+			return failureResult(failureReason, error);
+		}
+		if (!response.ok) return failureResult(failureReason, await this.readErrorResponse(response));
+		let payload;
+		try {
+			payload = await response.json();
+		} catch (error) {
+			return failureResult(invalidJsonReason, error);
+		}
+		return this.parseResponse(payload, failureReason);
+	}
+	parseResponse(payload, fallbackReason) {
+		if (!this.isRecord(payload)) return successResult(payload);
+		if (payload.success === false) return failureResult({
+			en: this.getResponseMessage(payload) ?? fallbackReason.en,
+			"zh-CN": this.getResponseMessage(payload) ?? fallbackReason["zh-CN"]
+		}, payload);
+		if (typeof payload.code === "number" && payload.code >= 400) return failureResult({
+			en: this.getResponseMessage(payload) ?? fallbackReason.en,
+			"zh-CN": this.getResponseMessage(payload) ?? fallbackReason["zh-CN"]
+		}, payload);
+		return successResult("data" in payload ? payload.data : payload);
+	}
+	async readErrorResponse(response) {
+		return {
+			status: response.status,
+			statusText: response.statusText,
+			body: (await response.text().catch(() => "")).slice(0, 1e3)
+		};
+	}
+	getResponseMessage(payload) {
+		return typeof payload.message === "string" ? payload.message : void 0;
+	}
+	isRecord(value) {
+		return Boolean(value && typeof value === "object" && !Array.isArray(value));
+	}
+};
+
+//#endregion
+//#region src/debug/remote-invoke.ts
+var RemoteDebugInvokeBridge = class {
+	sessions = /* @__PURE__ */ new Map();
+	getFastgptBaseUrl;
+	constructor(fastgptBaseUrl) {
+		this.getFastgptBaseUrl = typeof fastgptBaseUrl === "function" ? fastgptBaseUrl : () => fastgptBaseUrl;
+	}
+	attach(runtime) {
+		runtime.setHostRequestHandler((request) => this.handleHostRequest(request));
+	}
+	bind(traceId, input) {
+		this.sessions.set(traceId, { invokeToken: input.invokeToken });
+	}
+	release(traceId) {
+		this.sessions.delete(traceId);
+	}
+	async handleHostRequest({ method, args, input, traceId }) {
+		if (!traceId) throw new Error("远程调试反向调用缺少 traceId。");
+		const session = this.sessions.get(traceId);
+		if (!session) throw new Error("远程调试反向调用会话不存在或已结束。");
+		const invoke = new InvokeManager({
+			token: session.invokeToken,
+			fastgptBaseUrl: this.getFastgptBaseUrl()
+		});
+		switch (method) {
+			case InvokeMethodEnum.uploadFile: return invoke.uploadFile({
+				...ensurePlainObject(args),
+				file: input ? await readSourceToBuffer(input) : Buffer.alloc(0)
+			});
+			case InvokeMethodEnum.userInfo: return invoke.userInfo();
+			case InvokeMethodEnum.wecomCorpToken: return invoke.getWecomCorpToken();
+			default: throw new Error(`远程调试宿主暂不支持反向调用: ${String(method)}`);
+		}
+	}
+};
+function ensurePlainObject(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+async function readSourceToBuffer(source) {
+	const chunks = [];
+	const iterable = isStreamDataLike(source) ? source.values() : source;
+	for await (const chunk of iterable) chunks.push(toBuffer(chunk));
+	return Buffer.concat(chunks);
+}
+function isStreamDataLike(source) {
+	return source instanceof StreamData || typeof source === "object" && source !== null && typeof source.values === "function" && typeof source.consume === "function";
+}
+function toBuffer(value) {
+	if (Buffer.isBuffer(value)) return value;
+	if (value instanceof Uint8Array) return Buffer.from(value);
+	if (typeof value === "string") return Buffer.from(value);
+	return Buffer.from(JSON.stringify(value));
+}
+
 //#endregion
 //#region src/debug/remote-session.ts
 async function runRemoteDebugSession({ entriesInput, options, commandName, migrationHint }) {
@@ -2247,6 +2844,11 @@ async function runRemoteDebugSessionOnce({ entriesInput, options, commandName })
 		commandName,
 		targets
 	});
+	let currentGatewayOptions = gatewayOptions;
+	gatewayOptions.onResolvedReconnectOptions = (nextOptions) => {
+		currentGatewayOptions = nextOptions;
+	};
+	attachRemoteInvokeBridges(targets, () => currentGatewayOptions.fastgptBaseUrl);
 	const reporter = createRemoteDebugReporter({
 		commandName,
 		options,
@@ -2264,6 +2866,20 @@ async function runRemoteDebugSessionOnce({ entriesInput, options, commandName })
 			gateway.close();
 			if (force) process.exit(130);
 		});
+		reporter.attachConfigureConnectionKey(async () => {
+			await configureConnectionKey({
+				options,
+				commandName,
+				targets,
+				reconnect: () => {
+					if (gateway.reconnect) {
+						gateway.reconnect();
+						return;
+					}
+					gateway.close();
+				}
+			});
+		});
 		const source = gateway.session.sessionScope.source ?? gatewayOptions.source ?? "-";
 		reporter.ready(source);
 		await gateway.closed;
@@ -2284,6 +2900,11 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 		commandName,
 		targets: initialTargets
 	});
+	let currentGatewayOptions = gatewayOptions;
+	gatewayOptions.onResolvedReconnectOptions = (nextOptions) => {
+		currentGatewayOptions = nextOptions;
+	};
+	attachRemoteInvokeBridges(initialTargets, () => currentGatewayOptions.fastgptBaseUrl);
 	const reporter = createRemoteDebugReporter({
 		commandName,
 		options,
@@ -2294,6 +2915,7 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 	let reloadPending = false;
 	let closed = false;
 	let gateway;
+	let activeTargets = initialTargets;
 	const reloadTargets = async () => {
 		if (reloadRunning) {
 			reloadPending = true;
@@ -2305,6 +2927,8 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 				reloadPending = false;
 				try {
 					const nextTargets = await loadTargets(entries, options);
+					attachRemoteInvokeBridges(nextTargets, () => currentGatewayOptions.fastgptBaseUrl);
+					activeTargets = nextTargets;
 					gateway?.updateTargets(nextTargets);
 					reporter.log(`检测到插件文件变化，已热更新 ${nextTargets.length} 个本地插件。`);
 				} catch (error) {
@@ -2332,6 +2956,20 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 			connectedGateway.close();
 			if (force) process.exit(130);
 		});
+		reporter.attachConfigureConnectionKey(async () => {
+			await configureConnectionKey({
+				options,
+				commandName,
+				targets: activeTargets,
+				reconnect: () => {
+					if (connectedGateway.reconnect) {
+						connectedGateway.reconnect();
+						return;
+					}
+					connectedGateway.close();
+				}
+			});
+		});
 		const source = connectedGateway.session.sessionScope.source ?? gatewayOptions.source ?? "-";
 		reporter.ready(source);
 		await connectedGateway.closed;
@@ -2369,6 +3007,13 @@ async function loadTargets(entries, options) {
 	if (duplicatePluginIds.length > 0) throw new Error(`gateway pluginId 重复: ${duplicatePluginIds.join(", ")}`);
 	return targets;
 }
+function attachRemoteInvokeBridges(targets, getFastgptBaseUrl) {
+	targets.forEach((target) => {
+		const invokeBridge = new RemoteDebugInvokeBridge(getFastgptBaseUrl);
+		invokeBridge.attach(target.runtime);
+		target.invokeBridge = invokeBridge;
+	});
+}
 function watchDebugEntries(entries, onChange) {
 	const watchers = entries.map((entry) => fsWatch(entry, {
 		recursive: true,
@@ -2400,7 +3045,10 @@ function createRemoteDebugReporter({ commandName, options, gatewayOptions, targe
 	return options.interactive !== false && Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY) ? new TuiRemoteDebugReporter(summary) : new PlainRemoteDebugReporter(summary);
 }
 async function ensureConnectLink({ options, commandName, targets }) {
-	if (options.connect) return;
+	if (options.connect) {
+		options.connectPersistOnSuccess = true;
+		return;
+	}
 	const savedConnect = await readSavedConnectionKey();
 	if (savedConnect) {
 		options.connect = savedConnect;
@@ -2428,12 +3076,12 @@ async function promptConnectLink({ commandName, targets, defaultValue, errorMess
 		"",
 		...errorMessage ? [`Last error ${errorMessage}`, ""] : [],
 		"Paste the FastGPT connection key or connect link to start the WSS debug session.",
+		...defaultValue ? ["Press Enter to reuse the current value, or type a new one to replace it.", ""] : [],
 		""
 	].join("\n"));
 	return (await input({
 		message: "FastGPT connection key",
 		default: defaultValue,
-		prefill: defaultValue ? "editable" : void 0,
 		validate(value) {
 			return value.trim().length > 0 || "请输入 FastGPT connection key";
 		}
@@ -2463,6 +3111,16 @@ async function saveConnectionKey(connectionKey) {
 		mode: 384
 	});
 }
+async function configureConnectionKey({ options, commandName, targets, reconnect }) {
+	options.connect = await promptConnectLink({
+		commandName,
+		targets,
+		defaultValue: options.connect
+	});
+	options.connectPersistOnSuccess = true;
+	logger.info("已更新 FastGPT connection key，重连成功后会保存到本地配置。");
+	reconnect();
+}
 async function readCliConfig() {
 	const configPath = getCliConfigPath();
 	let raw;
@@ -2494,10 +3152,20 @@ const CLI_CONFIG_FILE_NAME = "config.json";
 const CLI_CONFIG_DIR_NAME = "fastgpt-plugin";
 const CliConfigSchema = z.object({ debug: z.object({ connectionKey: z.string().min(1).optional() }).optional() }).passthrough();
 var PlainRemoteDebugReporter = class {
+	closeSession;
+	interruptCount = 0;
+	onSigint = () => {
+		this.requestClose("SIGINT");
+	};
+	onSigterm = () => {
+		this.requestClose("SIGTERM");
+	};
 	constructor(summary) {
 		this.summary = summary;
 	}
 	start() {
+		process.on("SIGINT", this.onSigint);
+		process.on("SIGTERM", this.onSigterm);
 		logger.info([
 			"FastGPT 插件开发会话",
 			`  command: fastgpt-plugin ${this.summary.commandName}`,
@@ -2509,6 +3177,13 @@ var PlainRemoteDebugReporter = class {
 			...this.summary.targets.map(formatTargetLine)
 		].join("\n"));
 	}
+	requestClose(signal) {
+		this.interruptCount += 1;
+		const force = this.interruptCount >= 2;
+		this.log(force ? `再次收到 ${signal}，正在强制退出。` : `收到 ${signal}，正在关闭远程调试会话。再次发送 ${signal} 强制退出。`);
+		this.closeSession?.({ force });
+		if (force && !this.closeSession) process.exit(130);
+	}
 	log(message) {
 		logger.info(message);
 	}
@@ -2518,8 +3193,13 @@ var PlainRemoteDebugReporter = class {
 		});
 		logger.info(`已建立 1 个远程调试通道，挂载 ${this.summary.targets.length} 个插件，按 Ctrl+C 停止。`);
 	}
-	attachClose() {}
+	attachClose(close) {
+		this.closeSession = close;
+	}
+	attachConfigureConnectionKey() {}
 	end() {
+		process.off("SIGINT", this.onSigint);
+		process.off("SIGTERM", this.onSigterm);
 		logger.info("远程调试会话已结束。");
 	}
 };
@@ -2529,36 +3209,34 @@ var TuiRemoteDebugReporter = class {
 	logs = [];
 	instance;
 	closeSession;
+	configureConnectionKey;
 	interruptCount = 0;
+	configuring = false;
 	onSigint = () => {
-		this.requestClose("ctrl-c");
+		this.requestClose("SIGINT");
 	};
-	requestClose = (reason) => {
-		if (reason === "q") {
-			this.log("收到退出指令，正在关闭远程调试会话。");
-			this.closeSession?.({ force: false });
-			return;
-		}
+	requestClose = (signal) => {
 		this.interruptCount += 1;
 		const force = this.interruptCount >= 2;
 		this.status = force ? "closed" : "closing";
-		this.log(force ? "再次收到 Ctrl+C，正在强制退出。" : "收到 Ctrl+C，正在关闭远程调试会话。再次按 Ctrl+C 强制退出。");
+		this.log(force ? `再次收到 ${signal}，正在强制退出。` : `收到 ${signal}，正在关闭远程调试会话。再次按 Ctrl+C 强制退出。`);
 		this.closeSession?.({ force });
 		if (force && !this.closeSession) process.exit(130);
 	};
+	requestConfigureConnectionKey = () => {
+		if (this.configuring) return;
+		if (!this.configureConnectionKey) {
+			this.log("connection key 配置入口尚未就绪。");
+			return;
+		}
+		this.runConfigureConnectionKey();
+	};
 	constructor(summary) {
 		this.summary = summary;
 	}
 	start() {
 		process.on("SIGINT", this.onSigint);
-		this.instance = render(this.createApp(), {
-			stdin: process.stdin,
-			stdout: process.stdout,
-			stderr: process.stderr,
-			exitOnCtrlC: false,
-			interactive: true,
-			patchConsole: false
-		});
+		this.mount();
 	}
 	log(message) {
 		this.logs.push({
@@ -2576,39 +3254,78 @@ var TuiRemoteDebugReporter = class {
 	attachClose(close) {
 		this.closeSession = close;
 	}
+	attachConfigureConnectionKey(handler) {
+		this.configureConnectionKey = handler;
+	}
 	async end() {
 		process.off("SIGINT", this.onSigint);
 		this.status = "closed";
 		this.rerender();
-		const instance = this.instance;
-		this.instance = void 0;
-		if (instance) {
-			await Promise.race([instance.waitUntilRenderFlush(), setTimeout$1(50)]).catch(() => void 0);
-			instance.unmount();
-			await Promise.race([instance.waitUntilExit(), setTimeout$1(50)]).catch(() => void 0);
-		}
+		await this.unmount();
 		logger.info("远程调试会话已结束。");
 	}
 	rerender() {
 		this.instance?.rerender(this.createApp());
 	}
+	mount() {
+		if (this.instance) return;
+		this.instance = render(this.createApp(), {
+			stdin: process.stdin,
+			stdout: process.stdout,
+			stderr: process.stderr,
+			exitOnCtrlC: false,
+			interactive: true,
+			patchConsole: false
+		});
+	}
+	async unmount() {
+		const instance = this.instance;
+		this.instance = void 0;
+		if (!instance) return;
+		await Promise.race([instance.waitUntilRenderFlush(), setTimeout$1(50)]).catch(() => void 0);
+		instance.unmount();
+		await Promise.race([instance.waitUntilExit(), setTimeout$1(50)]).catch(() => void 0);
+	}
+	async runConfigureConnectionKey() {
+		if (!this.configureConnectionKey) return;
+		const previousStatus = this.status;
+		this.configuring = true;
+		this.status = "configuring";
+		this.rerender();
+		try {
+			await this.unmount();
+			await this.configureConnectionKey();
+			this.status = "connecting";
+			this.log("已更新 connection key，正在重新连接 Connection Gateway。");
+		} catch (error) {
+			this.status = previousStatus;
+			this.log(`connection key 配置失败: ${formatConnectionKeyExchangeError(error)}`);
+		} finally {
+			this.configuring = false;
+			if (this.status !== "closed") {
+				this.mount();
+				this.rerender();
+			}
+		}
+	}
 	createApp() {
 		return React.createElement(RemoteDebugInkApp, {
 			summary: this.summary,
 			status: this.status,
 			source: this.source,
 			logs: this.logs,
-			onQuit: this.requestClose
+			onClose: () => this.requestClose("SIGINT"),
+			onConfigureConnectionKey: this.requestConfigureConnectionKey
 		});
 	}
 };
-function RemoteDebugInkApp({ summary, status, source, logs, onQuit }) {
+function RemoteDebugInkApp({ summary, status, source, logs, onClose, onConfigureConnectionKey }) {
 	useInput((inputValue, key) => {
 		if (key.ctrl && inputValue === "c") {
-			onQuit("ctrl-c");
+			onClose();
 			return;
 		}
-		if (inputValue === "q") onQuit("q");
+		if (inputValue === "c") onConfigureConnectionKey();
 	});
 	const statusMeta = getTuiStatusMeta(status);
 	const sourceLabel = source === "-" ? "waiting for bind" : source;
@@ -2700,7 +3417,7 @@ function RemoteDebugInkApp({ summary, status, source, logs, onQuit }) {
 	}, ...activityItems)), React.createElement(Box, {
 		marginTop: 1,
 		justifyContent: "space-between"
-	}, React.createElement(Text, { dimColor: true }, "q stop"), React.createElement(Text, { dimColor: true }, "Ctrl+C stop · second Ctrl+C force exit")));
+	}, React.createElement(Text, { dimColor: true }, "c configure connection key"), React.createElement(Text, { dimColor: true }, "Ctrl+C stop · second Ctrl+C force exit")));
 }
 function getTuiStatusMeta(status) {
 	if (status === "connected") return {
@@ -2717,6 +3434,13 @@ function getTuiStatusMeta(status) {
 		color: "gray",
 		borderColor: "gray"
 	};
+	if (status === "configuring") return {
+		label: "CONFIGURE",
+		marker: "◆",
+		description: "Waiting for a new FastGPT connection key.",
+		color: "cyanBright",
+		borderColor: "cyan"
+	};
 	if (status === "closing") return {
 		label: "CLOSING",
 		marker: "◆",
@@ -2773,15 +3497,28 @@ function formatConnectionKeyExchangeError(error) {
 }
 async function resolveConnectGatewayOptions(options) {
 	const info = await exchangeConnectLink(options.connect);
-	return {
+	const resolvedOptions = {
 		gatewayUrl: normalizeGatewayWsUrl(info.gatewayUrl),
 		connectToken: info.connectToken,
 		userId: info.tmbId,
 		source: info.source,
+		fastgptBaseUrl: info.fastgptBaseUrl,
 		tokenTtlMs: Math.max(1, info.expiresAt - Date.now()),
 		reconnect: options.noReconnect ? false : options.reconnect ?? true,
 		reconnectIntervalMs: toPositiveInt(options.reconnectIntervalMs ?? process.env.CONNECTION_GATEWAY_RECONNECT_INTERVAL_MS ?? "2000", "reconnect-interval-ms")
 	};
+	resolvedOptions.resolveReconnectOptions = async () => {
+		const nextOptions = await resolveConnectGatewayOptions(options);
+		if (options.connectPersistOnSuccess === true) {
+			await saveConnectionKey(options.connect);
+			logger.info(`已保存 FastGPT connection key 到本地配置: ${getCliConfigPath()}`);
+			options.connectPersistOnSuccess = false;
+		}
+		resolvedOptions.onResolvedReconnectOptions?.(nextOptions);
+		nextOptions.onResolvedReconnectOptions = resolvedOptions.onResolvedReconnectOptions;
+		return nextOptions;
+	};
+	return resolvedOptions;
 }
 function resolveUploadDir({ entryDir, index, total, uploadDir }) {
 	if (!uploadDir) return path.resolve(path.join(entryDir, ".fastgpt-plugin-debug/uploads"));
@@ -2793,10 +3530,12 @@ const ConnectInfoSchema = z.object({
 	transport: z.literal("websocket"),
 	source: z.string().min(1),
 	connectToken: z.string().min(1),
+	fastgptBaseUrl: z.string().min(1).optional(),
 	expiresAt: z.number().int().positive()
 });
 async function exchangeConnectLink(connectInput) {
-	const response = isHttpUrl(connectInput) ? await fetch(connectInput) : await fetch(resolveConnectionKeyExchangeUrl(), {
+	const exchangeUrl = isHttpUrl(connectInput) ? connectInput : resolveConnectionKeyExchangeUrl();
+	const response = isHttpUrl(connectInput) ? await fetch(exchangeUrl) : await fetch(exchangeUrl, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({ connectionKey: connectInput })
@@ -2807,6 +3546,7 @@ async function exchangeConnectLink(connectInput) {
 	const info = ConnectInfoSchema.parse(payload.data ?? payload);
 	return {
 		...info,
+		fastgptBaseUrl: info.fastgptBaseUrl ?? new URL(exchangeUrl).origin,
 		tmbId: parseTmbIdFromDebugSource(info.source)
 	};
 }
@@ -2826,11 +3566,9 @@ function resolveConnectionKeyExchangeUrl() {
 	return new URL("/api/plugin/debug-sessions/connection-key:exchange", baseUrl).toString();
 }
 function parseTmbIdFromDebugSource(source) {
-	const parts = source.split(":");
-	const index = parts.indexOf("tmbId");
-	const tmbId = index >= 0 ? parts[index + 1] : void 0;
-	if (!tmbId) throw new Error(`debug source 缺少 tmbId: ${source}`);
-	return tmbId;
+	const parsed = parsePluginDebugSessionSource(source);
+	if (!parsed) throw new Error(`debug source 缺少 tmbId: ${source}`);
+	return parsed.tmbId;
 }
 function normalizeGatewayWsUrl(gatewayUrl) {
 	const parsed = new URL(gatewayUrl);
@@ -3160,9 +3898,6 @@ async function run(argv) {
 
 //#endregion
 //#region src/index.ts
-process.on("SIGINT", () => {
-	process.exit(130);
-});
 const main = async () => {
 	try {
 		await run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastgpt-plugin/cli",
-  "version": "0.2.0-alpha.1",
+  "version": "0.2.0-alpha.3",
   "type": "module",
   "private": false,
   "publishConfig": {