nextclaw 0.48.3 → 0.49.0

package/dist/cli/app/index.js

@@ -5,7 +5,7 @@ import { NextclawDistributionService } from "@nextclaw/service";
 const distribution = createNextclawDistribution(import.meta.url);
 repairPackagedPortableRunnerPermissions(distribution);
 NextclawDistributionService.configureRuntime(distribution);
-const { nextclawCliProgram } = await import("../../nextclaw-cli-app-BJSCnCIN.js");
+const { nextclawCliProgram } = await import("../../nextclaw-cli-app-CjtgVEdo.js");
 await nextclawCliProgram.parseAsync(process.argv);
 //#endregion
 export {};

package/dist/{nextclaw-cli-app-BJSCnCIN.js → nextclaw-cli-app-CjtgVEdo.js}

@@ -3,7 +3,7 @@ import { APP_NAME, APP_TAGLINE, getConfigPath, getDataDir, getRunPath, loadConfi
 import { NextclawDistributionService, NextclawServiceRuntime, readLearningLoopRuntimeConfig } from "@nextclaw/service";
 import { constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path, { join, resolve } from "node:path";
-import { Command, InvalidArgumentError } from "commander";
+import { Argument, Command, InvalidArgumentError, Option } from "commander";
 import { createHash, randomBytes } from "node:crypto";
 import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -6127,6 +6127,302 @@ function registerExecCommand(program, nextclaw) {
 	});
 }
 //#endregion
