codiedev 0.10.0-beta.4 → 0.10.0-beta.6

package/dist/packs/paths.js

@@ -0,0 +1,81 @@
+"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;
+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);
+}
+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");
+}
+function lastSyncPath(root) {
+    return path.join(root, ".last-sync");
+}
+function statusCachePath(root) {
+    return path.join(root, "status-cache.json");
+}
+function lastNagPath(root) {
+    return path.join(root, ".last-nag");
+}

package/dist/packs/shim.js

@@ -0,0 +1,214 @@
+"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;
+const fs = __importStar(require("fs"));
+const store_1 = require("./store");
+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;
+}
+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 });
+        }
+      }
+    },
+  };
+};
+`;
+}
+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.js

@@ -0,0 +1,155 @@
+"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.AGENT_LEVELS = void 0;
+exports.pluginVersion = pluginVersion;
+exports.writeFileAtomic = writeFileAtomic;
+exports.portableAgentContent = portableAgentContent;
+exports.pluginFiles = pluginFiles;
+exports.writePluginDir = writePluginDir;
+exports.readRegistry = readRegistry;
+exports.writeRegistry = writeRegistry;
+exports.marketplaceDocument = marketplaceDocument;
+exports.writeMarketplace = writeMarketplace;
+const fs = __importStar(require("fs"));
+const skillMarker_1 = require("../skillMarker");
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+function pluginVersion(version) {
+    return `${version}.0.0`;
+}
+function writeFileAtomic(file, content, mode = 0o644) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmp, content, { encoding: "utf8", mode });
+    fs.renameSync(tmp, file);
+}
+exports.AGENT_LEVELS = new Set(["opus", "sonnet", "haiku"]);
+function portableAgentContent(content) {
+    const fm = content.match(/^(\uFEFF?---\r?\n)([\s\S]*?)(\r?\n---[ \t]*(?:\r?\n|$))/);
+    if (!fm)
+        return content;
+    const lines = fm[2].split(/\r?\n/);
+    const kept = lines.filter((line) => {
+        const m = line.match(/^model\s*:\s*["']?([^"'\r\n]*?)["']?\s*$/);
+        return !m || m[1].includes("/");
+    });
+    if (kept.length === lines.length)
+        return content;
+    return fm[1] + kept.join("\n") + fm[3] + content.slice(fm[0].length);
+}
+function pluginFiles(manifest, options = {}) {
+    const files = {};
+    files[path.join(".claude-plugin", "plugin.json")] = JSON.stringify({
+        name: manifest.slug,
+        version: pluginVersion(manifest.version),
+        description: manifest.description || manifest.name,
+    }, null, 2) + "\n";
+    for (const skill of manifest.skills) {
+        files[path.join("skills", skill.name, "SKILL.md")] = (0, skillMarker_1.stampSkillMarker)(skill.content, skill.artifactId);
+    }
+    for (const agent of manifest.agents) {
+        files[path.join("agents", `${agent.name}.md`)] = options.portable ? portableAgentContent(agent.content) : agent.content;
+    }
+    if (manifest.hooksJson) {
+        files[path.join("hooks", "hooks.json")] = manifest.hooksJson;
+    }
+    return files;
+}
+function assertInside(parent, child) {
+    const rel = path.relative(parent, child);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`refusing to write outside the pack dir: ${child}`);
+    }
+}
+function writePluginDir(root, manifest, options = {}) {
+    const target = (0, paths_1.pluginDir)(root, manifest.slug);
+    const parent = (0, paths_1.pluginsDir)(root);
+    assertInside(parent, target);
+    fs.mkdirSync(parent, { recursive: true });
+    const stamp = `${process.pid}-${Date.now()}`;
+    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 file = path.join(tmp, rel);
+            assertInside(tmp, file);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, content, "utf8");
+        }
+        if (fs.existsSync(target))
+            fs.renameSync(target, old);
+        fs.renameSync(tmp, target);
+    }
+    catch (error) {
+        fs.rmSync(tmp, { recursive: true, force: true });
+        if (!fs.existsSync(target) && fs.existsSync(old))
+            fs.renameSync(old, target);
+        throw error;
+    }
+    fs.rmSync(old, { recursive: true, force: true });
+    return target;
+}
+function readRegistry(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, paths_1.registryPath)(root), "utf8"));
+        if (parsed && typeof parsed === "object" && parsed.packs && typeof parsed.packs === "object") {
+            return { packs: parsed.packs };
+        }
+    }
+    catch {
+    }
+    return { packs: {} };
+}
+function writeRegistry(root, registry) {
+    writeFileAtomic((0, paths_1.registryPath)(root), JSON.stringify(registry, null, 2) + "\n");
+}
+function marketplaceDocument(entries) {
+    const sorted = [...entries].sort((a, b) => a.slug.localeCompare(b.slug));
+    return {
+        name: paths_1.MARKETPLACE_NAME,
+        owner: { name: "Codiedev" },
+        metadata: { description: "Codiedev team starter packs" },
+        plugins: sorted.map((entry) => ({
+            name: entry.slug,
+            source: `./plugins/${entry.slug}`,
+            description: entry.description || entry.slug,
+            version: pluginVersion(entry.version),
+        })),
+    };
+}
+function writeMarketplace(root, entries) {
+    writeFileAtomic((0, paths_1.marketplacePath)(root), JSON.stringify(marketplaceDocument(entries), null, 2) + "\n");
+}

package/dist/packs/sync.js

@@ -0,0 +1,170 @@
+"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.EMPTY_RECHECK_MS = exports.NAG_INTERVAL_MS = exports.SYNC_INTERVAL_MS = void 0;
+exports.isPackCiMode = isPackCiMode;
+exports.readStatusCache = readStatusCache;
+exports.writeStatusCache = writeStatusCache;
+exports.autosyncDisabled = autosyncDisabled;
+exports.decideSync = decideSync;
+exports.cliEntry = cliEntry;
+exports.maybeSpawnPackSync = maybeSpawnPackSync;
+exports.packNagLine = packNagLine;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+const store_1 = require("./store");
+exports.SYNC_INTERVAL_MS = 60 * 60 * 1000;
+function isPackCiMode(env = process.env) {
+    const ci = (env.CI ?? "").trim().toLowerCase();
+    return (env.CODIEDEV_TOKEN ?? "").trim().startsWith("cdvci_") || ci === "true" || ci === "1";
+}
+exports.NAG_INTERVAL_MS = 24 * 60 * 60 * 1000;
+exports.EMPTY_RECHECK_MS = 24 * 60 * 60 * 1000;
+function readStatusCache(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, paths_1.statusCachePath)(root), "utf8"));
+        if (typeof parsed?.checkedAt !== "number")
+            return null;
+        return {
+            checkedAt: parsed.checkedAt,
+            available: typeof parsed.available === "number" ? parsed.available : 0,
+            outdated: Array.isArray(parsed.outdated) ? parsed.outdated.filter((o) => typeof o?.slug === "string") : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeStatusCache(root, cache) {
+    try {
+        (0, store_1.writeFileAtomic)((0, paths_1.statusCachePath)(root), JSON.stringify(cache) + "\n");
+    }
+    catch {
+    }
+}
+function mtime(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function registryNonEmpty(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, paths_1.registryPath)(root), "utf8"));
+        return Boolean(parsed?.packs && Object.keys(parsed.packs).length > 0);
+    }
+    catch {
+        return false;
+    }
+}
+function autosyncDisabled(env) {
+    const v = (env.CODIEDEV_PACK_AUTOSYNC ?? "").trim().toLowerCase();
+    return v === "0" || v === "false" || v === "off" || v === "no";
+}
+function decideSync(root, env, now) {
+    const last = mtime((0, paths_1.lastSyncPath)(root));
+    if (last !== null && now - last < exports.SYNC_INTERVAL_MS && last <= now)
+        return "throttled";
+    if (!registryNonEmpty(root)) {
+        const cache = readStatusCache(root);
+        if (cache && cache.available === 0 && now - cache.checkedAt < exports.EMPTY_RECHECK_MS)
+            return "no-packs";
+    }
+    return autosyncDisabled(env) ? "spawn-check" : "spawn-install";
+}
+function cliEntry() {
+    return path.join(__dirname, "..", "cli.js");
+}
+function maybeSpawnPackSync(options = {}) {
+    try {
+        if (options.connected === false)
+            return "not-connected";
+        const env = options.env ?? process.env;
+        if (isPackCiMode(env))
+            return "ci";
+        const root = (0, paths_1.packsRoot)(env, options.home ?? os.homedir());
+        const now = options.now ?? Date.now();
+        const decision = decideSync(root, env, now);
+        if (decision !== "spawn-install" && decision !== "spawn-check")
+            return decision;
+        fs.mkdirSync(root, { recursive: true });
+        fs.writeFileSync((0, paths_1.lastSyncPath)(root), String(now));
+        const time = new Date(now);
+        fs.utimesSync((0, paths_1.lastSyncPath)(root), time, time);
+        const args = decision === "spawn-install"
+            ? ["pack", "install", "--quiet"]
+            : ["pack", "status", "--quiet", "--no-prune"];
+        const child = (options.spawn ?? child_process_1.spawn)(process.execPath, [options.cli ?? cliEntry(), ...args], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...env, CODIEDEV_PACK_BACKGROUND: "1" },
+        });
+        child.on?.("error", () => { });
+        child.unref?.();
+        return decision;
+    }
+    catch {
+        return "error";
+    }
+}
+function packNagLine(options = {}) {
+    try {
+        const env = options.env ?? process.env;
+        if (env.CODIEDEV_PACK_BACKGROUND || isPackCiMode(env))
+            return null;
+        const root = (0, paths_1.packsRoot)(env, options.home ?? os.homedir());
+        const now = options.now ?? Date.now();
+        const cache = readStatusCache(root);
+        if (!cache || cache.outdated.length === 0)
+            return null;
+        const last = mtime((0, paths_1.lastNagPath)(root));
+        if (last !== null && now - last < exports.NAG_INTERVAL_MS && last <= now)
+            return null;
+        fs.writeFileSync((0, paths_1.lastNagPath)(root), String(now));
+        const time = new Date(now);
+        fs.utimesSync((0, paths_1.lastNagPath)(root), time, time);
+        const first = cache.outdated[0];
+        const more = cache.outdated.length > 1 ? ` (+${cache.outdated.length - 1} more)` : "";
+        return `Starter pack ${first.name || first.slug}${more} has updates. Run \`codiedev pack install\`.`;
+    }
+    catch {
+        return null;
+    }
+}