codiedev 0.9.84 → 0.9.86

package/dist/commands/pack.d.ts

@@ -2,6 +2,7 @@ import { CodiedevConfig } from "../utils";
 import { InstallOptions, PackInstallResult, PackUninstallResult } from "../packs/install";
 import { HarnessName } from "../packs/harnesses";
 import { PackManifest } from "../packs/manifest";
+import { PackBundleFile } from "../packs/files";
 export declare const DEFAULT_BACKEND_URL = "https://cli.codiedev.com";
 /** CODIEDEV_TOKEN alone is enough: no ~/.codiedev/config.json needed (CI).
  * CODIEDEV_URL defaults to production. Otherwise the connected config. */
@@ -20,8 +21,14 @@ export interface PackArgs {
     out?: string;
     git?: boolean;
     manifest?: boolean;
+    /** publish / apply --publish: which channel (default stable). */
+    channel?: "stable" | "beta" | "alpha";
+    /** apply: publish the draft afterwards. */
+    publish?: boolean;
 }
 export declare function parsePackArgs(args: string[]): PackArgs;
+/** Download a pack's files (SIG-127) into the blob cache, verified by sha256. */
+export declare function downloadPackFiles(config: CodiedevConfig, slug: string, files: PackBundleFile[], dir: string): Promise<number>;
 export declare function runList(config: CodiedevConfig, json: boolean, overrides?: Partial<InstallOptions>): Promise<void>;
 export interface InstallRun {
     installed: PackInstallResult[];
@@ -45,10 +52,19 @@ export declare function commitExport(dir: string, message: string): string;
 /** Write a CI-committable copy of the pack: `<out>/plugins/<slug>/…` plus
  * `<out>/.claude-plugin/marketplace.json` (existing entries for other packs
  * in the same folder are kept). */
-export declare function exportPluginFolder(out: string, manifest: PackManifest): string;
+export declare function exportPluginFolder(out: string, manifest: PackManifest, blobDir?: string): string;
 export declare function runExport(config: CodiedevConfig, args: PackArgs): Promise<{
     written: string;
     commit?: string;
 }>;
 export declare function runApply(config: CodiedevConfig, args: PackArgs): Promise<Record<string, unknown>>;
-export declare const PACK_HELP = "Usage:\n  codiedev pack list                     Packs assigned to your team\n  codiedev pack install [slug] [--harness claude,codex,copilot,cursor,codie,pi] [--dry-run] [--json] [--quiet]\n                                         Install one pack, or every pack that applies\n  codiedev pack status [--json]          Installed packs and whether they're up to date\n  codiedev pack export <slug> --out <dir> [--git] [--manifest]\n                                         Write the pack as a Claude-format plugin folder plus\n                                         .claude-plugin/marketplace.json (commit it for CI).\n                                         --git inits the folder and commits; --manifest writes\n                                         an editable <slug>.pack.md instead\n  codiedev pack apply <pack.md>          Create or update a pack from a pack.md\n\nCursor: packs are copied to ~/.cursor/plugins/local/codiedev-<slug>/. A Cursor\nteam admin can disable \"user local plugin imports\"; then Cursor ignores them.\n\nAuto-update: session starts run `codiedev pack install --quiet` in the background\nabout once an hour. Opt out with CODIEDEV_PACK_AUTOSYNC=0.\n\nHooks for specific skills only: codiedev hook-gate --skills a,b --cmd-b64 <base64url of the command>\n(the pack editor writes this; the command runs via /bin/sh, or cmd.exe on Windows)\n\nCI: set CODIEDEV_TOKEN to a pack CI key (cdvci_\u2026, from the pack's page in the portal).\nNo `codiedev connect` or config file is needed. CI mode (a cdvci_ key, or CI=true)\nnever auto-syncs, reports or prunes, installs the one pack the key can see, defaults\n--harness to claude when it's on PATH, and exits non-zero unless every requested tool\ngot the pack. Skills from a pack are /<pack-slug>:<skill> in Claude Code.\n\n  GitLab CI (.gitlab-ci.yml; add CODIEDEV_TOKEN and ANTHROPIC_API_KEY as masked\n  CI/CD variables):\n    pack-scan:\n      image: node:22\n      script:\n        - npm i -g codiedev @anthropic-ai/claude-code\n        - codiedev pack install --harness claude\n        - claude -p \"/platform-starter:healthcare-scan\" --output-format text\n\n  GitHub Actions (repository secrets CODIEDEV_TOKEN and ANTHROPIC_API_KEY):\n    - uses: actions/setup-node@v4\n      with: { node-version: 22 }\n    - run: npm i -g codiedev @anthropic-ai/claude-code\n    - run: codiedev pack install --harness claude\n      env:\n        CODIEDEV_TOKEN: ${{ secrets.CODIEDEV_TOKEN }}\n    - run: claude -p \"/platform-starter:healthcare-scan\" --output-format text\n      env:\n        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}\n\n  Or vendor the plugin into the repo instead of installing at build time:\n    codiedev pack export <slug> --out .codiedev/packs";
+export interface PublishResult {
+    slug: string;
+    channel: string;
+    version: number;
+    unchanged: boolean;
+}
+/** `codiedev pack publish <slug> [--channel stable|beta|alpha]`: snapshot the
+ * draft onto a channel. Re-running with no changes publishes nothing. */
+export declare function runPublish(config: CodiedevConfig, args: PackArgs): Promise<PublishResult>;
+export declare const PACK_HELP = "Usage:\n  codiedev pack list                     Packs assigned to your team\n  codiedev pack install [slug] [--harness claude,codex,copilot,cursor,codie,pi] [--dry-run] [--json] [--quiet]\n                                         Install one pack, or every pack that applies\n  codiedev pack status [--json]          Installed packs and whether they're up to date\n  codiedev pack export <slug> --out <dir> [--git] [--manifest]\n                                         Write the pack as a Claude-format plugin folder plus\n                                         .claude-plugin/marketplace.json (commit it for CI).\n                                         --git inits the folder and commits; --manifest writes\n                                         an editable <slug>.pack.md instead\n  codiedev pack apply <pack.md> [--publish] [--channel stable|beta|alpha] [--dry-run]\n                                         Create or update a pack from a pack.md\n                                         (--publish then publishes it, see below)\n  codiedev pack publish <slug> [--channel stable|beta|alpha]\n                                         Publish the pack's draft to a channel (default\n                                         stable). Nothing happens when it hasn't changed.\n\nFiles (scripts, PDFs, a runner folder): list them under \"## Files\" in pack.md,\none \"- <path in pack> <- <local path>\" per line (local paths are relative to\nthe pack.md; \".\" is the pack root):\n\n  ## Files\n\n  - runner <- ~/.claude/runner\n  - skills/healthcare-scan <- ~/.claude/skills/healthcare-scan\n\n`pack apply` uploads them (admins and team managers; 15MB per file, 50MB per\npack; caches, .git and hidden files are skipped). Without a \"## Files\"\nsection the pack's files are left alone. In skills, point at files relative to\nthe skill's folder, or use ${CLAUDE_PLUGIN_ROOT}/runner/...: Codiedev swaps in the\nreal path for Codex, Copilot, Cursor, pi and Codie.\n\nCursor: packs are copied to ~/.cursor/plugins/local/codiedev-<slug>/. A Cursor\nteam admin can disable \"user local plugin imports\"; then Cursor ignores them.\n\nAuto-update: session starts run `codiedev pack install --quiet` in the background\nabout once an hour. Opt out with CODIEDEV_PACK_AUTOSYNC=0.\n\nHooks for specific skills only: codiedev hook-gate --skills a,b --cmd-b64 <base64url of the command>\n(the pack editor writes this; the command runs via /bin/sh, or cmd.exe on Windows)\n\nCI: set CODIEDEV_TOKEN to a pack CI key (cdvci_\u2026, from the pack's page in the portal).\nNo `codiedev connect` or config file is needed. CI mode (a cdvci_ key, or CI=true)\nnever auto-syncs, reports or prunes, installs the one pack the key can see, defaults\n--harness to claude when it's on PATH, and exits non-zero unless every requested tool\ngot the pack. Skills from a pack are /<pack-slug>:<skill> in Claude Code.\n\n  GitLab CI (.gitlab-ci.yml; add CODIEDEV_TOKEN and ANTHROPIC_API_KEY as masked\n  CI/CD variables):\n    pack-scan:\n      image: node:22\n      script:\n        - npm i -g codiedev @anthropic-ai/claude-code\n        - codiedev pack install --harness claude\n        - claude -p \"/platform-starter:healthcare-scan\" --output-format text\n\n  GitHub Actions (repository secrets CODIEDEV_TOKEN and ANTHROPIC_API_KEY):\n    - uses: actions/setup-node@v4\n      with: { node-version: 22 }\n    - run: npm i -g codiedev @anthropic-ai/claude-code\n    - run: codiedev pack install --harness claude\n      env:\n        CODIEDEV_TOKEN: ${{ secrets.CODIEDEV_TOKEN }}\n    - run: claude -p \"/platform-starter:healthcare-scan\" --output-format text\n      env:\n        ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}\n\n  Keep a pack up to date from its repo (GitLab; on merges to main). Use a\n  personal Codiedev token of a pack owner (portal \u2192 Integrations \u2192 CLI tokens) as a\n  masked CODIEDEV_TOKEN: pack CI keys can only install, not publish.\n    pack-release:\n      image: node:22\n      rules: [{ if: '$CI_COMMIT_BRANCH == \"main\"' }]\n      script:\n        - npm i -g codiedev\n        - codiedev pack apply packs/platform-starter.pack.md --publish\n  This ships the pack's files, agents, hooks and skill list. Edits to a skill's\n  own SKILL.md still go to the library with `codiedev push`.\n\n  Or vendor the plugin into the repo instead of installing at build time:\n    codiedev pack export <slug> --out .codiedev/packs";

package/dist/commands/pack.js

@@ -37,6 +37,7 @@ exports.PACK_HELP = exports.DEFAULT_BACKEND_URL = void 0;
 exports.resolvePackConfig = resolvePackConfig;
 exports.ciHarnesses = ciHarnesses;
 exports.parsePackArgs = parsePackArgs;
+exports.downloadPackFiles = downloadPackFiles;
 exports.runList = runList;
 exports.runInstall = runInstall;
 exports.runStatus = runStatus;
@@ -45,6 +46,7 @@ exports.commitExport = commitExport;
 exports.exportPluginFolder = exportPluginFolder;
 exports.runExport = runExport;
 exports.runApply = runApply;
+exports.runPublish = runPublish;
 const install_1 = require("../packs/install");
 const harnesses_1 = require("../packs/harnesses");
 const manifest_1 = require("../packs/manifest");
@@ -59,6 +61,7 @@ const harnesses_2 = require("../packs/harnesses");
 const os = __importStar(require("os"));
 const utils_1 = require("../utils");
 const shared_1 = require("./shared");
+const files_1 = require("../packs/files");
 // --- CI (pack-scoped `cdvci_` keys) ------------------------------------------
 exports.DEFAULT_BACKEND_URL = "https://cli.codiedev.com";
 /** CODIEDEV_TOKEN alone is enough: no ~/.codiedev/config.json needed (CI).
@@ -101,7 +104,27 @@ const USAGE = `Usage:
                                          .claude-plugin/marketplace.json (commit it for CI).
                                          --git inits the folder and commits; --manifest writes
                                          an editable <slug>.pack.md instead
-  codiedev pack apply <pack.md>          Create or update a pack from a pack.md
+  codiedev pack apply <pack.md> [--publish] [--channel stable|beta|alpha] [--dry-run]
+                                         Create or update a pack from a pack.md
+                                         (--publish then publishes it, see below)
+  codiedev pack publish <slug> [--channel stable|beta|alpha]
+                                         Publish the pack's draft to a channel (default
+                                         stable). Nothing happens when it hasn't changed.
+
+Files (scripts, PDFs, a runner folder): list them under "## Files" in pack.md,
+one "- <path in pack> <- <local path>" per line (local paths are relative to
+the pack.md; "." is the pack root):
+
+  ## Files
+
+  - runner <- ~/.claude/runner
+  - skills/healthcare-scan <- ~/.claude/skills/healthcare-scan
+
+\`pack apply\` uploads them (admins and team managers; 15MB per file, 50MB per
+pack; caches, .git and hidden files are skipped). Without a "## Files"
+section the pack's files are left alone. In skills, point at files relative to
+the skill's folder, or use \${CLAUDE_PLUGIN_ROOT}/runner/...: Codiedev swaps in the
+real path for Codex, Copilot, Cursor, pi and Codie.
 
 Cursor: packs are copied to ~/.cursor/plugins/local/codiedev-<slug>/. A Cursor
 team admin can disable "user local plugin imports"; then Cursor ignores them.
@@ -138,8 +161,25 @@ got the pack. Skills from a pack are /<pack-slug>:<skill> in Claude Code.
       env:
         ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
 
+  Keep a pack up to date from its repo (GitLab; on merges to main). Use a
+  personal Codiedev token of a pack owner (portal → Integrations → CLI tokens) as a
+  masked CODIEDEV_TOKEN: pack CI keys can only install, not publish.
+    pack-release:
+      image: node:22
+      rules: [{ if: '$CI_COMMIT_BRANCH == "main"' }]
+      script:
+        - npm i -g codiedev
+        - codiedev pack apply packs/platform-starter.pack.md --publish
+  This ships the pack's files, agents, hooks and skill list. Edits to a skill's
+  own SKILL.md still go to the library with \`codiedev push\`.
+
   Or vendor the plugin into the repo instead of installing at build time:
     codiedev pack export <slug> --out .codiedev/packs`;
+function parseChannel(value) {
+    if (value === "stable" || value === "beta" || value === "alpha")
+        return value;
+    throw new Error(`--channel must be stable, beta or alpha (got ${value})`);
+}
 function parsePackArgs(args) {
     const out = { dryRun: false, json: false };
     const positional = [];
@@ -157,6 +197,15 @@ function parsePackArgs(args) {
             out.git = true;
         else if (a === "--manifest")
             out.manifest = true;
+        else if (a === "--publish")
+            out.publish = true;
+        else if (a === "--channel") {
+            if (i + 1 >= args.length)
+                throw new Error("--channel needs stable, beta or alpha");
+            out.channel = parseChannel(args[++i]);
+        }
+        else if (a.startsWith("--channel="))
+            out.channel = parseChannel(a.slice("--channel=".length));
         else if (a === "--out" || a === "-o") {
             if (i + 1 >= args.length)
                 throw new Error("--out needs a directory");
@@ -188,6 +237,16 @@ async function fetchManifest(config, slug) {
     const raw = await (0, shared_1.apiRequest)("GET", "/api/cli/packs/manifest", { config, query: { slug } });
     return (0, manifest_1.parseManifest)(raw);
 }
+/** Download a pack's files (SIG-127) into the blob cache, verified by sha256. */
+async function downloadPackFiles(config, slug, files, dir) {
+    if (!files.length)
+        return 0;
+    const { downloaded } = await (0, files_1.ensureBlobs)(dir, files, (file) => (0, shared_1.apiRequestBytes)("GET", "/api/cli/packs/file", { config, query: { slug, sha256: file.sha256 }, maxBytes: files_1.PACK_FILE_MAX_BYTES + 1 })
+        .catch((error) => {
+        throw new Error(`couldn't download ${file.path} (${error.message})`);
+    }));
+    return downloaded;
+}
 async function runList(config, json, overrides = {}) {
     const packs = await listPacks(config);
     const registry = (0, store_1.readRegistry)((0, paths_1.packsRoot)(overrides.env, overrides.home));
@@ -206,6 +265,7 @@ async function runList(config, json, overrides = {}) {
             `${p.itemCount ?? 0} skill${p.itemCount === 1 ? "" : "s"}`,
             `${p.agentCount ?? 0} agent${p.agentCount === 1 ? "" : "s"}`,
             ...(p.hasHooks ? ["hooks"] : []),
+            ...(p.fileCount ? [`${p.fileCount} file${p.fileCount === 1 ? "" : "s"}`] : []),
         ].join(", ");
         const channel = (0, manifest_2.cleanLabel)(p.channel, 16);
         console.log(`${p.slug}  v${p.version}${channel ? ` [${channel}]` : ""}  ${(0, manifest_2.displayName)(p)}  (${counts}) — ${state}`);
@@ -244,8 +304,27 @@ async function runInstall(config, args, overrides = {}) {
             // A listed pack that 404s a moment later (race with an unassign) is skipped.
         }
     }
-    let installed = manifests.length
-        ? (0, install_1.installPacks)({ ...overrides, manifests, harnesses, dryRun: args.dryRun })
+    // Pack files first: a pack whose files can't be fetched keeps its previous
+    // install untouched rather than shipping half its folders.
+    const blobDir = overrides.blobDir ?? (0, files_1.blobsDir)(root);
+    const ready = [];
+    let downloadFailed = false;
+    for (const manifest of manifests) {
+        if (args.dryRun || !manifest.files?.length) {
+            ready.push(manifest);
+            continue;
+        }
+        try {
+            await downloadPackFiles(config, manifest.slug, manifest.files, blobDir);
+            ready.push(manifest);
+        }
+        catch (error) {
+            downloadFailed = true;
+            console.error(`✗ ${manifest.slug}: ${error.message}`);
+        }
+    }
+    let installed = ready.length
+        ? (0, install_1.installPacks)({ ...overrides, manifests: ready, harnesses, dryRun: args.dryRun, blobDir })
         : [];
     let removed = [];
     if (!args.dryRun && !ci) {
@@ -293,7 +372,7 @@ async function runInstall(config, args, overrides = {}) {
     const ciFailed = ci && !args.dryRun && (installed.length === 0 || installed.some((p) => p.results.some((r) => r.status !== "ok")));
     if (ci && !args.dryRun && installed.length === 0)
         console.error("No pack is visible to this key.");
-    if (failed || ciFailed || (args.slug && removed.length + revoked.length > 0))
+    if (failed || ciFailed || downloadFailed || (args.slug && removed.length + revoked.length > 0))
         process.exitCode = 1;
     return run;
 }
@@ -408,7 +487,7 @@ async function runPack(args) {
         console.error(USAGE);
         process.exit(1);
     }
-    if (!parsed.sub || !["list", "ls", "install", "status", "export", "apply"].includes(parsed.sub)) {
+    if (!parsed.sub || !["list", "ls", "install", "status", "export", "apply", "publish"].includes(parsed.sub)) {
         console.error(USAGE);
         process.exit(parsed.sub ? 1 : 0);
     }
@@ -428,6 +507,8 @@ async function runPack(args) {
                 await runExport(config, parsed);
             else if (parsed.sub === "apply")
                 await runApply(config, parsed);
+            else if (parsed.sub === "publish")
+                await runPublish(config, parsed);
             else
                 await runStatus(config, parsed.json, {}, { prune: !parsed.noPrune });
         });
@@ -494,9 +575,9 @@ function readMarketplaceEntries(dir) {
 /** Write a CI-committable copy of the pack: `<out>/plugins/<slug>/…` plus
  * `<out>/.claude-plugin/marketplace.json` (existing entries for other packs
  * in the same folder are kept). */
-function exportPluginFolder(out, manifest) {
+function exportPluginFolder(out, manifest, blobDir) {
     fs.mkdirSync(out, { recursive: true });
-    const dir = (0, store_1.writePluginDir)(out, manifest);
+    const dir = (0, store_1.writePluginDir)(out, manifest, { blobDir });
     const entries = readMarketplaceEntries(out).filter((e) => e.slug !== manifest.slug);
     entries.push({ slug: manifest.slug, description: manifest.description || manifest.name, version: manifest.version });
     (0, store_1.writeMarketplace)(out, entries);
@@ -524,7 +605,24 @@ async function runExport(config, args) {
         fs.mkdirSync(out, { recursive: true });
         // <slug>.pack.md so several packs can share one folder.
         written = path.join(out, `${args.slug}.pack.md`);
-        (0, store_1.writeFileAtomic)(written, res.markdown.endsWith("\n") ? res.markdown : `${res.markdown}\n`);
+        let markdown = res.markdown.endsWith("\n") ? res.markdown : `${res.markdown}\n`;
+        // Pack files go beside it in <slug>.files/, mapped back with `## Files`
+        // so `pack apply` round-trips them.
+        const files = (0, manifest_1.parseManifest)({ slug: args.slug, version: 0, contentHash: "-", files: res.files }).files ?? [];
+        if (files.length) {
+            const blobDir = (0, files_1.blobsDir)((0, paths_1.packsRoot)());
+            await downloadPackFiles(config, args.slug, files, blobDir);
+            const filesDir = path.join(out, `${args.slug}.files`);
+            fs.rmSync(filesDir, { recursive: true, force: true });
+            for (const f of files) {
+                const target = path.join(filesDir, ...f.path.split("/"));
+                fs.mkdirSync(path.dirname(target), { recursive: true });
+                fs.copyFileSync((0, files_1.blobPath)(blobDir, f.sha256), target);
+                fs.chmodSync(target, f.executable ? 0o755 : 0o644);
+            }
+            markdown = `${markdown.trimEnd()}\n\n## Files\n\n- . <- ./${args.slug}.files\n`;
+        }
+        (0, store_1.writeFileAtomic)(written, markdown);
         message = `codiedev pack export ${args.slug} (${args.slug}.pack.md)`;
     }
     else {
@@ -539,7 +637,9 @@ async function runExport(config, args) {
                 throw new Error(`Refusing to export ${args.slug}: ${error.message}`);
             throw error;
         }
-        written = exportPluginFolder(out, manifest);
+        const blobDir = (0, files_1.blobsDir)((0, paths_1.packsRoot)());
+        await downloadPackFiles(config, manifest.slug, manifest.files ?? [], blobDir);
+        written = exportPluginFolder(out, manifest, blobDir);
         message = `codiedev pack export ${manifest.slug} v${manifest.version}`;
     }
     const commit = args.git ? commitExport(out, message) : undefined;
@@ -567,13 +667,31 @@ async function runApply(config, args) {
     }
     if (!markdown.trim())
         throw new Error(`${file} is empty`);
+    // `## Files` (SIG-127): local folders/files to ship in the plugin dir.
+    // Absent ⇒ the pack's files are left as they are.
+    const entries = (0, files_1.parseFilesSection)(markdown);
+    const local = entries ? (0, files_1.collectLocalFiles)(entries, path.dirname(file)) : null;
+    for (const note of local?.notes ?? [])
+        console.log(`  · ${note}`);
     if (args.dryRun) {
-        console.log(`Dry run — would apply ${file} (${Buffer.byteLength(markdown)} bytes).`);
+        const extra = local ? `, ${local.files.length} file${local.files.length === 1 ? "" : "s"} (${formatBytes(local.files.reduce((n, f) => n + f.size, 0))})` : "";
+        console.log(`Dry run — would apply ${file} (${Buffer.byteLength(markdown)} bytes${extra}).`);
+        for (const f of local?.files ?? [])
+            console.log(`  ${f.path}`);
         return {};
     }
+    let uploaded = 0;
+    if (local?.files.length)
+        uploaded = await uploadPackFiles(config, local.files);
     let res;
     try {
-        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/apply", { config, body: { markdown } });
+        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/apply", {
+            config,
+            body: {
+                markdown,
+                ...(local ? { files: local.files.map((f) => ({ path: f.path, sha256: f.sha256, ...(f.executable ? { executable: true } : {}) })) } : {}),
+            },
+        });
     }
     catch (error) {
         // The server reports pack.md problems with line numbers; show them as-is.
@@ -590,6 +708,8 @@ async function runApply(config, args) {
         const verb = res.created === true ? "Created" : res.changed === false ? "No changes to" : "Updated";
         const version = typeof res.version === "number" ? ` v${res.version}` : "";
         console.log(`✓ ${verb} ${slug}${version} from ${path.basename(file)}`);
+        if (local)
+            console.log(`  files: ${local.files.length} (${uploaded} uploaded, ${local.files.length - uploaded} already on Codiedev)`);
         if (Array.isArray(res.warnings)) {
             for (const w of res.warnings) {
                 const text = typeof w === "string" ? w : typeof w?.message === "string" ? `${w.agent ? `${w.agent}: ` : ""}${w.message}` : JSON.stringify(w);
@@ -597,6 +717,81 @@ async function runApply(config, args) {
             }
         }
     }
+    if (args.publish && typeof res.slug === "string") {
+        const published = await runPublish(config, { ...args, slug: res.slug, json: false });
+        if (args.json)
+            return { ...res, published };
+    }
     return res;
 }
+/** `codiedev pack publish <slug> [--channel stable|beta|alpha]`: snapshot the
+ * draft onto a channel. Re-running with no changes publishes nothing. */
+async function runPublish(config, args) {
+    if (!args.slug)
+        throw new Error("Usage: codiedev pack publish <slug> [--channel stable|beta|alpha]");
+    if (!(0, manifest_2.isSafeSegment)(args.slug))
+        throw new Error(`Not a pack slug: ${args.slug}`);
+    const channel = args.channel ?? "stable";
+    if (args.dryRun) {
+        console.log(`Dry run — would publish ${args.slug}'s draft to ${channel}.`);
+        return { slug: args.slug, channel, version: 0, unchanged: true };
+    }
+    let res;
+    try {
+        res = await (0, shared_1.apiRequest)("POST", "/api/cli/packs/publish", { config, body: { slug: args.slug, channel } });
+    }
+    catch (error) {
+        const e = error;
+        if (e.status === 404)
+            throw new Error(`Pack not found: ${args.slug}`);
+        if (e.status === 403)
+            throw new Error(`You can't publish ${args.slug} (only its owners and admins can)`);
+        throw new Error(e.message);
+    }
+    const out = {
+        slug: typeof res.slug === "string" ? res.slug : args.slug,
+        channel,
+        version: typeof res.version === "number" ? res.version : 0,
+        unchanged: res.unchanged === true,
+    };
+    if (args.json)
+        console.log(JSON.stringify(out));
+    else if (out.unchanged)
+        console.log(`· ${out.slug} v${out.version} is already on ${channel} (no changes to publish)`);
+    else
+        console.log(`✓ Published ${out.slug} v${out.version} to ${channel}. Teams on ${channel} get it at their next sync.`);
+    return out;
+}
+function formatBytes(n) {
+    return n >= 1024 * 1024 ? `${(n / (1024 * 1024)).toFixed(1)}MB` : n >= 1024 ? `${Math.round(n / 1024)}KB` : `${n}B`;
+}
+/** Upload the blobs Codiedev doesn't have yet. Returns how many were sent. */
+async function uploadPackFiles(config, files) {
+    const unique = [...new Map(files.map((f) => [f.sha256, f])).values()];
+    let known;
+    try {
+        known = (await (0, shared_1.apiRequest)("POST", "/api/cli/packs/files/known", { config, body: { sha256s: unique.map((f) => f.sha256) } })).known ?? [];
+    }
+    catch (error) {
+        const e = error;
+        if (e.status === 403)
+            throw new Error(`Only admins and team managers can add files to a pack (${e.message})`);
+        throw error;
+    }
+    const have = new Set(known);
+    let sent = 0;
+    for (const f of unique) {
+        if (have.has(f.sha256))
+            continue;
+        const body = fs.readFileSync(f.abs);
+        try {
+            await (0, shared_1.apiRequestBytes)("POST", "/api/cli/packs/files/upload", { config, body, query: { sha256: f.sha256 } });
+        }
+        catch (error) {
+            throw new Error(`couldn't upload ${f.path} (${error.message})`);
+        }
+        sent += 1;
+    }
+    return sent;
+}
 exports.PACK_HELP = USAGE;

package/dist/commands/shared.d.ts

@@ -21,6 +21,17 @@ export declare function apiRequest<T = unknown>(method: "GET" | "POST", path: st
     body?: Record<string, unknown>;
     query?: Record<string, string | number | undefined>;
 }): Promise<T>;
+/**
+ * Binary twin of apiRequest: GET returns the raw body; POST sends `body` as
+ * application/octet-stream and returns parsed JSON. Same auth and errors
+ * (`status` on non-2xx). Used for starter-pack files (SIG-127).
+ */
+export declare function apiRequestBytes(method: "GET" | "POST", path: string, options: {
+    config: CodiedevConfig;
+    body?: Buffer;
+    query?: Record<string, string | number | undefined>;
+    maxBytes?: number;
+}): Promise<Buffer>;
 /**
  * Fire-and-forget per-invocation telemetry from CLI subcommands. Mirrors
  * the MCP server's emitTelemetry but stamps `source: "cli"` so adoption

package/dist/commands/shared.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyConfigEnvOverrides = applyConfigEnvOverrides;
 exports.requireConfig = requireConfig;
 exports.apiRequest = apiRequest;
+exports.apiRequestBytes = apiRequestBytes;
 exports.recordAgentEvent = recordAgentEvent;
 exports.recordInstallEvent = recordInstallEvent;
 exports.withTelemetry = withTelemetry;
@@ -135,6 +136,62 @@ function apiRequest(method, path, options) {
         req.end();
     });
 }
+/**
+ * Binary twin of apiRequest: GET returns the raw body; POST sends `body` as
+ * application/octet-stream and returns parsed JSON. Same auth and errors
+ * (`status` on non-2xx). Used for starter-pack files (SIG-127).
+ */
+function apiRequestBytes(method, path, options) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(path, options.config.backendUrl);
+        for (const [k, v] of Object.entries(options.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, String(v));
+        }
+        const lib = url.protocol === "https:" ? https : http;
+        const req = lib.request({
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: url.pathname + url.search,
+            method,
+            headers: {
+                Authorization: `Bearer ${options.config.token}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+                ...(options.body ? { "Content-Type": "application/octet-stream", "Content-Length": options.body.length } : {}),
+            },
+        }, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on("data", (c) => {
+                size += c.length;
+                if (options.maxBytes !== undefined && size > options.maxBytes) {
+                    req.destroy(Object.assign(new Error(`response over ${options.maxBytes} bytes`), { status: res.statusCode }));
+                    return;
+                }
+                chunks.push(c);
+            });
+            res.on("end", () => {
+                const buf = Buffer.concat(chunks);
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+                    return resolve(buf);
+                let message = `HTTP ${res.statusCode}`;
+                try {
+                    const parsed = JSON.parse(buf.toString("utf8"));
+                    if (parsed && typeof parsed.error === "string")
+                        message = parsed.error;
+                }
+                catch {
+                    // not JSON
+                }
+                reject(Object.assign(new Error(message), { status: res.statusCode }));
+            });
+        });
+        req.on("error", reject);
+        if (options.body)
+            req.write(options.body);
+        req.end();
+    });
+}
 /**
  * Fire-and-forget per-invocation telemetry from CLI subcommands. Mirrors
  * the MCP server's emitTelemetry but stamps `source: "cli"` so adoption

package/dist/packs/files.d.ts

@@ -0,0 +1,46 @@
+export declare const PACK_MAX_FILES = 500;
+export declare const PACK_FILE_MAX_BYTES: number;
+export declare const PACK_FILES_MAX_TOTAL_BYTES: number;
+export declare const SHA256_HEX: RegExp;
+export interface PackBundleFile {
+    path: string;
+    sha256: string;
+    size: number;
+    executable?: boolean;
+}
+/** Why a plugin-relative path can't be written, or null when it's fine. */
+export declare function packFilePathProblem(raw: unknown): string | null;
+export declare function blobsDir(root: string): string;
+export declare function blobPath(dir: string, sha256: string): string;
+export declare function sha256Of(buf: Buffer): string;
+/** Download every blob the manifest needs that isn't cached yet. Each body
+ * must match its sha256 and size or nothing is kept. */
+export declare function ensureBlobs(dir: string, files: PackBundleFile[], download: (file: PackBundleFile) => Promise<Buffer>): Promise<{
+    downloaded: number;
+}>;
+export interface FilesEntry {
+    dest: string;
+    source: string;
+    line: number;
+}
+/** 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. */
+export declare function parseFilesSection(markdown: string): FilesEntry[] | null;
+/** pack.md with its `## Files` section (heading and body) removed. */
+export declare function stripFilesSection(markdown: string): string;
+export interface LocalFile extends PackBundleFile {
+    abs: string;
+}
+export declare function expandHome(p: string, home?: string): string;
+/** 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. */
+export declare function collectLocalFiles(entries: FilesEntry[], baseDir: string, home?: string): {
+    files: LocalFile[];
+    notes: string[];
+};
+/** 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). */
+export declare function rewritePluginRoot(content: string, pluginRoot: string): string;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.84",
+  "version": "0.9.86",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",