aai-gateway 0.6.0 → 0.7.1

package/README.md

@@ -1,29 +1,25 @@
 # AAI Gateway
 
-## One MCP. Many Apps. Less Context.
+## Why AAI Gateway
 
-AAI Gateway turns many apps, agents, skills, and MCP servers into one MCP server.
+AAI stands for **Agent App Interface**.
 
-## Core Values
+### Three Pain Points of MCP/Skill Configuration
 
-### Value 1: Natural Language-Driven Tool Integration
+**1. Context Token Waste**: Every MCP server injects its schema, descriptions, and tool lists into the prompt. As you add more servers, the model spends more tokens understanding tools than executing tasks.
 
-After installing the AAI Gateway MCP, you can quickly integrate any other MCP or skill through natural language descriptions, and control other AI Agent tools (including Claude Code, Codex, OpenCode, etc.).
+**2. Config Cannot Be Shared Across Agents**: MCP/Skill configured in Claude Code cannot be directly used in OpenCode or Codex. You have to configure it separately for each agent tool.
 
-AAI Gateway also integrates a search tool that helps you search for official and secure MCPs and skills from authoritative, mainstream websites, and install them with a single sentence. Control of other AI Agent tools is done via Agent Client Protocol (ACP), including session management.
+**3. Requires Agent Restart After Installation**: Traditionally, adding a new MCP or Skill requires restarting the agent tool to take effect.
 
-### Value 2: Progressive Disclosure Strategy
+### What AAI Gateway Solves
 
-AAI Gateway does not dump all tool descriptions into the LLM context at once. Instead, it employs a progressive disclosure strategy:
+- **Progressive Disclosure**: Expose app overview first, reveal tool details only when needed, avoiding context explosion
+- **Centralized Config Management**: Import MCP/Skill once, share across all agent tools
+- **Hot Loading**: Auto-notify agents after import, **no restart required**
+- **Natural Language Interaction**: Search, import, and manage MCPs/Skills through simple conversation
 
-**MCP Server Level**: Only the overall description of the MCP Server is exposed initially. When the LLM determines that a specific tool needs to be used, it returns tool usage guidance first. The Agent then calls the unified `aai:exec` to execute based on that guidance. `aai:exec` accepts `appId`, `tool`, and `tool args` as parameters.
-
-**MCP / Skill Description Level**: Two tiers of disclosure are provided:
-
-- `summary` — Natural language description; good for automatic triggering
-- `keywords` — Compact keyword set; further reduces context overhead
-
-This allows OpenClaw (a popular personal assistant application) and similar tools that require many tools and skills to still run smoothly.
+AAI Gateway unifies MCP servers, Skills, ACP agents, and CLI tools under one roof, making it simple and efficient for agents to discover and use software.
 
 ## How To Use
 
@@ -86,19 +82,16 @@ Main workflow: Copy a mainstream MCP config snippet into your AI tool and ask it
 The AI tool will:
 
 1. Read the MCP config you pasted
-2. Ask you to choose an exposure mode
-3. Call `mcp:import`
+2. Inspect the downstream MCP tools through AAI Gateway
+3. Summarize when the MCP should be used
+4. Ask whether it should be enabled for the current agent only or for all agents
+5. Call `mcp:import`
 
 AAI Gateway keeps import parameters consistent with standard MCP config shapes:
 
 - stdio MCP: `command`, `args`, `env`, `cwd`
 - remote MCP: `url`, optional `transport`, optional `headers`
 
-Choose an exposure mode before import:
-
-- `summary`: Easier automatic triggering
-- `keywords`: Leaves room for more tools, but usually needs more explicit keyword mentions
-
 **stdio MCP Example**:
 
 ```json
@@ -128,18 +121,18 @@ Choose an exposure mode before import:
 After import, AAI Gateway returns:
 
 - The generated app id
-- The generated `keywords`
 - The generated `summary`
 - The guide tool name: `app:<id>`
 
-> **Important**: Restart your AI tool before using the newly imported tool. After restart, the imported app will appear as `app:<id>`. Use `aai:exec` to actually run the imported app's operations.
+> AAI Gateway sends `tools/listChanged` after import. Clients that implement this notification can pick up new tools without restart.
 
 ### 4. Import a Skill
 
-Skills are imported through the AI tool as well. Just tell the AI tool to import a skill using AAI Gateway, then provide either:
+Skills are imported through the AI tool as well. Tell the AI tool to import a skill using AAI Gateway, then provide:
 
 - A local skill path
-- A remote skill root URL that exposes `SKILL.md`
+
+If the skill is remote, download and extract the whole skill directory first. AAI Gateway only imports from a local directory and copies the full directory into managed storage.
 
 **Local Skill Example**:
 
@@ -149,17 +142,7 @@ Skills are imported through the AI tool as well. Just tell the AI tool to import
 }
 ```
 
