opencode-thrum-pro 0.1.16 → 0.1.18

package/dist/installer.js

@@ -5,16 +5,32 @@ import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ASSETS_DIR = path.resolve(__dirname, "..", "assets");
 const VERSION_FILE = ".thrum-plugin-version";
-function getPluginVersion() {
+// Written next to the version file so a later release can tell pro from
+// open-core installs and clean up safely.
+const FLAVOR_FILE = ".thrum-plugin-flavor";
+const DEFAULT_SKILLS_SUBDIR = "thrum";
+function readPackageJson() {
     const pkgPath = path.resolve(__dirname, "..", "package.json");
     try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        return pkg.version ?? "0.0.0";
+        return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
     }
     catch {
-        return "0.0.0";
+        return {};
     }
 }
+function getPluginVersion() {
+    return readPackageJson().version ?? "0.0.0";
+}
+// The pro build sets thrum.skillsSubdir in the packaged package.json to
+// "thrum-pro" so it never shares a directory with the open-core package.
+export function sanitizeSkillsSubdir(sub) {
+    return sub && /^[A-Za-z0-9._-]+$/.test(sub) && sub !== "." && sub !== ".."
+        ? sub
+        : DEFAULT_SKILLS_SUBDIR;
+}
+export function getSkillsSubdir() {
+    return sanitizeSkillsSubdir(readPackageJson().thrum?.skillsSubdir);
+}
 export function getConfigDir() {
     const xdg = process.env.XDG_CONFIG_HOME;
     if (xdg)
@@ -34,11 +50,77 @@ function copyDirRecursive(src, dest) {
         }
     }
 }
