nextclaw 0.45.5 → 0.46.0

package/dist/{nextclaw-cli-app-Bwa2L2Jv.js → nextclaw-cli-app-BVdP2e0w.js}

@@ -9,7 +9,7 @@ import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
 import "@nextclaw/server";
 import { access, mkdtemp, readFile, rm, stat } from "node:fs/promises";
-import { AppBundleService, AppHomeService, AppInstanceInventoryService, AppInstanceStorageService, AppManifestService, AppPlatformTargetService, AppPublishService, AppPublishValidationService, isAppComponentManifestBundle } from "@nextclaw/app-runtime";
+import { AppBuildService, AppBundleService, AppHomeService, AppInstanceInventoryService, AppInstanceStorageService, AppManifestService, AppPlatformTargetService, AppPublishService, AppPublishValidationService, AppRuntimeToolchainService, AppScaffoldService, isAppComponentManifestBundle } from "@nextclaw/app-runtime";
 import { NextclawHarnessError, ServiceAppRuntimeService, buildServiceActionId, getServiceAppManifestPath, mergeServiceAppRuntimeActions, readServiceAppManifest } from "@nextclaw/kernel";
 import { format, promisify } from "node:util";
 import { formatNextClawAppInstallCommand } from "@nextclaw/shared";
@@ -3630,16 +3630,101 @@ const registerHostServiceControls = ({ program, nextclaw }) => {
 	autostart.command("doctor").description("Diagnose host autostart setup").option("--user", "Inspect the user-level autostart owner", false).option("--system", "Inspect the system-level autostart owner", false).option("--json", "Output JSON", false).action(async (opts) => serviceCommands.autostartDoctor(opts));
 };
 //#endregion
