codiedev 0.9.66 → 0.9.68

package/dist/packs/manifest.d.ts

@@ -0,0 +1,52 @@
+export interface PackManifestFile {
+    name: string;
+    content: string;
+    /** Skills only: the artifact the content came from (identity marker). */
+    artifactId?: string;
+}
+export interface PackManifest {
+    slug: string;
+    name: string;
+    description: string;
+    version: number;
+    contentHash: string;
+    skills: PackManifestFile[];
+    agents: PackManifestFile[];
+    hooksJson: string | null;
+    /** Release channel the manifest resolved to (stable|beta|alpha|draft). */
+    channel?: string;
+    /** Display emoji/icon; never used in paths. */
+    icon?: string;
+}
+export interface PackSummary {
+    slug: string;
+    name: string;
+    description?: string;
+    version: number;
+    channel?: string;
+    icon?: string;
+    itemCount?: number;
+    agentCount?: number;
+    hasHooks?: boolean;
+}
+export declare function isSafeSegment(value: unknown): value is string;
+export declare function isSafeSkillName(value: unknown): value is string;
+export declare class ManifestError extends Error {
+}
+/** Validate a manifest from the server. Throws ManifestError on anything
+ * unsafe or malformed — a partial install of a tampered pack is worse than
+ * none. */
+export declare function parseManifest(input: unknown): PackManifest;
+/** Short display-only label from the server: printable, no control chars. */
+export declare function cleanLabel(value: unknown, max: number): string | undefined;
+/** "🧰 Backend starter" when an icon is set. */
+export declare function displayName(pack: {
+    name?: string;
+    slug: string;
+    icon?: unknown;
+}): string;
+/** Parse leading `---` YAML-ish frontmatter (flat `key: value` lines only). */
+export declare function parseFrontmatter(content: string): {
+    data: Record<string, string>;
+    body: string;
+};

package/dist/packs/manifest.js

