alegra-data-agent 0.2.3 → 0.2.5

package/dist/installer.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
-import { fetchManifest, fetchSkillFile } from "./api.js";
+import { copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { AuthRequiredError, fetchManifest, fetchSkillFile } from "./api.js";
 import { dim, gray, green, logError, red, yellow } from "./colors.js";
-import { adaptStdioCommand, ensureDir, getLockFilePath, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getOpenCodeLegacyPromptsDir, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.js";
+import { adaptStdioCommand, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getLockFilePath, getOpenCodeLegacyPromptsDir, getPackageVersion, readLockFile, sha256File, writeLockFile, } from "./lib.js";
 import { inlineReferences, renderMcpForTarget } from "./render.js";
 import { TARGETS, detectInstalledTargets } from "./targets.js";
 const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -44,6 +44,17 @@ function mcpConfigHash(mcp) {
     });
     return createHash("sha256").update(salient).digest("hex");
 }
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    const o = value;
+    return `{${Object.keys(o)
+        .sort()
+        .map((k) => `${JSON.stringify(k)}:${stableStringify(o[k])}`)
+        .join(",")}}`;
+}
 function safeJoinSkillFile(skillRoot, rel) {
     const candidate = resolve(skillRoot, rel);
     const root = resolve(skillRoot);
@@ -73,33 +84,51 @@ export function verifyInstalledFiles(dir, entry) {
 function sha256Buffer(buf) {
     return createHash("sha256").update(buf).digest("hex");
 }
+const DOWNLOAD_CONCURRENCY = 8;
+async function mapWithLimit(items, limit, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        for (;;) {
+            const i = next++;
+            if (i >= items.length)
+                return;
+            out[i] = await fn(items[i]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return out;
+}
 async function stageSkill(skillName, entry) {
     validateSkillName(skillName);
     for (const rel of entry.files)
         validateRelPath(rel);
-    const staged = [];
-    for (const rel of entry.files) {
+    return mapWithLimit(entry.files, DOWNLOAD_CONCURRENCY, async (rel) => {
         const data = await fetchSkillFile(skillName, rel);
         const actualHash = sha256Buffer(data);
         const expectedHash = entry.sha256[rel];
         if (actualHash !== expectedHash) {
             throw new Error(`hash inválido para ${skillName}/${rel}: esperaba ${expectedHash.slice(0, 12)}…, recibido ${actualHash.slice(0, 12)}…`);
         }
-        staged.push({ rel, data });
-    }
-    return staged;
+        return { rel, data };
+    });
+}
+function skillDirsFor(spec) {
+    return [spec.skillsDir, ...(spec.mirrorSkillsDirs ?? [])];
 }
 function writeSkillToTarget(skillName, staged, spec) {
     validateSkillName(skillName);
     if (spec.skillFormat === "folder") {
-        const dst = join(spec.skillsDir, skillName);
-        if (existsSync(dst))
-            rmSync(dst, { recursive: true, force: true });
-        ensureDir(dst);
-        for (const f of staged) {
-            const dstFile = safeJoinSkillFile(dst, f.rel);
-            ensureDir(dirname(dstFile));
-            writeFileSync(dstFile, f.data);
+        for (const base of skillDirsFor(spec)) {
+            const dst = join(base, skillName);
+            if (existsSync(dst))
+                withFsRetry(() => rmSync(dst, { recursive: true, force: true }));
+            ensureDir(dst);
+            for (const f of staged) {
+                const dstFile = safeJoinSkillFile(dst, f.rel);
+                ensureDir(dirname(dstFile));
+                withFsRetry(() => writeFileSync(dstFile, f.data));
+            }
         }
         return;
     }
@@ -151,6 +180,22 @@ function parseFrontmatterMinimal(content) {
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
+function withFsRetry(fn) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            fn();
+            return;
+        }
+        catch (err) {
+            const code = err.code;
+            if (attempt < 4 && (code === "EPERM" || code === "EBUSY" || code === "EACCES")) {
+                sleepSync(150);
+                continue;
+            }
+            throw err;
+        }
+    }
+}
 function atomicWriteFile(path, content) {
     ensureDir(dirname(path));
     const tmp = `${path}.${process.pid}.tmp`;
@@ -174,11 +219,30 @@ function atomicWriteFile(path, content) {
         }
     }
 }
+const MAX_BACKUPS = 3;
+const backedUpThisRun = new Set();
 function backupIfExists(path) {
     if (!existsSync(path))
         return;
-    const bak = `${path}.bak-${Date.now()}`;
-    copyFileSync(path, bak);
+    if (backedUpThisRun.has(path))
+        return;
+    copyFileSync(path, `${path}.bak-${Date.now()}`);
+    backedUpThisRun.add(path);
+    pruneBackups(path);
+}
+function pruneBackups(path) {
+    try {
+        const dir = dirname(path);
+        const prefix = `${basename(path)}.bak-`;
+        const stale = readdirSync(dir)
+            .filter((f) => f.startsWith(prefix))
+            .sort()
+            .slice(0, -MAX_BACKUPS);
+        for (const f of stale)
+            rmSync(join(dir, f), { force: true });
+    }
+    catch {
+    }
 }
 function readJsonOrEmpty(path) {
     if (!existsSync(path))
@@ -266,6 +330,19 @@ export function upsertTomlBlock(content, name, block) {
     const sep = content.endsWith("\n\n") ? "" : content.endsWith("\n") ? "\n" : "\n\n";
     return `${content}${sep}${fenced}\n`;
 }
+export function extractTomlBlock(content, name) {
+    const { begin, end } = tomlMarkers(name);
+    const bi = content.indexOf(begin);
+    if (bi === -1)
+        return null;
+    const ei = content.indexOf(end, bi);
+    if (ei === -1)
+        return null;
+    return content
+        .slice(bi + begin.length, ei)
+        .replace(/^\n/, "")
+        .replace(/\n$/, "");
+}
 export function removeTomlBlock(content, name) {
     const { begin, end } = tomlMarkers(name);
     const bi = content.indexOf(begin);
@@ -283,9 +360,7 @@ export function removeTomlBlock(content, name) {
     return content.slice(0, start) + content.slice(stop);
 }
 function registerMcpInTomlBlock(mcp, spec) {
-    const existing = existsSync(spec.mcpConfigPath)
-        ? readFileSync(spec.mcpConfigPath, "utf-8")
-        : "";
+    const existing = existsSync(spec.mcpConfigPath) ? readFileSync(spec.mcpConfigPath, "utf-8") : "";
     const next = upsertTomlBlock(existing, mcp.name, renderMcpToml(mcp));
     if (next === existing)
         return;
@@ -303,14 +378,47 @@ function unregisterMcpInTomlBlock(name, spec) {
     atomicWriteFile(spec.mcpConfigPath, next);
     return true;
 }
+export function inspectMcpInTarget(mcp, spec) {
+    try {
+        if (!existsSync(spec.mcpConfigPath))
+            return "missing";
+        if (spec.mcpMechanism === "toml-block") {
+            const block = extractTomlBlock(readFileSync(spec.mcpConfigPath, "utf-8"), mcp.name);
+            if (block === null)
+                return "missing";
+            return block.trim() === renderMcpToml(mcp).trim() ? "ok" : "modified";
+        }
+        const cfg = JSON.parse(readFileSync(spec.mcpConfigPath, "utf-8"));
+        const section = cfg[spec.mcpRootKey];
+        if (!section || typeof section !== "object")
+            return "missing";
+        const current = section[mcp.name];
+        if (current === undefined)
+            return "missing";
+        return stableStringify(current) === stableStringify(renderMcpForTarget(mcp, spec))
+            ? "ok"
+            : "modified";
+    }
+    catch {
+        return "missing";
+    }
+}
+function mcpMissingInTargets(mcp, targets) {
+    return targets.filter((id) => inspectMcpInTarget(mcp, TARGETS[id]) === "missing");
+}
+const cleanedTargets = new Set();
 function resolveTargets(opts) {
     const ids = opts.targets?.length ? opts.targets : detectInstalledTargets();
     if (ids.length === 0) {
         ids.push("claude-code");
     }
     const specs = ids.map((id) => TARGETS[id]);
-    for (const spec of specs)
+    for (const spec of specs) {
+        if (cleanedTargets.has(spec.id))
+            continue;
+        cleanedTargets.add(spec.id);
         cleanupLegacySkillArtifacts(spec);
+    }
     return specs;
 }
 const LEGACY_RENAMED_SKILLS = ["alanube", "alegra-producto", "alegra-ce-universe"];
@@ -346,10 +454,12 @@ function stripMcpEntries(path, names) {
 function cleanupLegacySkillArtifacts(spec) {
     try {
         if (spec.skillFormat === "folder") {
-            for (const old of LEGACY_RENAMED_SKILLS) {
-                const dir = join(spec.skillsDir, old);
-                if (existsSync(dir))
-                    rmSync(dir, { recursive: true, force: true });
+            for (const base of skillDirsFor(spec)) {
+                for (const old of LEGACY_RENAMED_SKILLS) {
+                    const dir = join(base, old);
+                    if (existsSync(dir))
+                        rmSync(dir, { recursive: true, force: true });
+                }
             }
         }
         const lock = readLockFile();
@@ -368,12 +478,19 @@ function cleanupLegacySkillArtifacts(spec) {
             stripMcpEntries(getClaudeSettingsPath(), ourMcps);
         }
         if (spec.id === "antigravity") {
-            for (const name of [...Object.keys(lock.skills), ...LEGACY_RENAMED_SKILLS]) {
-                const d = join(getAntigravityLegacySkillsDir(), name);
-                if (existsSync(d))
-                    rmSync(d, { recursive: true, force: true });
+            const legacySkillDirs = [
+                getAntigravityLegacySkillsDir(),
+                getAntigravityGeminiLegacySkillsDir(),
+            ];
+            for (const base of legacySkillDirs) {
+                for (const name of [...Object.keys(lock.skills), ...LEGACY_RENAMED_SKILLS]) {
+                    const d = join(base, name);
+                    if (existsSync(d))
+                        rmSync(d, { recursive: true, force: true });
+                }
             }
             stripMcpEntries(getAntigravityLegacyMcpConfigPath(), ourMcps);
+            stripMcpEntries(getAntigravityGeminiLegacyMcpConfigPath(), ourMcps);
         }
     }
     catch {
@@ -411,35 +528,56 @@ export async function installSkill(name, manifest, opts = {}) {
             targets: targetIds,
         };
     }
+    let staged;
     try {
-        const staged = await stageSkill(name, entry);
-        for (const t of targets) {
-            writeSkillToTarget(name, staged, t);
-        }
-        lock.skills[name] = {
-            name,
-            installedFrom: getPackageVersion(),
-            installedAt: new Date().toISOString(),
-            bundleHash: entry.bundleHash,
-            targets: targetIds,
-        };
-        writeLockFile(lock);
+        staged = await stageSkill(name, entry);
+    }
+    catch (err) {
+        if (err instanceof AuthRequiredError)
+            throw err;
         return {
             name,
             kind: "skill",
-            status: prev ? "updated" : "installed",
+            status: "failed",
             targets: targetIds,
+            error: err instanceof Error ? err.message : String(err),
         };
     }
-    catch (err) {
+    const okTargets = [];
+    const failures = [];
+    for (const t of targets) {
+        try {
+            writeSkillToTarget(name, staged, t);
+            okTargets.push(t.id);
+        }
+        catch (err) {
+            failures.push(`${t.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (okTargets.length === 0) {
         return {
             name,
             kind: "skill",
             status: "failed",
             targets: targetIds,
-            error: err instanceof Error ? err.message : String(err),
+            error: failures.join("; "),
         };
     }
+    lock.skills[name] = {
+        name,
+        installedFrom: getPackageVersion(),
+        installedAt: new Date().toISOString(),
+        bundleHash: entry.bundleHash,
+        targets: okTargets,
+    };
+    writeLockFile(lock);
+    return {
+        name,
+        kind: "skill",
+        status: prev ? "updated" : "installed",
+        targets: okTargets,
+        error: failures.length > 0 ? `targets con fallo — ${failures.join("; ")}` : undefined,
+    };
 }
 export function installMcp(mcp, opts = {}) {
     try {
@@ -470,7 +608,14 @@ export function installMcp(mcp, opts = {}) {
     const targetsMatch = prev?.targets &&
         prev.targets.length === targetIds.length &&
         prev.targets.every((t) => targetIds.includes(t));
-    if (prev && targetsMatch && prev.configHash === mcpConfigHash(mcp) && !opts.force) {
+    const configChanged = !prev || prev.configHash !== mcpConfigHash(mcp);
+    const writeTargets = opts.force || configChanged
+        ? wantedTargets
+        : wantedTargets.filter((t) => inspectMcpInTarget(mcp, t) === "missing");
+    const alreadyThere = wantedTargets
+        .filter((t) => !writeTargets.includes(t) && inspectMcpInTarget(mcp, t) !== "missing")
+        .map((t) => t.id);
+    if (writeTargets.length === 0 && targetsMatch) {
         return { name: mcp.name, kind: "mcp", status: "unchanged", targets: targetIds };
     }
     if (opts.dryRun) {
@@ -478,37 +623,45 @@ export function installMcp(mcp, opts = {}) {
             name: mcp.name,
             kind: "mcp",
             status: prev ? "updated" : "installed",
-            targets: targetIds,
+            targets: writeTargets.map((t) => t.id),
         };
     }
-    try {
-        for (const t of wantedTargets) {
+    const written = [];
+    const failures = [];
+    for (const t of writeTargets) {
+        try {
             registerMcpInTarget(mcp, t);
+            written.push(t.id);
+        }
+        catch (err) {
+            failures.push(`${t.id}: ${err instanceof Error ? err.message : String(err)}`);
         }
-        lock.mcps[mcp.name] = {
-            name: mcp.name,
-            installedFrom: getPackageVersion(),
-            installedAt: new Date().toISOString(),
-            configHash: mcpConfigHash(mcp),
-            targets: targetIds,
-        };
-        writeLockFile(lock);
-        return {
-            name: mcp.name,
-            kind: "mcp",
-            status: prev ? "updated" : "installed",
-            targets: targetIds,
-        };
     }
-    catch (err) {
+    const okTargets = [...new Set([...alreadyThere, ...written])];
+    if (okTargets.length === 0) {
         return {
             name: mcp.name,
             kind: "mcp",
             status: "failed",
             targets: targetIds,
-            error: err instanceof Error ? err.message : String(err),
+            error: failures.join("; "),
         };
     }
+    lock.mcps[mcp.name] = {
+        name: mcp.name,
+        installedFrom: getPackageVersion(),
+        installedAt: new Date().toISOString(),
+        configHash: mcpConfigHash(mcp),
+        targets: okTargets,
+    };
+    writeLockFile(lock);
+    return {
+        name: mcp.name,
+        kind: "mcp",
+        status: prev ? "updated" : "installed",
+        targets: okTargets,
+        error: failures.length > 0 ? `targets con fallo — ${failures.join("; ")}` : undefined,
+    };
 }
 export async function installAll(opts = {}) {
     let manifest;
@@ -561,9 +714,11 @@ export function uninstallSkill(name, opts = {}) {
         for (const tId of targetIds) {
             const spec = TARGETS[tId];
             if (spec.skillFormat === "folder") {
-                const dst = join(spec.skillsDir, name);
-                if (existsSync(dst))
-                    rmSync(dst, { recursive: true, force: true });
+                for (const base of skillDirsFor(spec)) {
+                    const dst = join(base, name);
+                    if (existsSync(dst))
+                        rmSync(dst, { recursive: true, force: true });
+                }
             }
             else {
                 const ext = spec.skillFormat === "cursor-mdc" ? ".mdc" : ".md";
@@ -621,6 +776,15 @@ export function uninstallAll(opts = {}) {
         results.push(uninstallSkill(name, opts));
     for (const name of Object.keys(lock.mcps ?? {}))
         results.push(uninstallMcp(name, opts));
+    if (!opts.dryRun) {
+        for (const spec of Object.values(TARGETS)) {
+            try {
+                cleanupLegacySkillArtifacts(spec);
+            }
+            catch {
+            }
+        }
+    }
     return results;
 }
 export function detectDrift(manifest) {
@@ -651,16 +815,27 @@ export function detectDrift(manifest) {
         toUpdate: [],
         unchanged: [],
         orphaned: [],
+        missing: [],
     };
     const manifestMcps = manifest.mcps ?? {};
     for (const name of Object.keys(manifestMcps)) {
         const prevMcp = lock.mcps?.[name];
-        if (!prevMcp)
+        if (!prevMcp) {
             mcps.toInstall.push(name);
-        else if (prevMcp.configHash !== mcpConfigHash(manifestMcps[name]))
+            continue;
+        }
+        if (prevMcp.configHash !== mcpConfigHash(manifestMcps[name])) {
             mcps.toUpdate.push(name);
-        else
+            continue;
+        }
+        const missing = mcpMissingInTargets(manifestMcps[name], (prevMcp.targets ?? []));
+        if (missing.length > 0) {
+            mcps.toUpdate.push(name);
+            mcps.missing.push(name);
+        }
+        else {
             mcps.unchanged.push(name);
+        }
     }
     for (const name of Object.keys(lock.mcps ?? {})) {
         if (!manifestMcps[name])

package/dist/lib.js

@@ -5,7 +5,7 @@ import { dirname, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 export const PRODUCT_NAME = "alegra-data-agent";
 export const COMMAND_NAME = "alegra-data-agent";
-export const REPO_SLUG = "alegradev/alegra-data-agent";
+export const REPO_SLUG = "Alegra-Team/data-agent-selfservice";
 export const REPO_DEFAULT_BRANCH = "main";
 export const GATEWAY_URL = process.env.ALEGRA_DATA_AGENT_GATEWAY_URL ?? "https://alegra-data-agent.vercel.app";
 export const ALL_TARGETS = [
@@ -19,12 +19,6 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 export function getPackageRoot() {
     return join(__dirname, "..");
 }
-export function getRegistryDir() {
-    return join(getPackageRoot(), "skills-registry");
-}
-export function getManifestPath() {
-    return join(getRegistryDir(), "index.json");
-}
 export function getClaudeSkillsDir() {
     return join(homedir(), ".claude", "skills");
 }
@@ -59,10 +53,16 @@ export function getOpenCodeConfigPath() {
     return join(base, "opencode", "opencode.json");
 }
 export function getAntigravitySkillsDir() {
-    return join(homedir(), ".gemini", "antigravity", "skills");
+    return join(homedir(), ".gemini", "antigravity-cli", "skills");
+}
+export function getAntigravityGeminiSkillsDir() {
+    return join(homedir(), ".gemini", "skills");
 }
 export function getAntigravityMcpConfigPath() {
-    return join(homedir(), ".gemini", "antigravity", "mcp_config.json");
+    return join(homedir(), ".gemini", "config", "mcp_config.json");
+}
+export function getGeminiSettingsPath() {
+    return join(homedir(), ".gemini", "settings.json");
 }
 export function getAntigravityLegacySkillsDir() {
     return join(homedir(), ".antigravity", "skills");
@@ -70,6 +70,28 @@ export function getAntigravityLegacySkillsDir() {
 export function getAntigravityLegacyMcpConfigPath() {
     return join(homedir(), ".antigravity", "settings.json");
 }
+export function getAntigravityGeminiLegacySkillsDir() {
+    return join(homedir(), ".gemini", "antigravity", "skills");
+}
+export function getAntigravityGeminiLegacyMcpConfigPath() {
+    return join(homedir(), ".gemini", "antigravity", "mcp_config.json");
+}
+export function getCursorHooksPath() {
+    return join(homedir(), ".cursor", "hooks.json");
+}
+export function getCodexHooksPath() {
+    const codexHome = process.env.CODEX_HOME;
+    const base = codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
+    return join(base, "hooks.json");
+}
+export function getOpenCodePluginsDir() {
+    const xdgHome = process.env.XDG_CONFIG_HOME;
+    const base = xdgHome && xdgHome.length > 0 ? xdgHome : join(homedir(), ".config");
+    return join(base, "opencode", "plugins");
+}
+export function getOpenCodePluginPath() {
+    return join(getOpenCodePluginsDir(), "alegra-data-agent-autoupdate.js");
+}
 export function getCodexSkillsDir() {
     return join(homedir(), ".agents", "skills");
 }
@@ -117,6 +139,15 @@ export function getConfigDir() {
 export function getAuthFilePath() {
     return join(getConfigDir(), "auth.json");
 }
+export function getLastCheckPath() {
+    return join(getConfigDir(), "last-check.json");
+}
+export function getManifestCachePath() {
+    return join(getConfigDir(), "manifest-cache.json");
+}
+export function getAutoUpdateLogPath() {
+    return join(getConfigDir(), "autoupdate.log");
+}
 let _cachedVersion = null;
 export function getPackageVersion() {
     if (_cachedVersion)
@@ -130,31 +161,29 @@ export function getPackageVersion() {
     }
     return _cachedVersion;
 }
-export function readManifest() {
-    const path = getManifestPath();
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
-    }
+let _lockCache = null;
+function emptyLock() {
+    return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
 }
 export function readLockFile() {
+    if (_lockCache)
+        return _lockCache;
     const path = getLockFilePath();
-    if (!existsSync(path)) {
-        return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
-    }
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
+    let lock = emptyLock();
+    if (existsSync(path)) {
+        try {
+            lock = JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            lock = emptyLock();
+        }
     }
+    _lockCache = lock;
+    return lock;
 }
 export function writeLockFile(lock) {
     const path = getLockFilePath();
+    _lockCache = lock;
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(lock, null, 2)}\n`, "utf-8");
 }
@@ -254,7 +283,8 @@ export function ensureDir(path) {
         mkdirSync(path, { recursive: true });
 }
 export function adaptStdioCommand(command, args, platform = process.platform) {
-    if (platform === "win32" && (command === "npx" || command === "npm" || command === "pnpm")) {
+    const winShims = new Set(["npx", "npm", "pnpm", "sf", "uvx", "bunx", "yarn", "deno"]);
+    if (platform === "win32" && winShims.has(command)) {
         return { command: "cmd", args: ["/c", command, ...args] };
     }
     return { command, args };

package/dist/main.js

@@ -37,6 +37,7 @@ function parseArgs(argv) {
         noHook: false,
         noBounce: false,
         autoUpdate: false,
+        background: false,
     };
     const positional = [];
     const only = [];
@@ -56,6 +57,8 @@ function parseArgs(argv) {
             flags.noBounce = true;
         else if (a === "--auto-update")
             flags.autoUpdate = true;
+        else if (a === "--background")
+            flags.background = true;
         else if (a === "-h" || a === "--help")
             flags.help = true;
         else if (a === "-v" || a === "--version")
@@ -128,6 +131,7 @@ async function main() {
             exitCode = await runUpdate({
                 yes: args.flags.yes,
                 dryRun: args.flags.dryRun,
+                background: args.flags.background,
                 targets: args.targets.length > 0 ? args.targets : undefined,
             });
             break;

package/dist/render.js

@@ -81,6 +81,9 @@ export function renderMcpForTarget(mcp, spec) {
         obj.type = "remote";
         obj.enabled = true;
     }
+    else if (spec.mcpHttpTypeValue) {
+        obj.type = spec.mcpHttpTypeValue;
+    }
     if (mcp.auth.type === "gateway") {
         if (!mcp.auth.tokenEnv) {
             throw new Error(`MCP '${mcp.name}' es type=gateway pero no trae tokenEnv`);