codiedev 0.9.66 → 0.9.68

package/dist/packs/store.js

@@ -0,0 +1,167 @@
+"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;
+// On-disk layout for installed packs: the Claude-format plugin dir, the local
+// marketplace that every harness reads, and the installed.json registry.
+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`;
+}
+/** Write a file via temp + rename so readers never see a partial file. */
+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"]);
+/** 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). */
+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);
+}
+/** The full file set for a pack's plugin dir, relative path → content. */
+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) {
+        // 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);
+    }
+    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}`);
+    }
+}
+/** 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. */
+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 {
+        // Missing or corrupt registry → start fresh.
+    }
+    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),
+        })),
+    };
+}
+/** Rewrite marketplace.json atomically with one entry per pack. */
+function writeMarketplace(root, entries) {
+    writeFileAtomic((0, paths_1.marketplacePath)(root), JSON.stringify(marketplaceDocument(entries), null, 2) + "\n");
+}

package/dist/packs/sync.d.ts

@@ -0,0 +1,40 @@
+import { spawn as nodeSpawn } from "child_process";
+export declare const SYNC_INTERVAL_MS: number;
+/** CI mode: a pack-scoped CI key (`cdvci_…`) or CI=true. No auto-sync, no
+ * nudge, no server writes, no pruning — CI machines are ephemeral and CI keys
+ * can only read packs. */
+export declare function isPackCiMode(env?: NodeJS.ProcessEnv): boolean;
+export declare const NAG_INTERVAL_MS: number;
+export declare const EMPTY_RECHECK_MS: number;
+export interface StatusCache {
+    checkedAt: number;
+    available: number;
+    outdated: Array<{
+        slug: string;
+        name?: string;
+    }>;
+}
+export declare function readStatusCache(root: string): StatusCache | null;
+export declare function writeStatusCache(root: string, cache: StatusCache): void;
+export declare function autosyncDisabled(env: NodeJS.ProcessEnv): boolean;
+export type SyncDecision = "spawn-install" | "spawn-check" | "throttled" | "no-packs";
+/** Pure decision for the hourly background sync. */
+export declare function decideSync(root: string, env: NodeJS.ProcessEnv, now: number): SyncDecision;
+export declare function cliEntry(): string;
+export interface SpawnSyncOptions {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    now?: number;
+    spawn?: typeof nodeSpawn;
+    cli?: string;
+    connected?: boolean;
+}
+/** Called from session-start hooks. Never throws, never waits. */
+export declare function maybeSpawnPackSync(options?: SpawnSyncOptions): SyncDecision | "error" | "not-connected" | "ci";
+/** One-line nudge when the cached status shows an outdated pack, at most once
+ * a day. Returns null (and records nothing) when there's nothing to say. */
+export declare function packNagLine(options?: {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    now?: number;
+}): string | null;

package/dist/packs/sync.js

@@ -0,0 +1,190 @@
+"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;
+// Background auto-update and the "pack has updates" nudge.
+//
+// Hot-path rule: maybeSpawnPackSync and packNagLine run inside session-start
+// hooks and every `codiedev` command, so they only stat/read tiny local files
+// and, at most once an hour, spawn a detached child. No network here, ever.
+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;
+/** CI mode: a pack-scoped CI key (`cdvci_…`) or CI=true. No auto-sync, no
+ * nudge, no server writes, no pruning — CI machines are ephemeral and CI keys
+ * can only read packs. */
+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;
+// With nothing installed and a fresh "your team has no packs" answer, only
+// re-ask once a day so a newly assigned pack still arrives.
+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 {
+        // best-effort
+    }
+}
+function mtime(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function registryNonEmpty(root) {
+    // installed.json is tiny; `{"packs":{}}` means nothing is installed.
+    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";
+}
+/** Pure decision for the hourly background sync. */
+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";
+    }
+    // Opted out of auto-install: still refresh the cached status (read-only,
+    // no install, no pruning) so the outdated nudge can tell them.
+    return autosyncDisabled(env) ? "spawn-check" : "spawn-install";
+}
+function cliEntry() {
+    // dist/packs/sync.js → dist/cli.js
+    return path.join(__dirname, "..", "cli.js");
+}
+/** Called from session-start hooks. Never throws, never waits. */
+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;
+        // Stamp first so concurrent session starts don't each spawn a sync.
+        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";
+    }
+}
+/** One-line nudge when the cached status shows an outdated pack, at most once
+ * a day. Returns null (and records nothing) when there's nothing to say. */
+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;
+    }
+}