-**Remote Skill Example**:
-
-```json
-{
-  "url": "https://example.com/skill"
-}
-```
-
-Like MCP import, skill import returns `app id`, `keywords`, `summary`, and the `app:<id>` guide tool name.
-
-Restart your AI tool after import.
+AAI Gateway derives the imported skill summary from the skill's own `SKILL.md` description. It can also generate a lightweight proxy `SKILL.md` for the current agent so the agent can discover the skill automatically.
 
 ### 5. Supported ACP Agents
 
@@ -187,7 +170,7 @@ Currently supported ACP agent types:
 │  ┌─────────────────────────────────────────────────────────┐│
 │  │              Progressive Disclosure Layer               ││
 │  │  - App-level exposure (not tool-level)                  ││
-│  │  - Summary / Keywords modes                              ││
+│  │  - Summary-only disclosure                               ││
 │  │  - Lazy tool loading on demand                          ││
 │  └─────────────────────────────────────────────────────────┘│
 │  ┌─────────────────────────────────────────────────────────┐│
@@ -197,8 +180,8 @@ Currently supported ACP agent types:
 │  └─────────────────────────────────────────────────────────┘│
 │  ┌─────────────────────────────────────────────────────────┐│
 │  │                  Discovery Layer                         ││
-│  │  - Desktop Descriptors  - Web Descriptors               ││
-│  │  - Gateway Imports       - Built-in Descriptors          ││
+│  │  - Desktop Descriptors  - Managed Imports                ││
+│  │  - Built-in Descriptors                                   ││
 │  └─────────────────────────────────────────────────────────┘│
 └────────────────────────┬────────────────────────────────────┘
                          │  Native Protocol
@@ -243,7 +226,6 @@ To integrate an app with AAI Gateway, simply provide an app descriptor file (`aa
     }
   },
   "exposure": {
-    "keywords": ["file", "filesystem", "read", "write"],
     "summary": "Use this app when the user wants to read from or write to the local filesystem."
   }
 }
@@ -263,11 +245,10 @@ To integrate an app with AAI Gateway, simply provide an app descriptor file (`aa
   "access": {
     "protocol": "skill",
     "config": {
-      "url": "https://github.com/example/git-commit-skill"
+      "path": "/absolute/path/to/git-commit-skill"
     }
   },
   "exposure": {
-    "keywords": ["git", "commit", "version control"],
     "summary": "Use this app when the user wants to create git commits with auto-generated messages."
   }
 }
@@ -291,7 +272,6 @@ To integrate an app with AAI Gateway, simply provide an app descriptor file (`aa
     }
   },
   "exposure": {
-    "keywords": ["claude", "code", "coding", "agent"],
     "summary": "Use this app when the user wants Claude Code to perform coding tasks."
   }
 }
@@ -315,7 +295,6 @@ To integrate an app with AAI Gateway, simply provide an app descriptor file (`aa
     }
   },
   "exposure": {
-    "keywords": ["example", "utility"],
     "summary": "Use this app when the user wants to work with Example App."
   }
 }
@@ -355,16 +334,6 @@ If you're unsure whether an integration should be bundled, open an issue first t
 
 AAI Gateway discovers apps from the following locations:
 
-#### Web Apps
-
-Publish at:
-
-```
-https://<your-host>/.well-known/aai.json
-```
-
-AAI Gateway fetches this path when the user calls `remote:discover`.
-
 #### macOS Apps
 
 Recommended locations:
@@ -393,7 +362,6 @@ Scanned locations:
 
 - Keep descriptors small and practical
 - Make `app.name.default` clear
-- Keep `keywords` short and high-signal
 - Make `summary` explain when the app should be used
 - Put detailed capability data in the downstream protocol, not in the descriptor
 - If your app already speaks MCP, keep the descriptor minimal and let MCP provide lazy tool details

package/dist/cli.js

@@ -1,279 +1,79 @@
 #!/usr/bin/env node
