test: add install and packaging coverage

Protect the release flow with fixture tests, tarball smoke checks, and CI workflows that validate the package before publishing.

Author: bitfalt

.github/workflows/ci.yml

@@ -0,0 +1,21 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      - run: npm run build
+      - run: npm test
+      - run: npm run pack:smoke

.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+          cache: npm
+      - run: npm ci
+      - run: npm run build
+      - run: npm test
+      - run: npm run pack:smoke
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

tests/config-merge.test.ts

@@ -0,0 +1,67 @@
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { addPluginToConfig, removePluginFromConfig } from "../src/lib/merge-opencode-config.js";
+import { PACKAGE_NAME } from "../src/lib/paths.js";
+
+const tempRoots: string[] = [];
+
+async function makeConfigDir(): Promise<string> {
+  const root = await mkdtemp(join(os.tmpdir(), "opencode-srd-config-"));
+  tempRoots.push(root);
+  const configDir = join(root, "config");
+  await mkdir(configDir, { recursive: true });
+  return configDir;
+}
+
+afterEach(async () => {
+  const { rm } = await import("node:fs/promises");
+  await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+describe("merge-opencode-config", () => {
+  it("adds the plugin entry only once", async () => {
+    const configDir = await makeConfigDir();
+    const configPath = join(configDir, "opencode.json");
+
+    await writeFile(
+      configPath,
+      `{
+  // keep my comments
+  "plugin": ["example-plugin"]
+}
+`,
+      "utf8",
+    );
+
+    await addPluginToConfig(configDir, PACKAGE_NAME);
+    await addPluginToConfig(configDir, PACKAGE_NAME);
+
+    const content = await readFile(configPath, "utf8");
+    expect(content.match(new RegExp(PACKAGE_NAME.replace("/", "\\/"), "g"))?.length).toBe(1);
+    expect(content).toContain("// keep my comments");
+  });
+
+  it("removes the plugin entry without disturbing the rest", async () => {
+    const configDir = await makeConfigDir();
+    const configPath = join(configDir, "opencode.json");
+
+    await writeFile(
+      configPath,
+      `{
+  "plugin": ["example-plugin", "${PACKAGE_NAME}"],
+  "theme": "dark"
+}
+`,
+      "utf8",
+    );
+
+    await removePluginFromConfig(configDir, PACKAGE_NAME);
+
+    const content = await readFile(configPath, "utf8");
+    expect(content).not.toContain(PACKAGE_NAME);
+    expect(content).toContain("example-plugin");
+    expect(content).toContain('"theme": "dark"');
+  });
+});

tests/fixtures/.gitkeep

@@ -0,0 +1,82 @@
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { doctorSrdFramework } from "../src/lib/doctor.js";
+import { installSrdFramework } from "../src/lib/install.js";
+import { resolvePackageRoot } from "../src/lib/paths.js";
+import { uninstallSrdFramework } from "../src/lib/uninstall.js";
+import { updateSrdFramework } from "../src/lib/update.js";
+
+const tempRoots: string[] = [];
+
+async function makeTempDir(prefix: string): Promise<string> {
+  const root = await mkdtemp(join(os.tmpdir(), prefix));
+  tempRoots.push(root);
+  return root;
+}
+
+afterEach(async () => {
+  const { rm } = await import("node:fs/promises");
+  await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+describe("install/update/uninstall/doctor", () => {
+  it("installs into a temp config directory and is idempotent", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const configDir = await makeTempDir("opencode-srd-install-");
+
+    const first = await installSrdFramework({ configDir, packageRoot });
+    const second = await installSrdFramework({ configDir, packageRoot });
+
+    expect(first.copied.length).toBeGreaterThan(0);
+    expect(second.copied).toHaveLength(0);
+    expect(second.updated).toHaveLength(0);
+    expect(join(configDir, "commands", "srd-assess.md")).toBeTruthy();
+    expect(await readFile(join(configDir, "commands", "srd-assess.md"), "utf8")).toContain("SRD Assess");
+  });
+
+  it("update refreshes managed files", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const configDir = await makeTempDir("opencode-srd-update-");
+
+    await installSrdFramework({ configDir, packageRoot });
+    await writeFile(join(configDir, "commands", "srd-quick.md"), "mutated", "utf8");
+
+    const result = await updateSrdFramework({ configDir, packageRoot });
+    const content = await readFile(join(configDir, "commands", "srd-quick.md"), "utf8");
+
+    expect(result.updated).toContain("commands/srd-quick.md");
+    expect(content).toContain("SRD Quick");
+  });
+
+  it("uninstall removes only managed files", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const configDir = await makeTempDir("opencode-srd-uninstall-");
+    await installSrdFramework({ configDir, packageRoot });
+
+    await mkdir(join(configDir, "commands"), { recursive: true });
+    await writeFile(join(configDir, "commands", "custom.md"), "keep me", "utf8");
+
+    await uninstallSrdFramework({ configDir });
+
+    await expect(readFile(join(configDir, "commands", "custom.md"), "utf8")).resolves.toBe("keep me");
+    await expect(readFile(join(configDir, "commands", "srd-assess.md"), "utf8")).rejects.toThrow();
+  });
+
+  it("doctor reports healthy and unhealthy states", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const configDir = await makeTempDir("opencode-srd-doctor-");
+
+    await installSrdFramework({ configDir, packageRoot });
+    const healthy = await doctorSrdFramework({ configDir, packageRoot });
+
+    expect(healthy.healthy).toBe(true);
+
+    await writeFile(join(configDir, "commands", "srd-assess.md"), "drifted", "utf8");
+    const unhealthy = await doctorSrdFramework({ configDir, packageRoot });
+
+    expect(unhealthy.healthy).toBe(false);
+    expect(unhealthy.driftedFiles).toContain("commands/srd-assess.md");
+  });
+});

