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

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.2";
 
 //#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([
@@ -997,7 +1031,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 +1059,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 +1304,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 +1982,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 +1994,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 +2029,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 +2037,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 +2097,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 +2110,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 +2122,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 +2135,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 +2158,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 +2206,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 +2237,7 @@ async function assertPathExists(targetPath, message) {
 
 //#endregion
 //#region src/debug/gateway.ts
+const GATEWAY_DUPLICATE_CONNECTION_CODE = "connection_gateway.session_already_bound";
 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 +2256,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;
@@ -2030,7 +2336,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;
@@ -2088,6 +2394,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 +2408,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 +2525,244 @@ 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();
+	constructor(fastgptBaseUrl) {
+		this.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.fastgptBaseUrl
+		});
+		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 +2793,7 @@ async function runRemoteDebugSessionOnce({ entriesInput, options, commandName })
 		commandName,
 		targets
 	});
+	attachRemoteInvokeBridges(targets, gatewayOptions.fastgptBaseUrl);
 	const reporter = createRemoteDebugReporter({
 		commandName,
 		options,
@@ -2284,6 +2831,7 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 		commandName,
 		targets: initialTargets
 	});
+	attachRemoteInvokeBridges(initialTargets, gatewayOptions.fastgptBaseUrl);
 	const reporter = createRemoteDebugReporter({
 		commandName,
 		options,
@@ -2305,6 +2853,7 @@ async function runWatchRemoteDebugSession({ entriesInput, options, commandName }
 				reloadPending = false;
 				try {
 					const nextTargets = await loadTargets(entries, options);
+					attachRemoteInvokeBridges(nextTargets, gatewayOptions.fastgptBaseUrl);
 					gateway?.updateTargets(nextTargets);
 					reporter.log(`检测到插件文件变化，已热更新 ${nextTargets.length} 个本地插件。`);
 				} catch (error) {
@@ -2369,6 +2918,13 @@ async function loadTargets(entries, options) {
 	if (duplicatePluginIds.length > 0) throw new Error(`gateway pluginId 重复: ${duplicatePluginIds.join(", ")}`);
 	return targets;
 }
+function attachRemoteInvokeBridges(targets, fastgptBaseUrl) {
+	targets.forEach((target) => {
+		const invokeBridge = new RemoteDebugInvokeBridge(fastgptBaseUrl);
+		invokeBridge.attach(target.runtime);
+		target.invokeBridge = invokeBridge;
+	});
+}
 function watchDebugEntries(entries, onChange) {
 	const watchers = entries.map((entry) => fsWatch(entry, {
 		recursive: true,
@@ -2428,12 +2984,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";
 		}
@@ -2778,9 +3334,11 @@ async function resolveConnectGatewayOptions(options) {
 		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")
+		reconnectIntervalMs: toPositiveInt(options.reconnectIntervalMs ?? process.env.CONNECTION_GATEWAY_RECONNECT_INTERVAL_MS ?? "2000", "reconnect-interval-ms"),
+		resolveReconnectOptions: () => resolveConnectGatewayOptions(options)
 	};
 }
 function resolveUploadDir({ entryDir, index, total, uploadDir }) {
@@ -2793,10 +3351,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 +3367,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 +3387,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);

package/package.json

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