@agent-native/core 0.44.4 → 0.45.1

package/dist/cli/connect.js

@@ -8,6 +8,7 @@
  *   agent-native connect <url> [--client all|claude-code|claude-code-cli|
  *                               codex|cowork] [--scope user|project]
  *                               [--name <serverName>]
+ *   agent-native reconnect [<url>] [--client ...] [--name <serverName>]
  *   agent-native connect <url> --token <token>   (no-browser fallback)
  *   agent-native connect        [--client ...]   (pick first-party apps)
  *   agent-native connect --all  [--client ...]   (separate first-party app MCP resources)
@@ -105,8 +106,10 @@ export function parseConnectArgs(argv) {
         else if ((v = eat("--token")) !== undefined)
             out.token = v;
         else if (!a.startsWith("-") && !out.url) {
-            if (!out.mode && (a === "dev" || a === "prod"))
+            if (!out.mode &&
+                (a === "dev" || a === "prod" || a === "reauth" || a === "reconnect")) {
                 out.mode = a;
+            }
             else
                 out.url = a;
         }
@@ -713,6 +716,106 @@ function savedEntryUrl(saved) {
     const match = saved.block.match(/^\s*url\s*=\s*"((?:\\.|[^"])*)"/m);
     return match ? unescapeTomlString(match[1]) : undefined;
 }
