@polderlabs/bizar 3.23.1 → 4.2.0

package/bizar-dash/tests/mod-instructions.node.test.mjs

@@ -0,0 +1,188 @@
+/**
+ * mod-instructions.node.test.mjs — Node-compatible test runner.
+ *
+ * Bun's homedir() doesn't pick up process.env.HOME changes at import
+ * time, so we run this suite with `node --test` instead, where env
+ * overrides work as expected.
+ *
+ * Run with:  node --test tests/mod-instructions.node.test.mjs
+ */
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+
+// ── Sandbox HOME before importing the loader ─────────────────────
+const SANDBOX_HOME = join(tmpdir(), `bizar-mod-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+process.env.HOME = SANDBOX_HOME;
+process.env.XDG_CONFIG_HOME = join(SANDBOX_HOME, '.config');
+
+const REPO = resolve(import.meta.dirname, '..');
+const LOADER = join(REPO, 'src/server/mods-loader.mjs');
+// Import AFTER HOME is set so the loader resolves constants correctly.
+const loaderModule = await import(LOADER);
+const { modsLoader } = loaderModule;
+
+const TEST_MOD_ID = 'testmod';
+
+function buildTestMod() {
+  const modDir = join(SANDBOX_HOME, '.config/bizar/mods', TEST_MOD_ID);
+  rmSync(modDir, { recursive: true, force: true });
+  mkdirSync(modDir, { recursive: true });
+  writeFileSync(join(modDir, 'mod.json'), JSON.stringify({
+    id: TEST_MOD_ID,
+    name: 'Test Mod',
+    version: '1.0.0',
+    description: 'A test mod for the instructions installer.',
+    permissions: [],
+  }, null, 2));
+  mkdirSync(join(modDir, 'agents'), { recursive: true });
+  writeFileSync(join(modDir, 'agents', 'thor.md'), '---\ndescription: test thor\n---\n# Thor override\n');
+  writeFileSync(join(modDir, 'agents', 'tyr.md'), '---\ndescription: test tyr\n---\n# Tyr override\n');
+  mkdirSync(join(modDir, 'commands'), { recursive: true });
+  writeFileSync(join(modDir, 'commands', 'plan.md'), '---\ndescription: test plan\n---\n# Plan command\n');
+  writeFileSync(join(modDir, 'INSTRUCTIONS.md'), '---\nname: test-instructions\n---\n# Test instructions\n');
+  mkdirSync(join(modDir, 'skills', 'my-skill'), { recursive: true });
+  writeFileSync(join(modDir, 'skills', 'my-skill', 'SKILL.md'), '---\nname: test-my-skill\n---\n# My skill\n');
+  return modDir;
+}
+
+before(() => {
+  mkdirSync(join(SANDBOX_HOME, '.config/opencode/agents'), { recursive: true });
+  mkdirSync(join(SANDBOX_HOME, '.config/opencode/commands'), { recursive: true });
+  mkdirSync(join(SANDBOX_HOME, '.opencode/skills'), { recursive: true });
+  mkdirSync(join(SANDBOX_HOME, '.config/bizar/mods'), { recursive: true });
+});
+
+after(() => {
+  try {
+    rmSync(SANDBOX_HOME, { recursive: true, force: true });
+  } catch { /* ignore */ }
+  process.env.HOME = homedir();
+  delete process.env.XDG_CONFIG_HOME;
+});
+
+describe('mod instructions install/uninstall', () => {
+  it('installs agents, commands, INSTRUCTIONS, and skills with the right prefixes', () => {
+    const modDir = buildTestMod();
+    const counts = modsLoader.reinstallInstructions(TEST_MOD_ID);
+    assert.equal(counts.agents, 2);
+    assert.equal(counts.commands, 1);
+    assert.equal(counts.instructions, 1);
+    assert.equal(counts.skills, 1);
+
+    const agentsDir = join(SANDBOX_HOME, '.config/opencode/agents');
+    assert.ok(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.md`)));
+    assert.ok(existsSync(join(agentsDir, `${TEST_MOD_ID}__tyr.md`)));
+    assert.equal(existsSync(join(agentsDir, 'thor.md')), false);
+
+    const commandsDir = join(SANDBOX_HOME, '.config/opencode/commands');
+    assert.ok(existsSync(join(commandsDir, `${TEST_MOD_ID}__plan.md`)));
+
+    const skillsDir = join(SANDBOX_HOME, '.opencode/skills');
+    assert.ok(existsSync(join(skillsDir, `${TEST_MOD_ID}-instructions`, 'SKILL.md')));
+    assert.ok(existsSync(join(skillsDir, `${TEST_MOD_ID}-my-skill`, 'SKILL.md')));
+
+    rmSync(modDir, { recursive: true, force: true });
+  });
+
+  it('does not touch files installed by other mods or base agents', () => {
+    const modDir = buildTestMod();
+    const agentsDir = join(SANDBOX_HOME, '.config/opencode/agents');
+    writeFileSync(join(agentsDir, 'othermod__thor.md'), '# othermod thor');
+    writeFileSync(join(agentsDir, 'odin.md'), '# base odin');
+
+    const counts = modsLoader.reinstallInstructions(TEST_MOD_ID);
+    assert.equal(counts.agents, 2);
+    assert.ok(existsSync(join(agentsDir, 'othermod__thor.md')));
+    assert.ok(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.md`)));
+    assert.ok(existsSync(join(agentsDir, 'odin.md')));
+
+    rmSync(modDir, { recursive: true, force: true });
+    try { rmSync(join(agentsDir, 'othermod__thor.md')); } catch { /* ignore */ }
+    try { rmSync(join(agentsDir, 'odin.md')); } catch { /* ignore */ }
+  });
+
+  it('uninstall removes only what this mod installed', () => {
+    const modDir = buildTestMod();
+    modsLoader.reinstallInstructions(TEST_MOD_ID);
+
+    const agentsDir = join(SANDBOX_HOME, '.config/opencode/agents');
+    writeFileSync(join(agentsDir, 'othermod__thor.md'), '# othermod');
+    writeFileSync(join(agentsDir, 'odin.md'), '# base odin');
+
+    const ok = modsLoader.uninstall(TEST_MOD_ID);
+    assert.equal(ok, true);
+
+    assert.equal(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.md`)), false);
+    assert.equal(existsSync(join(agentsDir, `${TEST_MOD_ID}__tyr.md`)), false);
+    const commandsDir = join(SANDBOX_HOME, '.config/opencode/commands');
+    assert.equal(existsSync(join(commandsDir, `${TEST_MOD_ID}__plan.md`)), false);
+    const skillsDir = join(SANDBOX_HOME, '.opencode/skills');
+    assert.equal(existsSync(join(skillsDir, `${TEST_MOD_ID}-instructions`)), false);
+    assert.equal(existsSync(join(skillsDir, `${TEST_MOD_ID}-my-skill`)), false);
+
+    assert.ok(existsSync(join(agentsDir, 'othermod__thor.md')));
+    assert.ok(existsSync(join(agentsDir, 'odin.md')));
+
+    try { rmSync(join(agentsDir, 'othermod__thor.md')); } catch { /* ignore */ }
+    try { rmSync(join(agentsDir, 'odin.md')); } catch { /* ignore */ }
+  });
+
+  it('install/uninstall round-trips cleanly', () => {
+    for (let i = 0; i < 2; i++) {
+      const modDir = buildTestMod();
+      const agentsDir = join(SANDBOX_HOME, '.config/opencode/agents');
+
+      const counts = modsLoader.reinstallInstructions(TEST_MOD_ID);
+      assert.equal(counts.agents, 2);
+      assert.ok(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.md`)));
+
+      modsLoader.uninstall(TEST_MOD_ID);
+
+      assert.equal(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.md`)), false);
+      assert.equal(existsSync(modDir), false);
+    }
+  });
+
+  it('listModInstructions reports exactly the files this mod installed', () => {
+    const modDir = buildTestMod();
+    modsLoader.reinstallInstructions(TEST_MOD_ID);
+
+    const list = modsLoader.listModInstructions(TEST_MOD_ID);
+    assert.deepEqual(list.agents.sort(), [
+      `${TEST_MOD_ID}__thor.md`,
+      `${TEST_MOD_ID}__tyr.md`,
+    ]);
+    assert.deepEqual(list.commands, [`${TEST_MOD_ID}__plan.md`]);
+    assert.deepEqual(list.skills.sort(), [
+      `${TEST_MOD_ID}-instructions`,
+      `${TEST_MOD_ID}-my-skill`,
+    ]);
+
+    modsLoader.uninstall(TEST_MOD_ID);
+  });
+
+  it('ignores non-md files in agents/ and commands/', () => {
+    const modDir = buildTestMod();
+    writeFileSync(join(modDir, 'agents', 'thor.txt'), 'should not be installed');
+    writeFileSync(join(modDir, 'commands', 'plan.txt'), 'should not be installed');
+
+    const counts = modsLoader.reinstallInstructions(TEST_MOD_ID);
+    assert.equal(counts.agents, 2);
+    assert.equal(counts.commands, 1);
+
+    const agentsDir = join(SANDBOX_HOME, '.config/opencode/agents');
+    const commandsDir = join(SANDBOX_HOME, '.config/opencode/commands');
+    assert.equal(existsSync(join(agentsDir, `${TEST_MOD_ID}__thor.txt`)), false);
+    assert.equal(existsSync(join(commandsDir, `${TEST_MOD_ID}__plan.txt`)), false);
+
+    modsLoader.uninstall(TEST_MOD_ID);
+  });
+});

