nexarch 0.3.1 → 0.4.2

package/README.md

@@ -1,6 +1,6 @@
 # nexarch
 
-Connect AI coding tools to your Nexarch architecture workspace.
+Your architecture workspace for AI delivery.
 
 ## Quick start
 
@@ -9,15 +9,18 @@ npx nexarch login
 npx nexarch setup
 ```
 
+> `setup`, `mcp-config`, and `init-agent` are registry-driven and fail closed.
+> If the published integration registry is unavailable/invalid, these commands stop until service is restored.
+
 ## Commands
 
 | Command | Description |
 |---|---|
 | `nexarch login [--company <id>]` | Authenticate via browser and store company-scoped credentials; prompts for company when multiple memberships exist |
 | `nexarch logout` | Remove local credentials |
-| `nexarch status` | Check connection and show architecture summary for the company selected at login |
+| `nexarch status` | Check connection, registry health/version, and architecture summary for the company selected at login |
 | `nexarch setup` | Auto-configure detected MCP clients |
-| `nexarch mcp-config [client]` | Print config block for manual setup (`claude-desktop`, `cursor`, `windsurf`) |
+| `nexarch mcp-config [client]` | Print config block for manual setup (supported client codes are registry-managed) |
 | `nexarch mcp-proxy` | stdio→HTTP bridge used internally by MCP clients |
 | `nexarch init-agent [--json] [--strict] [--agent-id <id>] [--redact-hostname]` | Run onboarding handshake and mandatory `agent` entity registration in graph |
 | `nexarch init-agent --bind-to-external-key <key> [--bind-relationship-type <code>]` | Optionally bind the agent node to an existing graph external key |

package/dist/commands/init-agent.js

@@ -3,8 +3,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import process from "process";
 import { requireCredentials } from "../lib/credentials.js";
+import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
 import { callMcpTool, mcpInitialize, mcpListTools } from "../lib/mcp.js";
-const CLI_VERSION = "0.2.6";
+const CLI_VERSION = "0.4.2";
 const AGENT_ENTITY_TYPE = "agent";
 const TECH_COMPONENT_ENTITY_TYPE = "technology_component";
 function parseFlag(args, flag) {
@@ -23,6 +24,19 @@ function parseToolText(result) {
     const text = result.content?.[0]?.text ?? "{}";
     return JSON.parse(text);
 }
+function renderChecksTable(checks) {
+    const headers = ["Status", "Check", "Details"];
+    const rows = checks.map((check) => [
+        check.ok ? "✓" : "x",
+        check.name,
+        check.detail?.trim() || "-",
+    ]);
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const hr = `+${widths.map((w) => "-".repeat(w + 2)).join("+")}+`;
+    const formatRow = (cells) => `| ${cells.map((cell, i) => cell.padEnd(widths[i])).join(" | ")} |`;
+    const lines = [hr, formatRow(headers), hr, ...rows.map(formatRow), hr];
+    return lines.join("\n");
+}
 function getDefaultAgentId() {
     const osUser = process.env.USERNAME || process.env.USER || userInfo().username || "unknown";
     const host = hostname() || "unknown-host";
@@ -145,36 +159,58 @@ After running, confirm \`"ok": true\` in the JSON output. No further action is n
     writeFileSync(filePath, content, "utf8");
     return filePath;
 }
-const CLAUDE_MD_SECTION_MARKER = "## Nexarch Agent Registration";
-const CLAUDE_MD_SECTION = `
-## Nexarch Agent Registration
-
-When a human has run \`nexarch login\` and \`nexarch init-agent\`, they may ask you to run \`npx nexarch agent prompt\`. Do so, read the output, and follow the instructions — it contains a pre-filled \`npx nexarch agent identify\` command for you to complete with your own provider, model, client, and capability values, then execute. Confirm \`"ok": true\` in the JSON output.
-
-This applies to any AI coding assistant with MCP tool access (Claude Code, Cursor, Windsurf, Continue.dev, Codex CLI, etc.).
-`;
-function injectAgentConfigs() {
-    const candidateNames = [
-        "CLAUDE.md", "claude.md", "Claude.md", // Claude Code
-        "AGENTS.md", "agents.md", // OpenAI Codex CLI / generic
-        ".github/copilot-instructions.md", // GitHub Copilot
-        ".cursorrules", // Cursor (legacy)
-        ".continue/rules.md", // Continue.dev
-        ".windsurfrules", // Windsurf
-    ];
+function replaceInjectedSection(existing, sectionHeading, sectionBody) {
+    const headingRegex = new RegExp(`^${sectionHeading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?(?=^##\\s|\\Z)`, "m");
+    if (headingRegex.test(existing)) {
+        const replaced = existing.replace(headingRegex, sectionBody.trim());
+        return replaced.endsWith("\n") ? replaced : `${replaced}\n`;
+    }
+    return existing;
+}
+function injectAgentConfigs(registry) {
+    const templateByCode = new Map(registry.instructionTemplates.map((t) => [t.code, t]));
+    const targets = [...registry.instructionTargets].sort((a, b) => a.sortOrder - b.sortOrder || a.filePathPattern.localeCompare(b.filePathPattern));
     const results = [];
-    for (const name of candidateNames) {
-        const filePath = join(process.cwd(), name);
+    for (const target of targets) {
+        if (target.matchMode !== "exact")
+            continue;
+        const template = templateByCode.get(target.templateCode);
+        if (!template)
+            continue;
+        const filePath = join(process.cwd(), target.filePathPattern);
         if (!existsSync(filePath))
             continue;
         const existing = readFileSync(filePath, "utf8");
-        if (existing.includes(CLAUDE_MD_SECTION_MARKER)) {
-            results.push({ path: filePath, status: "already_present" });
+        const sectionBody = template.body.trim();
+        const sectionHeading = target.sectionHeading ?? "## Nexarch Agent Registration";
+        const sectionMarker = target.sectionMarker ?? sectionHeading;
+        if (target.insertionMode === "replace_section") {
+            let replaced = replaceInjectedSection(existing, sectionHeading, sectionBody);
+            if (replaced === existing && existing.includes(sectionMarker)) {
+                const markerIndex = existing.indexOf(sectionMarker);
+                const before = existing.slice(0, markerIndex).replace(/\s*$/, "\n\n");
+                replaced = `${before}${sectionBody}\n`;
+            }
+            if (replaced !== existing) {
+                writeFileSync(filePath, replaced, "utf8");
+                results.push({ path: filePath, status: "updated" });
+            }
+            else {
+                const separator = existing.endsWith("\n") ? "" : "\n";
+                writeFileSync(filePath, existing + separator + sectionBody + "\n", "utf8");
+                results.push({ path: filePath, status: "injected" });
+            }
             continue;
         }
         const separator = existing.endsWith("\n") ? "" : "\n";
-        writeFileSync(filePath, existing + separator + CLAUDE_MD_SECTION, "utf8");
-        results.push({ path: filePath, status: "injected" });
+        const next = existing + separator + sectionBody + "\n";
+        if (next === existing) {
+            results.push({ path: filePath, status: "already_present" });
+        }
+        else {
+            writeFileSync(filePath, next, "utf8");
+            results.push({ path: filePath, status: "injected" });
+        }
     }
     return results;
 }
@@ -198,6 +234,7 @@ export async function initAgent(args) {
     const checks = [];
     const creds = requireCredentials();
     const selectedCompanyId = creds.companyId;
+    const registry = await fetchAgentRegistryOrThrow();
     const init = await mcpInitialize({ companyId: selectedCompanyId });
     checks.push({
         name: "mcp.initialize",
@@ -207,6 +244,7 @@ export async function initAgent(args) {
     const tools = await mcpListTools({ companyId: selectedCompanyId });
     const toolNames = new Set(tools.map((t) => t.name));
     const required = [
+        "nexarch_get_agent_registry",
         "nexarch_get_applied_policies",
         "nexarch_get_ingest_contract",
         "nexarch_upsert_entities",
@@ -639,7 +677,7 @@ export async function initAgent(args) {
             // non-fatal
         }
         try {
-            agentConfigResults = injectAgentConfigs();
+            agentConfigResults = injectAgentConfigs(registry);
         }
         catch {
             // non-fatal
@@ -703,6 +741,7 @@ export async function initAgent(args) {
                 submitCommandTemplate: `nexarch agent identify --agent-id \"${agentId}\" --provider \"<provider>\" --model \"<model>\" --client \"<client>\" --framework \"<openclaw|n8n|m365-agent-framework|other>\" --session-id \"<session-id>\" --tool-version \"<tool-version>\" --capabilities \"<capability1,capability2>\" --notes \"<optional notes>\" --json`,
             },
             companyId: creds.companyId,
+            registry: { version: registry.release.version, registryVersion: registry.registryVersion, publishedAt: registry.release.publishedAt },
             bootstrapFile: bootstrapFilePath,
             agentConfigs: agentConfigResults,
         };
@@ -711,12 +750,9 @@ export async function initAgent(args) {
             process.exitCode = 1;
         return;
     }
+    console.log(`Using integration registry release v${registry.release.version}.`);
     console.log("Running agent onboarding handshake…\n");
-    for (const check of checks) {
-        console.log(`${check.ok ? "✓" : "✗"} ${check.name}`);
-        if (check.detail)
-            console.log(`    ${check.detail}`);
-    }
+    console.log(renderChecksTable(checks));
     if (registration.graphEntityId) {
         console.log(`\nRegistered graph entity: ${registration.graphEntityId}`);
     }
@@ -733,8 +769,12 @@ export async function initAgent(args) {
             if (r.status === "injected") {
                 console.log(`📝 Nexarch registration instructions added to: ${r.path}`);
             }
+            if (r.status === "updated") {
+                console.log(`📝 Nexarch registration instructions updated in: ${r.path}`);
+            }
         }
-        console.log("\n   Tell your agent: \"run npx nexarch agent prompt and follow the instructions\"");
+        console.log("\n➡ Next step: paste this into your coding agent:");
+        console.log("\nrun npx nexarch@latest init-agent\n");
     }
     else {
         console.log("⚠ Handshake/registration completed with issues.");

package/dist/commands/login.js

@@ -5,6 +5,20 @@ import { execFile } from "child_process";
 import { saveCredentials } from "../lib/credentials.js";
 const NEXARCH_URL = "https://nexarch.ai";
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+function printLoginBanner() {
+    const logo = String.raw `
+        ######        ######
+        #######      ######
+       #########   ######    ##
+      ##################   #####
+     #####   ##########     ######
+   ######     #######        ######
+  #####         ####   #############
+######           ##   ###############
+`;
+    console.log(logo);
+    console.log("NEXARCH CLI login\n");
+}
 function generateState() {
     return randomBytes(16).toString("hex");
 }
@@ -115,6 +129,7 @@ function getArgValue(args, flag) {
     return v;
 }
 export async function login(args) {
+    printLoginBanner();
     const state = generateState();
     const port = await findFreePort();
     const requestedCompany = getArgValue(args, "--company");

package/dist/commands/mcp-config.js

@@ -1,53 +1,23 @@
 import { loadCredentials } from "../lib/credentials.js";
-import { nexarchServerBlock } from "../lib/clients.js";
+import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
+import { findClientProfile } from "../lib/clients.js";
+function renderConfigForProfile(profile) {
+    const serverBlock = { command: profile.serverCommand, args: profile.serverArgs };
+    if (profile.mergeStrategy === "continue_style") {
+        return { mcpServers: [{ name: "nexarch", ...serverBlock }] };
+    }
+    return { mcpServers: { nexarch: serverBlock } };
+}
 export async function mcpConfig(args) {
-    const clientFlag = args.find((a) => !a.startsWith("-")) ?? "claude-desktop";
-    const serverBlock = nexarchServerBlock();
-    console.log(`\nMCP server config for ${clientFlag}:\n`);
-    switch (clientFlag) {
-        case "claude-desktop": {
-            const config = { mcpServers: { nexarch: serverBlock } };
-            console.log("Add the following to your claude_desktop_config.json:\n");
-            console.log(JSON.stringify(config, null, 2));
-            console.log(`
-Locations:
-  macOS:   ~/Library/Application Support/Claude/claude_desktop_config.json
-  Windows: %APPDATA%\\Claude\\claude_desktop_config.json
-      `);
-            break;
-        }
-        case "cursor":
-        case "windsurf": {
-            const config = { mcpServers: { nexarch: serverBlock } };
-            console.log(`Add the following to your ${clientFlag === "cursor" ? ".cursor/mcp.json" : ".windsurf/mcp.json"}:\n`);
-            console.log(JSON.stringify(config, null, 2));
-            break;
-        }
-        case "continue":
-        case "continue-dev": {
-            // Continue.dev uses an array-style mcpServers with a "name" field per entry
-            const config = { mcpServers: [{ name: "nexarch", ...serverBlock }] };
-            console.log("Add (or merge) the following into your ~/.continue/config.json:\n");
-            console.log(JSON.stringify(config, null, 2));
-            console.log(`
-Locations:
-  macOS/Linux: ~/.continue/config.json
-  Windows:     %USERPROFILE%\\.continue\\config.json
-      `);
-            break;
-        }
-        case "http":
-        case "direct": {
-            // Direct HTTP connection — for MCP clients that support Streamable HTTP transport.
-            // The gateway accepts JSON-RPC 2.0 POST requests at the /mcp endpoint.
-            // Auth is via Bearer token (your nexarch token from ~/.nexarch/credentials.json).
-            const creds = loadCredentials();
-            const tokenHint = creds ? creds.token : "<your-nexarch-token>";
-            console.log("Direct HTTP MCP connection (Streamable HTTP / SSE transport):\n");
-            console.log(`  Endpoint : https://mcp.nexarch.ai/mcp`);
-            console.log(`  Auth     : Authorization: Bearer ${tokenHint}`);
-            console.log(`  Protocol : MCP JSON-RPC 2.0 over HTTP POST`);
-            console.log(`
+    const clientFlag = (args.find((a) => !a.startsWith("-")) ?? "claude-desktop").toLowerCase();
+    if (clientFlag === "http" || clientFlag === "direct") {
+        const creds = loadCredentials();
+        const tokenHint = creds ? creds.token : "<your-nexarch-token>";
+        console.log("Direct HTTP MCP connection (Streamable HTTP / SSE transport):\n");
+        console.log(`  Endpoint : https://mcp.nexarch.ai/mcp`);
+        console.log(`  Auth     : Authorization: Bearer ${tokenHint}`);
+        console.log(`  Protocol : MCP JSON-RPC 2.0 over HTTP POST`);
+        console.log(`
 Use this when your MCP client supports connecting to a remote HTTP MCP server directly
 (no stdio proxy required). Examples: custom agent frameworks, LangChain MCP integration,
 or any client that speaks the MCP Streamable HTTP or SSE transport.
@@ -62,13 +32,24 @@ Example curl to verify connectivity:
 If your client requires an MCP server URL instead of command/args, use:
   https://mcp.nexarch.ai/mcp
       `);
-            break;
-        }
-        default: {
-            const config = { mcpServers: { nexarch: serverBlock } };
-            console.log(JSON.stringify(config, null, 2));
-            break;
-        }
+        return;
+    }
+    const registry = await fetchAgentRegistryOrThrow();
+    const profile = findClientProfile(registry, clientFlag);
+    if (!profile) {
+        const known = registry.mcpClientProfiles.map((c) => c.code).join(", ");
+        throw new Error(`Unknown MCP client '${clientFlag}'. Supported clients from registry: ${known}`);
+    }
+    const config = renderConfigForProfile(profile);
+    console.log(`\nUsing integration registry release v${registry.release.version}.`);
+    console.log(`\nMCP server config for ${profile.code} (${profile.name}):\n`);
+    console.log(JSON.stringify(config, null, 2));
+    const platformKey = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "win32" : "linux";
+    const locations = profile.osPaths?.[platformKey] ?? [];
+    if (locations.length > 0) {
+        console.log("\nKnown config locations for this platform:");
+        for (const p of locations)
+            console.log(`  ${p}`);
     }
     console.log("\nOr run `nexarch setup` to have the CLI write the config automatically.");
 }

package/dist/commands/mcp-proxy.js

@@ -2,7 +2,7 @@ import * as readline from "readline";
 import { requireCredentials } from "../lib/credentials.js";
 import { forwardToGateway } from "../lib/mcp.js";
 /**
- * stdio MCP proxy — bridges MCP clients (Claude Desktop, Cursor, etc.) that
+ * stdio MCP proxy — bridges registry-managed MCP clients that
  * use stdio transport to the Nexarch HTTP MCP gateway.
  *
  * The MCP protocol over stdio is newline-delimited JSON-RPC 2.0.

package/dist/commands/setup.js

@@ -1,37 +1,49 @@
 import { requireCredentials } from "../lib/credentials.js";
-import { detectClients, writeClientConfig, nexarchServerBlock } from "../lib/clients.js";
-export async function setup(_args) {
-    requireCredentials(); // ensure logged in before configuring anything
+import { detectClientsFromRegistry, writeClientConfig, nexarchServerBlockFromRegistry } from "../lib/clients.js";
+import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
+import { initAgent } from "./init-agent.js";
+import { login } from "./login.js";
+export async function setup(args) {
+    try {
+        requireCredentials();
+    }
+    catch {
+        console.log("No active Nexarch session found. Starting login flow…\n");
+        await login(args);
+    }
+    requireCredentials(); // ensure login succeeded before continuing
+    const registry = await fetchAgentRegistryOrThrow();
+    console.log(`Using integration registry release v${registry.release.version}.`);
     console.log("Detecting installed MCP clients…\n");
-    const clients = detectClients();
+    const clients = detectClientsFromRegistry(registry);
     if (clients.length === 0) {
-        console.log("No supported MCP clients detected.");
-        console.log("\nSupported clients: Claude Desktop, Cursor, Windsurf, Continue.dev");
+        console.log("No supported MCP clients detected for this platform.");
+        const supported = registry.mcpClientProfiles.map((c) => c.name).join(", ");
+        console.log(`\nSupported clients (registry): ${supported}`);
         console.log("\nTo configure manually, run:");
-        console.log("  nexarch mcp-config --client claude-desktop");
-        console.log("  nexarch mcp-config --client cursor");
-        console.log("  nexarch mcp-config --client continue");
+        for (const cp of registry.mcpClientProfiles) {
+            console.log(`  nexarch mcp-config --client ${cp.code}`);
+        }
         console.log("\nFor clients that support direct HTTP MCP connections:");
         console.log("  nexarch mcp-config --client http");
-        return;
     }
-    const serverBlock = nexarchServerBlock();
-    for (const client of clients) {
-        process.stdout.write(`  ${client.name.padEnd(20)} ${client.configPath}\n`);
-        process.stdout.write(`  ${"".padEnd(20)} `);
-        try {
-            writeClientConfig(client, serverBlock);
-            console.log("✓ configured");
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.log(`✗ failed — ${message}`);
+    else {
+        const serverBlock = nexarchServerBlockFromRegistry(registry);
+        for (const client of clients) {
+            process.stdout.write(`  ${client.name.padEnd(20)} ${client.configPath}\n`);
+            process.stdout.write(`  ${"".padEnd(20)} `);
+            try {
+                writeClientConfig(client, serverBlock);
+                console.log("✓ configured");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.log(`✗ failed — ${message}`);
+            }
         }
+        console.log("\nDone. Restart your MCP client for the changes to take effect.");
     }
-    console.log("\nDone. Restart your MCP client for the changes to take effect.");
-    console.log("\nThe nexarch tools will be available to your AI coding assistant:");
-    console.log("  nexarch_list_architecture_snapshots");
-    console.log("  nexarch_get_snapshot_facts");
-    console.log("  nexarch_get_governance_summary");
-    console.log("  nexarch_get_applied_policies");
+    console.log("\nRegistering this runtime as a Nexarch agent…\n");
+    await initAgent(args.includes("--strict") ? args : [...args, "--strict"]);
+    console.log("\nSetup complete: MCP client config + agent registration are now in place.");
 }

package/dist/commands/status.js

@@ -1,4 +1,5 @@
 import { requireCredentials } from "../lib/credentials.js";
+import { fetchAgentRegistryOrThrow } from "../lib/agent-registry.js";
 import { callMcpTool } from "../lib/mcp.js";
 export async function status(_args) {
     const creds = requireCredentials();
@@ -7,9 +8,14 @@ export async function status(_args) {
     const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
     process.stdout.write("Connecting to mcp.nexarch.ai… ");
     let governance;
+    let registryInfo = null;
     try {
-        const result = await callMcpTool("nexarch_get_governance_summary", { companyId: selectedCompanyId || undefined }, { companyId: selectedCompanyId || undefined });
-        governance = JSON.parse(result.content[0]?.text ?? "{}");
+        const [governanceResult, registry] = await Promise.all([
+            callMcpTool("nexarch_get_governance_summary", { companyId: selectedCompanyId || undefined }, { companyId: selectedCompanyId || undefined }),
+            fetchAgentRegistryOrThrow(),
+        ]);
+        governance = JSON.parse(governanceResult.content[0]?.text ?? "{}");
+        registryInfo = { version: registry.release.version, publishedAt: registry.release.publishedAt };
     }
     catch (err) {
         console.error("failed\n");
@@ -22,6 +28,9 @@ export async function status(_args) {
     if (creds.company) {
         console.log(`  Workspace:      ${creds.company}`);
     }
+    if (registryInfo) {
+        console.log(`\n  Integration registry: v${registryInfo.version} (published ${new Date(registryInfo.publishedAt).toLocaleString()})`);
+    }
     console.log(`\n  Architecture facts:  ${governance.canonicalFactCount}`);
     console.log(`  Pending review:      ${governance.reviewQueue.pending_entities} entities, ${governance.reviewQueue.pending_relationships} relationships`);
     if (governance.latestSnapshot) {

package/dist/index.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import { homedir } from "os";
-import { readFileSync } from "fs";
-import { join } from "path";
 import { login } from "./commands/login.js";
 import { logout } from "./commands/logout.js";
 import { status } from "./commands/status.js";
@@ -44,39 +41,25 @@ async function main() {
             await agentIdentify(subArgs);
             return;
         }
-        if (subcommand === "prompt") {
-            const filePath = join(homedir(), ".nexarch", "agent-bootstrap.md");
-            try {
-                process.stdout.write(readFileSync(filePath, "utf8") + "\n");
-            }
-            catch {
-                console.error("No bootstrap file found. Run 'nexarch init-agent' first.");
-                process.exit(1);
-            }
-            return;
-        }
     }
     const handler = commands[command ?? ""];
     if (!handler) {
         console.log(`
-nexarch — Connect AI coding tools to your architecture workspace
+nexarch — Your architecture workspace for AI delivery.
 
 Usage:
   nexarch login         Authenticate in browser and store company-scoped credentials
                         Option: --company <id>
   nexarch logout        Remove stored credentials
   nexarch status        Check connection and show architecture summary
-  nexarch setup         Auto-configure your MCP client (Claude Desktop, Cursor, etc.)
+  nexarch setup         One-step onboarding: login (if needed) + MCP config + register agent
   nexarch mcp-config    Print MCP server config block for manual setup
+                        Client list is registry-managed (see 'nexarch mcp-config --client <code>')
   nexarch mcp-proxy     Run as stdio MCP proxy (used by MCP clients)
-  nexarch init-agent    Run handshake + mandatory agent registration in graph
+  nexarch init-agent    Run handshake + mandatory agent registration in graph (advanced/manual)
                         Options: --agent-id <id> --bind-to-external-key <key>
                                  --bind-relationship-type <code> --redact-hostname
                                  --json --strict
-  nexarch agent prompt
-                      Print bootstrap instructions for a Claude Code agent to complete
-                      its registration (written by init-agent). Tell Claude:
-                      "run npx nexarch agent prompt and follow the instructions"
   nexarch agent identify
                       Capture richer coding-agent identity metadata
                       Options: --agent-id <id> --provider <provider> --model <model>

package/dist/lib/agent-registry.js

@@ -0,0 +1,49 @@
+import { callMcpTool } from "./mcp.js";
+import { requireCredentials } from "./credentials.js";
+function parseToolText(result) {
+    const text = result.content?.[0]?.text ?? "{}";
+    return JSON.parse(text);
+}
+function isString(v) {
+    return typeof v === "string";
+}
+function ensureRegistryShape(raw) {
+    const r = raw;
+    if (!r || typeof r !== "object")
+        throw new Error("invalid payload");
+    if (typeof r.registryVersion !== "number")
+        throw new Error("missing registryVersion");
+    if (!r.release || !isString(r.release.id) || typeof r.release.version !== "number" || !isString(r.release.publishedAt)) {
+        throw new Error("missing release metadata");
+    }
+    if (!Array.isArray(r.instructionTemplates) || !Array.isArray(r.instructionTargets) || !Array.isArray(r.mcpClientProfiles)) {
+        throw new Error("missing registry collections");
+    }
+    for (const t of r.instructionTemplates) {
+        if (!isString(t.code) || !isString(t.body))
+            throw new Error("invalid instruction template");
+    }
+    for (const it of r.instructionTargets) {
+        if (!isString(it.filePathPattern) || !isString(it.runtimeCode) || !isString(it.templateCode)) {
+            throw new Error("invalid instruction target");
+        }
+    }
+    for (const cp of r.mcpClientProfiles) {
+        if (!isString(cp.code) || !isString(cp.name) || !isString(cp.serverCommand) || !Array.isArray(cp.serverArgs)) {
+            throw new Error("invalid mcp client profile");
+        }
+    }
+    return r;
+}
+export async function fetchAgentRegistryOrThrow() {
+    const creds = requireCredentials();
+    try {
+        const raw = await callMcpTool("nexarch_get_agent_registry", {}, { companyId: creds.companyId });
+        const parsed = parseToolText(raw);
+        return ensureRegistryShape(parsed);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Nexarch integration registry unavailable. This command is blocked until service is restored. (${message})`);
+    }
+}

package/dist/lib/clients.js

@@ -4,45 +4,15 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 function appData() {
     return process.env.APPDATA ?? null;
 }
-function claudeDesktopPaths() {
-    switch (process.platform) {
-        case "darwin":
-            return [join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")];
-        case "win32": {
-            const ad = appData();
-            return ad ? [join(ad, "Claude", "claude_desktop_config.json")] : [];
-        }
-        default:
-            return [join(homedir(), ".config", "Claude", "claude_desktop_config.json")];
-    }
-}
-function cursorPaths() {
-    switch (process.platform) {
-        case "darwin":
-            return [join(homedir(), ".cursor", "mcp.json")];
-        case "win32": {
-            const ad = appData();
-            return ad ? [join(ad, "Cursor", "User", "mcp.json")] : [];
-        }
-        default:
-            return [join(homedir(), ".cursor", "mcp.json")];
-    }
-}
-function windsurfPaths() {
-    switch (process.platform) {
-        case "darwin":
-            return [join(homedir(), ".windsurf", "mcp.json")];
-        case "win32": {
-            const ad = appData();
-            return ad ? [join(ad, "Windsurf", "User", "mcp.json")] : [];
-        }
-        default:
-            return [join(homedir(), ".windsurf", "mcp.json")];
-    }
-}
-function continueDevPaths() {
-    // Continue.dev stores config at ~/.continue/config.json on all platforms
-    return [join(homedir(), ".continue", "config.json")];
+function expandPath(p) {
+    let out = p;
+    if (out.startsWith("~/"))
+        out = join(homedir(), out.slice(2));
+    const ad = appData();
+    if (ad)
+        out = out.replace(/%APPDATA%/g, ad);
+    out = out.replace(/%USERPROFILE%/g, homedir());
+    return out;
 }
 function mergeClaudeStyle(existing, serverBlock) {
     let config = {};
@@ -57,8 +27,6 @@ function mergeClaudeStyle(existing, serverBlock) {
     config.mcpServers = servers;
     return JSON.stringify(config, null, 2);
 }
-// Continue.dev uses an array under mcpServers (each entry has a "name" field).
-// We upsert by name so re-running setup is idempotent.
 function mergeContinueStyle(existing, serverBlock) {
     let config = {};
     try {
@@ -92,14 +60,40 @@ function mergeFlatStyle(existing, serverBlock) {
     config.mcpServers = servers;
     return JSON.stringify(config, null, 2);
 }
-export function detectClients() {
-    const candidates = [
-        ...claudeDesktopPaths().map((p) => ({ name: "Claude Desktop", configPath: p, merge: mergeClaudeStyle })),
-        ...cursorPaths().map((p) => ({ name: "Cursor", configPath: p, merge: mergeFlatStyle })),
-        ...windsurfPaths().map((p) => ({ name: "Windsurf", configPath: p, merge: mergeFlatStyle })),
-        ...continueDevPaths().map((p) => ({ name: "Continue.dev", configPath: p, merge: mergeContinueStyle })),
-    ];
-    return candidates.filter((c) => existsSync(join(c.configPath, "..")));
+function mergeForStrategy(strategy) {
+    switch (strategy) {
+        case "claude_style":
+            return mergeClaudeStyle;
+        case "continue_style":
+            return mergeContinueStyle;
+        case "flat_style":
+        default:
+            return mergeFlatStyle;
+    }
+}
+function osKey() {
+    if (process.platform === "darwin")
+        return "darwin";
+    if (process.platform === "win32")
+        return "win32";
+    return "linux";
+}
+export function detectClientsFromRegistry(registry) {
+    const current = osKey();
+    const out = [];
+    for (const cp of [...registry.mcpClientProfiles].sort((a, b) => a.sortOrder - b.sortOrder || a.code.localeCompare(b.code))) {
+        const paths = cp.osPaths?.[current] ?? [];
+        for (const p of paths) {
+            const configPath = expandPath(p);
+            out.push({
+                code: cp.code,
+                name: cp.name,
+                configPath,
+                merge: mergeForStrategy(cp.mergeStrategy),
+            });
+        }
+    }
+    return out.filter((c) => existsSync(join(c.configPath, "..")));
 }
 export function writeClientConfig(client, serverBlock) {
     const dir = join(client.configPath, "..");
@@ -107,9 +101,20 @@ export function writeClientConfig(client, serverBlock) {
     const existing = existsSync(client.configPath) ? readFileSync(client.configPath, "utf-8") : "";
     writeFileSync(client.configPath, client.merge(existing, serverBlock), "utf-8");
 }
-export function nexarchServerBlock() {
+export function nexarchServerBlockFromRegistry(registry) {
+    const first = [...registry.mcpClientProfiles].sort((a, b) => a.sortOrder - b.sortOrder || a.code.localeCompare(b.code))[0];
+    if (!first) {
+        throw new Error("Nexarch integration registry is missing MCP client profiles.");
+    }
     return {
-        command: "npx",
-        args: ["-y", "nexarch@latest", "mcp-proxy"],
+        command: first.serverCommand,
+        args: first.serverArgs,
     };
 }
+export function findClientProfile(registry, code) {
+    const normalized = code.trim().toLowerCase();
+    if (normalized === "continue") {
+        return registry.mcpClientProfiles.find((c) => c.code === "continue-dev") ?? null;
+    }
+    return registry.mcpClientProfiles.find((c) => c.code === normalized) ?? null;
+}

package/dist/lib/mcp.js

@@ -33,7 +33,13 @@ async function callMcpRpc(method, params = {}, options = {}) {
                     const raw = Buffer.concat(chunks).toString("utf-8");
                     const json = JSON.parse(raw);
                     if (json.error) {
-                        reject(new Error(json.error.message));
+                        const detail = json.error.data &&
+                            typeof json.error.data === "object" &&
+                            "detail" in json.error.data &&
+                            typeof json.error.data.detail === "string"
+                            ? json.error.data.detail
+                            : null;
+                        reject(new Error(detail ? `${json.error.message} (${detail})` : json.error.message));
                     }
                     else if (json.result !== undefined) {
                         resolve(json.result);
@@ -62,7 +68,7 @@ export async function mcpInitialize(options = {}) {
     return callMcpRpc("initialize", {
         protocolVersion: "2024-11-05",
         capabilities: {},
-        clientInfo: { name: "nexarch-cli", version: "0.3.1" },
+        clientInfo: { name: "nexarch-cli", version: "0.4.2" },
     }, options);
 }
 export async function mcpListTools(options = {}) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nexarch",
-  "version": "0.3.1",
-  "description": "Connect AI coding tools to your Nexarch architecture workspace",
+  "version": "0.4.2",
+  "description": "Your architecture workspace for AI delivery.",
   "keywords": [
     "nexarch",
     "mcp",