-export async function installAssets(ctx) {
+// Older pro releases (0.1.x) installed flat (skills/<name>) with the marker in
+// skills/thrum, the same layout open-core still uses. OpenCode resolves
+// duplicate skill names to the flat copy, so stale flat pro skills would shadow
+// the nested ones. Remove them only when the install is positively identified
+// as pro; anything else (open-core, unknown version, unreadable) is left alone.
+function isLegacyProInstall(markerDir) {
+    const read = (name) => {
+        try {
+            return fs.readFileSync(path.join(markerDir, name), "utf8").trim();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const flavor = read(FLAVOR_FILE);
+    if (flavor !== undefined)
+        return flavor === "pro";
+    const version = read(VERSION_FILE);
+    return version !== undefined && /^0\.1\.\d+([-+].*)?$/.test(version);
+}
+async function cleanLegacyFlatInstall(skillsDir, log) {
+    const markerDir = path.join(skillsDir, DEFAULT_SKILLS_SUBDIR);
+    if (!fs.existsSync(path.join(markerDir, VERSION_FILE)))
+        return;
+    if (!isLegacyProInstall(markerDir)) {
+        await log(`Legacy flat install found at ${markerDir}; not removed (not identified as an old pro install). If it is one, delete it and its sibling skill dirs manually.`);
+        return;
+    }
+    const assetsSkillsDir = path.join(ASSETS_DIR, "skills");
+    let removed = 0;
+    if (fs.existsSync(assetsSkillsDir)) {
+        for (const entry of fs.readdirSync(assetsSkillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const flat = path.join(skillsDir, entry.name);
+            if (!fs.existsSync(flat))
+                continue;
+            try {
+                fs.rmSync(flat, { recursive: true });
+                removed++;
+            }
+            catch {
+                // best-effort; a locked dir must not block the install
+            }
+        }
+    }
+    for (const marker of [VERSION_FILE, FLAVOR_FILE]) {
+        try {
+            fs.rmSync(path.join(markerDir, marker), { force: true });
+        }
+        catch {
+            // best-effort
+        }
+    }
+    try {
+        fs.rmdirSync(markerDir); // only succeeds when empty
+    }
+    catch {
+        // not empty or already gone
+    }
+    await log(`Removed ${removed} legacy flat pro skill dirs under ${skillsDir}`);
+}
+export async function installAssets(ctx, opts = {}) {
     const configDir = getConfigDir();
     const skillsDir = path.join(configDir, "skills");
     const commandsDir = path.join(configDir, "commands");
-    const versionPath = path.join(skillsDir, "thrum", VERSION_FILE);
+    const subdir = opts.skillsSubdir !== undefined
+        ? sanitizeSkillsSubdir(opts.skillsSubdir)
+        : getSkillsSubdir();
+    const installRoot = path.join(skillsDir, subdir);
+    const versionPath = path.join(installRoot, VERSION_FILE);
     const currentVersion = getPluginVersion();
     // Check if already installed at this version
     try {
@@ -52,6 +134,9 @@ export async function installAssets(ctx) {
     const log = (msg) => ctx.client.app.log({
         body: { service: "opencode-thrum", level: "info", message: msg },
     });
+    if (subdir !== DEFAULT_SKILLS_SUBDIR) {
+        await cleanLegacyFlatInstall(skillsDir, log);
+    }
     // Copy each skill subdirectory
     const assetsSkillsDir = path.join(ASSETS_DIR, "skills");
     if (fs.existsSync(assetsSkillsDir)) {
@@ -61,7 +146,9 @@ export async function installAssets(ctx) {
             if (!entry.isDirectory())
                 continue;
             const src = path.join(assetsSkillsDir, entry.name);
-            const dest = path.join(skillsDir, entry.name);
+            // Open-core keeps its historical flat layout (skills/<name>); only a
+            // non-default subdir (pro) nests skills under skills/<subdir>/.
+            const dest = path.join(subdir === DEFAULT_SKILLS_SUBDIR ? skillsDir : installRoot, entry.name);
             copyDirRecursive(src, dest);
             await log(`Installed skill: ${entry.name}`);
         }
@@ -82,6 +169,7 @@ export async function installAssets(ctx) {
     // Write version marker
     fs.mkdirSync(path.dirname(versionPath), { recursive: true });
     fs.writeFileSync(versionPath, currentVersion);
+    fs.writeFileSync(path.join(installRoot, FLAVOR_FILE), subdir === DEFAULT_SKILLS_SUBDIR ? "open-core" : "pro");
     await log(`opencode-thrum v${currentVersion} assets installed`);
 }
 const ALLOWLIST_ASSET_PATH = path.join(ASSETS_DIR, "thrum_allowlist.json");

package/dist/installer.test.js

@@ -0,0 +1,102 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { installAssets, sanitizeSkillsSubdir } from "./installer.js";
+const ctx = { client: { app: { log: async () => { } } } };
+function withConfig(fn) {
+    return async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "oc-inst-"));
+        const prev = process.env.XDG_CONFIG_HOME;
+        process.env.XDG_CONFIG_HOME = dir;
+        try {
+            await fn(path.join(dir, "opencode"));
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = prev;
+            fs.rmSync(dir, { recursive: true });
+        }
+    };
+}
+const pkgVersion = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, "..", "package.json"), "utf8")).version;
+test("open-core: flat skills/<name>, marker in skills/thrum", withConfig(async (cfg) => {
+    await installAssets(ctx, { skillsSubdir: "thrum" });
+    assert.ok(fs.existsSync(path.join(cfg, "skills", "thrum", ".thrum-plugin-version")));
+    assert.ok(fs.existsSync(path.join(cfg, "skills", "configure-roles")));
+    assert.ok(!fs.existsSync(path.join(cfg, "skills", "thrum-pro")));
+    assert.equal(fs.readFileSync(path.join(cfg, "skills", "thrum", ".thrum-plugin-flavor"), "utf8"), "open-core");
+}));
+test("pro: skills nested under skills/thrum-pro, marker there", withConfig(async (cfg) => {
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    const v = fs.readFileSync(path.join(cfg, "skills", "thrum-pro", ".thrum-plugin-version"), "utf8");
+    assert.equal(v, pkgVersion);
+    assert.ok(fs.existsSync(path.join(cfg, "skills", "thrum-pro", "configure-roles")));
+    assert.ok(!fs.existsSync(path.join(cfg, "skills", "configure-roles")));
+    assert.equal(fs.readFileSync(path.join(cfg, "skills", "thrum-pro", ".thrum-plugin-flavor"), "utf8"), "pro");
+}));
+test("pro: leaves an existing skills/thrum install untouched", withConfig(async (cfg) => {
+    const legacy = path.join(cfg, "skills", "thrum");
+    fs.mkdirSync(legacy, { recursive: true });
+    fs.writeFileSync(path.join(legacy, ".thrum-plugin-version"), "9.9.9");
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    assert.equal(fs.readFileSync(path.join(legacy, ".thrum-plugin-version"), "utf8"), "9.9.9");
+}));
+test("invalid subdir falls back to default", () => {
+    for (const bad of ["../evil", "a/b", "", "..", ".", undefined]) {
+        assert.equal(sanitizeSkillsSubdir(bad), "thrum");
+    }
+    assert.equal(sanitizeSkillsSubdir("thrum-pro"), "thrum-pro");
+});
+function seedLegacy(cfg, marker) {
+    const skills = path.join(cfg, "skills");
+    const thrumDir = path.join(skills, "thrum");
+    fs.mkdirSync(thrumDir, { recursive: true });
+    if (marker.version !== undefined)
+        fs.writeFileSync(path.join(thrumDir, ".thrum-plugin-version"), marker.version);
+    if (marker.flavor !== undefined)
+        fs.writeFileSync(path.join(thrumDir, ".thrum-plugin-flavor"), marker.flavor);
+    for (const n of ["configure-roles", "adversarial-critique", "user-own-skill"]) {
+        fs.mkdirSync(path.join(skills, n), { recursive: true });
+        fs.writeFileSync(path.join(skills, n, "SKILL.md"), "stale");
+    }
+    return skills;
+}
+test("pro: legacy flavor=pro removes matching flat dirs, keeps others", withConfig(async (cfg) => {
+    const skills = seedLegacy(cfg, { version: "0.1.16", flavor: "pro" });
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    assert.ok(!fs.existsSync(path.join(skills, "configure-roles")));
+    assert.ok(!fs.existsSync(path.join(skills, "adversarial-critique")));
+    assert.ok(fs.existsSync(path.join(skills, "user-own-skill", "SKILL.md")));
+    assert.ok(!fs.existsSync(path.join(skills, "thrum", ".thrum-plugin-version")));
+    assert.ok(!fs.existsSync(path.join(skills, "thrum", ".thrum-plugin-flavor")));
+    assert.ok(fs.existsSync(path.join(skills, "thrum-pro", "configure-roles")));
+}));
+test("pro: legacy 0.1.16 without flavor is removed", withConfig(async (cfg) => {
+    const skills = seedLegacy(cfg, { version: "0.1.16" });
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    assert.ok(!fs.existsSync(path.join(skills, "configure-roles")));
+    assert.ok(fs.existsSync(path.join(skills, "user-own-skill")));
+    assert.ok(!fs.existsSync(path.join(skills, "thrum", ".thrum-plugin-version")));
+}));
+test("pro: legacy 0.3.105 without flavor removes nothing", withConfig(async (cfg) => {
+    const skills = seedLegacy(cfg, { version: "0.3.105" });
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    assert.ok(fs.existsSync(path.join(skills, "configure-roles", "SKILL.md")));
+    assert.ok(fs.existsSync(path.join(skills, "thrum", ".thrum-plugin-version")));
+}));
+test("pro: legacy flavor=open-core removes nothing", withConfig(async (cfg) => {
+    const skills = seedLegacy(cfg, { version: "0.1.16", flavor: "open-core" });
+    await installAssets(ctx, { skillsSubdir: "thrum-pro" });
+    assert.ok(fs.existsSync(path.join(skills, "configure-roles", "SKILL.md")));
+    assert.ok(fs.existsSync(path.join(skills, "thrum", ".thrum-plugin-flavor")));
+}));
+test("open-core build: existing flat install is not cleaned", withConfig(async (cfg) => {
+    const skills = seedLegacy(cfg, { version: "0.1.16", flavor: "pro" });
+    await installAssets(ctx, { skillsSubdir: "thrum" });
+    assert.ok(fs.existsSync(path.join(skills, "user-own-skill", "SKILL.md")));
+    assert.equal(fs.readFileSync(path.join(skills, "thrum", ".thrum-plugin-flavor"), "utf8"), "open-core");
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-thrum-pro",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Thrum multi-agent coordination plugin for Open Code",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,5 +46,8 @@
     "@opencode-ai/plugin": "^1.4.0",
     "@types/node": "^25.5.2",
     "typescript": "^5.3.0"
+  },
+  "thrum": {
+    "skillsSubdir": "thrum-pro"
   }
 }