+//#region src/cli/app/utils/config-command-options.utils.ts
+function requireConfigApiClient() {
+	const client = createLocalUiApiClient();
+	if (!client) throw new Error("NextClaw is not running. Run nextclaw start before managing providers, models or search.");
+	return client;
+}
+function printConfigResult(value) {
+	process.stdout.write(`${JSON.stringify(value, (key, item) => {
+		if (key === "extraHeaders" && item && typeof item === "object") return Object.fromEntries(Object.keys(item).map((name) => [name, "[redacted]"]));
+		return item;
+	}, 2)}\n`);
+}
+function parseConfigBoolean(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new InvalidArgumentError("Expected true or false.");
+}
+function collectConfigOption(value, previous = []) {
+	return [...previous, value];
+}
+function parseConfigAssignment(value) {
+	const separator = value.indexOf("=");
+	if (separator < 1 || !value.slice(0, separator).trim() || separator === value.length - 1) throw new InvalidArgumentError("Expected name=value.");
+	return [value.slice(0, separator).trim(), value.slice(separator + 1)];
+}
+function readConfigApiKey(options) {
+	const { apiKeyEnv, clearApiKey } = options;
+	if (apiKeyEnv && clearApiKey) throw new Error("Choose --api-key-env or --clear-api-key, not both.");
+	if (clearApiKey) return null;
+	if (!apiKeyEnv) return void 0;
+	const value = process.env[apiKeyEnv];
+	if (!value?.trim()) throw new Error(`Environment variable ${apiKeyEnv} is empty or missing.`);
+	return value;
+}
+function requireConfigChange(patch) {
+	if (Object.keys(patch).length === 0) throw new Error("No changes specified. See command --help for supported options.");
+}
+//#endregion
+//#region src/cli/app/controllers/config/provider-command.controller.ts
+const thinkingLevels = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"adaptive",
+	"xhigh"
+];
+var ProviderCommandController = class {
+	constructor(createApi = requireConfigApiClient) {
+		this.createApi = createApi;
+	}
+	path = (id) => `/api/providers/${encodeURIComponent(id)}`;
+	showRequest = async (path, method = "GET", body) => {
+		printConfigResult(await this.createApi().request({
+			path,
+			method,
+			body
+		}));
+	};
+	list = async () => this.showRequest("/api/providers");
+	templates = async () => this.showRequest("/api/provider-templates");
+	show = async (id) => {
+		const result = await this.createApi().request({ path: "/api/providers" });
+		if (!Object.hasOwn(result.providers, id)) throw new Error(`Unknown provider: ${id}`);
+		printConfigResult(result.providers[id]);
+	};
+	add = async (id, options) => {
+		if (!id.trim() || id.includes("/")) throw new Error("Provider id must be non-empty and cannot contain '/'.");
+		const patch = this.providerPatch(options);
+		await this.validateTemplate(patch.providerType);
+		await this.showRequest("/api/providers", "POST", {
+			providerId: id,
+			...patch
+		});
+	};
+	update = async (id, options) => {
+		const patch = this.providerPatch(options);
+		requireConfigChange(patch);
+		await this.validateTemplate(patch.providerType);
+		await this.showRequest(this.path(id), "PUT", patch);
+	};
+	remove = async (id) => this.showRequest(this.path(id), "DELETE");
+	enabled = async (id, enabled) => this.showRequest(this.path(id), "PUT", { enabled });
+	models = async (id) => {
+		const result = await this.createApi().request({ path: "/api/providers" });
+		if (!Object.hasOwn(result.providers, id)) throw new Error(`Unknown provider: ${id}`);
+		const provider = result.providers[id];
+		printConfigResult({
+			providerId: id,
+			models: provider.models ?? [],
+			modelConfig: provider.modelConfig ?? {}
+		});
+	};
+	discover = async (id) => this.showRequest(`${this.path(id)}/models/discover`, "POST", {});
+	setModels = async (id, models) => this.showRequest(this.path(id), "PUT", { models });
+	configureModels = async (id, options) => {
+		const { vision = [], thinking = [], thinkingDefault = [], clear } = options;
+		const entries = [
+			...vision,
+			...thinking,
+			...thinkingDefault
+		];
+		if (clear && entries.length) throw new Error("--clear cannot be combined with model capability options.");
+		if (!clear && !entries.length) throw new Error("Specify model capabilities or --clear.");
+		const modelConfig = Object.create(null);
+		for (const entry of vision) {
+			const [model, value] = parseConfigAssignment(entry);
+			(modelConfig[model] ??= {}).vision = parseConfigBoolean(value);
+		}
+		for (const entry of thinking) {
+			const [model, value] = parseConfigAssignment(entry);
+			(modelConfig[model] ??= {}).thinking = { supported: value.split(",").map(parseThinkingLevel) };
+		}
+		for (const entry of thinkingDefault) {
+			const [model, value] = parseConfigAssignment(entry);
+			const config = modelConfig[model] ??= {};
+			const level = parseThinkingLevel(value);
+			if (!config.thinking?.supported?.includes(level)) throw new Error(`Default thinking level for ${model} must be included in --thinking for that model.`);
+			config.thinking.default = level;
+		}
+		await this.showRequest(this.path(id), "PUT", { modelConfig });
+	};
+	test = async (id, options) => {
+		const result = await this.createApi().request({
+			path: `${this.path(id)}/test`,
+			method: "POST",
+			body: { model: options.model }
+		});
+		printConfigResult(result);
+		if (!result.success) process.exitCode = 1;
+	};
+	startAuth = async (id, options) => this.showRequest(`${this.path(id)}/auth/start`, "POST", { methodId: options.method });
+	pollAuth = async (id, sessionId) => {
+		const result = await this.createApi().request({
+			path: `${this.path(id)}/auth/poll`,
+			method: "POST",
+			body: { sessionId }
+		});
+		printConfigResult(result);
+		if ([
+			"denied",
+			"expired",
+			"error"
+		].includes(result.status)) process.exitCode = 1;
+	};
+	importAuth = async (id) => this.showRequest(`${this.path(id)}/auth/import-cli`, "POST", {});
+	validateTemplate = async (type) => {
+		if (type == null) return;
+		const { providerTemplates } = await this.createApi().request({ path: "/api/provider-templates" });
+		if (!providerTemplates.some((template) => template.id === type)) throw new Error(`Unknown provider type: ${type}. Use providers templates or --type custom.`);
+	};
+	providerPatch = (options) => {
+		const { type, name, apiBase, wireApi, header, clearHeaders } = options;
+		const patch = {};
+		if (type !== void 0) patch.providerType = type === "custom" ? null : type;
+		if (name !== void 0) patch.displayName = name;
+		if (apiBase !== void 0) patch.apiBase = apiBase || null;
+		if (wireApi !== void 0) patch.wireApi = wireApi;
+		const key = readConfigApiKey(options);
+		if (key !== void 0) patch.apiKey = key;
+		if (header && clearHeaders) throw new Error("Choose --header or --clear-headers, not both.");
+		if (header) patch.extraHeaders = Object.fromEntries(header.map(parseConfigAssignment));
+		if (clearHeaders) patch.extraHeaders = null;
+		return patch;
+	};
+};
+function parseThinkingLevel(value) {
+	const level = thinkingLevels.find((item) => item === value);
+	if (!level) throw new Error(`Unknown thinking level: ${value}. Choose ${thinkingLevels.join(", ")}.`);
+	return level;
+}
+//#endregion
+//#region src/cli/app/commands/provider-command-registration.utils.ts
+function registerProviderCommands(program, controller = new ProviderCommandController()) {
+	const providers = program.command("providers").description("Manage model providers through the running NextClaw host");
+	const output = (command) => command.option("--json", "Output JSON (also the default)");
+	output(providers.command("list").description("List providers without exposing credentials")).action(controller.list);
+	output(providers.command("templates").description("List provider templates and authorization methods")).action(controller.templates);
+	output(providers.command("show <provider-id>").description("Show one provider")).action(controller.show);
+	output(providerOptions(providers.command("add <provider-id>").description("Create a provider instance"))).action(controller.add);
+	output(providerOptions(providers.command("update <provider-id>").description("Update specified provider settings"))).action(controller.update);
+	output(providers.command("remove <provider-id>").description("Remove a provider and its secret references")).action(controller.remove);
+	output(providers.command("enable <provider-id>").description("Enable a provider")).action(async (id) => controller.enabled(id, true));
+	output(providers.command("disable <provider-id>").description("Disable a provider")).action(async (id) => controller.enabled(id, false));
+	output(providers.command("test <provider-id>").description("Test a provider connection; failure exits non-zero").option("--model <model>", "Model to test")).action(controller.test);
+	const models = providers.command("models").description("Manage a provider's models");
+	output(models.command("list <provider-id>").description("Show configured models and capability overrides")).action(controller.models);
+	output(models.command("discover <provider-id>").description("Discover available models without changing configuration")).action(controller.discover);
+	output(models.command("set <provider-id> [models...]").description("Replace the configured model list; omit models to clear it")).action(controller.setModels);
+	output(models.command("configure <provider-id>").description("Replace all model capability overrides (model list is unchanged)").option("--vision <model=true|false>", "Vision capability (repeatable)", collectConfigOption).option("--thinking <model=levels>", "Comma-separated supported thinking levels (repeatable)", collectConfigOption).option("--thinking-default <model=level>", "Default thinking level (repeatable)", collectConfigOption).option("--clear", "Clear all model capability overrides")).action(controller.configureModels);
+	const auth = providers.command("auth").description("Authorize a provider");
+	output(auth.command("start <provider-id>").description("Start authorization; returns verification URI, user code and session id").option("--method <id>", "Authorization method from providers templates")).action(controller.startAuth);
+	output(auth.command("poll <provider-id> <session-id>").description("Poll once; respect the returned nextPollMs before polling again")).action(controller.pollAuth);
+	output(auth.command("import <provider-id>").description("Import credentials from a supported provider CLI")).action(controller.importAuth);
+}
+function providerOptions(command) {
+	return command.option("--type <type>", "Template type from providers templates, or custom").option("--name <name>", "Display name").option("--api-base <url>", "API base URL; empty string resets it").option("--api-key-env <name>", "Read the API key from an environment variable").option("--clear-api-key", "Clear the stored API key and its secret reference").addOption(new Option("--wire-api <protocol>", "API protocol").choices([
+		"auto",
+		"chat",
+		"responses"
+	])).option("--header <name=value>", "Replace custom headers with the supplied entries (repeatable)", collectConfigOption).option("--clear-headers", "Clear custom headers");
+}
+//#endregion
+//#region src/cli/app/controllers/config/model-search-command.controller.ts
+var ModelSearchCommandController = class {
+	constructor(createApi = requireConfigApiClient) {
+		this.createApi = createApi;
+	}
+	listModels = async () => {
+		printConfigResult(await this.createApi().request({ path: "/api/provider-model-catalog" }));
+	};
+	showModel = async () => {
+		printConfigResult({ model: (await this.createApi().request({ path: "/api/config" })).agents.defaults.model });
+	};
+	setModel = async (model) => {
+		if (!model.trim()) throw new Error("Model must not be empty.");
+		printConfigResult(await this.createApi().request({
+			path: "/api/config/model",
+			method: "PUT",
+			body: { model }
+		}));
+	};
+	showSearch = async () => {
+		printConfigResult((await this.createApi().request({ path: "/api/config" })).search);
+	};
+	configureSearch = async (options) => {
+		const { provider, enabledProvider, clearEnabledProviders, maxResults } = options;
+		const patch = {};
+		if (provider !== void 0) patch.provider = provider;
+		if (enabledProvider !== void 0) patch.enabledProviders = enabledProvider;
+		if (clearEnabledProviders) {
+			if (enabledProvider) throw new Error("Choose --enabled-provider or --clear-enabled-providers, not both.");
+			patch.enabledProviders = [];
+		}
+		if (maxResults !== void 0) patch.defaults = { maxResults };
+		await this.updateSearch(patch);
+	};
+	configureSearchProvider = async (provider, options) => {
+		const patch = {};
+		const apiKey = readConfigApiKey(options);
+		if (apiKey !== void 0) patch.apiKey = apiKey;
+		if (options.baseUrl !== void 0) patch.baseUrl = options.baseUrl || null;
+		const bochaFields = [
+			"docsUrl",
+			"summary",
+			"freshness"
+		];
+		const tavilyFields = ["searchDepth", "includeAnswer"];
+		for (const field of bochaFields) {
+			if (options[field] === void 0) continue;
+			if (provider !== "bocha") throw new Error(`${field} is only supported by bocha.`);
+			patch[field] = options[field];
+		}
+		for (const field of tavilyFields) {
+			if (options[field] === void 0) continue;
+			if (provider !== "tavily") throw new Error(`${field} is only supported by tavily.`);
+			patch[field] = options[field];
+		}
+		requireConfigChange(patch);
+		await this.updateSearch({ providers: { [provider]: patch } });
+	};
+	updateSearch = async (patch) => {
+		requireConfigChange(patch);
+		printConfigResult(await this.createApi().request({
+			path: "/api/config/search",
+			method: "PUT",
+			body: patch
+		}));
+	};
+};
+//#endregion
+//#region src/cli/app/commands/model-search-command-registration.utils.ts
+const searchProviders = [
+	"bocha",
+	"tavily",
+	"brave",
+	"exa"
+];
+function registerModelSearchCommands(program, controller = new ModelSearchCommandController()) {
+	const output = (command) => command.option("--json", "Output JSON (also the default)");
+	const models = program.command("models").description("Inspect available models and manage the default model");
+	output(models.command("list").description("Show the runtime model catalog and discovery status")).action(controller.listModels);
+	output(models.command("show").description("Show the default model")).action(controller.showModel);
+	output(models.command("set <model>").description("Set the default model using a provider-scoped model id")).action(controller.setModel);
+	const search = program.command("search").description("Manage web search settings through the running host");
+	output(search.command("show").description("Show search settings without exposing credentials")).action(controller.showSearch);
+	output(search.command("configure").description("Configure default search provider, enabled providers and result count").addOption(new Option("--provider <provider>", "Default search provider").choices(searchProviders)).addOption(new Option("--enabled-provider <providers...>", "Replace enabled search providers").choices(searchProviders)).option("--clear-enabled-providers", "Disable all search providers").option("--max-results <count>", "Default result count (1-50)", parseResultCount)).action(controller.configureSearch);
+	output(search.command("provider").description("Update one search provider's credentials and supported options").addArgument(new Argument("<provider>").choices(searchProviders)).option("--api-key-env <name>", "Read the API key from an environment variable").option("--clear-api-key", "Clear the stored API key and its secret reference").option("--base-url <url>", "Search API base URL; empty string resets it").option("--docs-url <url>", "Bocha documentation URL").option("--summary <boolean>", "Bocha summary", parseConfigBoolean).option("--freshness <value>", "Bocha freshness").addOption(new Option("--search-depth <depth>", "Tavily search depth").choices(["basic", "advanced"])).option("--include-answer <boolean>", "Tavily synthesized answer", parseConfigBoolean)).action(controller.configureSearchProvider);
+}
+function parseResultCount(value) {
+	const count = Number(value);
+	if (!Number.isInteger(count) || count < 1 || count > 50) throw new InvalidArgumentError("Expected an integer from 1 to 50.");
+	return count;
+}
+//#endregion
 //#region src/cli/app/nextclaw-cli-app.ts
 const LOGO = "🤖";
 const program = new Command();
@@ -6162,6 +6458,8 @@ registerSessionCommands(program, runtime);
 registerExecCommand(program, runtime);
 registerAppCommands(program, { portableServiceRunnerPath: NextclawDistributionService.get().portableServiceRunnerPath });
 const config = program.command("config").description("Manage config values");
+registerProviderCommands(program);
+registerModelSearchCommands(program);
 config.command("get <path>").description("Get a config value by dot path").option("--json", "Output JSON", false).action((path, opts) => runtime.commands.config.get(path, opts));
 config.command("set <path> <value>").description("Set a config value by dot path").option("--json", "Parse value as JSON", false).action((path, value, opts) => runtime.commands.config.set(path, value, opts));
 config.command("unset <path>").description("Remove a config value by dot path").action((path) => runtime.commands.config.unset(path));
@@ -6200,4 +6498,4 @@ program.command("usage").description("Show observed LLM usage snapshots, history
 //#endregion
 export { program as nextclawCliProgram };
 
-//# sourceMappingURL=nextclaw-cli-app-BJSCnCIN.js.map
+//# sourceMappingURL=nextclaw-cli-app-CjtgVEdo.js.map