codiedev 0.9.83 → 0.9.85

package/dist/packs/files.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHA256_HEX = exports.PACK_FILES_MAX_TOTAL_BYTES = exports.PACK_FILE_MAX_BYTES = exports.PACK_MAX_FILES = void 0;
+exports.packFilePathProblem = packFilePathProblem;
+exports.blobsDir = blobsDir;
+exports.blobPath = blobPath;
+exports.sha256Of = sha256Of;
+exports.ensureBlobs = ensureBlobs;
+exports.parseFilesSection = parseFilesSection;
+exports.stripFilesSection = stripFilesSection;
+exports.expandHome = expandHome;
+exports.collectLocalFiles = collectLocalFiles;
+exports.rewritePluginRoot = rewritePluginRoot;
+// Starter-pack files (SIG-127): skill subfolders, scripts, PDFs and runner
+// folders shipped inside a pack's plugin dir.
+//
+//   - Path rules mirror convex/lib/skillPackManifest.ts packFilePathProblem.
+//     The server checks them; the CLI checks again before any write, because a
+//     manifest is untrusted input that becomes paths on the member's machine.
+//   - Blobs are content-addressed (sha256 hex) and cached under
+//     <packs root>/.blobs/<sha256>, verified on download, so reinstalls and
+//     the portable copy never fetch twice.
+//   - `## Files` in pack.md maps local folders to plugin paths for
+//     `codiedev pack apply`:  `- runner <- ./runner`  (`.` = plugin root).
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.PACK_MAX_FILES = 500;
+exports.PACK_FILE_MAX_BYTES = 15 * 1024 * 1024;
+exports.PACK_FILES_MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+const PATH_MAX = 300;
+const MAX_DEPTH = 16;
+const FILE_SEGMENT = /^[A-Za-z0-9_@+][A-Za-z0-9._ @+=,-]{0,127}$/;
+exports.SHA256_HEX = /^[0-9a-f]{64}$/;
+/** Why a plugin-relative path can't be written, or null when it's fine. */
+function packFilePathProblem(raw) {
+    if (typeof raw !== "string" || !raw)
+        return "empty path";
+    if (raw.length > PATH_MAX)
+        return `longer than ${PATH_MAX} characters`;
+    if (raw.includes("\\"))
+        return "use / as the separator";
+    if (raw.startsWith("/") || /^[A-Za-z]:/.test(raw))
+        return "must be relative to the pack folder";
+    const segments = raw.split("/");
+    if (segments.length > MAX_DEPTH)
+        return `nested deeper than ${MAX_DEPTH} folders`;
+    for (const seg of segments) {
+        if (!seg || seg === "." || seg === "..")
+            return "empty, . or .. segment";
+        if (!FILE_SEGMENT.test(seg) || seg.trim() !== seg || seg.endsWith("."))
+            return `unsupported name "${seg}"`;
+    }
+    const lower = raw.toLowerCase();
+    if (lower.startsWith(".claude-plugin/"))
+        return ".claude-plugin/ is written by Codiedev";
+    if (lower === "hooks/hooks.json")
+        return "hooks/hooks.json comes from the pack's hooks";
+    if (segments.length === 2 && segments[0].toLowerCase() === "agents" && lower.endsWith(".md"))
+        return "agents/*.md come from the pack's agents";
+    if (segments.length === 3 && segments[0].toLowerCase() === "skills" && segments[2].toLowerCase() === "skill.md") {
+        return "SKILL.md comes from the skill library";
+    }
+    return null;
+}
+// ─── Blob cache ─────────────────────────────────────────────────────────────
+function blobsDir(root) {
+    return path.join(root, ".blobs");
+}
+function blobPath(dir, sha256) {
+    if (!exports.SHA256_HEX.test(sha256))
+        throw new Error(`bad sha256: ${sha256}`);
+    return path.join(dir, sha256);
+}
+function sha256Of(buf) {
+    return (0, crypto_1.createHash)("sha256").update(buf).digest("hex");
+}
+function hasBlob(dir, file) {
+    try {
+        return fs.statSync(blobPath(dir, file.sha256)).size === file.size;
+    }
+    catch {
+        return false;
+    }
+}
+/** Download every blob the manifest needs that isn't cached yet. Each body
+ * must match its sha256 and size or nothing is kept. */
+async function ensureBlobs(dir, files, download) {
+    let downloaded = 0;
+    const seen = new Set();
+    for (const file of files) {
+        if (seen.has(file.sha256) || hasBlob(dir, file))
+            continue;
+        seen.add(file.sha256);
+        const body = await download(file);
+        if (body.length !== file.size || sha256Of(body) !== file.sha256) {
+            throw new Error(`${file.path}: downloaded bytes don't match the pack (checksum mismatch)`);
+        }
+        fs.mkdirSync(dir, { recursive: true });
+        const target = blobPath(dir, file.sha256);
+        const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tmp, body, { mode: 0o644 });
+        fs.renameSync(tmp, target);
+        downloaded += 1;
+    }
+    return { downloaded };
+}
+/** The `## Files` section of a pack.md, or null when there is none (then
+ * `pack apply` leaves the pack's files alone). Fenced blocks are skipped so
+ * agent bodies can't open a section. */
+function parseFilesSection(markdown) {
+    const lines = markdown.replace(/^/, "").split("\n").map((l) => l.replace(/\r$/, ""));
+    let fence = null;
+    let inFiles = false;
+    let found = false;
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const f = line.match(/^(`{3,})/);
+        if (f) {
+            if (!fence)
+                fence = f[1];
+            else if (f[1].length >= fence.length && /^`+\s*$/.test(line))
+                fence = null;
+            continue;
+        }
+        if (fence)
+            continue;
+        const h2 = line.match(/^##\s+(.+?)\s*$/);
+        if (h2 && !line.startsWith("###")) {
+            inFiles = h2[1].toLowerCase() === "files";
+            if (inFiles)
+                found = true;
+            continue;
+        }
+        if (!inFiles || !line.trim())
+            continue;
+        const m = line.match(/^\s*[-*]\s+(.+?)\s+<-\s+(.+?)\s*$/);
+        if (!m)
+            throw new Error(`pack.md line ${i + 1}: expected "- <path in pack> <- <local path>" under ## Files`);
+        out.push({ dest: unquote(m[1]), source: unquote(m[2]), line: i + 1 });
+    }
+    return found ? out : null;
+}
+function unquote(value) {
+    const v = value.trim();
+    return (v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")) ? v.slice(1, -1) : v;
+}
+/** pack.md with its `## Files` section (heading and body) removed. */
+function stripFilesSection(markdown) {
+    const lines = markdown.split("\n");
+    const out = [];
+    let fence = null;
+    let skipping = false;
+    for (const raw of lines) {
+        const line = raw.replace(/\r$/, "");
+        const f = line.match(/^(`{3,})/);
+        if (f && !skipping) {
+            if (!fence)
+                fence = f[1];
+            else if (f[1].length >= fence.length && /^`+\s*$/.test(line))
+                fence = null;
+            out.push(raw);
+            continue;
+        }
+        if (!fence) {
+            const h2 = line.match(/^##\s+(.+?)\s*$/);
+            if (h2 && !line.startsWith("###"))
+                skipping = h2[1].toLowerCase() === "files";
+        }
+        if (!skipping)
+            out.push(raw);
+    }
+    return out.join("\n");
+}
+// ─── Collecting local files for `pack apply` ────────────────────────────────
+// Build/cache/VCS clutter that never belongs in a pack.
+const SKIP_DIRS = new Set(["__pycache__", ".git", "node_modules", ".venv", "venv", ".mypy_cache", ".pytest_cache", ".ruff_cache", ".idea", ".vscode"]);
+const SKIP_FILES = new Set([".DS_Store", "Thumbs.db", "desktop.ini"]);
+const SKIP_EXT = /\.(pyc|pyo|swp|tmp)$/i;
+function expandHome(p, home = os.homedir()) {
+    return p === "~" ? home : p.startsWith("~/") ? path.join(home, p.slice(2)) : p;
+}
+/** Walk each `## Files` entry. Junk (caches, VCS, editor files) is skipped
+ * quietly; symlinks, hidden files and a skill folder's own SKILL.md are
+ * skipped with a note. Throws on a missing source or a bad destination. */
+function collectLocalFiles(entries, baseDir, home = os.homedir()) {
+    const files = new Map();
+    const notes = [];
+    let total = 0;
+    const add = (dest, abs) => {
+        const problem = packFilePathProblem(dest);
+        if (problem) {
+            const parts = dest.split("/");
+            if (parts.length === 3 && parts[0] === "skills" && parts[2].toLowerCase() === "skill.md") {
+                notes.push(`skipped ${dest} (the skill itself comes from the skill library; push it with \`codiedev push\`)`);
+                return;
+            }
+            if (parts.some((s) => s.startsWith(".") && s !== "." && s !== "..")) {
+                notes.push(`skipped hidden file ${dest}`);
+                return;
+            }
+            throw new Error(`can't ship ${dest}: ${problem}`);
+        }
+        const stat = fs.statSync(abs);
+        if (stat.size > exports.PACK_FILE_MAX_BYTES)
+            throw new Error(`${abs} is over ${exports.PACK_FILE_MAX_BYTES / (1024 * 1024)}MB`);
+        const key = dest.toLowerCase();
+        if (files.has(key))
+            throw new Error(`two sources write ${dest}`);
+        const buf = fs.readFileSync(abs);
+        total += buf.length;
+        files.set(key, { path: dest, abs, size: buf.length, sha256: sha256Of(buf), ...((stat.mode & 0o111) !== 0 ? { executable: true } : {}) });
+    };
+    const walk = (dir, dest, depth) => {
+        if (depth > MAX_DEPTH)
+            throw new Error(`${dir} is nested too deep`);
+        for (const name of fs.readdirSync(dir).sort()) {
+            const abs = path.join(dir, name);
+            const lst = fs.lstatSync(abs);
+            const child = dest ? `${dest}/${name}` : name;
+            if (lst.isSymbolicLink()) {
+                notes.push(`skipped symlink ${child}`);
+                continue;
+            }
+            if (lst.isDirectory()) {
+                if (!SKIP_DIRS.has(name))
+                    walk(abs, child, depth + 1);
+                continue;
+            }
+            if (!lst.isFile() || SKIP_FILES.has(name) || SKIP_EXT.test(name))
+                continue;
+            add(child, abs);
+        }
+    };
+    for (const entry of entries) {
+        const dest = entry.dest.replace(/^\.\/+/, "").replace(/\/+$/, "");
+        if (dest !== "." && (!dest || dest.startsWith("/") || dest.split("/").some((seg) => !seg || seg === "." || seg === ".."))) {
+            throw new Error(`pack.md line ${entry.line}: "${entry.dest}" must be a path inside the pack (or "." for its root)`);
+        }
+        const source = path.resolve(baseDir, expandHome(entry.source, home));
+        let stat;
+        try {
+            stat = fs.statSync(source);
+        }
+        catch {
+            throw new Error(`pack.md line ${entry.line}: ${entry.source} doesn't exist`);
+        }
+        if (stat.isDirectory())
+            walk(source, dest === "." ? "" : dest, 0);
+        else if (stat.isFile()) {
+            if (dest === "." || !dest)
+                throw new Error(`pack.md line ${entry.line}: give a file a path, e.g. "- tools/${path.basename(source)} <- ${entry.source}"`);
+            add(dest, source);
+        }
+        else
+            throw new Error(`pack.md line ${entry.line}: ${entry.source} is not a file or folder`);
+    }
+    const list = [...files.values()].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    if (list.length > exports.PACK_MAX_FILES)
+        throw new Error(`a pack holds at most ${exports.PACK_MAX_FILES} files (found ${list.length})`);
+    if (total > exports.PACK_FILES_MAX_TOTAL_BYTES)
+        throw new Error(`pack files total over ${exports.PACK_FILES_MAX_TOTAL_BYTES / (1024 * 1024)}MB`);
+    return { files: list, notes };
+}
+// ─── Portable copies ────────────────────────────────────────────────────────
+/** Only Claude Code sets ${CLAUDE_PLUGIN_ROOT}. In the copy other tools read,
+ * replace it with the plugin dir's real path (forward slashes, which every
+ * shell and Python accept, Windows included). */
+function rewritePluginRoot(content, pluginRoot) {
+    const root = pluginRoot.split(path.sep).join("/");
+    return content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}|\$CLAUDE_PLUGIN_ROOT(?![A-Za-z0-9_])/g, root);
+}

