@polderlabs/bizar 4.4.13 → 4.5.0

package/bizar-dash/tests/env-vars-store.test.mjs

@@ -0,0 +1,216 @@
+/**
+ * env-vars-store.test.mjs — tests for the env-vars route and loadEnvJson.
+ *
+ * Run with: node --test bizar-dash/tests/env-vars-store.test.mjs
+ */
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, chmodSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+// Sandbox process.env for isolation
+let SANDBOX_HOME;
+let ORIGINAL_HOME;
+let BIZAR_DIR;
+let ENV_FILE;
+
+before(() => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-env-vars-test-${Date.now()}-`));
+  ORIGINAL_HOME = process.env.HOME;
+  process.env.HOME = SANDBOX_HOME;
+  BIZAR_DIR = join(SANDBOX_HOME, '.config', 'bizar');
+  ENV_FILE = join(BIZAR_DIR, 'env.json');
+});
+
+after(() => {
+  process.env.HOME = ORIGINAL_HOME;
+  // Clean up any lingering BIZAR_* test vars
+  for (const k of Object.keys(process.env)) {
+    if (k.startsWith('BIZAR_TEST_')) delete process.env[k];
+  }
+  try { rmSync(SANDBOX_HOME, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+// Helper to create a supertest-like request helper via native http
+async function request(app, method, path, body) {
+  const http = await import('node:http');
+  return new Promise((resolve, reject) => {
+    const server = app.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      const bodyStr = body ? JSON.stringify(body) : '';
+      const opts = {
+        hostname: '127.0.0.1',
+        port,
+        path,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(bodyStr),
+        },
+      };
+      const req = http.request(opts, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          server.close();
+          try {
+            const parsed = data ? JSON.parse(data) : {};
+            resolve({ status: res.statusCode, body: parsed, raw: data });
+          } catch {
+            resolve({ status: res.statusCode, body: data, raw: data });
+          }
+        });
+      });
+      req.on('error', (err) => { server.close(); reject(err); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  });
+}
+
+describe('env-vars.mjs', () => {
+  // Build a minimal express app with just the env-vars router
+  let app;
+  beforeEach(async () => {
+    // Reset module state between tests by deleting the env file
+    try { rmSync(ENV_FILE); } catch { /* ignore */ }
+    // Force-reload the module for fresh state
+    const express = (await import('express')).default;
+    const { createEnvVarsRouter, loadEnvJson, resetStore } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    resetStore();
+    app = express();
+    app.use(express.json());
+    app.use('/api', createEnvVarsRouter());
+    // Clear any BIZAR_TEST_ vars left from previous tests
+    for (const k of Object.keys(process.env)) {
+      if (k.startsWith('BIZAR_TEST_')) delete process.env[k];
+    }
+    app.use(createEnvVarsRouter());
+  });
+
+  it('GET /api/env-vars returns empty list when file does not exist', async () => {
+    const res = await request(app, 'GET', '/api/env-vars');
+    assert.equal(res.status, 200);
+    assert.ok(Array.isArray(res.body), 'response should be an array');
+    assert.equal(res.body.length, 0);
+  });
+
+  it('POST creates entry, GET lists it with masked value', async () => {
+    const create = await request(app, 'POST', '/api/env-vars', {
+      name: 'BIZAR_TEST_KEY',
+      value: 'super-secret-value-123',
+    });
+    assert.equal(create.status, 201);
+    assert.equal(create.body.name, 'BIZAR_TEST_KEY');
+    assert.ok(create.body.value.includes('*'), 'value should be masked');
+    assert.ok(create.body.value.endsWith('-123'), 'masked value should include last 4 chars');
+    assert.ok(create.body.createdAt, 'should have createdAt');
+
+    const list = await request(app, 'GET', '/api/env-vars');
+    assert.equal(list.status, 200);
+    const entry = list.body.find((e) => e.name === 'BIZAR_TEST_KEY');
+    assert.ok(entry, 'entry should be in list');
+    assert.equal(entry.value, create.body.value, 'value should be masked on list');
+  });
+
+  it('PUT updates entry, DELETE removes it', async () => {
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_PUT', value: 'original' });
+    const update = await request(app, 'PUT', '/api/env-vars/BIZAR_TEST_PUT', { value: 'updated-value' });
+    assert.equal(update.status, 200);
+    assert.ok(update.body.value.endsWith('lue'), 'updated value should be masked');
+
+    // Verify in list
+    const list = await request(app, 'GET', '/api/env-vars');
+    const entry = list.body.find((e) => e.name === 'BIZAR_TEST_PUT');
+    assert.ok(entry);
+
+    // Delete
+    const del = await request(app, 'DELETE', '/api/env-vars/BIZAR_TEST_PUT');
+    assert.equal(del.status, 200);
+    assert.ok(del.body.ok);
+
+    // Verify gone
+    const listAfter = await request(app, 'GET', '/api/env-vars');
+    const gone = listAfter.body.find((e) => e.name === 'BIZAR_TEST_PUT');
+    assert.equal(gone, undefined, 'entry should be deleted');
+  });
+
+  it('rejects invalid name (must match /^BIZAR_[A-Z0-9_]+$/)', async () => {
+    const r1 = await request(app, 'POST', '/api/env-vars', { name: 'INVALID', value: 'x' });
+    assert.equal(r1.status, 400);
+    assert.ok(r1.body.error === 'invalid_name');
+
+    const r2 = await request(app, 'POST', '/api/env-vars', { name: 'bizar_lowercase', value: 'x' });
+    assert.equal(r2.status, 400);
+
+    const r3 = await request(app, 'POST', '/api/env-vars', { name: 'BIZAR HAS_SPACE', value: 'x' });
+    assert.equal(r3.status, 400);
+  });
+
+  it('creates env.json with mode 0600', async () => {
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_PERM', value: 'perm-check' });
+    const mode = statSync(ENV_FILE).mode & 0o777;
+    assert.equal(mode, 0o600, `expected 0o600, got ${octal(mode)}`);
+  });
+
+  it('loadEnvJson sets process.env', async () => {
+    // Create an env var
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_LOADENV', value: 'env-loaded-value' });
+
+    // Delete from process.env to simulate fresh start
+    delete process.env.BIZAR_TEST_LOADENV;
+
+    // Call loadEnvJson
+    const { loadEnvJson } = await import(`${REPO}/bizar-dash/src/server/routes/env-vars.mjs`);
+    loadEnvJson();
+
+    assert.equal(process.env.BIZAR_TEST_LOADENV, 'env-loaded-value',
+      'process.env should be set after loadEnvJson');
+  });
+
+  it('DELETE removes from process.env', async () => {
+    // Create
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_DELPROCESS', value: 'to-be-deleted' });
+    assert.equal(process.env.BIZAR_TEST_DELPROCESS, 'to-be-deleted');
+
+    // Delete via API
+    await request(app, 'DELETE', '/api/env-vars/BIZAR_TEST_DELPROCESS');
+
+    assert.equal(process.env.BIZAR_TEST_DELPROCESS, undefined,
+      'process.env should be cleared after DELETE');
+  });
+
+  it('POST /api/env-vars/:name/test returns referenced and inProcessEnv', async () => {
+    // Not in process.env yet
+    const r1 = await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_REFS', value: 'refs-val' });
+    assert.equal(r1.status, 201);
+
+    const test = await request(app, 'POST', '/api/env-vars/BIZAR_TEST_REFS/test');
+    assert.equal(test.status, 200);
+    assert.ok(typeof test.body.referenced === 'boolean');
+    assert.ok(typeof test.body.inProcessEnv === 'boolean');
+    assert.equal(test.body.inProcessEnv, true, 'should be in process.env after creation');
+  });
+
+  it('409 on duplicate POST', async () => {
+    await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_DUP', value: 'first' });
+    const r = await request(app, 'POST', '/api/env-vars', { name: 'BIZAR_TEST_DUP', value: 'second' });
+    assert.equal(r.status, 409);
+    assert.ok(r.body.error === 'already_exists');
+  });
+
+  it('404 on PUT/DELETE non-existent var', async () => {
+    const put = await request(app, 'PUT', '/api/env-vars/BIZAR_NONEXISTENT', { value: 'x' });
+    assert.equal(put.status, 404);
+
+    const del = await request(app, 'DELETE', '/api/env-vars/BIZAR_NONEXISTENT');
+    assert.equal(del.status, 404);
+  });
+});
+
+function octal(n) {
+  return '0o' + n.toString(8);
+}

package/bizar-dash/tests/lightrag-defaults.node.test.mjs

@@ -0,0 +1,118 @@
+/**
+ * lightrag-defaults.node.test.mjs — regression tests for the v4.6.0
+ * LightRAG defaults.
+ *
+ * The memory service's lightrag subsystem starts with the free opencode
+ * Zen models by default (no API key required). Operators can override
+ * via env vars `BIZAR_LIGHTRAG_LLM` and `BIZAR_LIGHTRAG_EMBEDDING`.
+ *
+ * The defaults surface:
+ *   - GET /api/lightrag/defaults   (lightrag settings view)
+ *   - GET /api/memory/lightrag/status (existing memory surface)
+ *
+ * Run with: node --test tests/lightrag-defaults.node.test.mjs
+ */
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve } from 'node:path';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let memoryStore;
+let memoryLightrag;
+let ORIGINAL_ENV;
+
+before(async () => {
+  const cb = '?cb=' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  memoryStore = await import(join(REPO, 'bizar-dash/src/server/memory-store.mjs') + cb);
+  memoryLightrag = await import(join(REPO, 'bizar-dash/src/server/memory-lightrag.mjs') + cb);
+  ORIGINAL_ENV = {
+    BIZAR_LIGHTRAG_LLM: process.env.BIZAR_LIGHTRAG_LLM,
+    BIZAR_LIGHTRAG_EMBEDDING: process.env.BIZAR_LIGHTRAG_EMBEDDING,
+  };
+  delete process.env.BIZAR_LIGHTRAG_LLM;
+  delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+});
+
+after(() => {
+  for (const [k, v] of Object.entries(ORIGINAL_ENV)) {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  }
+});
+
+import { join } from 'node:path';
+
+describe('LIGHTRAG_DEFAULT_* constants (v4.6.0)', () => {
+  it('default LLM is opencode/gpt-5-nano', () => {
+    assert.equal(memoryStore.LIGHTRAG_DEFAULT_LLM, 'opencode/gpt-5-nano');
+  });
+  it('default embedding is opencode/text-embedding-3-small', () => {
+    assert.equal(memoryStore.LIGHTRAG_DEFAULT_EMBEDDING, 'opencode/text-embedding-3-small');
+  });
+});
+
+describe('getDefaultLightRAGConfig()', () => {
+  it('returns opencode-free defaults when no env overrides', () => {
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    assert.equal(cfg.source, 'opencode-free');
+    assert.equal(cfg.llmSource, 'default');
+    assert.equal(cfg.embeddingSource, 'default');
+  });
+
+  it('env BIZAR_LIGHTRAG_LLM overrides the default LLM', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = 'anthropic/claude-haiku-4-5';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'anthropic/claude-haiku-4-5');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    assert.equal(cfg.source, 'env');
+    assert.equal(cfg.llmSource, 'env');
+    assert.equal(cfg.embeddingSource, 'default');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+  });
+
+  it('env BIZAR_LIGHTRAG_EMBEDDING overrides the default embedding', () => {
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = 'openai/text-embedding-3-large';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'openai/text-embedding-3-large');
+    assert.equal(cfg.embeddingSource, 'env');
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+
+  it('both env vars override together', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = 'minimax/MiniMax-M3';
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = 'openai/text-embedding-3-small';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'minimax/MiniMax-M3');
+    assert.equal(cfg.embedding, 'openai/text-embedding-3-small');
+    assert.equal(cfg.source, 'env');
+    assert.equal(cfg.llmSource, 'env');
+    assert.equal(cfg.embeddingSource, 'env');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+
+  it('treats empty env vars as unset (falls back to defaults)', () => {
+    process.env.BIZAR_LIGHTRAG_LLM = '';
+    process.env.BIZAR_LIGHTRAG_EMBEDDING = '   ';
+    const cfg = memoryStore.getDefaultLightRAGConfig();
+    assert.equal(cfg.llm, 'opencode/gpt-5-nano');
+    assert.equal(cfg.embedding, 'opencode/text-embedding-3-small');
+    delete process.env.BIZAR_LIGHTRAG_LLM;
+    delete process.env.BIZAR_LIGHTRAG_EMBEDDING;
+  });
+});
+
+describe('memory-lightrag.mjs LIGHTRAG_DEFAULTS (v4.6.0)', () => {
+  it('default llmModel matches the opencode-Zen-free default', () => {
+    assert.equal(memoryLightrag.LIGHTRAG_DEFAULTS.llmModel, 'opencode/gpt-5-nano');
+  });
+  it('default embeddingModel matches the opencode-Zen-free default', () => {
+    assert.equal(memoryLightrag.LIGHTRAG_DEFAULTS.embeddingModel, 'opencode/text-embedding-3-small');
+  });
+});

package/bizar-dash/tests/minimax-chat-usage.test.mjs

@@ -0,0 +1,178 @@
+/**
+ * minimax-chat-usage.test.mjs
+ *
+ * Verifies that chatCompletion() in minimax.mjs calls recordUsage()
+ * with the correct shape after every call (success, error, and cached).
+ *
+ * Run with: node --test bizar-dash/tests/minimax-chat-usage.test.mjs
+ */
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let SANDBOX_HOME;
+let ORIGINAL_BIZAR_STORE_HOME;
+
+before(() => {
+  SANDBOX_HOME = mkdtempSync(join(tmpdir(), `bizar-chat-usage-test-${Date.now()}-`));
+  ORIGINAL_BIZAR_STORE_HOME = process.env.BIZAR_STORE_HOME;
+  // Set BIZAR_STORE_HOME so the store module resolves to our sandbox.
+  process.env.BIZAR_STORE_HOME = join(SANDBOX_HOME, '.local', 'share', 'bizar');
+});
+
+after(() => {
+  process.env.BIZAR_STORE_HOME = ORIGINAL_BIZAR_STORE_HOME ?? '';
+  try { rmSync(SANDBOX_HOME, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+beforeEach(() => {
+  // Wipe the usage store before each test by directly unlinking the file.
+  const storeFile = join(process.env.BIZAR_STORE_HOME, 'usage.jsonl');
+  try { unlinkSync(storeFile); } catch { /* ignore */ }
+});
+
+/** Load the store module fresh each time with a unique cache-busting query param. */
+async function getStore() {
+  const stamp = `${Date.now()}-${Math.random()}`;
+  return import(`../src/server/minimax-usage-store.mjs?nocache=${stamp}`);
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+/**
+ * We can't easily intercept recordUsage calls directly, but we CAN
+ * verify the effect: after calling chatCompletion, the JSONL file
+ * contains one more line, and the shape of the record is correct.
+ *
+ * We mock the globalThis.fetch to return a fake MiniMax response,
+ * and verify the recorded usage entry.
+ */
+describe('chatCompletion records usage', () => {
+  it('records a success usage entry', async () => {
+    const store = await getStore();
+
+    // Mock fetch to return a fake MiniMax chat completion response.
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = function mockFetch(url, opts) {
+      if (String(url).includes('/chat/completions')) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          headers: { get: () => 'application/json' },
+          text: () => Promise.resolve(JSON.stringify({
+            id: 'msg_test',
+            model: 'MiniMax-M3',
+            choices: [{
+              finish_reason: 'stop',
+              message: { role: 'assistant', content: 'pong' },
+            }],
+            usage: {
+              prompt_tokens: 12,
+              completion_tokens: 3,
+              total_tokens: 15,
+              completion_tokens_details: { reasoning_tokens: 1 },
+            },
+            base_resp: { status_code: 0, status_msg: 'Success' },
+          })),
+        });
+      }
+      return originalFetch.call(this, url, opts);
+    };
+
+    try {
+      // Force re-import of minimax.mjs with the patched HOME.
+      const { chatCompletion } = await import(`../src/server/minimax.mjs?v=${Date.now()}`);
+      const result = await chatCompletion({ prompt: 'pong', model: 'MiniMax-M3', maxTokens: 16 });
+
+      assert.equal(result.ok, true);
+      assert.equal(result.model, 'MiniMax-M3');
+      assert.equal(result.content, 'pong');
+
+      // Now verify the usage was recorded.
+      const all = store.readAllRecords();
+      const entries = all.filter(r => r.requestId.startsWith('msg_'));
+      assert.ok(entries.length >= 1, `Expected at least 1 usage record, got ${entries.length}`);
+
+      const entry = entries[entries.length - 1];
+      assert.equal(entry.providerId, 'minimax');
+      assert.equal(entry.modelId, 'MiniMax-M3');
+      assert.equal(entry.endpoint, 'chat');
+      assert.equal(entry.promptTokens, 12);
+      assert.equal(entry.completionTokens, 3);
+      assert.equal(entry.totalTokens, 15);
+      assert.equal(entry.reasoningTokens, 1);
+      assert.equal(entry.finishReason, 'stop');
+      assert.equal(entry.error, null);
+      assert.equal(entry.cached, false);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('records an error usage entry on network failure', async () => {
+    const store = await getStore();
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = function mockFetch(url, opts) {
+      if (String(url).includes('/chat/completions')) {
+        return Promise.reject(new Error('ECONNREFUSED'));
+      }
+      return originalFetch.call(this, url, opts);
+    };
+
+    try {
+      const { chatCompletion } = await import(`../src/server/minimax.mjs?v=${Date.now() + 1}`);
+      const result = await chatCompletion({ prompt: 'ping', model: 'MiniMax-M3' });
+
+      assert.equal(result.ok, false);
+      assert.equal(result.error, 'network_error');
+
+      const all = store.readAllRecords();
+      const errorEntries = all.filter(r => r.error !== null);
+      assert.ok(errorEntries.length >= 1);
+      const entry = errorEntries[errorEntries.length - 1];
+      assert.equal(entry.error.code, 'network_error');
+      assert.equal(entry.endpoint, 'chat');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it('records an error usage entry on HTTP 429', async () => {
+    const store = await getStore();
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = function mockFetch(url, opts) {
+      if (String(url).includes('/chat/completions')) {
+        return Promise.resolve({
+          ok: false,
+          status: 429,
+          headers: { get: () => 'application/json' },
+          text: () => Promise.resolve(JSON.stringify({
+            base_resp: { status_code: 429, status_msg: 'Rate limit exceeded' },
+          })),
+        });
+      }
+      return originalFetch.call(this, url, opts);
+    };
+
+    try {
+      const { chatCompletion } = await import(`../src/server/minimax.mjs?v=${Date.now() + 2}`);
+      const result = await chatCompletion({ prompt: 'ping', model: 'MiniMax-M3' });
+      assert.equal(result.ok, false);
+      assert.equal(result.error, 'http_429');
+
+      const all = store.readAllRecords();
+      const errorEntries = all.filter(r => r.error !== null);
+      assert.ok(errorEntries.length >= 1);
+      const entry = errorEntries[errorEntries.length - 1];
+      assert.equal(entry.error.code, 'http_429');
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});