package/bizar-dash/tests/mod-security.test.mjs

@@ -0,0 +1,273 @@
+/**
+ * mod-security unit tests.
+ *
+ * Covers permission parsing, filesystem sandboxing, subprocess
+ * allowlisting, and integrity hashing. These run as plain Node tests
+ * — no dashboard, no express, no DB.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdirSync, writeFileSync, rmSync, existsSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+
+import {
+  parsePermissions,
+  authorizeFsPath,
+  authorizeSpawn,
+  computeModHash,
+  verifyModIntegrity,
+  createAuditWriter,
+  createModSecurityContext,
+  ALLOWED_BINARIES,
+} from '../src/server/mod-security';
+
+// ---- Helpers ----
+function freshTmp() {
+  const d = join(tmpdir(), `modsec-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(d, { recursive: true });
+  return d;
+}
+
+describe('parsePermissions', () => {
+  it('accepts well-formed permission tokens', () => {
+    const r = parsePermissions([
+      'fs:read:/abs/path',
+      'fs:write:/abs/path/*',
+      'process:spawn:bizar',
+      'network:example.com',
+    ]);
+    expect(r.invalid).toEqual([]);
+    expect(r.allowed.size).toBe(4);
+  });
+
+  it('flags malformed tokens', () => {
+    const r = parsePermissions([
+      'garbage',
+      42,
+      null,
+      'unknown:foo',
+    ]);
+    expect(r.invalid.length).toBe(4);
+  });
+
+  it('mixes valid and invalid', () => {
+    const r = parsePermissions(['fs:read:/x', 'no-colon']);
+    expect(r.invalid).toEqual(['no-colon']);
+    expect(r.allowed.has('fs:read:/x')).toBe(true);
+  });
+});
+
+describe('authorizeFsPath', () => {
+  const perms = new Set([
+    'fs:read:/allowed',
+    'fs:read:/allowed/sub/*',
+    'fs:write:/writable/*',
+    'fs:read:~/config/bizar',   // home-relative
+  ]);
+
+  it('accepts exact match', () => {
+    expect(authorizeFsPath(perms, 'read', '/allowed')).toBe('/allowed');
+  });
+
+  it('accepts prefix match', () => {
+    expect(authorizeFsPath(perms, 'read', '/allowed/sub/x')).toBe('/allowed/sub/x');
+  });
+
+  it('rejects path outside scope', () => {
+    expect(() => authorizeFsPath(perms, 'read', '/notallowed')).toThrow(/not authorized/);
+  });
+
+  it('rejects null bytes', () => {
+    expect(() => authorizeFsPath(perms, 'read', '/allowed\0bad')).toThrow(/null bytes/);
+  });
+
+  it('expands ~ in scope', () => {
+    // ~/config/bizar resolves to homedir + /config/bizar
+    const r = authorizeFsPath(perms, 'read', '~/config/bizar/x');
+    expect(r).toContain('/config/bizar');
+  });
+
+  it('write scope does not grant read', () => {
+    expect(() => authorizeFsPath(perms, 'write', '/allowed')).toThrow(/not authorized/);
+  });
+});
+
+describe('authorizeSpawn', () => {
+  it('allows whitelisted binaries without explicit perm', () => {
+    for (const bin of ['bizar', 'opencode', 'python3', 'git', 'node', 'npm']) {
+      expect(() => authorizeSpawn(new Set(), () => {}, bin)).not.toThrow();
+    }
+  });
+
+  it('rejects non-whitelisted binaries without explicit perm', () => {
+    expect(() => authorizeSpawn(new Set(), () => {}, 'curl')).toThrow(/not authorized/);
+    expect(() => authorizeSpawn(new Set(), () => {}, 'wget')).toThrow(/not authorized/);
+  });
+
+  it('allows non-whitelisted with explicit permission', () => {
+    const perms = new Set(['process:spawn:curl']);
+    expect(() => authorizeSpawn(perms, () => {}, 'curl')).not.toThrow();
+  });
+
+  it('process:spawn:* wildcard allows any', () => {
+    const perms = new Set(['process:spawn:*']);
+    expect(() => authorizeSpawn(perms, () => {}, 'anything')).not.toThrow();
+  });
+
+  it('rejects paths (must use bare name or full perms)', () => {
+    expect(() => authorizeSpawn(new Set(), () => {}, '/bin/ls')).toThrow(/not authorized/);
+    const perms = new Set(['process:spawn:/bin/ls']);
+    expect(() => authorizeSpawn(perms, () => {}, '/bin/ls')).not.toThrow();
+  });
+});
+
+describe('computeModHash + verifyModIntegrity', () => {
+  let modDir;
+  beforeEach(() => {
+    modDir = freshTmp();
+    writeFileSync(join(modDir, 'mod.json'), '{"id":"test","version":"1.0.0"}');
+    writeFileSync(join(modDir, 'route.mjs'), 'export default function(){}');
+  });
+  afterEach(() => {
+    rmSync(modDir, { recursive: true, force: true });
+  });
+
+  it('hash is deterministic for identical content', () => {
+    const a = computeModHash(modDir);
+    const b = computeModHash(modDir);
+    expect(a).toBe(b);
+    expect(a.length).toBe(64);
+  });
+
+  it('hash changes when a file changes', () => {
+    const before = computeModHash(modDir);
+    writeFileSync(join(modDir, 'route.mjs'), 'export default function() {/* changed */}');
+    const after = computeModHash(modDir);
+    expect(after).not.toBe(before);
+  });
+
+  it('hash changes when a file is added', () => {
+    const before = computeModHash(modDir);
+    writeFileSync(join(modDir, 'README.md'), '# hi');
+    const after = computeModHash(modDir);
+    expect(after).not.toBe(before);
+  });
+
+  it('verifyModIntegrity returns ok=true when hash matches', () => {
+    const hash = computeModHash(modDir);
+    const mod = {
+      id: 'test',
+      version: '1.0.0',
+      path: modDir,
+      _integrity: hash,
+    };
+    const r = verifyModIntegrity(mod);
+    expect(r.ok).toBe(true);
+    expect(r.hash).toBe(hash);
+  });
+
+  it('verifyModIntegrity returns ok=false on mismatch', () => {
+    const mod = {
+      id: 'test', version: '1.0.0', path: modDir,
+      _integrity: 'a'.repeat(64), // wrong hash
+    };
+    const r = verifyModIntegrity(mod);
+    expect(r.ok).toBe(false);
+    expect(r.expected).toBe('a'.repeat(64));
+    expect(r.reason).toContain('modified');
+  });
+
+  it('verifyModIntegrity returns ok="unsigned" when no _integrity field', () => {
+    const mod = { id: 'test', version: '1.0.0', path: modDir };
+    const r = verifyModIntegrity(mod);
+    expect(r.ok).toBe('unsigned');
+  });
+
+  it('skips node_modules and .DS_Store', () => {
+    mkdirSync(join(modDir, 'node_modules'));
+    writeFileSync(join(modDir, 'node_modules', 'x.js'), 'noise');
+    writeFileSync(join(modDir, '.DS_Store'), 'noise');
+    const a = computeModHash(modDir);
+    // Remove the noise and re-hash
+    rmSync(join(modDir, 'node_modules'), { recursive: true, force: true });
+    rmSync(join(modDir, '.DS_Store'));
+    const b = computeModHash(modDir);
+    expect(a).toBe(b);
+  });
+});
+
+describe('createAuditWriter', () => {
+  let logPath;
+  beforeEach(() => {
+    logPath = join(tmpdir(), `audit-test-${Date.now()}.log`);
+    // Override the audit path by calling on a temp file via writeFileSync.
+    // createAuditWriter uses a hard-coded path; we'll read it directly.
+  });
+  afterEach(() => {
+    // Best-effort cleanup; we don't know the exact path the writer used.
+  });
+
+  it('writes a JSON line per audit call', () => {
+    // Create a mod-like object and call createAuditWriter
+    // We can't easily override the path, so we just verify the contract.
+    const mod = { id: 'audit-test-mod', version: '1.0.0' };
+    const audit = createAuditWriter(mod);
+    expect(typeof audit).toBe('function');
+    // Calling it shouldn't throw.
+    audit('test:event', { ok: true });
+  });
+});
+
+describe('createModSecurityContext', () => {
+  it('returns parsed perms, audit writer, and fs helpers', () => {
+    const mod = {
+      id: 'ctx-test',
+      version: '1.0.0',
+      permissions: ['fs:read:/x', 'bogus'],
+      path: '/some/path',
+    };
+    const ctx = createModSecurityContext(mod);
+    expect(ctx.permissions.has('fs:read:/x')).toBe(true);
+    expect(ctx.invalidPermissions).toEqual(['bogus']);
+    expect(typeof ctx.audit).toBe('function');
+    expect(typeof ctx.fs.readFileSync).toBe('function');
+    expect(typeof ctx.authorizeSpawn).toBe('function');
+  });
+
+  it('fs.readFileSync throws on out-of-scope paths', () => {
+    const mod = {
+      id: 'sandbox-test',
+      version: '1.0.0',
+      permissions: ['fs:read:/allowed'],
+      path: '/x',
+    };
+    const ctx = createModSecurityContext(mod);
+    expect(() => ctx.fs.readFileSync('/forbidden')).toThrow(/not authorized/);
+  });
+
+  it('authorizeSpawn rejects non-allowed binaries', () => {
+    const mod = {
+      id: 'spawn-test',
+      version: '1.0.0',
+      permissions: [],
+      path: '/x',
+    };
+    const ctx = createModSecurityContext(mod);
+    expect(() => ctx.authorizeSpawn('curl')).toThrow(/not authorized/);
+  });
+
+  it('verifyIntegrity returns the integrity object', () => {
+    const mod = {
+      id: 'integrity-test',
+      version: '1.0.0',
+      permissions: [],
+      path: '/tmp',
+    };
+    const ctx = createModSecurityContext(mod);
+    // No _integrity field on this fake mod, so should be 'unsigned'
+    const r = ctx.verifyIntegrity();
+    expect(['true', 'unsigned', 'false']).toContain(String(r.ok));
+  });
+});