+function readJsonMcpServerEntries(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+        const servers = parsed?.mcpServers;
+        if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+            return [];
+        }
+        return Object.entries(servers).flatMap(([serverName, entry]) => {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                return [];
+            }
+            return [
+                {
+                    serverName,
+                    saved: {
+                        kind: "json",
+                        entry: entry,
+                        savedAt: new Date().toISOString(),
+                    },
+                },
+            ];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function parseCodexMcpServerName(line) {
+    const trimmed = line.trim();
+    const quoted = trimmed.match(/^\[mcp_servers\."((?:\\.|[^"])*)"\]$/);
+    if (quoted)
+        return unescapeTomlString(quoted[1]);
+    const bare = trimmed.match(/^\[mcp_servers\.([A-Za-z0-9_-]+)\]$/);
+    return bare?.[1];
+}
+function readCodexMcpServerEntries(file) {
+    let content = "";
+    try {
+        content = fs.readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split(/\r?\n/);
+    const entries = [];
+    for (let i = 0; i < lines.length; i++) {
+        const serverName = parseCodexMcpServerName(lines[i]);
+        if (!serverName)
+            continue;
+        const block = [lines[i]];
+        i++;
+        while (i < lines.length && !/^\s*\[/.test(lines[i])) {
+            block.push(lines[i]);
+            i++;
+        }
+        i--;
+        entries.push({
+            serverName,
+            saved: {
+                kind: "codex",
+                block: block.join("\n").replace(/\n*$/, "") + "\n",
+                savedAt: new Date().toISOString(),
+            },
+        });
+    }
+    return entries;
+}
+function readExistingMcpEntries(clients, baseDir, scope) {
+    const entries = [];
+    for (const client of clients) {
+        const file = configPathFor(client, baseDir, scope);
+        const rawEntries = client === "codex"
+            ? readCodexMcpServerEntries(file)
+            : readJsonMcpServerEntries(file);
+        for (const { serverName, saved } of rawEntries) {
+            const url = savedEntryUrl(saved);
+            if (!url)
+                continue;
+            entries.push({ client, serverName, file, saved, url });
+        }
+    }
+    return entries;
+}
+function canonicalMcpUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        url.hash = "";
+        return url.toString().replace(/\/+$/, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameMcpUrl(a, b) {
+    const left = canonicalMcpUrl(a);
+    const right = canonicalMcpUrl(b);
+    return !!left && !!right && left === right;
+}
 function savedEntryHeaders(saved) {
     if (!saved)
         return {};
@@ -1031,9 +1134,77 @@ async function connectProdProfile(parsed, clients, deps) {
     logOut("  Restart your coding agent to pick up the production MCP servers.");
     return missing.length === 0;
 }
-// ---------------------------------------------------------------------------
-// Single-app connect
-// ---------------------------------------------------------------------------
+function distinctReconnectEntries(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const entry of entries) {
+        const key = `${entry.serverName}\0${canonicalMcpUrl(entry.url) ?? entry.url}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(entry);
+    }
+    return out;
+}
+function describeReconnectEntry(entry) {
+    return `${entry.serverName} (${entry.url}) in ${entry.client}`;
+}
+function resolveReconnectTarget(parsed, clients) {
+    const baseDir = projectBaseDir();
+    const scope = parsed.scope === "user" ? "user" : "project";
+    const entries = readExistingMcpEntries(clients, baseDir, scope);
+    if (parsed.url) {
+        const normalizedUrl = normalizeUrl(parsed.url);
+        const mcpUrl = mcpUrlForBaseUrl(normalizedUrl);
+        if (parsed.name) {
+            return { rawUrl: parsed.url, serverName: parsed.name };
+        }
+        const matches = distinctReconnectEntries(entries.filter((entry) => sameMcpUrl(entry.url, mcpUrl)));
+        const names = [...new Set(matches.map((entry) => entry.serverName))];
+        if (names.length === 1) {
+            return { rawUrl: parsed.url, serverName: names[0] };
+        }
+        if (names.length > 1) {
+            logErr(`  Found multiple MCP entries for ${mcpUrl}: ${names.join(", ")}.`);
+            logErr("  Re-run with --name <serverName> to choose one.");
+            return null;
+        }
+        return { rawUrl: parsed.url };
+    }
+    const candidates = distinctReconnectEntries(parsed.name
+        ? entries.filter((entry) => entry.serverName === parsed.name)
+        : entries.filter((entry) => entry.serverName.startsWith(`${SERVER_NAME_PREFIX}-`)));
+    if (candidates.length === 0) {
+        logErr("  No existing Agent Native MCP entry found to reconnect.");
+        logErr("  Pass a URL, or use --name <serverName> if the entry has a custom name.");
+        logErr("  First-time setup still uses: agent-native connect <url> --client <client>");
+        return null;
+    }
+    if (candidates.length > 1) {
+        logErr("  Found multiple Agent Native MCP entries:");
+        for (const entry of candidates) {
+            logErr(`    ${describeReconnectEntry(entry)}`);
+        }
+        logErr("  Re-run with a URL or --name <serverName>.");
+        return null;
+    }
+    const [entry] = candidates;
+    return { rawUrl: entry.url, serverName: entry.serverName };
+}
+async function reconnectOne(parsed, clients, deps) {
+    const target = resolveReconnectTarget(parsed, clients);
+    if (!target)
+        return false;
+    const effectiveParsed = {
+        ...parsed,
+        url: target.rawUrl,
+        name: target.serverName ?? parsed.name,
+    };
+    logOut("");
+    logOut(`  Reconnecting${effectiveParsed.name ? ` "${effectiveParsed.name}"` : ""}...`);
+    const res = await connectOne(target.rawUrl, effectiveParsed, clients, deps);
+    return res.ok;
+}
 async function connectOne(rawUrl, parsed, clients, deps) {
     const normalizedUrl = normalizeUrl(rawUrl);
     const baseUrl = stripMcpPath(normalizedUrl);
@@ -1097,11 +1268,45 @@ async function connectOne(rawUrl, parsed, clients, deps) {
     // a first-party Plans app, also persist `{ url, token }` to
     // `~/.agent-native/plan-publish.json` so the local Plans server can read the
     // same token for a server-to-server publish (publish-on-share). This is an
-    // ADDITIONAL write alongside the per-client MCP config; OAuth-only clients
-    // mint no local token, so this no-ops for them. Best-effort and merge-not-
-    // clobber — never fails the connect.
-    if (token && isFirstPartyPlanHost(baseUrl)) {
-        const canonicalPath = writePlanPublishAuth({ url: baseUrl, token });
+    // ADDITIONAL write alongside the per-client MCP config; Best-effort and
+    // merge-not-clobber — never fails the connect.
+    //
+    // OAuth clients (claude-code, claude-code-cli) authenticate in-host via
+    // standard MCP OAuth, so they never mint a local bearer token. To still
+    // populate the publish store for them, we run a supplemental device-flow
+    // mint using a non-OAuth client arg so the Plans server gets a usable token
+    // and `publish-visual-plan` doesn't send the user back to `agent-native
+    // connect` right after they just ran it.
+    let publishToken = token;
+    if (!publishToken &&
+        oauthClients.length > 0 &&
+        isFirstPartyPlanHost(baseUrl)) {
+        try {
+            logOut("");
+            logOut(`  Minting a publish token for the local Plans server (device flow)…`);
+            const grant = await runDeviceFlow(baseUrl, appSlug, 
+            // Use a non-OAuth client arg so the server mints a bearer token even
+            // though our primary clients are OAuth-native. "codex" is a stable,
+            // always-supported non-OAuth client identifier.
+            "codex", deps);
+            if (grant?.token) {
+                publishToken = grant.token;
+            }
+            else {
+                logOut(`  Warning: could not mint a publish token for the local Plans ` +
+                    `server. You can still publish via the hosted UI.`);
+            }
+        }
+        catch {
+            logOut(`  Warning: publish-token mint failed. You can still publish via the ` +
+                `hosted UI.`);
+        }
+    }
+    if (publishToken && isFirstPartyPlanHost(baseUrl)) {
+        const canonicalPath = writePlanPublishAuth({
+            url: baseUrl,
+            token: publishToken,
+        });
         if (canonicalPath) {
             logOut("");
             logOut(`  Saved publish token for the local Plans server → ${canonicalPath}`);
@@ -1200,6 +1405,13 @@ Usage:
       No-browser fallback. Skip the device flow and write the entry with
       the supplied token (get it from the app's Connect page).
 
+  agent-native reconnect [<url>] [--client <c>] [--scope user|project]
+  agent-native connect reconnect [<url>] [--client <c>] [--scope user|project]
+      Re-authenticate an existing MCP entry without reinstalling apps/skills.
+      With a URL, it reuses the existing server name for that MCP URL when
+      possible. Without a URL, it reconnects the only matching Agent Native
+      entry in the selected client config. Use --name for custom server names.
+
   agent-native connect --all [--client <c>] [--scope user|project]
       Connect every first-party hosted app as separate MCP resources.
 
@@ -1234,7 +1446,9 @@ export async function runConnect(args, deps = {}) {
                 return;
             const ok = parsed.mode === "dev"
                 ? await connectDevProfile(parsed, clients, deps)
-                : await connectProdProfile(parsed, clients, deps);
+                : parsed.mode === "prod"
+                    ? await connectProdProfile(parsed, clients, deps)
+                    : await reconnectOne(parsed, clients, deps);
             if (!ok)
                 process.exitCode = 1;
             return;