+//#region src/cli/app/services/development/service-app-package-target.service.ts
+var ServiceAppPackageTargetService = class {
+	resolve = async (target, componentId, issues) => {
+		const targetPath = path.resolve(target);
+		if (await this.pathExists(getServiceAppManifestPath(targetPath))) return { appPath: targetPath };
+		if (!await this.pathExists(path.join(targetPath, "manifest.json"))) return { appPath: targetPath };
+		try {
+			const manifestService = new AppManifestService();
+			const bundle = await manifestService.load(targetPath);
+			if (!isAppComponentManifestBundle(bundle)) {
+				issues.push({
+					severity: "error",
+					code: "service.package.schemaUnsupported",
+					message: "app dev/call requires a schema v2 package when the target is a package directory.",
+					fixHint: "Use a Service App directory or a schema v2 package with a Service component."
+				});
+				return null;
+			}
+			const services = bundle.components.filter((component) => component.kind === "service");
+			const selected = this.selectService(services, componentId, issues);
+			if (!selected) return null;
+			return {
+				appPath: selected.componentDirectory,
+				packageContext: { permissions: manifestService.resolvePlatformSecurity(bundle.manifest).permissions }
+			};
+		} catch (error) {
+			issues.push({
+				severity: "error",
+				code: "service.package.invalid",
+				message: `Cannot load schema v2 package: ${error instanceof Error ? error.message : String(error)}`
+			});
+			return null;
+		}
+	};
+	findOwningPackage = async (appPath, issues) => {
+		let candidate = path.dirname(appPath);
+		while (true) {
+			const permissions = await this.readOwningPermissions(candidate, appPath, issues);
+			if (permissions) return { permissions };
+			const parent = path.dirname(candidate);
+			if (parent === candidate) return void 0;
+			candidate = parent;
+		}
+	};
+	selectService = (services, componentId, issues) => {
+		const requested = componentId?.trim();
+		const selected = requested ? services.find((component) => component.id === requested) : services.length === 1 ? services[0] : void 0;
+		if (selected) return selected;
+		const available = services.map((component) => component.id);
+		issues.push({
+			severity: "error",
+			code: requested ? "service.package.componentNotFound" : "service.package.componentRequired",
+			message: requested ? `Service component does not exist in package: ${requested}.` : services.length === 0 ? "The package does not contain a Service component." : "The package contains multiple Service components; choose one with --component.",
+			fixHint: available.length > 0 ? `Available Service components: ${available.join(", ")}.` : void 0
+		});
+	};
+	readOwningPermissions = async (candidate, appPath, issues) => {
+		if (!await this.pathExists(path.join(candidate, "manifest.json"))) return;
+		const manifestService = new AppManifestService();
+		try {
+			const bundle = await manifestService.load(candidate);
+			if (!isAppComponentManifestBundle(bundle)) return void 0;
+			return bundle.components.some((component) => path.resolve(component.componentDirectory) === path.resolve(appPath)) ? manifestService.resolvePlatformSecurity(bundle.manifest).permissions : void 0;
+		} catch (error) {
+			issues.push({
+				severity: "error",
+				code: "service.package.invalid",
+				message: `Cannot load owning schema v2 package at ${candidate}: ${error instanceof Error ? error.message : String(error)}`
+			});
+			return;
+		}
+	};
+	pathExists = async (targetPath) => {
+		try {
+			await access(targetPath);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+};
+//#endregion
 //#region src/cli/app/services/service-app-dev.service.ts
 var ServiceAppDevService = class {
 	instanceInventoryService = new AppInstanceInventoryService();
 	instanceStorageService = new AppInstanceStorageService();
+	packageTargetService = new ServiceAppPackageTargetService();
 	constructor(params = {}) {
 		this.params = params;
 	}
 	inspect = async (target, options = {}) => {
-		const appPath = path.resolve(target);
 		const issues = [];
+		const resolvedTarget = await this.packageTargetService.resolve(target, options.componentId, issues);
+		const appPath = resolvedTarget?.appPath ?? path.resolve(target);
+		if (!resolvedTarget) return this.buildDevReport(appPath, void 0, [], issues);
 		const loaded = await this.loadServiceApp(appPath, issues);
 		if (!loaded) return this.buildDevReport(appPath, void 0, [], issues);
 		if (options.resetData && options.confirmAppId?.trim() !== loaded.manifest.id) issues.push({
@@ -3648,10 +3733,15 @@ var ServiceAppDevService = class {
 			message: `--reset-data requires --confirm ${loaded.manifest.id}.`
 		});
 		if (this.hasErrors(issues)) return this.buildDevReport(appPath, this.toServiceAppRecord(appPath, loaded.manifest, this.idleRuntimeStatus), [], issues);
-		const portable = await this.loadPortableDevContext(appPath, loaded.manifest, issues);
+		const portable = await this.loadPortableDevContext(appPath, loaded.manifest, issues, resolvedTarget.packageContext);
 		if (this.hasErrors(issues)) return this.buildDevReport(appPath, this.toServiceAppRecord(appPath, loaded.manifest, this.idleRuntimeStatus), [], issues);
 		const runtime = this.createRuntimeService();
-		const storage = await this.createDevStorage(appPath, loaded.manifest.id, options.resetData === true);
+		const transientDirectory = options.transientData ? await mkdtemp(path.join(tmpdir(), "nextclaw-app-check-")) : void 0;
+		const storage = transientDirectory ? (await this.instanceStorageService.materialize({
+			appId: loaded.manifest.id,
+			instanceId: "check",
+			instanceDirectory: path.join(transientDirectory, "instance")
+		})).storage : await this.createDevStorage(appPath, loaded.manifest.id, options.resetData === true);
 		try {
 			const startRecord = this.toServiceAppRecord(appPath, loaded.manifest, runtime, storage, portable);
 			const runtimeActions = await runtime.listActions({
@@ -3668,11 +3758,17 @@ var ServiceAppDevService = class {
 			return this.buildDevReport(appPath, record, actions, issues);
 		} finally {
 			await runtime.dispose();
+			if (transientDirectory) await rm(transientDirectory, {
+				recursive: true,
+				force: true
+			});
 		}
 	};
-	call = async (target, actionName, input) => {
-		const appPath = path.resolve(target);
+	call = async (target, actionName, input, options = {}) => {
 		const issues = [];
+		const resolvedTarget = await this.packageTargetService.resolve(target, options.componentId, issues);
+		const appPath = resolvedTarget?.appPath ?? path.resolve(target);
+		if (!resolvedTarget) return this.buildCallReport(appPath, void 0, void 0, void 0, issues);
 		const loaded = await this.loadServiceApp(appPath, issues);
 		if (!loaded) return this.buildCallReport(appPath, void 0, void 0, void 0, issues);
 		if (this.hasErrors(issues)) return this.buildCallReport(appPath, this.toServiceAppRecord(appPath, loaded.manifest, this.idleRuntimeStatus), void 0, void 0, issues);
@@ -3686,7 +3782,7 @@ var ServiceAppDevService = class {
 			const record = this.toServiceAppRecord(appPath, loaded.manifest, this.idleRuntimeStatus);
 			return this.buildCallReport(appPath, record, void 0, void 0, issues);
 		}
-		const portable = await this.loadPortableDevContext(appPath, loaded.manifest, issues);
+		const portable = await this.loadPortableDevContext(appPath, loaded.manifest, issues, resolvedTarget.packageContext);
 		if (this.hasErrors(issues)) return this.buildCallReport(appPath, this.toServiceAppRecord(appPath, loaded.manifest, this.idleRuntimeStatus), void 0, void 0, issues);
 		const runtime = this.createRuntimeService();
 		const storage = await this.createDevStorage(appPath, loaded.manifest.id);
@@ -3699,15 +3795,16 @@ var ServiceAppDevService = class {
 				input
 			});
 			const nextRecord = this.toServiceAppRecord(appPath, loaded.manifest, runtime, storage, portable);
-			return this.buildCallReport(appPath, nextRecord, buildServiceActionId(loaded.manifest.id, action), result, issues);
+			return this.buildCallReport(appPath, nextRecord, buildServiceActionId(loaded.manifest.id, action), result, issues, runtime.getLastObservation?.());
 		} catch (error) {
 			const record = this.toServiceAppRecord(appPath, loaded.manifest, runtime, storage, portable);
 			issues.push({
 				severity: "error",
-				code: "service.runtime.callFailed",
-				message: error instanceof Error ? error.message : String(error)
+				code: this.readRuntimeErrorCode(error),
+				message: error instanceof Error ? error.message : String(error),
+				fixHint: this.readRuntimeErrorHint(error)
 			});
-			return this.buildCallReport(appPath, record, buildServiceActionId(loaded.manifest.id, action), void 0, issues);
+			return this.buildCallReport(appPath, record, buildServiceActionId(loaded.manifest.id, action), void 0, issues, runtime.getLastObservation?.());
 		} finally {
 			await runtime.dispose();
 		}
@@ -3742,7 +3839,7 @@ var ServiceAppDevService = class {
 			portableServiceRunnerPath: this.params.portableServiceRunnerPath
 		});
 	};
-	loadPortableDevContext = async (appPath, manifest, issues) => {
+	loadPortableDevContext = async (appPath, manifest, issues, resolvedPackageContext) => {
 		if (manifest.protocol !== "wasi-component") return void 0;
 		const componentPath = path.resolve(appPath, manifest.componentEntry ?? "");
 		if (!await this.pathExists(componentPath)) {
@@ -3753,13 +3850,13 @@ var ServiceAppDevService = class {
 			});
 			return;
 		}
-		const packageContext = await this.findOwningPackage(appPath);
+		const packageContext = resolvedPackageContext ?? await this.packageTargetService.findOwningPackage(appPath, issues);
 		if (!packageContext) {
-			issues.push({
+			if (!issues.some((issue) => issue.code === "service.package.invalid")) issues.push({
 				severity: "error",
 				code: "service.package.required",
 				message: "Portable Service App development requires an owning schema v2 Mini App so permissions have one product owner.",
-				fixHint: "Place the service under a manifest.json components entry and run app dev on that service directory."
+				fixHint: "Place the service under a manifest.json components entry, or run app dev on the package directory."
 			});
 			return;
 		}
@@ -3768,27 +3865,6 @@ var ServiceAppDevService = class {
 			permissions: packageContext.permissions
 		};
 	};
-	findOwningPackage = async (appPath) => {
-		let candidate = path.dirname(appPath);
-		while (true) {
-			const permissions = await this.readOwningPackagePermissions(candidate, appPath);
-			if (permissions) return { permissions };
-			const parent = path.dirname(candidate);
-			if (parent === candidate) return void 0;
-			candidate = parent;
-		}
-	};
-	readOwningPackagePermissions = async (candidate, appPath) => {
-		if (!await this.pathExists(path.join(candidate, "manifest.json"))) return void 0;
-		const manifestService = new AppManifestService();
-		try {
-			const bundle = await manifestService.load(candidate);
-			if (!isAppComponentManifestBundle(bundle)) return void 0;
-			return bundle.components.some((component) => path.resolve(component.componentDirectory) === path.resolve(appPath)) ? manifestService.resolvePlatformSecurity(bundle.manifest).permissions : void 0;
-		} catch {
-			return;
-		}
-	};
 	loadRuntimeConfig = () => {
 		const configPath = getConfigPath();
 		return resolveConfigSecrets(loadConfig(configPath), { configPath });
@@ -3863,12 +3939,12 @@ var ServiceAppDevService = class {
 		for (const action of actions) {
 			if (action.runtimeState === "missing") issues.push({
 				severity: "error",
-				code: "service.action.runtimeMissing",
+				code: record.protocol === "wasi-component" ? "WASI_GUEST_EXPORT_MISSING" : "service.action.runtimeMissing",
 				message: `Declared action is missing from runtime tools/list: ${action.name}.`
 			});
 			if (action.runtimeState === "undeclared") issues.push({
 				severity: "error",
-				code: "service.action.runtimeUndeclared",
+				code: record.protocol === "wasi-component" ? "WASI_GUEST_EXPORT_UNDECLARED" : "service.action.runtimeUndeclared",
 				message: `Runtime exposes an undeclared action: ${action.name}.`,
 				fixHint: `Add "${action.name}" to service-app.json actions or remove it from the MCP server.`
 			});
@@ -3881,12 +3957,23 @@ var ServiceAppDevService = class {
 		actions,
 		issues
 	});
-	buildCallReport = (target, app, actionId, result, issues) => ({
+	readRuntimeErrorCode = (error) => {
+		const code = typeof error === "object" && error !== null ? error.code : void 0;
+		return typeof code === "string" ? code : "service.runtime.callFailed";
+	};
+	readRuntimeErrorHint = (error) => {
+		const details = typeof error === "object" && error !== null ? error.details : void 0;
+		if (!details || typeof details !== "object" || !("logs" in details)) return void 0;
+		const logs = details.logs;
+		return Array.isArray(logs) && logs.every((entry) => typeof entry === "string") ? `Runner log tail:\n${logs.join("\n")}` : void 0;
+	};
+	buildCallReport = (target, app, actionId, result, issues, observation) => ({
 		ok: !issues.some((issue) => issue.severity === "error"),
 		target,
 		actionId,
 		app,
 		result,
+		observation,
 		issues
 	});
 	hasErrors = (issues) => issues.some((issue) => issue.severity === "error");
@@ -3898,14 +3985,15 @@ var AppCallCommandController = class {
 		this.serviceAppDevService = serviceAppDevService;
 	}
 	call = async (target, actionName, options) => {
-		const input = this.parseInput(options.input);
+		const { component, input: rawInput, json } = options;
+		const input = this.parseInput(rawInput);
 		if (!input.ok) {
-			this.writeInputError(input.message, Boolean(options.json));
+			this.writeInputError(input.message, Boolean(json));
 			process.exitCode = 1;
 			return;
 		}
-		const report = await this.serviceAppDevService.call(target, actionName, input.value);
-		process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
+		const report = await this.serviceAppDevService.call(target, actionName, input.value, { componentId: component });
+		process.stdout.write(json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
 		if (!report.ok) process.exitCode = 1;
 	};
 	parseInput = (raw) => {
@@ -3963,6 +4051,23 @@ var AppCallCommandController = class {
 	};
 };
 //#endregion
+//#region src/cli/app/controllers/development/app-build-command.controller.ts
+var AppBuildCommandController = class {
+	constructor(buildService = new AppBuildService()) {
+		this.buildService = buildService;
+	}
+	build = async (target, options) => {
+		const result = await this.buildService.build({
+			appDirectory: target,
+			install: true
+		});
+		process.stdout.write(options.json ? `${JSON.stringify({
+			ok: true,
+			build: result
+		}, null, 2)}\n` : `Built ${result.mainKind}: ${result.mainEntryPath}\n`);
+	};
+};
+//#endregion
 //#region src/cli/app/utils/app-check.utils.ts
 const PANEL_MANIFEST_FILE = "panel-app.json";
 const SERVICE_MANIFEST_FILE = "service-app.json";
@@ -4162,11 +4267,11 @@ var PanelAppCheckService = class {
 		for (const action of actions) {
 			const match = action.match(SERVICE_ACTION_ID_PATTERN);
 			if (!match) continue;
-			await this.checkWorkspaceServiceAction(workspaceRoot, match[1] ?? "", match[2] ?? "", cache, issues);
+			await this.checkWorkspaceServiceAction(workspaceRoot, appPath, match[1] ?? "", match[2] ?? "", cache, issues);
 		}
 	};
-	checkWorkspaceServiceAction = async (workspaceRoot, serviceId, actionName, cache, issues) => {
-		const manifest = await this.readCachedServiceManifest(workspaceRoot, serviceId, cache, issues);
+	checkWorkspaceServiceAction = async (workspaceRoot, appPath, serviceId, actionName, cache, issues) => {
+		const manifest = await this.readCachedServiceManifest(workspaceRoot, appPath, serviceId, cache, issues);
 		if (!manifest) return;
 		const actions = manifest.actions;
 		if (!isRecord(actions) || !isRecord(actions[actionName])) issues.push({
@@ -4264,8 +4369,13 @@ var PanelAppCheckService = class {
 			fixHint: `Add "${action}" to panel-app.json actions or update the invoke call.`
 		});
 	};
-	readCachedServiceManifest = async (workspaceRoot, serviceId, cache, issues) => {
+	readCachedServiceManifest = async (workspaceRoot, appPath, serviceId, cache, issues) => {
 		if (cache.has(serviceId)) return cache.get(serviceId) ?? null;
+		const packageManifest = await this.readOwningPackageServiceManifest(appPath, serviceId, issues);
+		if (packageManifest !== void 0) {
+			cache.set(serviceId, packageManifest);
+			return packageManifest;
+		}
 		const manifestPath = path.join(workspaceRoot, "service-apps", serviceId, SERVICE_MANIFEST_FILE);
 		if (!await fileExists(manifestPath)) {
 			issues.push({
@@ -4289,6 +4399,46 @@ var PanelAppCheckService = class {
 		cache.set(serviceId, manifestResult.value);
 		return manifestResult.value;
 	};
+	readOwningPackageServiceManifest = async (appPath, serviceId, issues) => {
+		const bundle = await this.findOwningComponentPackage(appPath, issues);
+		if (bundle === void 0 || bundle === null) return bundle;
+		const service = bundle.components.find((component) => component.kind === "service" && component.id === serviceId);
+		if (!service) {
+			issues.push({
+				severity: "error",
+				code: "panel.action.serviceMissing",
+				message: `Declared Service component does not exist in the owning package: ${serviceId}.`,
+				fixHint: `Add ${serviceId} to manifest.json components or fix panel-app.json actions.`
+			});
+			return null;
+		}
+		const result = await readJsonObject(service.manifestPath);
+		if (result.issue) issues.push({
+			...result.issue,
+			code: `panel.action.${result.issue.code}`
+		});
+		return result.value ?? null;
+	};
+	findOwningComponentPackage = async (appPath, issues) => {
+		let candidate = path.dirname(appPath);
+		while (true) {
+			if (await fileExists(path.join(candidate, "manifest.json"))) try {
+				const bundle = await new AppManifestService().load(candidate);
+				if (isAppComponentManifestBundle(bundle) && this.packageOwnsPanel(bundle, appPath)) return bundle;
+			} catch (error) {
+				issues.push({
+					severity: "error",
+					code: "panel.package.invalid",
+					message: `Cannot load owning schema v2 package at ${candidate}: ${error instanceof Error ? error.message : String(error)}`
+				});
+				return null;
+			}
+			const parent = path.dirname(candidate);
+			if (parent === candidate) return void 0;
+			candidate = parent;
+		}
+	};
+	packageOwnsPanel = (bundle, appPath) => bundle.components.some((component) => component.kind === "panel" && path.resolve(component.componentDirectory) === path.resolve(appPath));
 	pushIssue = (issues, issue) => {
 		if (issue) issues.push(issue);
 	};
@@ -4453,9 +4603,10 @@ var ServiceAppCheckService = class {
 //#endregion
 //#region src/cli/app/services/app-check.service.ts
 var AppCheckService = class {
-	constructor(panelAppCheckService = new PanelAppCheckService(), serviceAppCheckService = new ServiceAppCheckService()) {
+	constructor(panelAppCheckService = new PanelAppCheckService(), serviceAppCheckService = new ServiceAppCheckService(), serviceAppDevService) {
 		this.panelAppCheckService = panelAppCheckService;
 		this.serviceAppCheckService = serviceAppCheckService;
+		this.serviceAppDevService = serviceAppDevService;
 	}
 	check = async (target) => {
 		const appPath = path.resolve(target);
@@ -4465,6 +4616,7 @@ var AppCheckService = class {
 		if (directoryIssue) return this.buildReport(appPath, "unknown", issues);
 		const hasPanelManifest = await fileExists(path.join(appPath, PANEL_MANIFEST_FILE));
 		const hasServiceManifest = await fileExists(path.join(appPath, SERVICE_MANIFEST_FILE));
+		if (await fileExists(path.join(appPath, "manifest.json")) && !hasPanelManifest && !hasServiceManifest) return await this.checkPackage(appPath, issues);
 		if (hasPanelManifest && hasServiceManifest) {
 			issues.push({
 				severity: "error",
@@ -4490,6 +4642,44 @@ var AppCheckService = class {
 		});
 		return this.buildReport(appPath, "unknown", issues);
 	};
+	checkPackage = async (appPath, issues) => {
+		try {
+			const bundle = await new AppManifestService().load(appPath);
+			if (!isAppComponentManifestBundle(bundle)) {
+				issues.push({
+					severity: "error",
+					code: "app.package.schemaUnsupported",
+					message: "app check package mode requires schemaVersion 2.",
+					fixHint: "Use napp inspect for a schema v1 App, or migrate it to schema v2 components."
+				});
+				return this.buildReport(appPath, "package", issues);
+			}
+			for (const component of bundle.components) {
+				const componentIssues = await (component.kind === "panel" ? this.panelAppCheckService.check(component.componentDirectory) : this.serviceAppCheckService.check(component.componentDirectory));
+				issues.push(...componentIssues);
+				if (component.kind === "service" && this.serviceAppDevService && !componentIssues.some((issue) => issue.severity === "error")) {
+					const runtimeReport = await this.serviceAppDevService.inspect(appPath, {
+						componentId: component.id,
+						transientData: true
+					});
+					issues.push(...runtimeReport.issues.map((issue) => ({
+						severity: issue.severity,
+						code: issue.code,
+						message: issue.message,
+						...issue.fixHint ? { fixHint: issue.fixHint } : {}
+					})));
+				}
+			}
+			return this.buildReport(appPath, "package", issues);
+		} catch (error) {
+			issues.push({
+				severity: "error",
+				code: "app.package.invalid",
+				message: error instanceof Error ? error.message : String(error)
+			});
+			return this.buildReport(appPath, "package", issues);
+		}
+	};
 	buildReport = (target, kind, issues) => ({
 		ok: !issues.some((issue) => issue.severity === "error"),
 		kind,
@@ -4529,17 +4719,75 @@ var AppCheckCommandController = class {
 	};
 };
 //#endregion
+//#region src/cli/app/controllers/development/app-create-command.controller.ts
+var AppCreateCommandController = class {
+	constructor(scaffoldService = new AppScaffoldService()) {
+		this.scaffoldService = scaffoldService;
+	}
+	create = async (target, options) => {
+		const result = await this.scaffoldService.scaffold(target, { template: this.parseTemplate(options.template ?? "rust-wasi") });
+		if (options.json) {
+			process.stdout.write(`${JSON.stringify({
+				ok: true,
+				created: result
+			}, null, 2)}\n`);
+			return;
+		}
+		process.stdout.write([
+			`Created NextClaw App at ${result.appDirectory}`,
+			`Template: ${result.template}`,
+			`Manifest: ${result.manifestPath}`,
+			"Next: follow README.md, then run nextclaw app check <app-dir>",
+			""
+		].join("\n"));
+	};
+	parseTemplate = (value) => {
+		if ([
+			"rust-wasi",
+			"starter",
+			"ts-http",
+			"ts-http-lite"
+		].includes(value)) return value;
+		throw new Error(`Unknown App template: ${value}.`);
+	};
+};
+//#endregion
+//#region src/cli/app/controllers/development/app-doctor-command.controller.ts
+var AppDoctorCommandController = class {
+	constructor(toolchainService = new AppRuntimeToolchainService()) {
+		this.toolchainService = toolchainService;
+	}
+	doctor = async (options) => {
+		const profile = this.parseProfile(options.profile ?? "wasi");
+		const result = await this.toolchainService.doctor(profile);
+		if (options.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		else process.stdout.write([
+			`NextClaw App doctor (${options.profile ?? "wasi"}): ${result.ok ? "ready" : "not ready"}`,
+			...result.tools.flatMap((tool) => [`${tool.ok ? "ok" : "missing"} ${tool.name}${tool.version ? `: ${tool.version}` : ""}`, ...!tool.ok ? [`  Fix: ${tool.installHint}`] : []]),
+			""
+		].join("\n"));
+		if (!result.ok) process.exitCode = 1;
+	};
+	parseProfile = (profile) => {
+		if (profile === "wasi") return "wasi-component";
+		if (profile === "wasi-http" || profile === "all") return profile;
+		throw new Error(`Unsupported App doctor profile: ${profile}. Use wasi, wasi-http, or all.`);
+	};
+};
+//#endregion
 //#region src/cli/app/controllers/app-dev-command.controller.ts
 var AppDevCommandController = class {
 	constructor(serviceAppDevService = new ServiceAppDevService()) {
 		this.serviceAppDevService = serviceAppDevService;
 	}
 	dev = async (target, options) => {
+		const { component, confirm, json, resetData } = options;
 		const report = await this.serviceAppDevService.inspect(target, {
-			resetData: options.resetData,
-			confirmAppId: options.confirm
+			componentId: component,
+			resetData,
+			confirmAppId: confirm
 		});
-		process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
+		process.stdout.write(json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
 		if (!report.ok) process.exitCode = 1;
 	};
 	format = (report) => {
@@ -4582,11 +4830,23 @@ var LocalUiApiClient = class {
 			headers,
 			...body ? { body: JSON.stringify(body) } : {}
 		});
-		if (!response.ok) throw new Error(`api request failed with status ${response.status}`);
-		const payload = await response.json();
-		if (!payload.ok) throw new Error(payload.error?.message ?? "api request failed");
+		const responseBody = await response.text();
+		const payload = this.parsePayload(responseBody);
+		if (!response.ok) {
+			const detail = [payload && !payload.ok ? payload.error?.code : void 0, payload && !payload.ok ? payload.error?.message : void 0].filter(Boolean).join(": ") || responseBody.trim().slice(0, 240);
+			throw new Error(`api request failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+		}
+		if (!payload) throw new Error("api request returned invalid JSON");
+		if (!payload.ok) throw new Error([payload.error?.code, payload.error?.message].filter(Boolean).join(": ") || "api request failed");
 		return payload.data;
 	};
+	parsePayload = (body) => {
+		try {
+			return JSON.parse(body);
+		} catch {
+			return null;
+		}
+	};
 	getCookie = async () => {
 		if (this.cookie !== void 0) return this.cookie;
 		const response = await fetch(`${this.apiBase}/api/auth/bridge`, {
@@ -4782,12 +5042,15 @@ var AppPublishingService = class {
 		this.bundleService = bundleService;
 		this.platformTargetService = platformTargetService;
 	}
-	pack = async (params) => this.bundleService.packAppDirectory({
-		appDirectory: params.appDirectory,
-		outputPath: params.outputPath,
-		mode: "bundle",
-		target: this.platformTargetService.parseTargetKey(params.target)
-	});
+	pack = async (params) => {
+		const { appDirectory, outputPath, target } = params;
+		return this.bundleService.packAppDirectory({
+			appDirectory,
+			outputPath,
+			mode: "bundle",
+			target: target ? this.platformTargetService.parseTargetKey(target) : void 0
+		});
+	};
 	validate = async (params) => {
 		const result = await this.validationService.validate({
 			appDirectory: params.appDirectory,
@@ -4846,28 +5109,37 @@ var AppPublishingService = class {
 //#endregion
 //#region src/cli/app/controllers/app-pack-command.controller.ts
 var AppPackCommandController = class {
-	constructor(appPublishingService = new AppPublishingService()) {
+	constructor(appPublishingService = new AppPublishingService(), appCheckService) {
 		this.appPublishingService = appPublishingService;
+		this.appCheckService = appCheckService;
 	}
 	pack = async (target, options) => {
+		const { json, out, target: platformTarget } = options;
 		try {
+			if (this.appCheckService) {
+				const check = await this.appCheckService.check(target);
+				if (!check.ok) {
+					const details = check.issues.filter((issue) => issue.severity === "error").map((issue) => `[${issue.code}] ${issue.message}`).join("; ");
+					throw new Error(`App check failed before pack: ${details}`);
+				}
+			}
 			const bundle = await this.appPublishingService.pack({
 				appDirectory: target,
-				outputPath: options.out,
-				target: options.target
+				outputPath: out,
+				target: platformTarget
 			});
-			process.stdout.write(options.json ? `${JSON.stringify({
+			process.stdout.write(json ? `${JSON.stringify({
 				ok: true,
 				bundle
 			}, null, 2)}\n` : [
 				`Packed ${bundle.metadata.name} ${bundle.metadata.version}.`,
-				bundle.metadata.target ? `Target: ${options.target}` : "Target: universal",
+				bundle.metadata.target ? `Target: ${platformTarget}` : "Target: universal",
 				`Bundle: ${bundle.bundlePath}`,
 				""
 			].join("\n"));
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			process.stdout.write(options.json ? `${JSON.stringify({
+			process.stdout.write(json ? `${JSON.stringify({
 				ok: false,
 				error: { message }
 			}, null, 2)}\n` : `Mini App pack failed: ${message}\n`);
@@ -4967,6 +5239,113 @@ var AppValidatePublishCommandController = class {
 	};
 };
 //#endregion
+//#region src/cli/app/services/development/app-test.service.ts
+var AppTestService = class {
+	constructor(appCheckService = new AppCheckService(), serviceAppDevService = new ServiceAppDevService()) {
+		this.appCheckService = appCheckService;
+		this.serviceAppDevService = serviceAppDevService;
+	}
+	test = async (target) => {
+		const appPath = path.resolve(target);
+		const check = await this.appCheckService.check(appPath);
+		if (!check.ok) return {
+			ok: false,
+			target: appPath,
+			steps: [],
+			issues: check.issues.filter((issue) => issue.severity === "error").map(({ code, message }) => ({
+				code,
+				message
+			}))
+		};
+		const bundle = await new AppManifestService().load(appPath);
+		if (!isAppComponentManifestBundle(bundle)) return {
+			ok: false,
+			target: appPath,
+			steps: [],
+			issues: [{
+				code: "app.test.schemaUnsupported",
+				message: "app test requires a schema v2 package."
+			}]
+		};
+		const fixture = await this.loadFixture(appPath);
+		if (!bundle.components.find((component) => component.kind === "service" && component.id === fixture.component)) return {
+			ok: false,
+			target: appPath,
+			component: fixture.component,
+			steps: [],
+			issues: [{
+				code: "app.test.componentMissing",
+				message: `Smoke fixture references an unknown Service Component: ${fixture.component}.`
+			}]
+		};
+		if (fixture.resetData) {
+			const reset = await this.serviceAppDevService.inspect(appPath, {
+				componentId: fixture.component,
+				resetData: true,
+				confirmAppId: fixture.component
+			});
+			if (!reset.ok) return {
+				ok: false,
+				target: appPath,
+				component: fixture.component,
+				steps: [],
+				issues: reset.issues.map(({ code, message }) => ({
+					code,
+					message
+				}))
+			};
+		}
+		const steps = [];
+		for (const step of fixture.steps) {
+			const report = await this.serviceAppDevService.call(appPath, step.action, step.input ?? {}, { componentId: fixture.component });
+			const matches = report.ok && this.matchesSubset(report.result, step.expect ?? {});
+			steps.push({
+				action: step.action,
+				ok: matches,
+				...report.result !== void 0 ? { result: report.result } : {},
+				...!matches ? { message: report.ok ? `Result does not match expected subset: ${JSON.stringify(step.expect ?? {})}` : report.issues.map((issue) => `[${issue.code}] ${issue.message}`).join("; ") } : {}
+			});
+			if (!matches) break;
+		}
+		return {
+			ok: steps.length === fixture.steps.length && steps.every((step) => step.ok),
+			target: appPath,
+			component: fixture.component,
+			steps,
+			issues: []
+		};
+	};
+	loadFixture = async (appPath) => {
+		const fixturePath = path.join(appPath, "tests", "service-smoke.json");
+		const parsed = JSON.parse(await readFile(fixturePath, "utf8"));
+		if (parsed.schemaVersion !== 1 || !parsed.component?.trim() || !Array.isArray(parsed.steps)) throw new Error(`Invalid App smoke fixture: ${fixturePath}.`);
+		return parsed;
+	};
+	matchesSubset = (actual, expected) => {
+		if (!actual || typeof actual !== "object" || Array.isArray(actual)) return false;
+		return Object.entries(expected).every(([key, value]) => JSON.stringify(actual[key]) === JSON.stringify(value));
+	};
+};
+//#endregion
+//#region src/cli/app/controllers/development/app-test-command.controller.ts
+var AppTestCommandController = class {
+	appTestService;
+	constructor(serviceAppDevService = new ServiceAppDevService()) {
+		this.appTestService = new AppTestService(new AppCheckService(void 0, void 0, serviceAppDevService), serviceAppDevService);
+	}
+	test = async (target, options) => {
+		const report = await this.appTestService.test(target);
+		process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
+		if (!report.ok) process.exitCode = 1;
+	};
+	format = (report) => [
+		`NextClaw App test ${report.ok ? "passed" : "failed"}: ${report.target}`,
+		...report.steps.map((step) => `${step.ok ? "ok" : "failed"} ${step.action}${step.message ? `: ${step.message}` : ""}`),
+		...report.issues.map((issue) => `failed [${issue.code}] ${issue.message}`),
+		""
+	].join("\n");
+};
+//#endregion
 //#region src/cli/app/services/app-packages/app-marketplace-query.service.ts
 const DEFAULT_APPS_MARKETPLACE_API_BASE = "https://apps-registry.nextclaw.io";
 var AppMarketplaceQueryService = class {
@@ -5021,11 +5400,27 @@ var AppPackageLiveService = class {
 	list = async () => await this.requireApiClient().request({ path: "/api/app-packages" });
 	info = async (appId) => await this.requireApiClient().request({ path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}` });
 	listOperations = async () => await this.requireApiClient().request({ path: "/api/app-package-operations" });
+	inspectDependencies = async (appId) => await this.requireApiClient().request({ path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/dependencies` });
+	verifyDependencies = async (appId) => await this.requireApiClient().request({ path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/dependencies/verify` });
+	setupDependencies = async (appId) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/dependencies/setup`,
+		method: "POST"
+	});
+	bindDependency = async (appId, input) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/dependencies/bind`,
+		method: "POST",
+		body: input
+	});
+	unbindDependency = async (appId, input) => await this.requireApiClient().request({
+		path: `/api/app-packages/${encodeURIComponent(this.requireId(appId))}/dependencies/unbind`,
+		method: "POST",
+		body: input
+	});
 	install = async (source, registryUrl) => await this.requireApiClient().request({
 		path: "/api/app-package-operations/install",
 		method: "POST",
 		body: {
-			source: this.requireSource(source),
+			source: this.normalizeInstallSource(source),
 			registryUrl
 		}
 	});
@@ -5057,6 +5452,11 @@ var AppPackageLiveService = class {
 	};
 	requireId = (value) => this.requireValue(value, "App id");
 	requireSource = (value) => this.requireValue(value, "App install source");
+	normalizeInstallSource = (value) => {
+		const source = this.requireSource(value);
+		return this.looksLikeLocalPath(source) ? path.resolve(source) : source;
+	};
+	looksLikeLocalPath = (value) => value.startsWith(".") || path.isAbsolute(value) || value.includes(path.sep) || value.endsWith(".napp");
 	requireVersion = (value) => this.requireValue(value, "App version");
 	requireValue = (value, name) => {
 		const normalized = value.trim();
@@ -5084,6 +5484,23 @@ var AppPackageCommandController = class {
 	marketplaceInfo = async (selector, options) => this.write(await this.marketplaceService.info(selector), options, this.formatMarketplaceInfo);
 	list = async (options) => this.write(await this.liveService.list(), options, this.formatList);
 	info = async (appId, options) => this.write(await this.liveService.info(appId), options, this.formatApp);
+	inspectDependencies = async (appId, options) => this.write(await this.liveService.inspectDependencies(appId), options, this.formatDependencyView);
+	verifyDependencies = async (appId, options) => this.write(await this.liveService.verifyDependencies(appId), options, this.formatDependencyView);
+	setupDependencies = async (appId, options) => this.write(await this.liveService.setupDependencies(appId), options, this.formatDependencyView);
+	bindDependency = async (appId, options) => {
+		const { componentId, requirementKind, requirementId, providerId } = options;
+		this.write(await this.liveService.bindDependency(appId, {
+			componentId,
+			requirementKind,
+			requirementId,
+			providerId
+		}), options, this.formatDependencyView);
+	};
+	unbindDependency = async (appId, options) => this.write(await this.liveService.unbindDependency(appId, {
+		componentId: options.componentId,
+		requirementKind: options.requirementKind,
+		requirementId: options.requirementId
+	}), options, this.formatDependencyView);
 	operations = async (options) => this.write(await this.liveService.listOperations(), options, this.formatOperations);
 	install = async (source, options) => this.write(await this.liveService.install(source, options.registry), options, this.formatOperation);
 	enable = async (appId, options) => this.write(await this.liveService.enable(appId), options, this.formatApp);
@@ -5121,6 +5538,8 @@ var AppPackageCommandController = class {
 		`${app.name} (${app.id})`,
 		`  version: ${app.activeVersion}`,
 		`  enabled: ${app.enabled ? "yes" : "no"}`,
+		`  readiness: ${app.readiness.status}`,
+		...app.readiness.requirements.map((requirement) => `  requirement: ${requirement.kind} ${requirement.title} (${requirement.id})`),
 		`  built-in: ${app.builtIn ? "yes" : "no"}`,
 		`  versions: ${app.installedVersions.join(", ")}`
 	].join("\n") + "\n";
@@ -5128,6 +5547,11 @@ var AppPackageCommandController = class {
 		if (result.entries.length === 0) return "App operations: none\n";
 		return `${result.entries.map((operation) => this.formatOperation(operation).trim()).join("\n\n")}\n`;
 	};
+	formatDependencyView = (result) => [
+		`Dependency readiness: ${result.readiness.status}`,
+		...result.readiness.requirements.map((requirement) => `  requirement: ${requirement.componentId}/${requirement.kind}/${requirement.id}`),
+		...result.bindings.map((binding) => `  binding: ${binding.componentId}/${binding.requirementKind}/${binding.requirementId} -> ${binding.providerId}`)
+	].join("\n") + "\n";
 	formatOperation = (operation) => [
 		`App operation ${operation.id}`,
 		`  action: ${operation.action}`,
@@ -5143,34 +5567,52 @@ var AppPackageCommandController = class {
 //#region src/cli/app/register-app-commands.ts
 function registerAppCommands(program, options = {}) {
 	const app = program.command("app").description("Develop, validate, and publish NextClaw apps");
-	const appCheck = new AppCheckCommandController();
 	const serviceAppDev = new ServiceAppDevService({ portableServiceRunnerPath: options.portableServiceRunnerPath });
+	const appCheckService = new AppCheckService(void 0, void 0, serviceAppDev);
+	const appCheck = new AppCheckCommandController(appCheckService);
+	const appBuild = new AppBuildCommandController();
+	const appCreate = new AppCreateCommandController();
+	const appDoctor = new AppDoctorCommandController();
 	const appDev = new AppDevCommandController(serviceAppDev);
 	const appData = new AppDataCommandController();
 	const appCall = new AppCallCommandController(serviceAppDev);
 	const appRestart = new AppRestartCommandController();
-	const appPack = new AppPackCommandController();
+	const appPack = new AppPackCommandController(void 0, appCheckService);
 	const appValidatePublish = new AppValidatePublishCommandController();
 	const appPublish = new AppPublishCommandController();
 	const appPackages = new AppPackageCommandController();
-	app.command("pack <app-dir>").description("Pack one declared platform target as a NextClaw App artifact").requiredOption("--target <target-key>", "Pack a declared platform target").requiredOption("--out <path>", "Write the .napp artifact to a specific path").option("--json", "Output JSON", false).action(async (target, opts) => appPack.pack(target, opts));
+	registerAppGuestDevelopmentCommands(app, {
+		appBuild,
+		appCreate,
+		appDoctor,
+		appTest: new AppTestCommandController(serviceAppDev)
+	});
+	app.command("pack <app-dir>").description("Pack a universal or declared platform NextClaw App artifact").option("--target <target-key>", "Pack a declared platform target").requiredOption("--out <path>", "Write the .napp artifact to a specific path").option("--json", "Output JSON", false).action(async (target, opts) => appPack.pack(target, opts));
 	app.command("validate-publish <app-dir>").description("Validate a NextClaw Mini App before Marketplace submission").option("--meta <path>", "Use a custom marketplace metadata file").option("--artifacts <dir>", "Use target-keyed .napp artifacts from a directory").option("--json", "Output JSON", false).action(async (target, opts) => appValidatePublish.validate(target, opts));
 	app.command("publish <app-dir>").description("Submit a NextClaw Mini App to the App Marketplace").option("--meta <path>", "Use a custom marketplace metadata file").option("--artifacts <dir>", "Publish target-keyed .napp artifacts from a directory").option("--allow-warnings", "Submit after reviewing validation warnings", false).option("--json", "Output JSON", false).action(async (target, opts) => appPublish.publish(target, opts));
-	app.command("check <app-dir>").description("Check a Panel App or Service App directory").option("--json", "Output JSON", false).action(async (target, opts) => appCheck.check(target, opts));
-	app.command("dev <service-app-dir>").description("Start a Service App through the real runtime and inspect its actions").option("--json", "Output JSON", false).option("--reset-data", "Reset the exact development instance before starting", false).option("--confirm <app-id>", "Confirm the Service App id when resetting data").action(async (target, opts) => appDev.dev(target, opts));
+	app.command("check <app-dir>").description("Check a schema v2 App package, Panel App, or Service App").option("--json", "Output JSON", false).action(async (target, opts) => appCheck.check(target, opts));
+	app.command("dev <app-dir>").description("Start a Service App or schema v2 package and inspect its actions").option("--component <service-id>", "Select a Service Component from a package").option("--json", "Output JSON", false).option("--reset-data", "Reset the exact development instance before starting", false).option("--confirm <app-id>", "Confirm the Service App id when resetting data").action(async (target, opts) => appDev.dev(target, opts));
 	const data = app.command("data").description("Inspect and manage NextClaw App data");
 	data.command("list").description("List active and retained App data through the running NextClaw host").option("--json", "Output JSON", false).action(async (opts) => appData.list(opts));
 	data.command("delete <data-id>").description("Permanently delete a retained App data instance").requiredOption("--confirm <app-id>", "Confirm the exact App id").option("--json", "Output JSON", false).action(async (dataId, opts) => appData.deleteRetained(dataId, opts));
-	app.command("call <service-app-dir> <action-name>").description("Call a Service App action through the real runtime").option("--input <json>", "JSON object input for the action").option("--json", "Output JSON", false).action(async (target, actionName, opts) => appCall.call(target, actionName, opts));
+	app.command("call <app-dir> <action-name>").description("Call a Service App or schema v2 package action through the real runtime").option("--component <service-id>", "Select a Service Component from a package").option("--input <json>", "JSON object input for the action").option("--json", "Output JSON", false).action(async (target, actionName, opts) => appCall.call(target, actionName, opts));
 	app.command("restart <app-id>").description("Restart a live Service App runtime in the running NextClaw UI").option("--json", "Output JSON", false).action(async (appId, opts) => appRestart.restart(appId, opts));
 	registerAppPackageCommands(app, appPackages);
 }
+function registerAppGuestDevelopmentCommands(app, controllers) {
+	const { appBuild, appCreate, appDoctor, appTest } = controllers;
+	app.command("create <app-dir>").description("Create a NextClaw App from a runnable template").option("--template <name>", "Template: rust-wasi, starter, ts-http, or ts-http-lite", "rust-wasi").option("--json", "Output JSON", false).action(async (target, opts) => appCreate.create(target, opts));
+	app.command("doctor").description("Check the App Guest development toolchain").option("--profile <profile>", "Toolchain profile: wasi, wasi-http, or all", "wasi").option("--json", "Output JSON", false).action(async (opts) => appDoctor.doctor(opts));
+	app.command("build <app-dir>").description("Build a NextClaw App Guest into its declared runtime artifact").option("--json", "Output JSON", false).action(async (target, opts) => appBuild.build(target, opts));
+	app.command("test <app-dir>").description("Run a schema v2 App smoke fixture through the real runtime").option("--json", "Output JSON", false).action(async (target, opts) => appTest.test(target, opts));
+}
 function registerAppPackageCommands(app, appPackages) {
 	const marketplace = app.command("marketplace").description("Browse NextClaw App Marketplace");
 	marketplace.command("search").description("Search Apps in NextClaw App Marketplace").option("-q, --query <text>", "Search text").option("--tag <tag>", "Filter by tag").option("--cursor <cursor>", "Continue from a marketplace cursor").option("--limit <n>", "Maximum number of items").option("--json", "Output JSON", false).action(async (opts) => appPackages.searchMarketplace(opts));
 	marketplace.command("info <selector>").description("Show an App Marketplace item").option("--json", "Output JSON", false).action(async (selector, opts) => appPackages.marketplaceInfo(selector, opts));
 	app.command("list").description("List Apps installed in the running NextClaw host").option("--json", "Output JSON", false).action(async (opts) => appPackages.list(opts));
 	app.command("info <app-id>").description("Show an App installed in the running NextClaw host").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.info(appId, opts));
+	registerAppDependencyCommands(app, appPackages);
 	app.command("operations").description("List App install, update, rollback, and uninstall operations").option("--json", "Output JSON", false).action(async (opts) => appPackages.operations(opts));
 	app.command("install <source>").description("Install an App through the running NextClaw host").option("--registry <url>", "Registry URL for an App id").option("--json", "Output JSON", false).action(async (source, opts) => appPackages.install(source, opts));
 	app.command("enable <app-id>").description("Enable an installed App").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.enable(appId, opts));
@@ -5179,6 +5621,25 @@ function registerAppPackageCommands(app, appPackages) {
 	app.command("rollback <app-id>").description("Roll back an App to an installed version").requiredOption("--version <version>", "Installed version to activate").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.rollback(appId, opts));
 	app.command("uninstall <app-id>").description("Uninstall an App through the running NextClaw host").option("--purge-data", "Permanently delete App data", false).option("--confirm <app-id>", "Confirm the exact App id when purging data").option("--json", "Output JSON", false).action(async (appId, opts) => appPackages.uninstall(appId, opts));
 }
+function registerAppDependencyCommands(app, controller) {
+	const dependencies = app.command("dependencies").description("Inspect and manage an App's capability and resource dependencies");
+	dependencies.command("inspect <app-id>").description("Inspect dependency readiness and available providers").option("--json", "Output JSON", false).action(async (appId, opts) => controller.inspectDependencies(appId, opts));
+	dependencies.command("verify <app-id>").description("Verify dependency readiness").option("--json", "Output JSON", false).action(async (appId, opts) => controller.verifyDependencies(appId, opts));
+	dependencies.command("setup <app-id>").description("Bind dependencies when exactly one compatible provider is available").option("--json", "Output JSON", false).action(async (appId, opts) => controller.setupDependencies(appId, opts));
+	dependencies.command("bind <app-id>").description("Bind one dependency to a trusted installed provider").requiredOption("--component <id>", "Service component id").requiredOption("--kind <kind>", "Requirement kind: capability or resource").requiredOption("--requirement <id>", "Declared requirement id").requiredOption("--provider <id>", "Installed provider id").option("--json", "Output JSON", false).action(async (appId, opts) => controller.bindDependency(appId, {
+		componentId: opts.component,
+		requirementKind: opts.kind,
+		requirementId: opts.requirement,
+		providerId: opts.provider,
+		json: opts.json
+	}));
+	dependencies.command("unbind <app-id>").description("Remove one dependency binding").requiredOption("--component <id>", "Service component id").requiredOption("--kind <kind>", "Requirement kind: capability or resource").requiredOption("--requirement <id>", "Declared requirement id").option("--json", "Output JSON", false).action(async (appId, opts) => controller.unbindDependency(appId, {
+		componentId: opts.component,
+		requirementKind: opts.kind,
+		requirementId: opts.requirement,
+		json: opts.json
+	}));
+}
 //#endregion
 //#region src/cli/app/register-project-commands.ts
 function registerProjectCommands(program, nextclaw) {
@@ -5448,4 +5909,4 @@ program.command("usage").description("Show observed LLM usage snapshots, history
 //#endregion
 export { program as nextclawCliProgram };
 
-//# sourceMappingURL=nextclaw-cli-app-Bwa2L2Jv.js.map
+//# sourceMappingURL=nextclaw-cli-app-BVdP2e0w.js.map