package/dist/skillMarker.d.ts

@@ -0,0 +1,6 @@
+/** Is this a SKILL.md-style file (frontmatter with name + description)? */
+export declare function looksLikeSkill(markdown: string): boolean;
+/** Remove every marker line (idempotent). */
+export declare function stripSkillMarker(markdown: string): string;
+/** Stamp (or re-stamp) the marker. Leaves the text alone for a bad id. */
+export declare function stampSkillMarker(markdown: string, artifactId: string | undefined | null): string;

package/dist/skillMarker.js

@@ -0,0 +1,37 @@
+"use strict";
+// Skill identity marker. Two authors can each publish a skill with the same
+// name ("/ticket"); a session's transcript only records the name it ran. A
+// company skill written to disk therefore carries the artifact it came from:
+//
+//   <!-- codiedev:artifact=<artifact id> -->
+//
+// appended after the body (frontmatter untouched, invisible when rendered).
+// When the harness loads the skill, the marker lands in the transcript and
+// parseCaptureSignals reports it as signals.skillInvocationArtifacts, so the
+// portal attributes the run to the exact skill. `push` strips it, so a
+// re-pushed copy never claims someone else's artifact id.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeSkill = looksLikeSkill;
+exports.stripSkillMarker = stripSkillMarker;
+exports.stampSkillMarker = stampSkillMarker;
+const ID = /^[a-z0-9]{16,64}$/i;
+const LINE = /^[ \t]*<!--\s*codiedev:artifact=[a-z0-9]+\s*-->[ \t]*(?:\r?\n|$)/gim;
+/** Is this a SKILL.md-style file (frontmatter with name + description)? */
+function looksLikeSkill(markdown) {
+    const fm = markdown.match(/^?---\r?\n([\s\S]*?)\r?\n---/);
+    if (!fm)
+        return false;
+    return /^name\s*:/im.test(fm[1]) && /^description\s*:/im.test(fm[1]);
+}
+/** Remove every marker line (idempotent). */
+function stripSkillMarker(markdown) {
+    return markdown.replace(LINE, "");
+}
+/** Stamp (or re-stamp) the marker. Leaves the text alone for a bad id. */
+function stampSkillMarker(markdown, artifactId) {
+    if (!artifactId || !ID.test(artifactId))
+        return markdown;
+    const body = stripSkillMarker(markdown);
+    const sep = body.endsWith("\n") ? "" : "\n";
+    return `${body}${sep}<!-- codiedev:artifact=${artifactId} -->\n`;
+}

package/dist/subagents.js

@@ -87,10 +87,14 @@ function foldSubagentSignals(parent, subs, source) {
     const invocations = new Set(parent.skillInvocations);
     const pulls = new Set(parent.skillPulls);
     const tools = new Map(parent.toolCalls.map((t) => [t.name, t.calls]));
+    const artifacts = new Map((parent.skillInvocationArtifacts ?? []).map((a) => [a.skill, a.artifactId]));
     let truncated = parent.truncated;
     for (const content of subs.contents) {
         const s = (0, captureSignals_1.parseCaptureSignals)(content, source);
         add(s.skillInvocationCounts, s.skillInvocations);
+        for (const a of s.skillInvocationArtifacts ?? [])
+            if (!artifacts.has(a.skill))
+                artifacts.set(a.skill, a.artifactId);
         for (const k of s.skillInvocations)
             invocations.add(k);
         for (const k of s.skillPulls)
@@ -108,6 +112,9 @@ function foldSubagentSignals(parent, subs, source) {
         ...parent,
         skillInvocations: cap([...invocations].sort()),
         skillInvocationCounts: cap([...counts].map(([skill, count]) => ({ skill, count: Math.min(count, 10_000) })).sort((a, b) => a.skill.localeCompare(b.skill))),
+        ...(artifacts.size
+            ? { skillInvocationArtifacts: cap([...artifacts].map(([skill, artifactId]) => ({ skill, artifactId })).sort((a, b) => a.skill.localeCompare(b.skill))) }
+            : {}),
         skillPulls: cap([...pulls].sort()),
         toolCalls: cap([...tools].map(([name, calls]) => ({ name, calls })).sort((a, b) => a.name.localeCompare(b.name))),
         subagents: { count: subs.count, truncated: subs.truncated },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.66",
+  "version": "0.9.68",
   "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",