package/dist/packs/harnesses.js

@@ -259,8 +259,8 @@ function copyCursorSkills(home, manifest, pluginDirPath) {
             }
             fs.rmSync(dest, { recursive: true, force: true });
         }
-        fs.mkdirSync(dest, { recursive: true });
-        fs.copyFileSync(path.join(pluginDirPath, "skills", skill.name, "SKILL.md"), path.join(dest, "SKILL.md"));
+        // The whole skill folder: SKILL.md plus any pack files under it (SIG-127).
+        copyTreeNoSymlinks(path.join(pluginDirPath, "skills", skill.name), dest);
         fs.writeFileSync(path.join(dest, exports.CURSOR_MARKER), `${manifest.slug}\n`);
     }
     return notes;
@@ -321,8 +321,9 @@ function copyTreeNoSymlinks(source, dest, depth = 0) {
         const stat = fs.statSync(from); // follows links
         if (stat.isDirectory())
             copyTreeNoSymlinks(from, to, depth + 1);
+        // Keep the executable bit (pack scripts).
         else if (stat.isFile())
-            fs.writeFileSync(to, fs.readFileSync(from));
+            fs.writeFileSync(to, fs.readFileSync(from), { mode: stat.mode & 0o777 });
     }
 }
 /** Copy the plugin dir into place via a sibling temp dir + rename. Refuses to

package/dist/packs/install.d.ts

@@ -10,6 +10,8 @@ export interface InstallOptions {
     home?: string;
     run?: Runner;
     now?: () => number;
+    /** Where pack file blobs were downloaded (default <packs root>/.blobs). */
+    blobDir?: string;
 }
 export interface PackInstallResult {
     slug: string;
@@ -26,6 +28,8 @@ export declare function codexPackHooksPath(codexDir: string, slug: string, versi
 /** Trust entries for every registry pack installed into Codex. */
 export declare function codexPackTrustEntries(registry: Registry, codexDir: string): Map<string, CodexHookTrustEntry[]>;
 export declare function installPacks(options: InstallOptions): PackInstallResult[];
+/** Drop cached blobs no installed pack references (best-effort). */
+export declare function pruneBlobs(root: string, registry: Registry, dir?: string): number;
 export interface UninstallOptions {
     slugs: string[];
     env?: NodeJS.ProcessEnv;

package/dist/packs/install.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.codexPackHooksPath = codexPackHooksPath;
 exports.codexPackTrustEntries = codexPackTrustEntries;
 exports.installPacks = installPacks;
+exports.pruneBlobs = pruneBlobs;
 exports.uninstallPacks = uninstallPacks;
 exports.formatUninstallLines = formatUninstallLines;
 exports.formatResultLines = formatResultLines;
@@ -50,6 +51,7 @@ const codexHookTrust_1 = require("../codexHookTrust");
 const harnesses_1 = require("./harnesses");
 const manifest_1 = require("./manifest");
 const paths_1 = require("./paths");
+const files_1 = require("./files");
 const shim_1 = require("./shim");
 const store_1 = require("./store");
 function marketplaceEntries(registry) {
@@ -136,7 +138,7 @@ function installPacks(options) {
     for (const manifest of options.manifests) {
         const dir = (0, paths_1.pluginDir)(root, manifest.slug);
         const previous = registry.packs[manifest.slug];
-        const files = Object.keys((0, store_1.pluginFiles)(manifest)).sort();
+        const files = [...Object.keys((0, store_1.pluginFiles)(manifest)), ...(manifest.files ?? []).map((f) => f.path)].sort();
         const results = [];
         if (options.dryRun) {
             for (const adapter of adapters) {
@@ -148,9 +150,11 @@ function installPacks(options) {
             output.push({ slug: manifest.slug, version: manifest.version, contentHash: manifest.contentHash, dir, files, results, harnesses: [] });
             continue;
         }
-        (0, store_1.writePluginDir)(root, manifest);
-        // Same plugin with agent model levels removed, for Codex/Copilot/Cursor.
-        (0, store_1.writePluginDir)((0, paths_1.portableRoot)(root), manifest, { portable: true });
+        const blobDir = options.blobDir ?? (0, files_1.blobsDir)(root);
+        (0, store_1.writePluginDir)(root, manifest, { blobDir });
+        // Same plugin with agent model levels removed and ${CLAUDE_PLUGIN_ROOT}
+        // made a real path, for Codex/Copilot/Cursor/pi/Codie.
+        (0, store_1.writePluginDir)((0, paths_1.portableRoot)(root), manifest, { portable: true, blobDir });
         // Harnesses read the marketplace during install, so it must list this pack first.
         const pending = {
             packs: {
@@ -196,12 +200,14 @@ function installPacks(options) {
             description: manifest.description,
             ...(manifest.channel ? { channel: manifest.channel } : {}),
             ...(manifest.icon ? { icon: manifest.icon } : {}),
+            ...(manifest.files?.length ? { blobs: [...new Set(manifest.files.map((f) => f.sha256))] } : {}),
         };
         (0, store_1.writeRegistry)(root, registry);
         output.push({ slug: manifest.slug, ...(manifest.channel ? { channel: manifest.channel } : {}), version: manifest.version, contentHash: manifest.contentHash, dir, files, results, harnesses });
     }
     if (options.dryRun || options.manifests.length === 0)
         return output;
+    pruneBlobs(root, registry, options.blobDir);
     if (selected.has("codex") && detected.get("codex")) {
         const bySlug = regenerateCodexTrust(registry, env, home);
         for (const pack of output) {
@@ -223,6 +229,30 @@ function installPacks(options) {
     }
     return output;
 }
+/** Drop cached blobs no installed pack references (best-effort). */
+function pruneBlobs(root, registry, dir = (0, files_1.blobsDir)(root)) {
+    const keep = new Set(Object.values(registry.packs).flatMap((e) => e.blobs ?? []));
+    let removed = 0;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const name of entries) {
+        if (keep.has(name))
+            continue;
+        try {
+            fs.rmSync(path.join(dir, name), { force: true });
+            removed += 1;
+        }
+        catch {
+            // in use or already gone
+        }
+    }
+    return removed;
+}
 function regenerateCodexTrust(registry, env, home) {
     const codexDir = (0, harnessDirs_1.codexHome)(env, home);
     const bySlug = codexPackTrustEntries(registry, codexDir);
@@ -276,6 +306,7 @@ function uninstallPacks(options) {
     if (fs.existsSync(codexConfig))
         regenerateCodexTrust(registry, env, home);
     (0, shim_1.writeShim)((0, paths_1.shimPath)(root), shimInputs(registry));
+    pruneBlobs(root, registry);
     return output;
 }
 function formatUninstallLines(results) {

package/dist/packs/manifest.d.ts

@@ -1,3 +1,4 @@
+import { PackBundleFile } from "./files";
 export interface PackManifestFile {
     name: string;
     content: string;
@@ -17,6 +18,8 @@ export interface PackManifest {
     channel?: string;
     /** Display emoji/icon; never used in paths. */
     icon?: string;
+    /** SIG-127: extra files in the plugin dir, fetched by sha256. */
+    files?: PackBundleFile[];
 }
 export interface PackSummary {
     slug: string;
@@ -28,6 +31,7 @@ export interface PackSummary {
     itemCount?: number;
     agentCount?: number;
     hasHooks?: boolean;
+    fileCount?: number;
 }
 export declare function isSafeSegment(value: unknown): value is string;
 export declare function isSafeSkillName(value: unknown): value is string;

package/dist/packs/manifest.js

@@ -1,7 +1,4 @@
 "use strict";
-// Server manifest shape (GET /api/cli/packs/manifest) and its validation.
-// Everything here is untrusted input that becomes file paths and shell hooks
-// on the member's machine, so names are checked strictly before any write.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManifestError = void 0;
 exports.isSafeSegment = isSafeSegment;
@@ -10,6 +7,8 @@ exports.parseManifest = parseManifest;
 exports.cleanLabel = cleanLabel;
 exports.displayName = displayName;
 exports.parseFrontmatter = parseFrontmatter;
+// Server manifest shape (GET /api/cli/packs/manifest) and its validation.
+const files_1 = require("./files");
 // One path segment: starts alphanumeric, then alphanumerics, dot, dash or
 // underscore. Rejects "", ".", "..", slashes, backslashes, absolute paths,
 // drive letters, NUL and whitespace.
@@ -49,6 +48,46 @@ function fileList(value, field, safe) {
         return { name: entry.name, content: entry.content, ...(artifactId ? { artifactId } : {}) };
     });
 }
+function bundleFiles(value, reserved) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new ManifestError("manifest.files must be an array");
+    if (value.length > files_1.PACK_MAX_FILES)
+        throw new ManifestError(`manifest.files has more than ${files_1.PACK_MAX_FILES} entries`);
+    const seen = new Set();
+    const dirs = new Set();
+    let total = 0;
+    const out = value.map((item, index) => {
+        const f = item;
+        if (!f || typeof f !== "object")
+            throw new ManifestError(`manifest.files[${index}] is not an object`);
+        const problem = (0, files_1.packFilePathProblem)(f.path);
+        if (problem)
+            throw new ManifestError(`manifest.files[${index}] has an unsafe path ${JSON.stringify(f.path)}: ${problem}`);
+        const p = f.path;
+        if (typeof f.sha256 !== "string" || !files_1.SHA256_HEX.test(f.sha256))
+            throw new ManifestError(`manifest.files[${index}].sha256 is not a sha256`);
+        const size = Number(f.size);
+        if (!Number.isInteger(size) || size < 0 || size > files_1.PACK_FILE_MAX_BYTES)
+            throw new ManifestError(`manifest.files[${index}].size is out of range`);
+        total += size;
+        const key = p.toLowerCase();
+        if (seen.has(key) || reserved.has(key))
+            throw new ManifestError(`manifest.files has a clashing path: ${p}`);
+        seen.add(key);
+        const parts = key.split("/");
+        for (let n = 1; n < parts.length; n++)
+            dirs.add(parts.slice(0, n).join("/"));
+        return { path: p, sha256: f.sha256, size, ...(f.executable === true ? { executable: true } : {}) };
+    });
+    for (const key of seen)
+        if (dirs.has(key))
+            throw new ManifestError(`manifest.files has a path that is also a folder: ${key}`);
+    if (total > files_1.PACK_FILES_MAX_TOTAL_BYTES)
+        throw new ManifestError("manifest.files is too large");
+    return out;
+}
 /** Validate a manifest from the server. Throws ManifestError on anything
  * unsafe or malformed — a partial install of a tampered pack is worse than
  * none. */
@@ -91,15 +130,24 @@ function parseManifest(input) {
             hooksJson = m.hooksJson;
         }
     }
+    const skills = fileList(m.skills, "skills", isSafeSkillName);
+    const agents = fileList(m.agents, "agents", isSafeSegment);
+    // Files may never land on a path Codiedev writes itself.
+    const reserved = new Set([
+        ...skills.map((s) => `skills/${s.name}/skill.md`.toLowerCase()),
+        ...agents.map((a) => `agents/${a.name}.md`.toLowerCase()),
+    ]);
+    const files = bundleFiles(m.files, reserved);
     return {
         slug: m.slug,
         name: typeof m.name === "string" && m.name ? m.name : m.slug,
         description: typeof m.description === "string" ? m.description : "",
         version,
         contentHash: m.contentHash,
-        skills: fileList(m.skills, "skills", isSafeSkillName),
-        agents: fileList(m.agents, "agents", isSafeSegment),
+        skills,
+        agents,
         hooksJson,
+        ...(files.length ? { files } : {}),
         ...(cleanLabel(m.channel, 16) ? { channel: cleanLabel(m.channel, 16) } : {}),
         ...(cleanLabel(m.icon, 16) ? { icon: cleanLabel(m.icon, 16) } : {}),
     };

package/dist/packs/store.d.ts

@@ -9,6 +9,8 @@ export interface RegistryEntry {
     description?: string;
     channel?: string;
     icon?: string;
+    /** sha256 of each pack file (SIG-127), so unused cached blobs can be dropped. */
+    blobs?: string[];
 }
 export interface Registry {
     packs: Record<string, RegistryEntry>;
@@ -20,16 +22,21 @@ export declare const AGENT_LEVELS: Set<string>;
 /** Agent file for tools other than Claude Code: drop a `model:` line unless it
  * is a full `provider/model` id (levels and `inherit` are Claude aliases). */
 export declare function portableAgentContent(content: string): string;
-/** The full file set for a pack's plugin dir, relative path → content. */
-export declare function pluginFiles(manifest: PackManifest, options?: {
+export interface PluginWriteOptions {
+    /** The copy for tools other than Claude Code (Codex, Copilot, Cursor, pi, Codie). */
     portable?: boolean;
-}): Record<string, string>;
+    /** Where pack file blobs are cached (required when the manifest has files). */
+    blobDir?: string;
+    /** Portable copies: the plugin dir's final path, substituted for ${CLAUDE_PLUGIN_ROOT}. */
+    pluginRoot?: string;
+}
+/** The full file set for a pack's plugin dir, relative path → content. Pack
+ * files (blobs) are copied separately by writePluginDir. */
+export declare function pluginFiles(manifest: PackManifest, options?: PluginWriteOptions): Record<string, string>;
 /** Build the plugin dir in a sibling temp dir and swap it into place, so a
  * failed write never leaves a half-updated plugin and stale files (a removed
  * skill, hooks that were cleared) never linger. */
-export declare function writePluginDir(root: string, manifest: PackManifest, options?: {
-    portable?: boolean;
-}): string;
+export declare function writePluginDir(root: string, manifest: PackManifest, options?: PluginWriteOptions): string;
 export declare function readRegistry(root: string): Registry;
 export declare function writeRegistry(root: string, registry: Registry): void;
 export interface MarketplaceEntry {

package/dist/packs/store.js

@@ -48,6 +48,7 @@ exports.writeMarketplace = writeMarketplace;
 const fs = __importStar(require("fs"));
 const skillMarker_1 = require("../skillMarker");
 const path = __importStar(require("path"));
+const files_1 = require("./files");
 const paths_1 = require("./paths");
 function pluginVersion(version) {
     return `${version}.0.0`;
@@ -75,8 +76,10 @@ function portableAgentContent(content) {
         return content;
     return fm[1] + kept.join("\n") + fm[3] + content.slice(fm[0].length);
 }
-/** The full file set for a pack's plugin dir, relative path → content. */
+/** The full file set for a pack's plugin dir, relative path → content. Pack
+ * files (blobs) are copied separately by writePluginDir. */
 function pluginFiles(manifest, options = {}) {
+    const rewrite = (content) => (options.portable && options.pluginRoot ? (0, files_1.rewritePluginRoot)(content, options.pluginRoot) : content);
     const files = {};
     files[path.join(".claude-plugin", "plugin.json")] = JSON.stringify({
         name: manifest.slug,
@@ -85,10 +88,10 @@ function pluginFiles(manifest, options = {}) {
     }, null, 2) + "\n";
     for (const skill of manifest.skills) {
         // Identity marker so the skill's runs attribute to this exact artifact.
-        files[path.join("skills", skill.name, "SKILL.md")] = (0, skillMarker_1.stampSkillMarker)(skill.content, skill.artifactId);
+        files[path.join("skills", skill.name, "SKILL.md")] = (0, skillMarker_1.stampSkillMarker)(rewrite(skill.content), skill.artifactId);
     }
     for (const agent of manifest.agents) {
-        files[path.join("agents", `${agent.name}.md`)] = options.portable ? portableAgentContent(agent.content) : agent.content;
+        files[path.join("agents", `${agent.name}.md`)] = options.portable ? rewrite(portableAgentContent(agent.content)) : agent.content;
     }
     if (manifest.hooksJson) {
         files[path.join("hooks", "hooks.json")] = manifest.hooksJson;
@@ -113,12 +116,28 @@ function writePluginDir(root, manifest, options = {}) {
     const tmp = path.join(parent, `.${manifest.slug}.tmp-${stamp}`);
     const old = path.join(parent, `.${manifest.slug}.old-${stamp}`);
     try {
-        for (const [rel, content] of Object.entries(pluginFiles(manifest, options))) {
+        const text = pluginFiles(manifest, { ...options, pluginRoot: options.pluginRoot ?? target });
+        for (const [rel, content] of Object.entries(text)) {
             const file = path.join(tmp, rel);
             assertInside(tmp, file);
             fs.mkdirSync(path.dirname(file), { recursive: true });
             fs.writeFileSync(file, content, "utf8");
         }
+        const written = new Set(Object.keys(text).map((rel) => rel.split(path.sep).join("/").toLowerCase()));
+        for (const f of manifest.files ?? []) {
+            const problem = (0, files_1.packFilePathProblem)(f.path);
+            if (problem)
+                throw new Error(`refusing pack file ${f.path}: ${problem}`);
+            if (written.has(f.path.toLowerCase()))
+                throw new Error(`pack file ${f.path} clashes with a file Codiedev writes`);
+            if (!options.blobDir)
+                throw new Error(`pack file ${f.path} wasn't downloaded`);
+            const file = path.join(tmp, ...f.path.split("/"));
+            assertInside(tmp, file);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.copyFileSync((0, files_1.blobPath)(options.blobDir, f.sha256), file);
+            fs.chmodSync(file, f.executable ? 0o755 : 0o644);
+        }
         if (fs.existsSync(target))
             fs.renameSync(target, old);
         fs.renameSync(tmp, target);

package/dist/teamSkillContext.d.ts

@@ -1,5 +1,5 @@
 /** Session-start context uses each client's supported output contract. */
-export declare const TEAM_SKILL_CONTEXT = "This machine is connected to Codiedev, the team's artifact and skill library.\nBefore a substantial coding task, run codiedev search \"<brief task description>\" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.\nUse codiedev push <file.md> to share an artifact when asked, codiedev ask \"<question>\" for team knowledge, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.";
+export declare const TEAM_SKILL_CONTEXT = "This machine is connected to Codiedev, the team's artifact and skill library.\nBefore a substantial coding task, run codiedev search \"<brief task description>\" and reuse a relevant team skill by running codiedev pull <exact-key> and following its instructions. If no skill fits, continue the task.\nUse codiedev push <file.md> to share an artifact when asked, and codiedev inbox to check messages. Use codiedev --help for other commands. If codiedev is unavailable, use npx codiedev@latest.";
 export declare function teamSkillSessionOutput(source: "cursor" | "copilot", context?: string): {
     additional_context: string;
     additionalContext?: undefined;