-import { A as logger, D as createDesktopDiscovery, O as getManagedAppDir, T as AAI_GATEWAY_VERSION, _ as isMcpAccess, a as buildMcpImportConfig, b as getMcpExecutor, c as importSkill, d as upsertSkillRegistryEntry, f as upsertMcpRegistryEntry, i as IMPORT_LIMITS, l as normalizeExposureInput, m as createSecureStorage, n as createGatewayServer, o as buildSkillImportSource, r as EXPOSURE_LIMITS, s as importMcpServer, u as validateImportHeaders, v as isSkillAccess } from "./server-C-9LuKWE.js";
-import { join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
+import { _ as logger, h as createDesktopDiscovery, m as AAI_GATEWAY_VERSION, n as createGatewayServer, r as createCliCallerContextFromEnv } from "./server-alVv1KNr.js";
 //#region src/cli.ts
-function parseKeyValue(value, flag) {
-	const index = value.indexOf("=");
-	if (index === -1) throw new Error(`${flag} expects KEY=VALUE`);
-	return [value.slice(0, index), value.slice(index + 1)];
-}
-function parsePositiveInteger(value, flag) {
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${flag} expects a positive integer`);
-	return parsed;
-}
 function parseArgs(args) {
 	const dev = args.includes("--dev");
+	const json = args.includes("--json");
 	if (args.includes("--scan")) return {
 		command: "scan",
-		dev
+		dev,
+		json
 	};
-	if (args[0] === "mcp" && args[1] === "import") {
-		const exposure = parseRequiredExposureArgs(args.slice(2));
-		let name;
-		let transport;
-		let url;
-		let launchCommand;
-		let timeout;
-		let launchCwd;
-		const launchArgs = [];
-		const launchEnv = {};
-		const headers = {};
-		for (let i = 2; i < args.length; i += 1) {
-			const arg = args[i];
-			const next = args[i + 1];
-			switch (arg) {
-				case "--dev": break;
-				case "--exposure":
-				case "--summary":
-				case "--keyword":
-					i += 1;
-					break;
-				case "--name":
-					name = next;
-					i += 1;
-					break;
-				case "--transport":
-					if (next !== "streamable-http" && next !== "sse") throw new Error("--transport must be streamable-http or sse");
-					transport = next;
-					i += 1;
-					break;
-				case "--url":
-					url = next;
-					i += 1;
-					break;
-				case "--command":
-					launchCommand = next;
-					i += 1;
-					break;
-				case "--timeout":
-					timeout = parsePositiveInteger(next, "--timeout");
-					i += 1;
-					break;
-				case "--arg":
-					launchArgs.push(next);
-					i += 1;
-					break;
-				case "--env": {
-					const [key, value] = parseKeyValue(next, "--env");
-					launchEnv[key] = value;
-					i += 1;
-					break;
-				}
-				case "--cwd":
-					launchCwd = next;
-					i += 1;
-					break;
-				case "--header": {
-					const [key, value] = parseKeyValue(next, "--header");
-					headers[key] = value;
-					i += 1;
-					break;
-				}
-				default: if (arg.startsWith("--") && ![
-					"--dev",
-					"--exposure",
-					"--summary",
-					"--keyword",
-					"--name",
-					"--transport",
-					"--url",
-					"--command",
-					"--timeout",
-					"--arg",
-					"--env",
-					"--cwd",
-					"--header"
-				].includes(arg)) throw new Error(`Unknown argument: ${arg}`);
-			}
-		}
-		return {
-			command: "mcp-import",
-			dev,
-			...exposure,
-			...name ? { name } : {},
-			transport,
-			url,
-			launchCommand,
-			...timeout !== void 0 ? { timeout } : {},
-			launchArgs,
-			launchEnv,
-			launchCwd,
-			headers
-		};
-	}
-	if (args[0] === "skill" && args[1] === "import") {
-		const exposure = parseRequiredExposureArgs(args.slice(2));
-		let path;
-		let url;
-		for (let i = 2; i < args.length; i += 1) {
-			const arg = args[i];
-			const next = args[i + 1];
-			switch (arg) {
-				case "--dev": break;
-				case "--exposure":
-				case "--summary":
-				case "--keyword":
-					i += 1;
-					break;
-				case "--path":
-					path = next;
-					i += 1;
-					break;
-				case "--url":
-					url = next;
-					i += 1;
-					break;
-				default: if (arg.startsWith("--") && ![
-					"--path",
-					"--url",
-					"--dev",
-					"--exposure",
-					"--summary",
-					"--keyword"
-				].includes(arg)) throw new Error(`Unknown argument: ${arg}`);
-			}
-		}
-		return {
-			command: "skill-import",
-			dev,
-			...exposure,
-			path,
-			url
-		};
-	}
-	if (args[0] === "app" && args[1] === "config") {
-		const appId = args[2];
-		if (!appId) throw new Error("Usage: aai-gateway app config <app-id>");
-		let exposure;
-		let summary;
-		const keywords = [];
-		for (let i = 3; i < args.length; i += 1) {
-			const arg = args[i];
-			const next = args[i + 1];
-			switch (arg) {
-				case "--dev": break;
-				case "--exposure":
-					if (next !== "summary" && next !== "keywords") throw new Error("--exposure must be summary or keywords");
-					exposure = next;
-					i += 1;
-					break;
-				case "--summary":
-					summary = next;
-					i += 1;
-					break;
-				case "--keyword":
-					keywords.push(next);
-					i += 1;
-					break;
-				default: if (arg.startsWith("--") && ![
-					"--dev",
-					"--exposure",
-					"--summary",
-					"--keyword"
-				].includes(arg)) throw new Error(`Unknown argument: ${arg}`);
-			}
-		}
-		return {
-			command: "app-config",
-			dev,
-			appId,
-			...exposure ? { exposure } : {},
-			...summary ? { summary } : {},
-			...keywords.length > 0 ? { keywords } : {}
-		};
-	}
-	return {
+	const command = normalizeCommand(args[0]);
+	if (!command) return {
 		command: "serve",
-		dev
+		dev,
+		json
 	};
-}
-function parseRequiredExposureArgs(args) {
-	let exposure;
-	let summary;
-	const keywords = [];
-	for (let i = 0; i < args.length; i += 1) {
+	let app;
+	let tool;
+	let argsJson;
+	for (let i = 1; i < args.length; i += 1) {
 		const arg = args[i];
 		const next = args[i + 1];
 		switch (arg) {
-			case "--exposure":
-				if (next !== "summary" && next !== "keywords") throw new Error("--exposure must be summary or keywords");
-				exposure = next;
+			case "--dev":
+			case "--json": break;
+			case "--app":
+				app = next;
 				i += 1;
 				break;
-			case "--summary":
-				summary = next;
+			case "--tool":
+				tool = next;
 				i += 1;
 				break;
-			case "--keyword":
-				keywords.push(next);
+			case "--args-json":
+				argsJson = next;
 				i += 1;
 				break;
-			default: break;
+			default: if (arg.startsWith("--")) throw new Error(`Unknown argument: ${arg}`);
 		}
 	}
-	if (!exposure) throw new Error("Import requires --exposure summary|keywords");
-	if (!summary) throw new Error(`Import requires --summary (maximum ${EXPOSURE_LIMITS.summaryLength} characters)`);
-	if (keywords.length === 0) throw new Error(`Import requires at least one --keyword (maximum ${EXPOSURE_LIMITS.keywordCount} total)`);
 	return {
-		exposure,
-		...normalizeExposureInput({
-			keywords,
-			summary
-		})
+		command,
+		dev,
+		json,
+		app,
+		tool,
+		argsJson
 	};
 }
+function normalizeCommand(value) {
+	switch (value) {
+		case "list":
+		case "guide":
+		case "schema":
+		case "exec": return value;
+		default: return;
+	}
+}
 function printHelp() {
 	console.log(`
 AAI Gateway
 
 Usage:
   aai-gateway [options]
-  aai-gateway mcp import [options]
-  aai-gateway skill import [options]
-  aai-gateway app config <app-id> [options]
+  aai-gateway list [--json]
+  aai-gateway guide --app <app-id>
+  aai-gateway schema --tool <tool> [--app <app-id>] [--json]
+  aai-gateway exec --tool <tool> [--app <app-id>] [--args-json <json>] [--json]
 
 Options:
   --scan        Scan for desktop descriptors and exit
   --dev         Enable development mode
+  --json        Print structured JSON when available
   --version     Show version
   --help, -h    Show help
-
-Shared metadata options:
-  --exposure MODE        Required for import. One of: summary, keywords
-  --summary TEXT         Required for import, max ${EXPOSURE_LIMITS.summaryLength} characters
-  --keyword VALUE        Required for import and repeatable, max ${EXPOSURE_LIMITS.keywordCount} items, each max ${EXPOSURE_LIMITS.keywordLength} characters
-
-MCP import options:
-  --name TEXT           Optional app name used for display and app id generation, max ${IMPORT_LIMITS.nameLength} chars
-  --command CMD          Import a local stdio MCP server, max ${IMPORT_LIMITS.commandLength} chars
-  --timeout MS           Optional MCP downstream inactivity timeout in milliseconds, default 60000
-  --arg VALUE            Repeatable stdio argument, max ${IMPORT_LIMITS.argCount} items, each max ${IMPORT_LIMITS.argLength} chars
-  --env KEY=VALUE        Repeatable stdio environment variable, max ${IMPORT_LIMITS.envCount} entries
-  --cwd DIR              Working directory for stdio launch, max ${IMPORT_LIMITS.cwdLength} chars
-  --url URL              Import a remote MCP server, max ${IMPORT_LIMITS.urlLength} chars
-  --transport TYPE       Remote transport: streamable-http or sse
-  --header KEY=VALUE     Repeatable remote header stored in secure storage, max ${IMPORT_LIMITS.headerCount} entries
-
-Skill import options:
-  --path DIR             Import a local skill directory, max ${IMPORT_LIMITS.pathLength} chars
-  --url URL              Import a remote skill root URL, max ${IMPORT_LIMITS.urlLength} chars
-
-App config options:
-  --exposure MODE        Optional. Update the recorded exposure mode
-  --summary TEXT         Optional. Override the current summary
-  --keyword VALUE        Optional and repeatable. Replace the current keywords
 `);
 }
 async function runScan(dev) {
@@ -290,92 +90,60 @@ async function runScan(dev) {
 		console.log(`  Summary: ${app.descriptor.exposure.summary}`);
 	}
 }
-async function runMcpImport(options) {
-	const storage = createSecureStorage();
-	const executor = getMcpExecutor();
-	validateImportHeaders(options.headers);
-	const config = buildMcpImportConfig({
-		transport: options.transport,
-		url: options.url,
-		command: options.launchCommand,
-		timeout: options.timeout,
-		args: options.launchArgs,
-		env: options.launchEnv,
-		cwd: options.launchCwd
-	});
-	const result = await importMcpServer(executor, storage, {
-		name: options.name,
-		exposureMode: options.exposure,
-		keywords: options.keywords,
-		summary: options.summary,
-		config,
-		headers: options.headers
-	});
-	console.log(`Imported MCP app: ${result.descriptor.app.name.default}`);
-	console.log(`App ID: ${result.entry.appId}`);
-	console.log(`Descriptor: ${result.entry.descriptorPath}`);
-	console.log(`Managed directory: ${getManagedAppDir(result.entry.appId)}`);
-	console.log(`Tool name after restart: app:${result.entry.appId}`);
-	console.log(`Keywords: ${result.descriptor.exposure.keywords.join(", ")}`);
-	console.log(`Summary: ${result.descriptor.exposure.summary}`);
-	console.log(`Exposure mode: ${options.exposure}`);
+async function withServer(dev, fn) {
+	const server = await createGatewayServer({ devMode: dev });
+	await server.initialize();
+	return fn(server);
+}
+async function runList(options) {
+	const caller = createCliCallerContextFromEnv();
+	const tools = await withServer(options.dev, (server) => server.listToolsForCaller(caller));
+	if (options.json) {
+		console.log(JSON.stringify({ tools }, null, 2));
+		return;
+	}
+	for (const tool of tools) {
+		console.log(`${tool.name}`);
+		console.log(`  ${tool.description}`);
+	}
 }
-async function runSkillImport(options) {
-	const source = buildSkillImportSource({
-		path: options.path,
-		url: options.url
-	});
-	const result = await importSkill({
-		exposureMode: options.exposure,
-		keywords: options.keywords,
-		summary: options.summary,
-		path: source.path,
-		url: source.url
-	});
-	console.log(`Imported skill: ${result.descriptor.app.name.default}`);
-	console.log(`App ID: ${result.appId}`);
-	console.log(`Descriptor: ${join(getManagedAppDir(result.appId), "aai.json")}`);
-	console.log(`Skill directory: ${result.managedPath}`);
-	console.log(`Tool name after restart: app:${result.appId}`);
-	console.log(`Keywords: ${result.descriptor.exposure.keywords.join(", ")}`);
-	console.log(`Summary: ${result.descriptor.exposure.summary}`);
-	console.log(`Exposure mode: ${options.exposure}`);
+async function runGuide(options) {
+	if (!options.app) throw new Error("guide requires --app <app-id>");
+	const caller = createCliCallerContextFromEnv();
+	const guide = await withServer(options.dev, (server) => server.getAppGuideForCaller(stripAppPrefix(options.app), caller));
+	console.log(guide);
 }
-async function runAppConfig(options) {
-	const descriptorPath = resolveManagedDescriptorPath(options.appId);
-	const descriptor = JSON.parse(readFileSync(descriptorPath, "utf-8"));
-	const nextExposure = normalizeAppConfigExposure(options, descriptor.exposure);
-	const nextDescriptor = {
-		...descriptor,
-		exposure: nextExposure
-	};
-	if (isMcpAccess(nextDescriptor.access)) await upsertMcpRegistryEntry({
-		appId: options.appId,
-		protocol: "mcp",
-		config: nextDescriptor.access.config
-	}, nextDescriptor);
-	else if (isSkillAccess(nextDescriptor.access)) await upsertSkillRegistryEntry({
-		appId: options.appId,
-		protocol: "skill",
-		config: nextDescriptor.access.config
-	}, nextDescriptor);
-	else throw new Error(`App '${options.appId}' is not an imported MCP app or imported skill`);
-	console.log(`Updated app: ${options.appId}`);
-	if (options.exposure) console.log(`Exposure mode: ${options.exposure}`);
-	console.log(`Keywords: ${nextDescriptor.exposure.keywords.join(", ")}`);
-	console.log(`Summary: ${nextDescriptor.exposure.summary}`);
+async function runSchema(options) {
+	if (!options.tool) throw new Error("schema requires --tool <tool>");
+	const caller = createCliCallerContextFromEnv();
+	printToolResult(await withServer(options.dev, (server) => server.getSchemaForCaller(options.app ? stripAppPrefix(options.app) : void 0, options.tool, caller)), options.json);
 }
-function normalizeAppConfigExposure(options, current) {
-	const summary = options.summary ?? current.summary;
-	return normalizeExposureInput({
-		keywords: options.keywords ?? current.keywords,
-		summary
-	});
+async function runExec(options) {
+	if (!options.tool) throw new Error("exec requires --tool <tool>");
+	const caller = createCliCallerContextFromEnv();
+	const args = parseArgsJson(options.argsJson);
+	printToolResult(await withServer(options.dev, (server) => server.executeForCaller(options.app ? stripAppPrefix(options.app) : void 0, options.tool, args, caller)), options.json);
 }
-function resolveManagedDescriptorPath(appId) {
-	const descriptorPath = join(getManagedAppDir(appId), "aai.json");
-	if (existsSync(descriptorPath)) return descriptorPath;
-	return descriptorPath;
+function stripAppPrefix(value) {
+	return value.startsWith("app:") ? value.slice(4) : value;
+}
+function parseArgsJson(value) {
+	if (!value) return {};
+	const parsed = JSON.parse(value);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("--args-json must be a JSON object");
+	return parsed;
+}
+function printToolResult(result, json) {
+	if (json && result.structuredContent) {
+		console.log(JSON.stringify(result.structuredContent, null, 2));
+		return;
+	}
+	const text = result.content?.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
+	if (text && text.length > 0) {
+		console.log(text);
+		return;
+	}
+	if (result.structuredContent) console.log(JSON.stringify(result.structuredContent, null, 2));
 }
 async function main() {
 	const args = process.argv.slice(2);
@@ -392,14 +160,17 @@ async function main() {
 		case "scan":
 			await runScan(options.dev);
 			return;
-		case "mcp-import":
-			await runMcpImport(options);
+		case "list":
+			await runList(options);
+			return;
+		case "guide":
+			await runGuide(options);
 			return;
-		case "skill-import":
-			await runSkillImport(options);
+		case "schema":
+			await runSchema(options);
 			return;
-		case "app-config":
-			await runAppConfig(options);
+		case "exec":
+			await runExec(options);
 			return;
 		case "serve":
 			await (await createGatewayServer({ devMode: options.dev })).start();