alegra-data-agent 0.4.4 → 0.5.1

package/dist/installer.js

@@ -1,12 +1,12 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmodSync, copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { appendFileSync, chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, 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 { AuthRequiredError, fetchManifest, fetchSkillFile, recordManifestFloor } from "./api.js";
+import { dim, gray, green, logError, logWarn, red, yellow } from "./colors.js";
 import { ensureLazyProxy, lazyMcpDir, lazyProxyPath, lazyToolsPath, stdioLaunch, } from "./lazy-mcp.js";
-import { ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getOpenCodeLegacyPromptsDir, getPackageVersion, getUserScopeMcpConfigPath, isMcpScopeEnvOverride, readLockFile, sha256File, writeLockFile, } from "./lib.js";
-import { inlineReferences, renderHermesMcpOps, renderMcpForTarget, } from "./render.js";
+import { computeBundleHash, ensureDir, getAntigravityGeminiLegacyMcpConfigPath, getAntigravityGeminiLegacySkillsDir, getAntigravityLegacyMcpConfigPath, getAntigravityLegacySkillsDir, getClaudeSettingsPath, getConfigDir, getCursorLegacyRulesDir, getHermesBin, getLockFilePath, getMcpScopeDir, getMcpScopeWarning, getOpenCodeLegacyPromptsDir, getPackageVersion, getUserScopeMcpConfigPath, isMcpScopeEnvOverride, readLockFile, sha256File, walkSkillFiles, writeLockFile, } from "./lib.js";
+import { renderHermesMcpOps, renderMcpForTarget } from "./render.js";
 import { TARGETS, detectInstalledTargets } from "./targets.js";
 const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 const MCP_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
@@ -120,66 +120,100 @@ async function stageSkill(skillName, entry) {
 function skillDirsFor(spec) {
     return [spec.skillsDir, ...(spec.mirrorSkillsDirs ?? [])];
 }
-function writeSkillToTarget(skillName, staged, spec) {
-    validateSkillName(skillName);
-    if (spec.skillFormat === "folder") {
-        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));
-            }
+const OS_JUNK_FILES = new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+function diskBundleHash(dir) {
+    const shas = {};
+    for (const rel of walkSkillFiles(dir)) {
+        if (OS_JUNK_FILES.has(basename(rel)))
+            continue;
+        shas[rel] = sha256File(join(dir, rel));
+    }
+    return computeBundleHash(shas);
+}
+function localDateStamp(d = new Date()) {
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+export function skillBackupRoot(target) {
+    return join(getConfigDir(), "backups", target);
+}
+export function skillBackupLogPath() {
+    return join(getConfigDir(), "backups", "backups.log");
+}
+function moveToBackup(dir, skillName, backupRoot) {
+    mkdirSync(backupRoot, { recursive: true });
+    const base = join(backupRoot, `${skillName}-${localDateStamp()}`);
+    let dst = base;
+    for (let n = 2; existsSync(dst); n++)
+        dst = `${base}-${n}`;
+    try {
+        withFsRetry(() => renameSync(dir, dst));
+    }
+    catch (err) {
+        if (err.code !== "EXDEV")
+            throw err;
+        cpSync(dir, dst, { recursive: true });
+        withFsRetry(() => rmSync(dir, { recursive: true, force: true }));
+    }
+    return dst;
+}
+function noteSkillBackup(skillName, from, to) {
+    const line = `${skillName}: tenías cambios locales en ${from}; los guardé en ${to} antes de actualizar.`;
+    logWarn(line);
+    try {
+        mkdirSync(dirname(skillBackupLogPath()), { recursive: true });
+        appendFileSync(skillBackupLogPath(), `${new Date().toISOString()} ${line}\n`);
+    }
+    catch {
+    }
+}
+export function replaceSkillDir(dst, skillName, staged, opts) {
+    let backup = null;
+    if (existsSync(dst)) {
+        const known = new Set(opts.knownBundleHashes.filter((h) => !!h));
+        if (!known.has(diskBundleHash(dst))) {
+            backup = moveToBackup(dst, skillName, opts.backupRoot);
+            noteSkillBackup(skillName, dst, backup);
+        }
+        else {
+            withFsRetry(() => rmSync(dst, { recursive: true, force: true }));
         }
-        return;
     }
-    const entry = staged.find((f) => f.rel === "SKILL.md") ?? staged.find((f) => f.rel === "README.md");
-    if (!entry) {
-        throw new Error(`Para target ${spec.id} se requiere SKILL.md o README.md en la skill`);
-    }
-    const references = staged
-        .filter((f) => f.rel !== "SKILL.md" && f.rel !== "README.md")
-        .map((f) => ({ rel: f.rel, text: new TextDecoder().decode(f.data) }));
-    const content = new TextDecoder().decode(entry.data);
-    const rendered = renderSkillForTargetFromContent(content, skillName, spec.skillFormat, references);
-    ensureDir(spec.skillsDir);
-    const dst = join(spec.skillsDir, rendered.filename);
-    atomicWriteFile(dst, rendered.content);
-}
-function renderSkillForTargetFromContent(content, skillName, format, references = []) {
-    if (format === "folder") {
-        throw new Error("renderSkillForTargetFromContent no soporta 'folder'");
-    }
-    const stripped = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").replace(/^\s+/, "");
-    const body = stripped + inlineReferences(references);
-    const fm = parseFrontmatterMinimal(content);
-    if (format === "cursor-mdc") {
-        const desc = fm.description ?? `Skill ${skillName}`;
-        const cursorDesc = desc.startsWith("USE WHEN") ? desc : `USE WHEN ${desc}`;
-        const safeDesc = cursorDesc.replace(/\n/g, " ").replace(/"/g, '\\"');
-        return {
-            filename: `${skillName}.mdc`,
-            content: `---\ndescription: "${safeDesc}"\nalwaysApply: false\n---\n\n${body}`,
-        };
+    ensureDir(dst);
+    for (const f of staged) {
+        const dstFile = safeJoinSkillFile(dst, f.rel);
+        ensureDir(dirname(dstFile));
+        withFsRetry(() => writeFileSync(dstFile, f.data));
     }
-    return { filename: `${skillName}.md`, content: body };
+    return backup;
 }
-function parseFrontmatterMinimal(content) {
-    const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!m)
-        return {};
-    const out = {};
-    for (const line of m[1].split(/\r?\n/)) {
-        const kv = line.match(/^description:\s*(.+)$/);
-        if (kv) {
-            out.description = kv[1].replace(/^["']|["']$/g, "").trim();
-            return out;
+function assertFolderFormat(spec) {
+    if (spec.skillFormat !== "folder") {
+        throw new Error(`formato de skill no soportado para ${spec.id}: ${spec.skillFormat}`);
+    }
+}
+function writeSkillToTarget(skillName, staged, spec, knownBundleHashes) {
+    validateSkillName(skillName);
+    assertFolderFormat(spec);
+    for (const base of skillDirsFor(spec)) {
+        replaceSkillDir(join(base, skillName), skillName, staged, {
+            knownBundleHashes,
+            backupRoot: skillBackupRoot(spec.id),
+        });
+    }
+}
+function brokenSkillDirs(name, entry, specs) {
+    const broken = [];
+    for (const spec of specs) {
+        if (spec.skillFormat !== "folder")
+            continue;
+        for (const base of skillDirsFor(spec)) {
+            const dir = join(base, name);
+            if (!verifyInstalledFiles(dir, entry).ok)
+                broken.push(dir);
         }
     }
-    return out;
+    return broken;
 }
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -885,14 +919,7 @@ export async function installSkill(name, manifest, opts = {}) {
         prev.targets.length === targetIds.length &&
         prev.targets.every((t) => targetIds.includes(t));
     if (prev && prev.bundleHash === entry.bundleHash && targetsMatch && !opts.force) {
-        const folderTarget = targets.find((t) => t.skillFormat === "folder");
-        if (folderTarget) {
-            const dst = join(folderTarget.skillsDir, name);
-            const drift = verifyInstalledFiles(dst, entry);
-            if (drift.ok)
-                return { name, kind: "skill", status: "unchanged", targets: targetIds };
-        }
-        else {
+        if (brokenSkillDirs(name, entry, targets).length === 0) {
             return { name, kind: "skill", status: "unchanged", targets: targetIds };
         }
     }
@@ -923,7 +950,7 @@ export async function installSkill(name, manifest, opts = {}) {
     const failures = [];
     for (const t of targets) {
         try {
-            writeSkillToTarget(name, staged, t);
+            writeSkillToTarget(name, staged, t, [prev?.bundleHash, entry.bundleHash]);
             okTargets.push(t.id);
         }
         catch (err) {
@@ -1193,6 +1220,8 @@ export async function installAll(opts = {}) {
         }
         results.push(installMcp(mcp, { ...opts, targets }));
     }
+    if (!opts.dryRun)
+        recordManifestFloor(manifest);
     return { manifest, results, targets };
 }
 export function uninstallSkill(name, opts = {}) {
@@ -1216,18 +1245,10 @@ export function uninstallSkill(name, opts = {}) {
     if (!opts.dryRun) {
         for (const tId of targetIds) {
             const spec = TARGETS[tId];
-            if (spec.skillFormat === "folder") {
-                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";
-                const dst = join(spec.skillsDir, `${name}${ext}`);
+            for (const base of skillDirsFor(spec)) {
+                const dst = join(base, name);
                 if (existsSync(dst))
-                    rmSync(dst, { force: true });
+                    rmSync(dst, { recursive: true, force: true });
             }
         }
         delete lock.skills[name];
@@ -1316,13 +1337,22 @@ export function detectDrift(manifest) {
     const toUpdate = [];
     const unchanged = [];
     const orphaned = [];
+    const detected = new Set(detectInstalledTargets());
     for (const name of Object.keys(manifest.skills)) {
         const prev = lock.skills[name];
         if (!prev) {
             toInstall.push(name);
             continue;
         }
-        if (prev.bundleHash !== manifest.skills[name].bundleHash) {
+        const entry = manifest.skills[name];
+        if (prev.bundleHash !== entry.bundleHash) {
+            toUpdate.push(name);
+            continue;
+        }
+        const specs = (prev.targets ?? ["claude-code"])
+            .filter((t) => detected.has(t) && TARGETS[t])
+            .map((t) => TARGETS[t]);
+        if (brokenSkillDirs(name, entry, specs).length > 0) {
             toUpdate.push(name);
         }
         else {

package/dist/lazy-mcp.js

@@ -58,6 +58,8 @@ const spec = JSON.parse(readFileSync(argv[0], "utf8"));
 const [cmd, ...args] = argv.slice(2);
 const INIT_ID = "__alegra_lazy_init__";
 const START_TIMEOUT_MS = 10 * 60 * 1000;
+const LEVELS = ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"];
+let logLevel = "info";
 
 const send = (m) => process.stdout.write(JSON.stringify(m) + "\\n");
 const key = (id) => JSON.stringify(id);
@@ -102,8 +104,23 @@ function forward(m) {
   child.stdin.write(JSON.stringify(m) + "\\n");
 }
 
-function start() {
+function notifyStarting(trigger) {
+  const text =
+    "Preparando " + spec.name + ": la primera vez tarda 1-2 min mientras se descarga " +
+    "(las siguientes llamadas de la sesión son inmediatas).";
+  process.stderr.write("[" + spec.name + "] " + text + "\\n");
+  if (LEVELS.indexOf(logLevel) <= LEVELS.indexOf("info")) {
+    send({ jsonrpc: "2.0", method: "notifications/message", params: { level: "info", logger: spec.name, data: text } });
+  }
+  const token = trigger && trigger.params && trigger.params._meta && trigger.params._meta.progressToken;
+  if (token !== undefined && token !== null) {
+    send({ jsonrpc: "2.0", method: "notifications/progress", params: { progressToken: token, progress: 0, message: text } });
+  }
+}
+
+function start(trigger) {
   if (child || dead) return;
+  notifyStarting(trigger);
   child = spawn(cmd, args, { stdio: ["pipe", "pipe", "inherit"] });
   startTimer = setTimeout(
     () => die("El MCP " + spec.name + " tardó más de 10 min en arrancar (¿se cortó la descarga?). Reintentá en una sesión nueva."),
@@ -152,7 +169,7 @@ createInterface({ input: process.stdin }).on("line", (line) => {
         id: m.id,
         result: {
           protocolVersion: spec.protocolVersion ?? initParams.protocolVersion ?? "2025-06-18",
-          capabilities: { tools: {} },
+          capabilities: { tools: {}, logging: {} },
           serverInfo: { name: spec.name, version: "lazy" },
         },
       });
@@ -160,6 +177,10 @@ createInterface({ input: process.stdin }).on("line", (line) => {
     case "ping":
       send({ jsonrpc: "2.0", id: m.id, result: {} });
       return;
+    case "logging/setLevel":
+      if (LEVELS.includes(m.params?.level)) logLevel = m.params.level;
+      send({ jsonrpc: "2.0", id: m.id, result: {} });
+      return;
     case "tools/list":
       send({ jsonrpc: "2.0", id: m.id, result: { tools: spec.tools } });
       return;
@@ -185,7 +206,7 @@ createInterface({ input: process.stdin }).on("line", (line) => {
     return;
   }
   queue.push(m);
-  start();
+  start(m);
 });
 
 function shutdown() {

package/dist/lib.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -7,7 +7,34 @@ export const PRODUCT_NAME = "alegra-data-agent";
 export const COMMAND_NAME = "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 DEFAULT_GATEWAY_URL = "https://alegra-data-agent.vercel.app";
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost"]);
+export function resolveGatewayUrl(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return { url: DEFAULT_GATEWAY_URL };
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        return {
+            url: DEFAULT_GATEWAY_URL,
+            warning: `ALEGRA_DATA_AGENT_GATEWAY_URL no es una URL válida ('${raw}'); uso ${DEFAULT_GATEWAY_URL}.`,
+        };
+    }
+    if (parsed.protocol === "https:")
+        return { url: raw };
+    if (parsed.protocol === "http:" && LOOPBACK_HOSTS.has(parsed.hostname))
+        return { url: raw };
+    return {
+        url: DEFAULT_GATEWAY_URL,
+        warning: `ALEGRA_DATA_AGENT_GATEWAY_URL debe ser https:// (http:// solo para 127.0.0.1/localhost); ignoro '${raw}' y uso ${DEFAULT_GATEWAY_URL}.`,
+    };
+}
+const _gateway = resolveGatewayUrl(process.env.ALEGRA_DATA_AGENT_GATEWAY_URL);
+if (_gateway.warning)
+    process.stderr.write(`  ⚠ ${_gateway.warning}\n`);
+export const GATEWAY_URL = _gateway.url;
 export const ALL_TARGETS = [
     "claude-code",
     "cursor",
@@ -278,27 +305,226 @@ let _lockCache = null;
 function emptyLock() {
     return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
 }
+function warn(message) {
+    process.stderr.write(`  ⚠ ${message}\n`);
+}
+function isLockShape(v) {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return false;
+    const skills = v.skills;
+    return !!skills && typeof skills === "object" && !Array.isArray(skills);
+}
 export function readLockFile() {
     if (_lockCache)
         return _lockCache;
     const path = getLockFilePath();
     let lock = emptyLock();
     if (existsSync(path)) {
+        let parsed;
+        let ok = false;
         try {
-            lock = JSON.parse(readFileSync(path, "utf-8"));
+            parsed = JSON.parse(readFileSync(path, "utf-8"));
+            ok = isLockShape(parsed);
         }
         catch {
-            lock = emptyLock();
+            ok = false;
+        }
+        if (ok) {
+            lock = parsed;
+        }
+        else {
+            const backup = `${path}.corrupt-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+            try {
+                renameSync(path, backup);
+                warn(`El lock del agente (${path}) estaba corrupto: lo aparté en ${backup} y sigo como si no hubiera nada instalado. Un \`install\` lo regenera.`);
+            }
+            catch {
+                warn(`El lock del agente (${path}) está corrupto y no pude apartarlo; lo leo como vacío.`);
+            }
         }
     }
     _lockCache = lock;
     return lock;
 }
-export function writeLockFile(lock) {
+export const LOCKFILE_STALE_MS = 60_000;
+export const LOCKFILE_MAX_WAIT_MS = 10_000;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function tryCreateLock(lockPath) {
+    let fd;
+    try {
+        fd = openSync(lockPath, "wx");
+    }
+    catch (err) {
+        if (err.code === "EEXIST")
+            return false;
+        throw err;
+    }
+    try {
+        writeSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
+    }
+    finally {
+        closeSync(fd);
+    }
+    return true;
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+function lockIsStale(lockPath) {
+    let at;
+    let pid;
+    try {
+        const raw = JSON.parse(readFileSync(lockPath, "utf-8"));
+        if (typeof raw.at === "number")
+            at = raw.at;
+        if (typeof raw.pid === "number")
+            pid = raw.pid;
+    }
+    catch {
+    }
+    if (at === undefined) {
+        try {
+            at = statSync(lockPath).mtimeMs;
+        }
+        catch {
+            return false;
+        }
+    }
+    const age = Date.now() - at;
+    if (age < 0 || age > LOCKFILE_STALE_MS)
+        return true;
+    if (pid !== undefined && pid !== process.pid && !pidAlive(pid))
+        return true;
+    return false;
+}
+function acquireWriteLock(lockPath, maxWaitMs) {
+    const deadline = Date.now() + maxWaitMs;
+    let backoff = 25;
+    for (;;) {
+        if (tryCreateLock(lockPath))
+            return true;
+        if (lockIsStale(lockPath)) {
+            const grave = `${lockPath}.stale-${process.pid}-${Date.now()}`;
+            try {
+                renameSync(lockPath, grave);
+                rmSync(grave, { force: true });
+            }
+            catch {
+            }
+            continue;
+        }
+        if (Date.now() >= deadline)
+            return false;
+        sleepSync(Math.min(backoff, Math.max(1, deadline - Date.now())));
+        backoff = Math.min(backoff * 2, 500);
+    }
+}
+export function writeLockFile(lock, opts = {}) {
     const path = getLockFilePath();
     _lockCache = lock;
     mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(lock, null, 2)}\n`, "utf-8");
+    const lockPath = `${path}.lock`;
+    if (!acquireWriteLock(lockPath, opts.maxWaitMs ?? LOCKFILE_MAX_WAIT_MS)) {
+        warn(`Otro proceso del agente está escribiendo ${path} (${lockPath}); no lo pisé. El próximo \`update\` lo reconcilia.`);
+        return false;
+    }
+    try {
+        const tmp = `${path}.tmp-${process.pid}`;
+        writeFileSync(tmp, `${JSON.stringify(lock, null, 2)}\n`, "utf-8");
+        renameSync(tmp, path);
+    }
+    finally {
+        rmSync(lockPath, { force: true });
+    }
+    return true;
+}
+export function parseTargetList(raw) {
+    const out = [];
+    for (const piece of raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)) {
+        if (ALL_TARGETS.includes(piece)) {
+            out.push(piece);
+        }
+        else {
+            throw new Error(`Target desconocido: '${piece}'. Válidos: ${ALL_TARGETS.join(", ")}`);
+        }
+    }
+    return out;
+}
+export function parseArgs(argv) {
+    const flags = {
+        yes: false,
+        dryRun: false,
+        force: false,
+        help: false,
+        version: false,
+        noHook: false,
+        noBounce: false,
+        autoUpdate: false,
+        background: false,
+    };
+    const positional = [];
+    const only = [];
+    const targets = [];
+    let i = 0;
+    while (i < argv.length) {
+        const a = argv[i];
+        if (a === "-y" || a === "--yes")
+            flags.yes = true;
+        else if (a === "--dry-run")
+            flags.dryRun = true;
+        else if (a === "--force")
+            flags.force = true;
+        else if (a === "--no-hook")
+            flags.noHook = true;
+        else if (a === "--no-bounce")
+            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")
+            flags.version = true;
+        else if (a === "--only") {
+            i++;
+            if (argv[i])
+                only.push(...argv[i].split(","));
+        }
+        else if (a.startsWith("--only=")) {
+            only.push(...a.slice("--only=".length).split(","));
+        }
+        else if (a === "--target") {
+            i++;
+            if (argv[i])
+                targets.push(...parseTargetList(argv[i]));
+        }
+        else if (a.startsWith("--target=")) {
+            targets.push(...parseTargetList(a.slice("--target=".length)));
+        }
+        else {
+            positional.push(a);
+        }
+        i++;
+    }
+    return {
+        command: positional[0] ?? "install",
+        subcommand: positional[1],
+        flags,
+        only,
+        targets,
+    };
 }
 export function sha256(buf) {
     return createHash("sha256").update(buf).digest("hex");