onto-mcp 0.4.0 → 0.4.2

package/README.md

@@ -100,12 +100,26 @@ Mechanism per host:
 | Cursor | edits `mcpServers.onto` in `~/.cursor/mcp.json` |
 
 For the CLI-backed hosts, `onto register` prefers the official CLI and falls back
-to printing manual instructions when it is not on PATH. JSON edits preserve any
+to printing manual instructions when it is not on PATH. It verifies the result
+after `mcp add` and reports `failed` (not a false `registered`) if the CLI exits
+successfully but the server is not listed afterward — e.g. when `claude` on PATH
+is an alias/wrapper or points at the wrong profile. JSON edits preserve any
 servers already present and are idempotent (re-running reports `skipped`).
 Registration writes only host-owned config; it never writes onto runtime data.
 Restart the host app after registering to pick up the new server. Override the
 launched command or server name with `--command <cmd>` / `--name <id>`.
 
+**Claude Code profiles.** Claude Code stores MCP servers per config directory
+(`CLAUDE_CONFIG_DIR`). If you run multiple profiles (e.g. `~/.claude`,
+`~/.claude-1`), target one explicitly so registration lands in the right place:
+
+```bash
+onto register --hosts claude-code --claude-config-dir ~/.claude-1 --yes
+```
+
+When `--claude-config-dir` is omitted, an ambient `CLAUDE_CONFIG_DIR` is honored
+(shown in the plan), otherwise the claude default `~/.claude` is used.
+
 For project-local installs, add `onto-mcp` to the project and run the local
 binary:
 

package/dist/core-runtime/onboard/cli-host.js

