@agent-native/core 0.122.3 → 0.122.4

package/dist/cli/skills.js

@@ -13,7 +13,7 @@ import { MCP_LEGACY_ROUTE_PREFIX, MCP_PUBLIC_ROUTE_PREFIX, } from "../mcp/route-
 import { buildAppSkillPack, ensureAppSkill, loadAppSkillManifest, normalizeAppSkillManifest, } from "./app-skill.js";
 import { resolveClients, runConnect, writeConnectClientPreferences, } from "./connect.js";
 import { CONTEXT_XRAY_SKILL_MD, installLocalContextXray, } from "./context-xray-local.js";
-import { CLIENTS } from "./mcp-config-writers.js";
+import { CLIENTS, configPathFor } from "./mcp-config-writers.js";
 import { installScreenMemoryForClient, resolveScreenMemoryStoreDir, } from "./mcp.js";
 import { PR_VISUAL_RECAP_SETUP, writePrVisualRecapWorkflow } from "./recap.js";
 import { setupAgentSymlinks } from "./setup-agents.js";
@@ -466,6 +466,34 @@ function normalizeKnownSkillTarget(value) {
 function isKnownSkill(value) {
     return Boolean(normalizeKnownSkillTarget(value));
 }
+function explicitlyTargetsRewind(parsed) {
+    return (normalizeKnownSkillTarget(parsed.target ?? "assets") === "rewind" ||
+        Boolean(parsed.plainSkillNames?.some((skillName) => normalizeKnownSkillTarget(skillName) === "rewind")));
+}
+const REWIND_MISSING_STORE_ERROR = "No local Clips Screen Memory store was found. Clips Desktop is required for Rewind. Download and launch the signed app from https://clips.agent-native.com/download, turn Rewind on, then run the setup again. Clips Desktop was not installed or enabled automatically.";
+function preflightRewindStore(parsed) {
+    if (parsed.command !== "add" || !explicitlyTargetsRewind(parsed))
+        return undefined;
+    if (!parsed.mcp) {
+        throw new Error("Rewind requires the local Clips Screen Memory MCP and cannot be installed with --no-mcp.");
+    }
+    if (parsed.mcpUrl) {
+        throw new Error("Rewind uses the local Clips Screen Memory MCP and does not accept --mcp-url.");
+    }
+    if (parsed.dryRun)
+        return undefined;
+    const screenMemoryDir = resolveScreenMemoryStoreDir();
+    if (!screenMemoryDir)
+        throw new Error(REWIND_MISSING_STORE_ERROR);
+    return screenMemoryDir;
+}
+function preflightResolvedRewindTargets(parsed, targets) {
+    preflightRewindStore({
+        ...parsed,
+        target: undefined,
+        plainSkillNames: [...(parsed.plainSkillNames ?? []), ...targets],
+    });
+}
 function isLocalOnlyBuiltInSkill(entry) {
     return Boolean(entry && "localOnly" in entry && entry.localOnly);
 }
@@ -895,13 +923,7 @@ $ARGUMENTS
     }
     return null;
 }