tests/install.test.ts

@@ -0,0 +1,71 @@
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { getInstallableAssets, syncManagedAssets } from "../src/lib/copy-assets.js";
+import { readInstallManifest, writeInstallManifest } from "../src/lib/manifest.js";
+import { defaultConfigDir, resolveConfigDir, resolvePackageRoot } from "../src/lib/paths.js";
+
+const tempRoots: string[] = [];
+
+async function makeTempDir(prefix: string): Promise<string> {
+  const root = await mkdtemp(join(os.tmpdir(), prefix));
+  tempRoots.push(root);
+  return root;
+}
+
+afterEach(async () => {
+  const { rm } = await import("node:fs/promises");
+  await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+describe("manifest and asset sync", () => {
+  it("tracks only installable managed files", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const assets = await getInstallableAssets(packageRoot);
+    expect(assets.every((asset) => /^(commands|agents|skills)\//.test(asset.relativePath))).toBe(true);
+    expect(assets.some((asset) => asset.relativePath === "commands/srd-assess.md")).toBe(true);
+    expect(assets.some((asset) => asset.relativePath === "agents/srd-guardian.md")).toBe(true);
+    expect(assets.some((asset) => asset.relativePath === "skills/srd-analysis/SKILL.md")).toBe(true);
+  });
+
+  it("detects unmanaged conflicts", async () => {
+    const packageRoot = resolvePackageRoot(import.meta.url);
+    const configDir = await makeTempDir("opencode-srd-conflict-");
+    await mkdir(join(configDir, "commands"), { recursive: true });
+    await writeFile(join(configDir, "commands", "srd-assess.md"), "user-owned", "utf8");
+
+    const result = await syncManagedAssets({
+      configDir,
+      packageRoot,
+    });
+
+    expect(result.conflicts).toContain("commands/srd-assess.md");
+  });
+
+  it("resolves default and custom config directories", () => {
+    expect(defaultConfigDir("/Users/example")).toBe("/Users/example/.config/opencode");
+    expect(resolveConfigDir("./custom-config")).toContain("custom-config");
+  });
+
+  it("reads and writes install manifests", async () => {
+    const configDir = await makeTempDir("opencode-srd-manifest-");
+    await writeInstallManifest(configDir, {
+      packageName: "pkg",
+      installedVersion: "0.1.0",
+      installedAt: new Date().toISOString(),
+      configDir,
+      managedFiles: [
+        {
+          relativePath: "commands/srd-assess.md",
+          checksum: "abc",
+          kind: "command",
+        },
+      ],
+    });
+
+    const manifest = await readInstallManifest(configDir);
+    expect(manifest?.managedFiles).toHaveLength(1);
+    expect(manifest?.managedFiles[0]?.relativePath).toBe("commands/srd-assess.md");
+  });
+});

tests/manifest.test.ts

@@ -0,0 +1,103 @@
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import { join } from "node:path";
+import { afterAll, describe, expect, it } from "vitest";
+import { spawnSync } from "node:child_process";
+
+const tempRoots: string[] = [];
+const repoRoot = process.cwd();
+
+async function makeTempDir(prefix: string): Promise<string> {
+  const root = await mkdtemp(join(os.tmpdir(), prefix));
+  tempRoots.push(root);
+  return root;
+}
+
+afterAll(async () => {
+  const { rm } = await import("node:fs/promises");
+  await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+describe("package smoke", () => {
+  it("packs, exposes assets, and installs from a tarball", async () => {
+    const packResult = spawnSync("npm", ["pack", "--json"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+    });
+
+    expect(packResult.status).toBe(0);
+    const tarballName = JSON.parse(packResult.stdout)[0].filename as string;
+    const tarballPath = join(repoRoot, tarballName);
+    tempRoots.push(tarballPath);
+
+    const tarList = spawnSync("tar", ["-tf", tarballPath], {
+      cwd: repoRoot,
+      encoding: "utf8",
+    });
+
+    expect(tarList.status).toBe(0);
+    expect(tarList.stdout).toContain("package/assets/commands/srd-assess.md");
+    expect(tarList.stdout).toContain("package/assets/agents/srd-analyst.md");
+    expect(tarList.stdout).toContain("package/assets/skills/srd-analysis/SKILL.md");
+
+    const installRoot = await makeTempDir("opencode-srd-pack-install-");
+    const configDir = await makeTempDir("opencode-srd-pack-config-");
+    await writeFile(join(installRoot, "package.json"), '{"name":"smoke","private":true}\n', "utf8");
+
+    const installResult = spawnSync("npm", ["install", tarballPath], {
+      cwd: installRoot,
+      encoding: "utf8",
+    });
+
+    expect(installResult.status).toBe(0);
+
+    const cliResult = spawnSync(
+      "node",
+      [
+        join(
+          installRoot,
+          "node_modules",
+          "@dojocoding",
+          "opencode-srd-framework",
+          "dist",
+          "cli.js",
+        ),
+        "install",
+        "--config-dir",
+        configDir,
+      ],
+      {
+        cwd: installRoot,
+        encoding: "utf8",
+      },
+    );
+
+    expect(cliResult.status).toBe(0);
+    await expect(readFile(join(configDir, "commands", "srd-assess.md"), "utf8")).resolves.toContain("SRD Assess");
+
+    const doctorResult = spawnSync(
+      "node",
+      [
+        join(
+          installRoot,
+          "node_modules",
+          "@dojocoding",
+          "opencode-srd-framework",
+          "dist",
+          "cli.js",
+        ),
+        "doctor",
+        "--config-dir",
+        configDir,
+        "--json",
+      ],
+      {
+        cwd: installRoot,
+        encoding: "utf8",
+      },
+    );
+
+    expect(doctorResult.status).toBe(0);
+    expect(JSON.parse(doctorResult.stdout).healthy).toBe(true);
+  });
+});