@cursor/july 0.1.79 → 0.1.82

package/dist/internal/skills-sync.js

@@ -0,0 +1,96 @@
+/**
+ * Sync authored skills into the deployment's Agent Store so cloud-runtime
+ * turns discover them natively. The engine writes through the hosted sink
+ * at store-root `skills/<name>/…`; the cloud VM is launched with
+ * `--agent-store-skills-dir /cursor/stores/deployment/skills` and walks that
+ * directory the same way it walks a user store.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readFile } from "node:fs/promises";
+import { posix } from "node:path";
+import { agentStoreKeys, FileConflictError } from "../files.js";
+import { STORAGE_KEY_ROOT } from "../storage.js";
+import { buildSkillMd } from "./workspace.js";
+/** Pre-native layout. Deleted on every sync so a rolled-forward deploy does not leave undiscoverable copies. */
+function legacySkillsPrefix(agent) {
+    return `${STORAGE_KEY_ROOT}/${agent}/skills/`;
+}
+/**
+ * Mirror the agent's skills onto the store: write every SKILL.md (with the
+ * same generated frontmatter local materialization uses) plus sibling files,
+ * and delete keys no authored skill claims so redeploys drop removed skills.
+ *
+ * Everything loads and validates before the store is touched, and writes
+ * land before stale deletes, so a failed sync never leaves a gap a
+ * concurrent cloud reader could see.
+ */
+export function syncSkillsToStore(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const desired = new Map();
+        for (const skill of args.skills) {
+            const key = (relPath) => agentStoreKeys.skillFile(skill.name, relPath);
+            desired.set(key("SKILL.md"), Buffer.from(buildSkillMd(skill), "utf8"));
+            for (const [relPath, source] of Object.entries(skill.files)) {
+                desired.set(key(storeRelPath(relPath)), yield sourceBytes(source));
+            }
+        }
+        yield Promise.all([...desired].map(([key, body]) => putLastWriterWins(args.sink, key, body)));
+        const [existing, leftover] = yield Promise.all([
+            args.sink.list(agentStoreKeys.skillsPrefix()),
+            args.sink.list(legacySkillsPrefix(args.agentName)),
+        ]);
+        yield Promise.all([...existing.filter((entry) => !desired.has(entry.key)), ...leftover].map((entry) => args.sink.delete(entry.key)));
+    });
+}
+/**
+ * Same refusals as local materialization's `resolveInside`: a rel that
+ * escapes the skill directory or would not round-trip through the FUSE
+ * mount (`..`, `.`, `//`, absolute) fails the sync, exactly as it fails a
+ * local turn's workspace write. Backslashes are refused too — the store
+ * normalizes `\` to `/` on write, so the stored key would differ from the
+ * desired one and the stale pass would delete the file it just wrote.
+ */
+function storeRelPath(relPath) {
+    if (relPath.includes("\0") ||
+        relPath.includes("\\") ||
+        posix.isAbsolute(relPath) ||
+        relPath.endsWith("/") ||
+        relPath.split("/").some((seg) => seg === ".." || seg === ".") ||
+        posix.normalize(relPath) !== relPath) {
+        throw new Error(`Refusing skill file path "${relPath}" (must be a normalized relative path)`);
+    }
+    return relPath;
+}
+/**
+ * Last writer wins. A raced conditional put (dual engine pods during a
+ * deploy rollover) clears the sink's cached etag, so one retry re-learns
+ * the current version and lands.
+ */
+function putLastWriterWins(sink, key, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield sink.put(key, body);
+        }
+        catch (error) {
+            if (!(error instanceof FileConflictError)) {
+                throw error;
+            }
+            yield sink.put(key, body);
+        }
+    });
+}
+function sourceBytes(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return "contents" in source
+            ? Buffer.from(source.contents, "utf8")
+            : readFile(source.sourcePath);
+    });
+}