-/**
- * Write a built-in skill's instruction folders straight into each client's
- * skills directory. Built-in skills ship their SKILL.md inside this package, so
- * there is no need to shell out to the separate @agent-native/skills installer
- * (which would have to be published to npm first). Returns the written folders.
- */
-function installBuiltInInstructions(input) {
+function builtInInstructionPaths(input) {
     const bundles = Object.values(skillFilesForBuiltIn(input.appSkillId, {
         planMode: input.planMode,
         mcpUrl: input.mcpUrl,
@@ -912,22 +934,72 @@ function installBuiltInInstructions(input) {
         const commandsRoot = builtInCommandsRootForAgent(agent, input.scope, input.baseDir);
         for (const bundle of bundles) {
             const dir = path.join(root, bundle.skillName);
-            if (!input.dryRun)
-                writeSkillFolder(dir, bundle);
             written.push(dir);
             const command = slashCommandForBuiltInSkill(bundle.skillName);
             if (command) {
                 const commandPath = path.join(commandsRoot, `${bundle.skillName}.md`);
-                if (!input.dryRun) {
-                    fs.mkdirSync(path.dirname(commandPath), { recursive: true });
-                    fs.writeFileSync(commandPath, command, "utf-8");
-                }
                 written.push(commandPath);
             }
         }
     }
     return written;
 }
+function installBuiltInInstructions(input) {
+    const bundles = Object.values(skillFilesForBuiltIn(input.appSkillId, {
+        planMode: input.planMode,
+        mcpUrl: input.mcpUrl,
+    })).filter((bundle) => !input.onlySkillNames || input.onlySkillNames.includes(bundle.skillName));
+    const written = builtInInstructionPaths(input);
+    if (input.dryRun)
+        return written;
+    for (const agent of input.skillsAgents) {
+        const root = builtInSkillsRootForAgent(agent, input.scope, input.baseDir);
+        const commandsRoot = builtInCommandsRootForAgent(agent, input.scope, input.baseDir);
+        for (const bundle of bundles) {
+            writeSkillFolder(path.join(root, bundle.skillName), bundle);
+            const command = slashCommandForBuiltInSkill(bundle.skillName);
+            if (command) {
+                const commandPath = path.join(commandsRoot, `${bundle.skillName}.md`);
+                fs.mkdirSync(path.dirname(commandPath), { recursive: true });
+                fs.writeFileSync(commandPath, command, "utf-8");
+            }
+        }
+    }
+    return written;
+}
+function snapshotInstallPaths(targets, backupRoot) {
+    return [...new Set(targets)].map((target, index) => {
+        const backup = path.join(backupRoot, `snapshot-${index}`);
+        const existed = fs.existsSync(target);
+        if (existed)
+            fs.cpSync(target, backup, { recursive: true });
+        return { target, backup, existed };
+    });
+}
+function removeEmptyParents(start, boundary) {
+    let current = path.resolve(start);
+    const stop = path.resolve(boundary);
+    while (current !== stop && current.startsWith(`${stop}${path.sep}`)) {
+        if (!fs.existsSync(current) || fs.readdirSync(current).length > 0)
+            return;
+        fs.rmdirSync(current);
+        current = path.dirname(current);
+    }
+}
+function restoreInstallPaths(snapshots, boundary) {
+    for (const snapshot of snapshots.toReversed()) {
+        fs.rmSync(snapshot.target, { recursive: true, force: true });
+        if (snapshot.existed) {
+            fs.mkdirSync(path.dirname(snapshot.target), { recursive: true });
+            fs.cpSync(snapshot.backup, snapshot.target, { recursive: true });
+        }
+    }
+    for (const snapshot of snapshots) {
+        if (!snapshot.existed) {
+            removeEmptyParents(path.dirname(snapshot.target), boundary);
+        }
+    }
+}
 function listSkillFolderFiles(dir) {
     const out = {};
     const walk = (current, prefix = "") => {
@@ -2558,6 +2630,9 @@ export async function addAgentNativeSkill(parsed, options = {}) {
     const knownBuiltIn = knownTarget ? BUILT_IN_APP_SKILLS[knownTarget] : null;
     const installsScreenMemoryMcp = isScreenMemoryMcpBuiltInSkill(knownBuiltIn);
     const baseDir = options.baseDir ?? process.cwd();
+    if (installsScreenMemoryMcp && !parsed.mcp) {
+        throw new Error("Rewind requires the local Clips Screen Memory MCP and cannot be installed with --no-mcp.");
+    }
     if (installsScreenMemoryMcp && parsed.mcpUrl) {
         throw new Error("Rewind uses the local Clips Screen Memory MCP and does not accept --mcp-url.");
     }
@@ -2652,7 +2727,7 @@ export async function addAgentNativeSkill(parsed, options = {}) {
     }
     installTarget = preserveMcpUrlAppPathOverride(installTarget, parsed.mcpUrl);
     const skillsAgents = installsScreenMemoryMcp
-        ? clients
+        ? clients.filter((client) => client !== "cowork")
         : skillsAgentsForClients(clients);
     if (parsed.dryRun) {
         try {
@@ -2698,6 +2773,7 @@ export async function addAgentNativeSkill(parsed, options = {}) {
         }
     }
     const commands = [];
+    const screenMemoryDir = preflightRewindStore(parsed);
     const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "an-skills-add-"));
     let instructionSource;
     let instructionsWritten;
@@ -2705,6 +2781,29 @@ export async function addAgentNativeSkill(parsed, options = {}) {
     let connectCommand;
     let registeredMcpClients = shouldRegisterMcp ? mcpClients : [];
     let localManifestPath;
+    const builtInInstructionInput = knownTarget
+        ? {
+            appSkillId: knownTarget,
+            onlySkillNames,
+            skillsAgents,
+            scope: parsed.scope,
+            baseDir,
+            dryRun: parsed.dryRun,
+            planMode,
+            mcpUrl: installTarget.loaded.manifest.hosted.mcpUrl,
+        }
+        : undefined;
+    const rewindSnapshots = installsScreenMemoryMcp
+        ? snapshotInstallPaths([
+            ...(parsed.instructions && builtInInstructionInput
+                ? builtInInstructionPaths(builtInInstructionInput)
+                : []),
+            ...(shouldRegisterMcp
+                ? mcpClients.map((client) => configPathFor(client, baseDir, parsed.scope))
+                : []),
+        ], tmpRoot)
+        : undefined;
+    const rollbackBoundary = parsed.scope === "user" ? os.homedir() : path.resolve(baseDir);
     try {
         if (parsed.instructions) {
             if (skillsAgents.length === 0) {
@@ -2712,21 +2811,12 @@ export async function addAgentNativeSkill(parsed, options = {}) {
                     throw new Error("Skill instructions use shared .agents for Codex, Pi, Cursor, OpenCode, Copilot, and similar agents, or Claude Code's native files. Use an MCP-capable client or omit --instructions-only.");
                 }
             }
-            else if (knownTarget) {
+            else if (knownTarget && builtInInstructionInput) {
                 // Built-in skills ship their instructions inside this package, so copy
                 // the skill folders straight into each client's skills directory. This
                 // avoids shelling out to the separate @agent-native/skills installer
                 // (which would need to be published to npm to run via npx).
-                instructionsWritten = installBuiltInInstructions({
-                    appSkillId: knownTarget,
-                    onlySkillNames,
-                    skillsAgents,
-                    scope: parsed.scope,
-                    baseDir,
-                    dryRun: parsed.dryRun,
-                    planMode,
-                    mcpUrl: installTarget.loaded.manifest.hosted.mcpUrl,
-                });
+                instructionsWritten = installBuiltInInstructions(builtInInstructionInput);
                 instructionSource = instructionsWritten[0];
                 commands.push(...instructionsWritten.map((dir) => `write ${dir}`));
             }
@@ -2767,27 +2857,30 @@ export async function addAgentNativeSkill(parsed, options = {}) {
             localManifestPath = writeContentLocalFilesManifest(baseDir);
             commands.push(`write ${localManifestPath}`);
         }
-        // Skill instructions are now on disk (built-in folders copied or external
-        // pack materialized) — record the install before MCP registration/connect.
-        options.telemetry?.track("skills_cli install completed", {
-            skills: installTarget.skillNames.join(","),
-            clients: clients.join(","),
-            scope: parsed.scope,
-            dryRun: Boolean(parsed.dryRun),
-        });
+        // Rewind reports completion only after both local writes succeed.
+        if (!installsScreenMemoryMcp) {
+            options.telemetry?.track("skills_cli install completed", {
+                skills: installTarget.skillNames.join(","),
+                clients: clients.join(","),
+                scope: parsed.scope,
+                dryRun: Boolean(parsed.dryRun),
+            });
+        }
         if (shouldRegisterMcp && installsScreenMemoryMcp) {
-            const screenMemoryDir = resolveScreenMemoryStoreDir();
-            if (!screenMemoryDir) {
-                throw new Error("No local Clips Screen Memory store was found. Turn Rewind on in Clips, then run the setup again.");
-            }
             registeredMcpClients = mcpClients.map((client) => {
                 commands.push(`npx @agent-native/core@latest mcp install-screen-memory --client ${client} --scope ${parsed.scope}`);
-                installScreenMemoryForClient(client, screenMemoryDir, baseDir, parsed.scope);
+                (options.installScreenMemory ?? installScreenMemoryForClient)(client, screenMemoryDir, baseDir, parsed.scope);
                 return client;
             });
             options.telemetry?.track("skills_cli mcp registered", {
                 skills: installTarget.skillNames.join(","),
             });
+            options.telemetry?.track("skills_cli install completed", {
+                skills: installTarget.skillNames.join(","),
+                clients: clients.join(","),
+                scope: parsed.scope,
+                dryRun: false,
+            });
         }
         else if (shouldRegisterMcp) {
             commands.push(`npx @agent-native/core@latest app-skill ensure --manifest ${installTarget.loaded.file} --client ${parsed.client} --scope ${parsed.scope} --yes`);
@@ -2898,6 +2991,17 @@ export async function addAgentNativeSkill(parsed, options = {}) {
             githubActionSuggestedCommand,
         };
     }
+    catch (error) {
+        if (rewindSnapshots) {
+            try {
+                restoreInstallPaths(rewindSnapshots, rollbackBoundary);
+            }
+            catch (rollbackError) {
+                throw new AggregateError([error, rollbackError], "Rewind setup failed and its partial installation could not be fully rolled back.");
+            }
+        }
+        throw error;
+    }
     finally {
         fs.rmSync(tmpRoot, { recursive: true, force: true });
         installTarget.cleanup?.();
@@ -3121,11 +3225,48 @@ function readCliVersion() {
         return "unknown";
     }
 }
+function deferCliTelemetry(target) {
+    const trackCalls = [];
+    const exceptionCalls = [];
+    let committed = false;
+    return {
+        telemetry: {
+            track(...args) {
+                if (committed)
+                    target.track(...args);
+                else
+                    trackCalls.push(args);
+            },
+            captureException(...args) {
+                if (committed)
+                    target.captureException(...args);
+                else
+                    exceptionCalls.push(args);
+            },
+            async flush() {
+                if (committed)
+                    await target.flush();
+            },
+        },
+        commit() {
+            if (committed)
+                return;
+            committed = true;
+            for (const args of trackCalls)
+                target.track(...args);
+            for (const args of exceptionCalls)
+                target.captureException(...args);
+            trackCalls.length = 0;
+            exceptionCalls.length = 0;
+        },
+    };
+}
 export async function runSkills(argv, options = {}) {
     const parsed = parseSkillsArgs(argv);
     if (parsed.baseDir) {
         options = { ...options, baseDir: path.resolve(parsed.baseDir) };
     }
+    preflightRewindStore(parsed);
     const clackForLog = parsed.printJson
         ? undefined
         : await import("@clack/prompts");
@@ -3157,13 +3298,20 @@ export async function runSkills(argv, options = {}) {
     // finally so events send on success, error, and cancellation — the CLI is
     // short-lived, so flushing before exit is essential or the events never send.
     const startedAt = Date.now();
-    const telemetry = options.telemetry ??
+    const telemetryTarget = options.telemetry ??
         createCliTelemetry({
             cli: "core",
             cliVersion: readCliVersion(),
             command: parsed.command,
             interactive: shouldPrompt(parsed, options),
         });
+    const deferredTelemetry = deferCliTelemetry(telemetryTarget);
+    const telemetry = deferredTelemetry.telemetry;
+    const deferUntilSkillSelection = parsed.command === "add" &&
+        !parsed.target &&
+        !(parsed.plainSkillNames?.length ?? 0);
+    if (!deferUntilSkillSelection)
+        deferredTelemetry.commit();
     const optionsWithTelemetry = {
         ...options,
         telemetry,
@@ -3198,9 +3346,12 @@ export async function runSkills(argv, options = {}) {
         }
         const targets = await resolveSkillTargets(parsed, optionsWithTelemetry);
         if (!targets) {
+            deferredTelemetry.commit();
             telemetry.track("skills_cli cancelled", { step: "skills" });
             return;
         }
+        preflightResolvedRewindTargets(parsed, targets);
+        deferredTelemetry.commit();
         const preselected = Boolean(parsed.target);
         telemetry.track("skills_cli skills selected", {
             selected: targets.join(","),