@@ -2,9 +2,12 @@ import { execFileSync } from "node:child_process";
 import { isCommandOnPath } from "./path-scan.js";
 export const defaultCommandRunner = {
     exists: (command) => isCommandOnPath(command),
-    run: (command, args) => {
+    run: (command, args, env) => {
         try {
-            const stdout = execFileSync(command, args, { encoding: "utf8" });
+            const stdout = execFileSync(command, args, {
+                encoding: "utf8",
+                ...(env ? { env: { ...process.env, ...env } } : {}),
+            });
             return { status: 0, stdout, stderr: "" };
         }
         catch (error) {
@@ -21,21 +24,22 @@ export const defaultCommandRunner = {
         }
     },
 };
-function isAlreadyRegistered(spec, runner, entry) {
-    const result = runner.run(spec.cli, spec.listArgs());
+function probeRegistered(spec, runner, entry) {
+    const result = runner.run(spec.cli, spec.listArgs(), spec.commandEnv);
     if (result.status !== 0)
-        return false;
+        return "unknown";
     const haystack = `${result.stdout}\n${result.stderr}`;
     // CLIs print one server name per line; a word-boundary match avoids
     // false positives from substrings of other server names.
     const pattern = new RegExp(`(^|[^\\w-])${escapeRegExp(entry.name)}([^\\w-]|$)`, "m");
-    return pattern.test(haystack);
+    return pattern.test(haystack) ? "present" : "absent";
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 export function createCliHost(spec, runner = defaultCommandRunner) {
     const detect = () => (runner.exists(spec.cli) ? "cli" : "absent");
+    const withNote = (summary) => spec.targetNote ? `${summary} (${spec.targetNote})` : summary;
     return {
         id: spec.id,
         displayName: spec.displayName,
@@ -58,52 +62,70 @@ export function createCliHost(spec, runner = defaultCommandRunner) {
                 displayName: spec.displayName,
                 detection,
                 method: "cli",
-                summary: `Run: ${commandLine}`,
+                summary: withNote(`Run: ${commandLine}`),
                 commandLine,
             };
         },
         async apply(entry, options) {
+            const base = { hostId: spec.id, displayName: spec.displayName };
             if (detect() === "absent") {
-                return {
-                    hostId: spec.id,
-                    displayName: spec.displayName,
-                    outcome: "manual",
-                    detail: spec.manualInstructions(entry),
-                };
+                return { ...base, outcome: "manual", detail: spec.manualInstructions(entry) };
             }
-            const exists = isAlreadyRegistered(spec, runner, entry);
-            if (exists && !options.force) {
+            const before = probeRegistered(spec, runner, entry);
+            if (before === "present" && !options.force) {
                 return {
-                    hostId: spec.id,
-                    displayName: spec.displayName,
+                    ...base,
                     outcome: "skipped",
                     detail: `${entry.name} already registered (use --force to re-add)`,
                 };
             }
-            if (exists && options.force) {
-                runner.run(spec.cli, spec.removeArgs(entry)); // best effort; ignore failure
+            if (before === "present" && options.force) {
+                runner.run(spec.cli, spec.removeArgs(entry), spec.commandEnv); // best effort
             }
-            const result = runner.run(spec.cli, spec.addArgs(entry));
-            if (result.status === 0) {
+            const result = runner.run(spec.cli, spec.addArgs(entry), spec.commandEnv);
+            if (result.status !== 0) {
                 return {
-                    hostId: spec.id,
-                    displayName: spec.displayName,
-                    outcome: exists ? "updated" : "registered",
-                    detail: `${spec.cli} ${spec.addArgs(entry).join(" ")}`,
+                    ...base,
+                    outcome: "failed",
+                    detail: (result.stderr || result.stdout || "command failed").trim(),
+                };
+            }
+            // Verify the add actually took effect. A CLI that exits 0 without
+            // registering (aliased/wrapper `claude`, wrong profile) must not be
+            // reported as success.
+            const after = probeRegistered(spec, runner, entry);
+            const outcome = before === "present" ? "updated" : "registered";
+            if (after === "present") {
+                return { ...base, outcome, detail: `${spec.cli} ${spec.addArgs(entry).join(" ")}` };
+            }
+            if (after === "unknown") {
+                return {
+                    ...base,
+                    outcome,
+                    detail: `${spec.cli} ${spec.addArgs(entry).join(" ")} (could not verify via ${spec.cli} mcp list)`,
                 };
             }
             return {
-                hostId: spec.id,
-                displayName: spec.displayName,
+                ...base,
                 outcome: "failed",
-                detail: (result.stderr || result.stdout || "command failed").trim(),
+                detail: `${spec.cli} accepted the command but ${entry.name} is not listed afterward. ` +
+                    `The ${spec.cli} on PATH may be an alias/wrapper or target a different profile` +
+                    (spec.targetNote ? ` (${spec.targetNote})` : "") +
+                    `. Try registering against the real CLI/profile directly.`,
             };
         },
     };
 }
-/** Claude Code — registers at user scope so it applies across all projects. */
-export function createClaudeCodeHost(runner) {
-    return createCliHost({
+/**
+ * Claude Code — registers at user scope so it applies across all projects.
+ *
+ * Config-dir resolution: explicit `configDir` wins; otherwise an ambient
+ * `CLAUDE_CONFIG_DIR` is honored (and shown in the plan); otherwise the claude
+ * default (`~/.claude`) applies.
+ */
+export function createClaudeCodeHost(options = {}) {
+    const effectiveDir = options.configDir ?? process.env.CLAUDE_CONFIG_DIR;
+    const spec = {
         id: "claude-code",
         displayName: "Claude Code",
         cli: "claude",
@@ -121,7 +143,10 @@ export function createClaudeCodeHost(runner) {
         listArgs: () => ["mcp", "list"],
         manualInstructions: (entry) => `claude CLI not found. Install Claude Code, then run:\n` +
             `  claude mcp add ${entry.name} -s user -- ${entry.command} ${entry.args.join(" ")}`,
-    }, runner);
+        ...(effectiveDir ? { commandEnv: { CLAUDE_CONFIG_DIR: effectiveDir } } : {}),
+        targetNote: effectiveDir ? `config dir: ${effectiveDir}` : "config dir: claude default (~/.claude)",
+    };
+    return createCliHost(spec, options.runner);
 }
 /** Codex CLI. */
 export function createCodexHost(runner) {

package/dist/core-runtime/onboard/host-target.js

@@ -4,9 +4,9 @@ import { claudeDesktopConfigPath, createJsonConfigHost, cursorConfigPath, } from
  * The four supported hosts in display order. CLI-backed hosts (Claude Code,
  * Codex) come first; JSON-config hosts (Claude Desktop, Cursor) follow.
  */
-export function getDefaultHostTargets() {
+export function getDefaultHostTargets(options = {}) {
     return [
-        createClaudeCodeHost(),
+        createClaudeCodeHost(options.claudeConfigDir ? { configDir: options.claudeConfigDir } : {}),
         createCodexHost(),
         createJsonConfigHost({
             id: "claude-desktop",

package/dist/core-runtime/onboard/register.js

@@ -18,6 +18,8 @@ const USAGE = [
     "  --force            Re-register CLI hosts even if already present",
     "  --name <id>        MCP server name (default: onto)",
     "  --command <cmd>    Executable the host launches (default: onto)",
+    "  --claude-config-dir <path>  Target a Claude Code profile (sets",
+    "                     CLAUDE_CONFIG_DIR; default: ambient env or ~/.claude)",
     "  --help, -h         Show this help",
 ].join("\n");
 export function parseRegisterArgs(argv) {
@@ -30,6 +32,7 @@ export function parseRegisterArgs(argv) {
         help: false,
         name: "onto",
         command: "onto",
+        claudeConfigDir: undefined,
         unknownFlags: [],
         invalidHosts: [],
     };
@@ -76,6 +79,9 @@ export function parseRegisterArgs(argv) {
             case "--command":
                 parsed.command = argv[++i] ?? parsed.command;
                 break;
+            case "--claude-config-dir":
+                parsed.claudeConfigDir = argv[++i] ?? parsed.claudeConfigDir;
+                break;
             default:
                 parsed.unknownFlags.push(arg);
                 break;
@@ -133,7 +139,8 @@ export async function runRegister(argv, deps = {}) {
             `Valid: ${ALL_HOST_IDS.join(", ")}`);
         return 1;
     }
-    const targets = deps.targets ?? getDefaultHostTargets();
+    const targets = deps.targets ??
+        getDefaultHostTargets(parsed.claudeConfigDir ? { claudeConfigDir: parsed.claudeConfigDir } : {});
     const isTty = deps.isTty ?? Boolean(process.stdin.isTTY);
     if (parsed.list) {
         console.log("Host detection:");

package/dist/mcp/server.js

@@ -507,6 +507,9 @@ function toReviewRequest(input) {
     return request;
 }
 function formatToolResult(data) {
+    // Per MCP, `structuredContent` must be a JSON object. Callers that produce a
+    // top-level array (e.g. a list of domains/profiles) must wrap it in an object
+    // before calling this, or strict MCP clients reject the result.
     const text = JSON.stringify(data, null, 2);
     return {
         content: [{ type: "text", text }],
@@ -963,11 +966,15 @@ async function callTool(name, args, options = {}) {
                 return formatToolResult(await reviewApi.listLenses());
             case "onto.list_domains": {
                 const parsed = OntoListDomainsToolInputSchema.parse(args ?? {});
-                return formatToolResult(await reviewApi.listDomains(parsed.projectRoot));
+                const domains = await reviewApi.listDomains(parsed.projectRoot);
+                // Wrap the array so structuredContent is a JSON object (MCP requirement).
+                return formatToolResult({ domains });
             }
             case "onto.list_source_profiles": {
                 const parsed = OntoListSourceProfilesToolInputSchema.parse(args ?? {});
-                return formatToolResult(await reconstructApi.listSourceProfiles(parsed.projectRoot));
+                const sourceProfiles = await reconstructApi.listSourceProfiles(parsed.projectRoot);
+                // Wrap the array so structuredContent is a JSON object (MCP requirement).
+                return formatToolResult({ sourceProfiles });
             }
             case "onto.observe_source": {
                 const parsed = OntoObserveSourceToolInputSchema.parse(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onto-mcp",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "MCP-native ontology review runtime with context-isolated lenses and controlled deliberation",
   "homepage": "https://github.com/kangminlee-maker/onto-mcp#readme",
   "bugs": {