@@ -0,0 +1,140 @@
+"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;
+exports.isSafeSkillName = isSafeSkillName;
+exports.parseManifest = parseManifest;
+exports.cleanLabel = cleanLabel;
+exports.displayName = displayName;
+exports.parseFrontmatter = parseFrontmatter;
+// One path segment: starts alphanumeric, then alphanumerics, dot, dash or
+// underscore. Rejects "", ".", "..", slashes, backslashes, absolute paths,
+// drive letters, NUL and whitespace.
+const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function isSafeSegment(value) {
+    return typeof value === "string" && SAFE_SEGMENT.test(value) && !value.includes("..");
+}
+// Skill dir names come from SKILL.md frontmatter and may contain inner spaces
+// (the server allows `[A-Za-z0-9][A-Za-z0-9._ -]*`); still one safe segment.
+const SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._ -]{0,127}$/;
+function isSafeSkillName(value) {
+    return typeof value === "string" && SAFE_SKILL_NAME.test(value) && !value.includes("..") && value.trim() === value;
+}
+class ManifestError extends Error {
+}
+exports.ManifestError = ManifestError;
+function fileList(value, field, safe) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new ManifestError(`manifest.${field} must be an array`);
+    const seen = new Set();
+    return value.map((item, index) => {
+        const entry = item;
+        if (!entry || typeof entry !== "object")
+            throw new ManifestError(`manifest.${field}[${index}] is not an object`);
+        if (!safe(entry.name)) {
+            throw new ManifestError(`manifest.${field}[${index}] has an unsafe name: ${JSON.stringify(entry.name)}`);
+        }
+        if (typeof entry.content !== "string")
+            throw new ManifestError(`manifest.${field}[${index}].content must be a string`);
+        const key = entry.name.toLowerCase();
+        if (seen.has(key))
+            throw new ManifestError(`manifest.${field} has a duplicate name: ${entry.name}`);
+        seen.add(key);
+        const artifactId = typeof entry.artifactId === "string" && /^[a-z0-9]{16,64}$/i.test(entry.artifactId) ? entry.artifactId : undefined;
+        return { name: entry.name, content: entry.content, ...(artifactId ? { artifactId } : {}) };
+    });
+}
+/** Validate a manifest from the server. Throws ManifestError on anything
+ * unsafe or malformed — a partial install of a tampered pack is worse than
+ * none. */
+function parseManifest(input) {
+    let raw = input;
+    if (typeof raw === "string") {
+        try {
+            raw = JSON.parse(raw);
+        }
+        catch {
+            throw new ManifestError("manifest is not valid JSON");
+        }
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new ManifestError("manifest is not an object");
+    const m = raw;
+    if (!isSafeSegment(m.slug))
+        throw new ManifestError(`manifest has an unsafe slug: ${JSON.stringify(m.slug)}`);
+    const version = Number(m.version);
+    if (!Number.isInteger(version) || version < 0)
+        throw new ManifestError("manifest.version must be a non-negative integer");
+    if (typeof m.contentHash !== "string" || !m.contentHash)
+        throw new ManifestError("manifest.contentHash is missing");
+    let hooksJson = null;
+    if (m.hooksJson !== undefined && m.hooksJson !== null) {
+        if (typeof m.hooksJson !== "string")
+            throw new ManifestError("manifest.hooksJson must be a string or null");
+        if (m.hooksJson.trim()) {
+            let parsed;
+            try {
+                parsed = JSON.parse(m.hooksJson);
+            }
+            catch {
+                throw new ManifestError("manifest.hooksJson is not valid JSON");
+            }
+            const hooks = parsed?.hooks;
+            if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+                throw new ManifestError("manifest.hooksJson must look like {\"hooks\":{...}}");
+            }
+            hooksJson = m.hooksJson;
+        }
+    }
+    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),
+        hooksJson,
+        ...(cleanLabel(m.channel, 16) ? { channel: cleanLabel(m.channel, 16) } : {}),
+        ...(cleanLabel(m.icon, 16) ? { icon: cleanLabel(m.icon, 16) } : {}),
+    };
+}
+/** Short display-only label from the server: printable, no control chars. */
+function cleanLabel(value, max) {
+    if (typeof value !== "string")
+        return undefined;
+    const clean = value
+        .replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, "") // ANSI CSI sequences
+        .replace(/[\u0000-\u001f\u007f-\u009f]/g, "")
+        .trim();
+    return clean ? [...clean].slice(0, max).join("") : undefined;
+}
+/** "🧰 Backend starter" when an icon is set. */
+function displayName(pack) {
+    const icon = cleanLabel(pack.icon, 8);
+    const name = pack.name || pack.slug;
+    return icon ? `${icon} ${name}` : name;
+}
+/** Parse leading `---` YAML-ish frontmatter (flat `key: value` lines only). */
+function parseFrontmatter(content) {
+    const match = content.match(/^?---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (!match)
+        return { data: {}, body: content };
+    const data = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        data[kv[1]] = value;
+    }
+    return { data, body: content.slice(match[0].length) };
+}

package/dist/packs/paths.d.ts

