@nextclaw/service 0.1.1

package/dist/commands/platform-auth/services/platform-auth-commands.service.js

@@ -0,0 +1,295 @@
+import { openBrowser, prompt } from "../../../shared/utils/cli.utils.js";
+import { buildPlatformApiBaseErrorMessage, resolvePlatformApiBase } from "../../remote/utils/platform-api-base.utils.js";
+import "../../remote/index.js";
+import { readBrowserAuthPollPayload, readBrowserAuthStartPayload, readLoginPayload, readPlatformAuthResultPayload, readPlatformErrorMessage, readPlatformUserPayload } from "../utils/payload.utils.js";
+import { printAccountStatus, printUsernameUpdated, toAccountStatusView } from "./account-status.service.js";
+import { getConfigPath, loadConfig, saveConfig } from "@nextclaw/core";
+import { createInterface } from "node:readline";
+//#region src/commands/platform-auth/services/platform-auth-commands.service.ts
+function resolveProviderConfig(opts) {
+	const configPath = getConfigPath();
+	const config = loadConfig(configPath);
+	const providers = config.providers;
+	const nextclawProvider = providers.nextclaw ?? {
+		displayName: "",
+		apiKey: "",
+		apiBase: null,
+		extraHeaders: null,
+		wireApi: "auto",
+		models: []
+	};
+	const configuredApiBase = typeof nextclawProvider.apiBase === "string" && nextclawProvider.apiBase.trim().length > 0 ? nextclawProvider.apiBase.trim() : "https://ai-gateway-api.nextclaw.io/v1";
+	const { platformBase, v1Base, inputApiBase } = resolvePlatformApiBase({
+		explicitApiBase: typeof opts.apiBase === "string" && opts.apiBase.trim().length > 0 ? opts.apiBase.trim() : configuredApiBase,
+		fallbackApiBase: "https://ai-gateway-api.nextclaw.io/v1"
+	});
+	return {
+		configPath,
+		config,
+		providers,
+		nextclawProvider,
+		platformBase,
+		v1Base,
+		inputApiBase
+	};
+}
+async function resolveCredentials(opts) {
+	let email = typeof opts.email === "string" ? opts.email.trim() : "";
+	let password = typeof opts.password === "string" ? opts.password : "";
+	if (email && password) return {
+		email,
+		password
+	};
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		if (!email) email = (await prompt(rl, "Email: ")).trim();
+		if (!password) password = await prompt(rl, "Password: ");
+	} finally {
+		rl.close();
+	}
+	if (!email || !password) throw new Error("Email and password are required.");
+	return {
+		email,
+		password
+	};
+}
+function persistPlatformToken(params) {
+	const { configPath, config, providers, nextclawProvider, v1Base, token } = params;
+	nextclawProvider.apiBase = v1Base;
+	nextclawProvider.apiKey = token;
+	providers.nextclaw = nextclawProvider;
+	saveConfig(config, configPath);
+}
+var PlatformAuthCommands = class {
+	shouldUseBrowserLogin = (opts) => {
+		const email = typeof opts.email === "string" ? opts.email.trim() : "";
+		const password = typeof opts.password === "string" ? opts.password : "";
+		return !email && !password;
+	};
+	waitFor = async (delayMs) => {
+		await new Promise((resolve) => setTimeout(resolve, delayMs));
+	};
+	formatLoginDeadline = (expiresAt) => {
+		const value = Date.parse(expiresAt);
+		return Number.isNaN(value) ? expiresAt : new Date(value).toLocaleString();
+	};
+	printLoginSuccess = (result) => {
+		console.log(`✓ Logged in to NextClaw platform (${result.platformBase})`);
+		console.log(`✓ Account: ${result.email} (${result.role})`);
+		console.log("✓ Token saved into providers.nextclaw.apiKey");
+	};
+	printBrowserLoginIntro = (params) => {
+		const { expiresAt, open, openedBrowser, verificationUri } = params;
+		const expiresText = this.formatLoginDeadline(expiresAt);
+		console.log("NextClaw browser sign-in");
+		console.log(`Open this link to continue: ${verificationUri}`);
+		if (open) if (openedBrowser) console.log("✓ Opened the default browser. Finish sign-in there and this terminal will complete automatically.");
+		else console.log("Browser did not open automatically. Open the link above in any browser to continue.");
+		else console.log("Automatic browser opening is disabled. Open the link above in any browser to continue.");
+		console.log("This link can be opened on this machine or on another device if your CLI is running remotely.");
+		console.log(`Waiting for authorization until ${expiresText}...`);
+	};
+	waitForBrowserLoginResult = async (params) => {
+		while (true) {
+			const result = await this.pollBrowserAuth({
+				apiBase: params.apiBase,
+				sessionId: params.sessionId
+			});
+			if (result.status === "pending") {
+				await this.waitFor(result.nextPollMs);
+				continue;
+			}
+			if (result.status === "expired") throw new Error(`${result.message} Run \`nextclaw login\` again to generate a new sign-in link.`);
+			return {
+				token: result.token,
+				role: result.role,
+				email: result.email,
+				platformBase: result.platformBase,
+				v1Base: result.v1Base
+			};
+		}
+	};
+	loginWithBrowserResult = async (opts = {}) => {
+		const startResult = await this.startBrowserAuth({ apiBase: opts.apiBase });
+		const shouldOpenBrowser = opts.open !== false;
+		const openedBrowser = shouldOpenBrowser ? openBrowser(startResult.verificationUri) : false;
+		this.printBrowserLoginIntro({
+			verificationUri: startResult.verificationUri,
+			expiresAt: startResult.expiresAt,
+			open: shouldOpenBrowser,
+			openedBrowser
+		});
+		const result = await this.waitForBrowserLoginResult({
+			apiBase: opts.apiBase,
+			sessionId: startResult.sessionId
+		});
+		console.log("✓ Browser authorization completed.");
+		return result;
+	};
+	readStoredToken = (params = {}) => {
+		const resolved = resolveProviderConfig({ apiBase: params.apiBase });
+		const token = resolved.nextclawProvider.apiKey?.trim() ?? "";
+		if (!token) throw new Error("Not logged in. Run `nextclaw login` first.");
+		return {
+			...resolved,
+			token
+		};
+	};
+	loginResult = async (opts = {}) => {
+		const { configPath, config, providers, nextclawProvider, platformBase, v1Base, inputApiBase } = resolveProviderConfig(opts);
+		const { email, password } = await resolveCredentials(opts);
+		const response = await fetch(`${platformBase}/platform/auth/login`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				email,
+				password
+			})
+		});
+		const raw = await response.text();
+		if (!response.ok) throw new Error(buildPlatformApiBaseErrorMessage(inputApiBase, readPlatformErrorMessage(raw, response.status)));
+		const { token, role } = readLoginPayload(raw);
+		persistPlatformToken({
+			configPath,
+			config,
+			providers,
+			nextclawProvider,
+			v1Base,
+			token
+		});
+		return {
+			token,
+			role,
+			email,
+			platformBase,
+			v1Base
+		};
+	};
+	startBrowserAuth = async (opts = {}) => {
+		const { platformBase, v1Base, inputApiBase } = resolveProviderConfig(opts);
+		const response = await fetch(`${platformBase}/platform/auth/browser/start`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({})
+		});
+		const raw = await response.text();
+		if (!response.ok) throw new Error(buildPlatformApiBaseErrorMessage(inputApiBase, readPlatformErrorMessage(raw, response.status)));
+		return {
+			...readBrowserAuthStartPayload(raw),
+			platformBase,
+			v1Base
+		};
+	};
+	pollBrowserAuth = async (params) => {
+		const { configPath, config, providers, nextclawProvider, platformBase, v1Base, inputApiBase } = resolveProviderConfig({ apiBase: params.apiBase });
+		const response = await fetch(`${platformBase}/platform/auth/browser/poll`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ sessionId: params.sessionId })
+		});
+		const raw = await response.text();
+		if (!response.ok) throw new Error(buildPlatformApiBaseErrorMessage(inputApiBase, readPlatformErrorMessage(raw, response.status)));
+		const result = readBrowserAuthPollPayload(raw);
+		if (result.status === "pending") return {
+			status: "pending",
+			nextPollMs: result.nextPollMs ?? 1500
+		};
+		if (result.status === "expired") return {
+			status: "expired",
+			message: result.message ?? "Authorization session expired."
+		};
+		persistPlatformToken({
+			configPath,
+			config,
+			providers,
+			nextclawProvider,
+			v1Base,
+			token: result.token ?? ""
+		});
+		return {
+			status: "authorized",
+			token: result.token ?? "",
+			role: result.role ?? "user",
+			email: result.email ?? "",
+			platformBase,
+			v1Base
+		};
+	};
+	login = async (opts = {}) => {
+		const result = this.shouldUseBrowserLogin(opts) ? await this.loginWithBrowserResult(opts) : await this.loginResult(opts);
+		this.printLoginSuccess(result);
+	};
+	me = async (params = {}) => {
+		const { platformBase, v1Base, inputApiBase, token } = this.readStoredToken(params);
+		const response = await fetch(`${platformBase}/platform/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
+		const raw = await response.text();
+		if (!response.ok) throw new Error(buildPlatformApiBaseErrorMessage(inputApiBase, readPlatformErrorMessage(raw, response.status)));
+		return {
+			user: readPlatformUserPayload(raw),
+			token,
+			platformBase,
+			v1Base
+		};
+	};
+	updateProfile = async (params) => {
+		const { configPath, config, providers, nextclawProvider, platformBase, v1Base, inputApiBase, token } = this.readStoredToken(params);
+		const response = await fetch(`${platformBase}/platform/auth/profile`, {
+			method: "PATCH",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ username: params.username })
+		});
+		const raw = await response.text();
+		if (!response.ok) throw new Error(buildPlatformApiBaseErrorMessage(inputApiBase, readPlatformErrorMessage(raw, response.status)));
+		const result = readPlatformAuthResultPayload(raw);
+		persistPlatformToken({
+			configPath,
+			config,
+			providers,
+			nextclawProvider,
+			v1Base,
+			token: result.token
+		});
+		return {
+			user: result.user,
+			token: result.token,
+			platformBase,
+			v1Base
+		};
+	};
+	logout = () => {
+		const { configPath, config, providers, nextclawProvider } = resolveProviderConfig({});
+		const cleared = Boolean(nextclawProvider.apiKey?.trim());
+		nextclawProvider.apiKey = "";
+		providers.nextclaw = nextclawProvider;
+		saveConfig(config, configPath);
+		return { cleared };
+	};
+	accountStatus = async (opts = {}) => {
+		const view = toAccountStatusView(await this.me({ apiBase: opts.apiBase }));
+		if (opts.json) {
+			console.log(JSON.stringify(view, null, 2));
+			return;
+		}
+		printAccountStatus(view);
+	};
+	accountSetUsername = async (opts) => {
+		const view = toAccountStatusView(await this.updateProfile({
+			apiBase: opts.apiBase,
+			username: opts.username
+		}));
+		if (opts.json) {
+			console.log(JSON.stringify(view, null, 2));
+			return;
+		}
+		printUsernameUpdated(view);
+		printAccountStatus(view);
+	};
+};
+//#endregion
+export { PlatformAuthCommands };

package/dist/commands/platform-auth/utils/payload.utils.d.ts

@@ -0,0 +1,28 @@
+import { PlatformUserView } from "../services/platform-auth-commands.service.js";
+//#region src/commands/platform-auth/utils/payload.utils.d.ts
+declare function readLoginPayload(raw: string): {
+  token: string;
+  role: string;
+};
+declare function readPlatformUserPayload(raw: string): PlatformUserView;
+declare function readPlatformAuthResultPayload(raw: string): {
+  token: string;
+  user: PlatformUserView;
+};
+declare function readPlatformErrorMessage(raw: string, fallbackStatus: number): string;
+declare function readBrowserAuthStartPayload(raw: string): {
+  sessionId: string;
+  verificationUri: string;
+  expiresAt: string;
+  intervalMs: number;
+};
+declare function readBrowserAuthPollPayload(raw: string): {
+  status: "pending" | "authorized" | "expired";
+  nextPollMs?: number;
+  token?: string;
+  role?: string;
+  email?: string;
+  message?: string;
+};
+//#endregion
+export { readBrowserAuthPollPayload, readBrowserAuthStartPayload, readLoginPayload, readPlatformAuthResultPayload, readPlatformErrorMessage, readPlatformUserPayload };

package/dist/commands/platform-auth/utils/payload.utils.js

@@ -0,0 +1,87 @@
+//#region src/commands/platform-auth/utils/payload.utils.ts
+function readLoginPayload(raw) {
+	const authResult = readPlatformAuthResultPayload(raw);
+	return {
+		token: authResult.token,
+		role: authResult.user.role
+	};
+}
+function readPlatformUserPayload(raw) {
+	const parsed = parseJsonText(raw);
+	const data = typeof parsed === "object" && parsed && "data" in parsed ? parsed.data : null;
+	const user = typeof data?.user === "object" && data.user ? data.user : null;
+	const id = typeof user?.id === "string" ? user.id.trim() : "";
+	const email = typeof user?.email === "string" ? user.email.trim() : "";
+	const role = typeof user?.role === "string" ? user.role.trim() : "user";
+	const username = typeof user?.username === "string" ? user.username.trim() : user?.username === null ? null : null;
+	if (!id || !email) throw new Error("Platform user payload is incomplete.");
+	return {
+		id,
+		email,
+		username: username && username.length > 0 ? username : null,
+		role
+	};
+}
+function readPlatformAuthResultPayload(raw) {
+	const parsed = parseJsonText(raw);
+	const token = typeof parsed === "object" && parsed && "data" in parsed && typeof parsed.data?.token === "string" ? parsed.data.token : "";
+	const user = readPlatformUserPayload(raw);
+	if (!token) throw new Error("Login succeeded but token is missing.");
+	return {
+		token,
+		user
+	};
+}
+function readPlatformErrorMessage(raw, fallbackStatus) {
+	const parsed = parseJsonText(raw);
+	return typeof parsed === "object" && parsed && "error" in parsed && typeof parsed.error?.message === "string" ? parsed.error.message : raw || `Request failed (${fallbackStatus})`;
+}
+function readBrowserAuthStartPayload(raw) {
+	const parsed = parseJsonText(raw);
+	const data = typeof parsed === "object" && parsed && "data" in parsed ? parsed.data : null;
+	const sessionId = typeof data?.sessionId === "string" ? data.sessionId.trim() : "";
+	const verificationUri = typeof data?.verificationUri === "string" ? data.verificationUri.trim() : "";
+	const expiresAt = typeof data?.expiresAt === "string" ? data.expiresAt.trim() : "";
+	const intervalMs = typeof data?.intervalMs === "number" && Number.isFinite(data.intervalMs) ? Math.max(1e3, Math.trunc(data.intervalMs)) : 1500;
+	if (!sessionId || !verificationUri || !expiresAt) throw new Error("Browser authorization session payload is incomplete.");
+	return {
+		sessionId,
+		verificationUri,
+		expiresAt,
+		intervalMs
+	};
+}
+function readBrowserAuthPollPayload(raw) {
+	const parsed = parseJsonText(raw);
+	const data = typeof parsed === "object" && parsed && "data" in parsed ? parsed.data : null;
+	const status = typeof data?.status === "string" ? data.status.trim() : "";
+	if (status === "pending") return {
+		status,
+		nextPollMs: typeof data?.nextPollMs === "number" && Number.isFinite(data.nextPollMs) ? Math.max(1e3, Math.trunc(data.nextPollMs)) : 1500
+	};
+	if (status === "expired") return {
+		status,
+		message: typeof data?.message === "string" && data.message.trim() ? data.message.trim() : "Authorization session expired."
+	};
+	if (status !== "authorized") throw new Error("Unexpected browser authorization status.");
+	const token = typeof data?.token === "string" ? data.token.trim() : "";
+	const user = typeof data?.user === "object" && data.user ? data.user : null;
+	const role = typeof user?.role === "string" ? user.role.trim() : "user";
+	const email = typeof user?.email === "string" ? user.email.trim() : "";
+	if (!token || !email) throw new Error("Authorized browser login payload is incomplete.");
+	return {
+		status,
+		token,
+		role,
+		email
+	};
+}
+function parseJsonText(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { readBrowserAuthPollPayload, readBrowserAuthStartPayload, readLoginPayload, readPlatformAuthResultPayload, readPlatformErrorMessage, readPlatformUserPayload };

package/dist/commands/plugin/development-source/dev-plugin-overrides.utils.d.ts

@@ -0,0 +1,18 @@
+import { Config } from "@nextclaw/core";
+
+//#region src/commands/plugin/development-source/dev-plugin-overrides.utils.d.ts
+declare const DEV_PLUGIN_OVERRIDES_ENV = "NEXTCLAW_DEV_PLUGIN_OVERRIDES";
+type PluginEntrySource = "production" | "development";
+type DevPluginOverride = {
+  pluginId: string;
+  pluginPath: string;
+  source: PluginEntrySource;
+};
+declare function resolveDevPluginOverrides(rawEnv?: string | undefined): DevPluginOverride[];
+declare function resolveDevPluginLoadingContext(config: Config, workspaceExtensionsDir: string | undefined, rawOverridesEnv?: string | undefined): {
+  configWithDevPluginOverrides: Config;
+  excludedRoots: string[];
+  overrides: DevPluginOverride[];
+};
+//#endregion
+export { DEV_PLUGIN_OVERRIDES_ENV, DevPluginOverride, resolveDevPluginLoadingContext, resolveDevPluginOverrides };

package/dist/commands/plugin/development-source/dev-plugin-overrides.utils.js

@@ -0,0 +1,111 @@
+import { applyDevFirstPartyPluginLoadPaths, resolveDevFirstPartyPluginInstallRoots } from "./first-party-plugin-load-paths.js";
+import path from "node:path";
+import fs from "node:fs";
+import { getPackageManifestExtensions, loadPluginManifest } from "@nextclaw/openclaw-compat";
+//#region src/commands/plugin/development-source/dev-plugin-overrides.utils.ts
+const DEV_PLUGIN_OVERRIDES_ENV = "NEXTCLAW_DEV_PLUGIN_OVERRIDES";
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readPackageManifest(pluginPath) {
+	const packageJsonPath = path.join(pluginPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function assertOverridePluginReadable(override) {
+	if (!fs.existsSync(override.pluginPath)) throw new Error(`[dev-plugin-override] plugin path does not exist for "${override.pluginId}": ${override.pluginPath}`);
+	const packageManifest = readPackageManifest(override.pluginPath);
+	if (!packageManifest) throw new Error(`[dev-plugin-override] package.json is missing or invalid for "${override.pluginId}": ${override.pluginPath}`);
+	const pluginManifest = loadPluginManifest(override.pluginPath);
+	if (!pluginManifest.ok) throw new Error(`[dev-plugin-override] ${pluginManifest.error} for "${override.pluginId}": ${override.pluginPath}`);
+	if (pluginManifest.manifest.id !== override.pluginId) throw new Error(`[dev-plugin-override] plugin id mismatch: expected "${override.pluginId}" but found "${pluginManifest.manifest.id}" at ${override.pluginPath}`);
+	if (getPackageManifestExtensions(packageManifest, override.source).length === 0) {
+		const missingEntry = override.source === "development" ? "openclaw.development.extensions" : "openclaw.extensions";
+		throw new Error(`[dev-plugin-override] ${missingEntry} is missing for "${override.pluginId}" at ${override.pluginPath}`);
+	}
+}
+function readOverrideRecord(value, index) {
+	if (!isRecord(value)) throw new Error(`[dev-plugin-override] override[${index}] must be an object`);
+	const pluginId = readOptionalString(value.pluginId);
+	const pluginPath = readOptionalString(value.pluginPath);
+	const source = value.source === "development" ? "development" : "production";
+	if (!pluginId || !pluginPath) throw new Error(`[dev-plugin-override] override[${index}] requires pluginId and pluginPath`);
+	const normalized = {
+		pluginId,
+		pluginPath: path.resolve(pluginPath),
+		source
+	};
+	assertOverridePluginReadable(normalized);
+	return normalized;
+}
+function resolveDevPluginOverrides(rawEnv = process.env[DEV_PLUGIN_OVERRIDES_ENV]) {
+	if (typeof rawEnv !== "string" || rawEnv.trim().length === 0) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(rawEnv);
+	} catch (error) {
+		throw new Error(`[dev-plugin-override] failed to parse ${DEV_PLUGIN_OVERRIDES_ENV}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!Array.isArray(parsed)) throw new Error(`[dev-plugin-override] ${DEV_PLUGIN_OVERRIDES_ENV} must be a JSON array`);
+	const seenPluginIds = /* @__PURE__ */ new Set();
+	const overrides = parsed.map((entry, index) => readOverrideRecord(entry, index));
+	for (const entry of overrides) {
+		if (seenPluginIds.has(entry.pluginId)) throw new Error(`[dev-plugin-override] duplicate plugin override for "${entry.pluginId}"`);
+		seenPluginIds.add(entry.pluginId);
+	}
+	return overrides;
+}
+function mergeLoadPaths(existingLoadPaths, overrideLoadPaths) {
+	const merged = [...overrideLoadPaths];
+	for (const entry of existingLoadPaths) if (!merged.includes(entry)) merged.push(entry);
+	return merged;
+}
+function applyExplicitDevPluginOverrides(config, overrides) {
+	if (overrides.length === 0) return config;
+	const nextEntries = { ...config.plugins.entries ?? {} };
+	for (const override of overrides) nextEntries[override.pluginId] = {
+		...nextEntries[override.pluginId] ?? {},
+		source: override.source
+	};
+	const existingLoadPaths = Array.isArray(config.plugins.load?.paths) ? config.plugins.load.paths.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+	return {
+		...config,
+		plugins: {
+			...config.plugins,
+			entries: nextEntries,
+			load: {
+				...config.plugins.load,
+				paths: mergeLoadPaths(existingLoadPaths, overrides.map((entry) => entry.pluginPath))
+			}
+		}
+	};
+}
+function resolveDevPluginOverrideInstallRoots(config, overrides) {
+	const installRoots = [];
+	for (const override of overrides) {
+		const installRecord = config.plugins.installs?.[override.pluginId];
+		const installPath = readOptionalString(installRecord?.installPath);
+		if (!installPath || installRoots.includes(installPath)) continue;
+		installRoots.push(installPath);
+	}
+	return installRoots;
+}
+function resolveDevPluginLoadingContext(config, workspaceExtensionsDir, rawOverridesEnv = process.env[DEV_PLUGIN_OVERRIDES_ENV]) {
+	const configWithFirstPartyOverrides = applyDevFirstPartyPluginLoadPaths(config, workspaceExtensionsDir);
+	const overrides = resolveDevPluginOverrides(rawOverridesEnv);
+	return {
+		configWithDevPluginOverrides: applyExplicitDevPluginOverrides(configWithFirstPartyOverrides, overrides),
+		excludedRoots: [...resolveDevFirstPartyPluginInstallRoots(config, workspaceExtensionsDir), ...resolveDevPluginOverrideInstallRoots(config, overrides)].filter((entry, index, list) => list.indexOf(entry) === index),
+		overrides
+	};
+}
+//#endregion
+export { DEV_PLUGIN_OVERRIDES_ENV, resolveDevPluginLoadingContext, resolveDevPluginOverrides };

package/dist/commands/plugin/development-source/first-party-plugin-load-paths.d.ts

@@ -0,0 +1,9 @@
+import { Config } from "@nextclaw/core";
+
+//#region src/commands/plugin/development-source/first-party-plugin-load-paths.d.ts
+declare const resolveDevFirstPartyPluginDir: (explicitDir: string | undefined, moduleDir?: string) => string | undefined;
+declare const resolveDevFirstPartyPluginLoadPaths: (config: Config, workspaceExtensionsDir: string | undefined) => string[];
+declare const resolveDevFirstPartyPluginInstallRoots: (config: Config, workspaceExtensionsDir: string | undefined) => string[];
+declare const applyDevFirstPartyPluginLoadPaths: (config: Config, workspaceExtensionsDir: string | undefined) => Config;
+//#endregion
+export { applyDevFirstPartyPluginLoadPaths, resolveDevFirstPartyPluginDir, resolveDevFirstPartyPluginInstallRoots, resolveDevFirstPartyPluginLoadPaths };