@@ -0,0 +1,17 @@
+export declare const MARKETPLACE_NAME = "codiedev-packs";
+export declare function packsRoot(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function pluginsDir(root: string): string;
+export declare function pluginDir(root: string, slug: string): string;
+/** Codex, Copilot and Cursor read a "portable" copy of each plugin: agent
+ * `model:` levels (opus/sonnet/haiku) are Claude Code aliases, so those tools
+ * get the line removed and use their own default. Same marketplace name, its
+ * own root. */
+export declare function portableRoot(root: string): string;
+export declare function marketplacePath(root: string): string;
+export declare function registryPath(root: string): string;
+export declare function shimPath(root: string): string;
+/** Stamp of the last background `pack install --quiet` spawn. */
+export declare function lastSyncPath(root: string): string;
+/** Cached `pack status`, written by every sync/status run, read by the nag. */
+export declare function statusCachePath(root: string): string;
+export declare function lastNagPath(root: string): string;

package/dist/packs/paths.js

@@ -0,0 +1,89 @@
+"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.MARKETPLACE_NAME = void 0;
+exports.packsRoot = packsRoot;
+exports.pluginsDir = pluginsDir;
+exports.pluginDir = pluginDir;
+exports.portableRoot = portableRoot;
+exports.marketplacePath = marketplacePath;
+exports.registryPath = registryPath;
+exports.shimPath = shimPath;
+exports.lastSyncPath = lastSyncPath;
+exports.statusCachePath = statusCachePath;
+exports.lastNagPath = lastNagPath;
+// Where starter packs live on disk. Resolved per call (not at import) so tests
+// and `CODIEDEV_CONFIG_DIR` overrides take effect without module reloads.
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.MARKETPLACE_NAME = "codiedev-packs";
+function packsRoot(env = process.env, home = os.homedir()) {
+    const override = env.CODIEDEV_CONFIG_DIR?.trim();
+    const stateDir = override ? path.resolve(override) : path.join(home, ".codiedev");
+    return path.join(stateDir, "packs");
+}
+function pluginsDir(root) {
+    return path.join(root, "plugins");
+}
+function pluginDir(root, slug) {
+    return path.join(pluginsDir(root), slug);
+}
+/** Codex, Copilot and Cursor read a "portable" copy of each plugin: agent
+ * `model:` levels (opus/sonnet/haiku) are Claude Code aliases, so those tools
+ * get the line removed and use their own default. Same marketplace name, its
+ * own root. */
+function portableRoot(root) {
+    return path.join(root, "portable");
+}
+function marketplacePath(root) {
+    return path.join(root, ".claude-plugin", "marketplace.json");
+}
+function registryPath(root) {
+    return path.join(root, "installed.json");
+}
+function shimPath(root) {
+    return path.join(root, "codie-hook-shim.mjs");
+}
+/** Stamp of the last background `pack install --quiet` spawn. */
+function lastSyncPath(root) {
+    return path.join(root, ".last-sync");
+}
+/** Cached `pack status`, written by every sync/status run, read by the nag. */
+function statusCachePath(root) {
+    return path.join(root, "status-cache.json");
+}
+function lastNagPath(root) {
+    return path.join(root, ".last-nag");
+}

package/dist/packs/shim.d.ts

@@ -0,0 +1,26 @@
+export interface ShimPack {
+    slug: string;
+    root: string;
+    hooks: Record<string, unknown>;
+}
+export declare const SHIM_EVENTS: readonly ["SessionStart", "PreToolUse", "PostToolUse", "Stop"];
+interface ShimHandler {
+    command: string;
+    timeout?: number;
+}
+interface ShimGroup {
+    matcher?: string;
+    hooks: ShimHandler[];
+}
+/** Per pack, the hook events in its hooks.json the shim cannot wire. */
+export declare function unsupportedShimEvents(packs: ShimPack[]): Map<string, string[]>;
+export declare function shimPacks(packs: ShimPack[]): Array<{
+    slug: string;
+    root: string;
+    hooks: Record<string, ShimGroup[]>;
+}>;
+export declare function generateShimSource(packs: ShimPack[]): string;
+/** Write (or remove, when no pack has wireable hooks) the shim. Returns the
+ * path when a shim exists afterwards. */
+export declare function writeShim(file: string, packs: ShimPack[]): string | null;
+export {};

package/dist/packs/shim.js

@@ -0,0 +1,222 @@
+"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.SHIM_EVENTS = void 0;
+exports.unsupportedShimEvents = unsupportedShimEvents;
+exports.shimPacks = shimPacks;
+exports.generateShimSource = generateShimSource;
+exports.writeShim = writeShim;
+// Generates the OpenCode plugin that runs starter-pack Claude hooks inside
+// Codie. Stock OpenCode cannot load a Claude plugin's hooks.json, so this shim
+// translates OpenCode plugin events into Claude hook invocations (Claude-style
+// JSON on stdin, exit 2 on PreToolUse blocks the tool).
+const fs = __importStar(require("fs"));
+const store_1 = require("./store");
+// Only events with an OpenCode equivalent are wired; others are dropped.
+exports.SHIM_EVENTS = ["SessionStart", "PreToolUse", "PostToolUse", "Stop"];
+function normalizeHooks(hooks) {
+    const out = {};
+    for (const event of exports.SHIM_EVENTS) {
+        const groups = hooks[event];
+        if (!Array.isArray(groups))
+            continue;
+        const normalized = [];
+        for (const groupValue of groups) {
+            const group = groupValue;
+            if (!group || !Array.isArray(group.hooks))
+                continue;
+            const handlers = [];
+            for (const handlerValue of group.hooks) {
+                const handler = handlerValue;
+                if (!handler || handler.type !== "command" || typeof handler.command !== "string")
+                    continue;
+                handlers.push({
+                    command: handler.command,
+                    ...(typeof handler.timeout === "number" && handler.timeout > 0 ? { timeout: handler.timeout } : {}),
+                });
+            }
+            if (handlers.length === 0)
+                continue;
+            normalized.push({
+                ...(typeof group.matcher === "string" ? { matcher: group.matcher } : {}),
+                hooks: handlers,
+            });
+        }
+        if (normalized.length)
+            out[event] = normalized;
+    }
+    return out;
+}
+/** Per pack, the hook events in its hooks.json the shim cannot wire. */
+function unsupportedShimEvents(packs) {
+    const out = new Map();
+    for (const pack of packs) {
+        const events = Object.keys(pack.hooks ?? {}).filter((e) => !exports.SHIM_EVENTS.includes(e)).sort();
+        if (events.length)
+            out.set(pack.slug, events);
+    }
+    return out;
+}
+function shimPacks(packs) {
+    return packs
+        .map((pack) => ({ slug: pack.slug, root: pack.root, hooks: normalizeHooks(pack.hooks) }))
+        .filter((pack) => Object.keys(pack.hooks).length > 0);
+}
+function generateShimSource(packs) {
+    const data = shimPacks(packs);
+    return `// Managed by \`codiedev pack install\`. Regenerated on every install; do not edit.
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const PACKS = ${JSON.stringify(data, null, 2)};
+
+// OpenCode tool ids are lowercase; Claude hook matchers use Claude casing.
+const TOOL_NAMES = {
+  bash: "Bash", edit: "Edit", write: "Write", read: "Read", grep: "Grep",
+  glob: "Glob", list: "LS", ls: "LS", webfetch: "WebFetch", websearch: "WebSearch",
+  todowrite: "TodoWrite", todoread: "TodoRead", task: "Task", multiedit: "MultiEdit",
+  patch: "Edit", apply_patch: "Edit",
+};
+
+export function claudeToolName(tool) {
+  const name = String(tool ?? "");
+  if (!name) return "unknown";
+  return TOOL_NAMES[name.toLowerCase()] ?? name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+// Claude semantics: empty or "*" matches everything; otherwise a regex that
+// must match the whole tool name ("Edit|Write", "Notebook.*").
+export function matches(matcher, value) {
+  if (matcher === undefined || matcher === null || matcher === "" || matcher === "*") return true;
+  try {
+    return new RegExp("^(?:" + matcher + ")$").test(value);
+  } catch {
+    return false;
+  }
+}
+
+function handlersFor(event, value) {
+  const out = [];
+  for (const pack of PACKS) {
+    for (const group of pack.hooks[event] ?? []) {
+      if (!matches(group.matcher, value)) continue;
+      for (const handler of group.hooks) out.push({ ...handler, root: pack.root });
+    }
+  }
+  return out;
+}
+
+function run(handler, payload) {
+  const cwd = typeof payload.cwd === "string" && existsSync(payload.cwd) ? payload.cwd : undefined;
+  return spawnSync(handler.command, [], {
+    input: JSON.stringify(payload),
+    encoding: "utf8",
+    shell: true,
+    cwd,
+    timeout: (handler.timeout ?? 60) * 1000,
+    env: { ...process.env, CLAUDE_PLUGIN_ROOT: handler.root },
+  });
+}
+
+function sessionId(value) {
+  return value?.sessionID ?? value?.sessionId ?? value?.properties?.sessionID ?? value?.properties?.info?.id ?? undefined;
+}
+
+export const CodiedevPackHooks = async (ctx = {}) => {
+  const cwd = ctx?.worktree || ctx?.directory || process.cwd();
+  const childSessions = new Set();
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool_name = claudeToolName(input?.tool);
+      for (const handler of handlersFor("PreToolUse", tool_name)) {
+        const result = run(handler, {
+          hook_event_name: "PreToolUse",
+          session_id: sessionId(input),
+          cwd,
+          tool_name,
+          tool_input: output?.args ?? {},
+        });
+        if (result.status === 2) throw new Error(String(result.stderr ?? "").trim() || "Blocked by hook");
+      }
+    },
+    "tool.execute.after": async (input, output) => {
+      const tool_name = claudeToolName(input?.tool);
+      for (const handler of handlersFor("PostToolUse", tool_name)) {
+        run(handler, {
+          hook_event_name: "PostToolUse",
+          session_id: sessionId(input),
+          cwd,
+          tool_name,
+          tool_input: input?.args ?? {},
+          tool_response: output ?? null,
+        });
+      }
+    },
+    event: async ({ event } = {}) => {
+      // OpenCode also emits session.created/idle for subagent (child)
+      // sessions. Claude's SessionStart/Stop are top-level only, so remember
+      // children (info.parentID) and skip them. session.idle carries only the
+      // sessionID, hence the set.
+      const info = event?.properties?.info;
+      if (info?.id && info?.parentID) childSessions.add(info.id);
+      if (event?.type === "session.created") {
+        if (info?.parentID) return;
+        for (const handler of handlersFor("SessionStart", "startup")) {
+          run(handler, { hook_event_name: "SessionStart", session_id: sessionId(event), cwd, source: "startup" });
+        }
+        return;
+      }
+      if (event?.type === "session.idle") {
+        const id = sessionId(event);
+        if (info?.parentID || (id && childSessions.has(id))) return;
+        for (const handler of handlersFor("Stop", "")) {
+          run(handler, { hook_event_name: "Stop", session_id: sessionId(event), cwd, stop_hook_active: false });
+        }
+      }
+    },
+  };
+};
+`;
+}
+/** Write (or remove, when no pack has wireable hooks) the shim. Returns the
+ * path when a shim exists afterwards. */
+function writeShim(file, packs) {
+    if (shimPacks(packs).length === 0) {
+        fs.rmSync(file, { force: true });
+        return null;
+    }
+    (0, store_1.writeFileAtomic)(file, generateShimSource(packs), 0o600);
+    return file;
+}

package/dist/packs/store.d.ts

@@ -0,0 +1,42 @@
+import { PackManifest } from "./manifest";
+export interface RegistryEntry {
+    version: number;
+    contentHash: string;
+    dir: string;
+    installedAt: number;
+    harnesses: string[];
+    name?: string;
+    description?: string;
+    channel?: string;
+    icon?: string;
+}
+export interface Registry {
+    packs: Record<string, RegistryEntry>;
+}
+export declare function pluginVersion(version: number): string;
+/** Write a file via temp + rename so readers never see a partial file. */
+export declare function writeFileAtomic(file: string, content: string, mode?: number): void;
+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?: {
+    portable?: boolean;
+}): 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 readRegistry(root: string): Registry;
+export declare function writeRegistry(root: string, registry: Registry): void;
+export interface MarketplaceEntry {
+    slug: string;
+    description?: string;
+    version: number;
+}
+export declare function marketplaceDocument(entries: MarketplaceEntry[]): Record<string, unknown>;
+/** Rewrite marketplace.json atomically with one entry per pack. */
+export declare function writeMarketplace(root: string, entries: MarketplaceEntry[]): void;