@polderlabs/bizar 3.23.1 → 4.2.0

package/bizar-dash/tests/memory-config.test.mjs

@@ -0,0 +1,422 @@
+/**
+ * tests/memory-config.test.mjs
+ *
+ * Tests for writeLightRAGConfig, patch-mode POST /memory/config,
+ * redact behaviour, and LightRAG lifecycle endpoints.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import http from 'node:http';
+
+const httpGet = (port, path) =>
+  new Promise((resolve) => {
+    const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }));
+    });
+    req.end();
+  });
+
+const httpPost = (port, path, body) =>
+  new Promise((resolve) => {
+    const data = JSON.stringify(body);
+    const req = http.request(
+      { hostname: 'localhost', port, path, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+      (res) => {
+        let respBody = '';
+        res.on('data', (c) => (respBody += c));
+        res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }));
+      },
+    );
+    req.write(data);
+    req.end();
+  });
+
+const {
+  writeLightRAGConfig,
+  resolveLightRAGConfig,
+} = await import('../src/server/memory-lightrag.mjs');
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function makeTmp() {
+  const root = join(tmpdir(), `bizar-lightrag-cfg-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(root, { recursive: true });
+  mkdirSync(join(root, '.bizar'), { recursive: true });
+  return root;
+}
+
+async function buildApp(projectRoot) {
+  const { createMemoryRouter } = await import('../src/server/routes/memory.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  app.use('/api', createMemoryRouter({ projectRoot }));
+  return app;
+}
+
+async function withApp(projectRoot, fn) {
+  const app = await buildApp(projectRoot);
+  const server = app.listen(0);
+  const port = server.address().port;
+  try {
+    return await fn(port);
+  } finally {
+    server.close();
+  }
+}
+
+// ── writeLightRAGConfig — unit tests ─────────────────────────────────────────
+
+describe('writeLightRAGConfig', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('deep-merges into existing lightrag block', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { enabled: false, port: 8000, llmModel: 'gpt-4o' },
+    }));
+
+    const result = writeLightRAGConfig(root, { enabled: true, port: 9000 });
+    assert.equal(result.ok, true);
+
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.lightrag.enabled, true);
+    assert.equal(mem.lightrag.port, 9000);
+    assert.equal(mem.lightrag.llmModel, 'gpt-4o'); // preserved
+  });
+
+  test('validates llmBinding is in known set', () => {
+    const result = writeLightRAGConfig(root, { llmBinding: 'not-a-binding' });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('llmBinding'));
+  });
+
+  test('validates embeddingBinding is in known set', () => {
+    const result = writeLightRAGConfig(root, { embeddingBinding: 'bad-embedding' });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('embeddingBinding'));
+  });
+
+  test('rejects port out of range (0)', () => {
+    const result = writeLightRAGConfig(root, { port: 0 });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('port'));
+  });
+
+  test('rejects port out of range (66666)', () => {
+    const result = writeLightRAGConfig(root, { port: 66666 });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('port'));
+  });
+
+  test('accepts port 1 and 65535', () => {
+    let r = writeLightRAGConfig(root, { port: 1 });
+    assert.equal(r.ok, true);
+    r = writeLightRAGConfig(root, { port: 65535 });
+    assert.equal(r.ok, true);
+  });
+
+  test('canonicalises <empty> to empty string for apiKey', () => {
+    const r = writeLightRAGConfig(root, { apiKey: '<empty>' });
+    assert.equal(r.ok, true);
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.lightrag.apiKey, '');
+  });
+
+  test('atomic — old or new file present after concurrent writes', () => {
+    writeLightRAGConfig(root, { port: 10000 });
+    for (let i = 0; i < 20; i++) {
+      writeLightRAGConfig(root, { port: i + 1 });
+    }
+    const content = readFileSync(join(root, '.bizar', 'memory.json'), 'utf8');
+    const parsed = JSON.parse(content);
+    assert.equal(parsed.lightrag.port, 20);
+  });
+
+  test('creates .bizar/memory.json if missing', () => {
+    const fresh = join(tmpdir(), `bizar-fresh-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(fresh, { recursive: true });
+    try {
+      const r = writeLightRAGConfig(fresh, { port: 5000 });
+      assert.equal(r.ok, true);
+      assert.ok(existsSync(join(fresh, '.bizar', 'memory.json')));
+      const mem = JSON.parse(readFileSync(join(fresh, '.bizar', 'memory.json'), 'utf8'));
+      assert.equal(mem.lightrag.port, 5000);
+    } finally {
+      rmSync(fresh, { recursive: true, force: true });
+    }
+  });
+
+  test('preserves non-lightrag fields when merging', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      projectId: 'test-proj',
+      memoryRepo: { mode: 'local-only' },
+      lightrag: { port: 7000 },
+    }));
+    const r = writeLightRAGConfig(root, { llmModel: 'claude-3' });
+    assert.equal(r.ok, true);
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.projectId, 'test-proj');
+    assert.equal(mem.lightrag.llmModel, 'claude-3');
+    assert.equal(mem.lightrag.port, 7000);
+  });
+});
+
+// ── resolveLightRAGConfig — apiKey defaults ───────────────────────────────────
+
+describe('resolveLightRAGConfig apiKey defaults', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('defaults apiKey to "env" when not set', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      lightrag: { port: 9621 },
+    }));
+    const cfg = resolveLightRAGConfig(root);
+    assert.equal(cfg.apiKey, 'env');
+    assert.equal(cfg.apiKeySource, 'env');
+  });
+
+  test('reads existing apiKeySource', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      lightrag: { port: 9621, apiKey: 'sk-123', apiKeySource: 'file' },
+    }));
+    const cfg = resolveLightRAGConfig(root);
+    assert.equal(cfg.apiKey, 'sk-123');
+    assert.equal(cfg.apiKeySource, 'file');
+  });
+});
+
+// ── HTTP route integration tests ─────────────────────────────────────────────
+
+describe('POST /api/memory/config patch mode', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, llmModel: 'original-model' },
+    }));
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns merged config with redacted apiKey', async () => {
+    writeLightRAGConfig(root, { apiKey: 'sk-secret123', apiKeySource: 'file' });
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', {
+        patch: true,
+        lightrag: { port: 5000 },
+      });
+      assert.equal(res.status, 200);
+      assert.equal(res.body.ok, true);
+      assert.equal(res.body.config.lightrag.port, 5000);
+      assert.equal(res.body.config.lightrag.llmModel, 'original-model');
+      // apiKey must be redacted
+      assert.equal(res.body.config.lightrag.apiKey, '***');
+    });
+  });
+
+  test('rejects patch without lightrag field', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, foo: 'bar' });
+      assert.equal(res.status, 400);
+    });
+  });
+
+  test('rejects unknown top-level fields in patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 1 }, mode: 'managed' });
+      assert.equal(res.status, 400);
+    });
+  });
+
+  test('validates port range through patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 99999 } });
+      assert.equal(res.status, 400);
+      assert.ok(res.body.message.includes('port'));
+    });
+  });
+
+  test('validates llmBinding through patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { llmBinding: 'invalid' } });
+      assert.equal(res.status, 400);
+      assert.ok(res.body.message.includes('llmBinding'));
+    });
+  });
+});
+
+describe('GET /api/memory/config — redaction', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, apiKey: 'sk-abc123', apiKeySource: 'file' },
+    }));
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('GET /memory/config redacts apiKey to ***', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/config');
+      assert.equal(res.status, 200);
+      assert.equal(res.body.config.lightrag.apiKey, '***');
+      assert.equal(res.body.config.lightrag.apiKeySource, 'file');
+    });
+  });
+});
+
+describe('GET /api/memory/lightrag/status', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, llmBinding: 'ollama', embeddingBinding: 'ollama', llmModel: 'test-model', embeddingModel: 'test-embed' },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns running:false when server not running', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/status');
+      assert.equal(res.status, 200);
+      assert.equal(res.body.running, false);
+      assert.equal(res.body.pid, null);
+      assert.equal(res.body.port, 9621);
+      assert.equal(res.body.llmBinding, 'ollama');
+      assert.equal(res.body.embeddingBinding, 'ollama');
+    });
+  });
+});
+
+describe('POST /api/memory/lightrag/start', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns ok:false with error when lightrag-server not installed (or ok:true if it is)', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/lightrag/start', {});
+      assert.equal(res.status, 200);
+      assert.equal(typeof res.body.ok, 'boolean');
+      if (!res.body.ok) {
+        assert.ok(res.body.error != null);
+      }
+    });
+  });
+});
+
+describe('POST /api/memory/lightrag/stop', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns ok:true when nothing is running', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/lightrag/stop', {});
+      assert.equal(res.status, 200);
+      assert.equal(res.body.ok, true);
+    });
+  });
+});
+
+describe('GET /api/memory/lightrag/log', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+    // Write a log file with 60 lines
+    const lines = Array.from({ length: 60 }, (_, i) => `log line ${i + 1}`).join('\n');
+    writeFileSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), lines);
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns last 200 lines', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/log');
+      assert.equal(res.status, 200);
+      assert.ok(Array.isArray(res.body.lines));
+      assert.ok(res.body.lines.length <= 200);
+    });
+  });
+
+  test('returns empty lines when no log file', async () => {
+    rmSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), { force: true });
+
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/log');
+      assert.equal(res.status, 200);
+      assert.ok(Array.isArray(res.body.lines));
+      assert.equal(res.body.lines.length, 0);
+    });
+  });
+});

package/bizar-dash/tests/memory-git.test.mjs

@@ -0,0 +1,246 @@
+/**
+ * tests/memory-git.test.mjs
+ *
+ * Tests for the memory-git module.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
+import { execSync, execFileSync } from 'node:child_process';
+
+const TEST_GIT = await import('../src/server/memory-git.mjs').then((m) => m);
+const GIT_INSTALLED = TEST_GIT.isGitInstalled();
+
+describe('memory-git', () => {
+  let bareRemote;
+  let workingDir;
+
+  beforeEach(() => {
+    // Guard: if git was removed since process start, bail gracefully
+    if (!TEST_GIT.isGitInstalled()) {
+      bareRemote = null;
+      workingDir = null;
+      return;
+    }
+    // Create a bare remote repo
+    bareRemote = join(tmpdir(), `bizar-git-test-remote-${Date.now()}-${Math.random().toString(36).slice(2)}.git`);
+    mkdirSync(bareRemote, { recursive: true });
+    try { execSync('git', ['init', '--bare'], { cwd: bareRemote, encoding: 'utf8' }); } catch { bareRemote = null; return; }
+
+    // Create a working clone
+    workingDir = join(tmpdir(), `bizar-git-test-work-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(workingDir, { recursive: true });
+    try {
+      execSync('git', ['clone', bareRemote, workingDir], { encoding: 'utf8' });
+      execSync('git', ['config', 'user.email', 'test@bizar.ai'], { cwd: workingDir, encoding: 'utf8' });
+      execSync('git', ['config', 'user.name', 'Bizar Test'], { cwd: workingDir, encoding: 'utf8' });
+    } catch { workingDir = null; }
+  });
+
+  afterEach(() => {
+    try { if (bareRemote) rmSync(bareRemote, { recursive: true, force: true }); } catch { /* ignore */ }
+    try { if (workingDir) rmSync(workingDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('isGitInstalled returns true when git is available', () => {
+    assert.strictEqual(TEST_GIT.isGitInstalled(), GIT_INSTALLED);
+    if (!GIT_INSTALLED) assert.fail('git not installed — this test should not run');
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('clone creates a working repo', () => {
+    if (!workingDir || !bareRemote) return;
+    const cloneTarget = join(tmpdir(), `clone-test-${Date.now()}`);
+    mkdirSync(cloneTarget, { recursive: true });
+    const result = TEST_GIT.clone(bareRemote, cloneTarget, { branch: 'main', depth: 1 });
+    try {
+      assert.strictEqual(result.ok, true);
+      assert.ok(existsSync(join(cloneTarget, '.git')));
+    } finally {
+      rmSync(cloneTarget, { recursive: true, force: true });
+    }
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('addFile + commit + push work', () => {
+    if (!workingDir) return;
+    writeFileSync(join(workingDir, 'test.txt'), 'hello world', 'utf8');
+    TEST_GIT.addFile(workingDir, 'test.txt');
+    const commitResult = TEST_GIT.commit(workingDir, 'Add test.txt');
+    assert.strictEqual(commitResult.ok, true);
+    const pushResult = TEST_GIT.push(workingDir, { remote: 'origin', branch: 'main' });
+    assert.strictEqual(pushResult.ok, true);
+    const status = TEST_GIT.status(workingDir);
+    assert.strictEqual(status.clean, true);
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('status reports dirty after changes', () => {
+    if (!workingDir) return;
+    writeFileSync(join(workingDir, 'dirty.txt'), 'dirty content', 'utf8');
+    const status = TEST_GIT.status(workingDir);
+    assert.strictEqual(status.clean, false);
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('status reports clean after push', () => {
+    if (!workingDir) return;
+    writeFileSync(join(workingDir, 'clean.txt'), 'clean', 'utf8');
+    TEST_GIT.addFile(workingDir, 'clean.txt');
+    TEST_GIT.commit(workingDir, 'Add clean');
+    TEST_GIT.push(workingDir, { remote: 'origin', branch: 'main' });
+    const status = TEST_GIT.status(workingDir);
+    assert.strictEqual(status.clean, true);
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('acquireLock + release works', () => {
+    if (!workingDir) return;
+    const lock = TEST_GIT.acquireLock(workingDir);
+    assert.strictEqual(lock.error, undefined);
+    assert.ok(typeof lock.release === 'function');
+    lock.release();
+    assert.ok(!existsSync(join(workingDir, '.sync.lock')));
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('acquireLock returns locked when held', () => {
+    if (!workingDir) return;
+    const lock1 = TEST_GIT.acquireLock(workingDir);
+    assert.strictEqual(lock1.error, undefined);
+    const lock2 = TEST_GIT.acquireLock(workingDir);
+    assert.strictEqual(lock2.error, 'locked');
+    lock1.release();
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('release is idempotent', () => {
+    if (!workingDir) return;
+    const lock = TEST_GIT.acquireLock(workingDir);
+    lock.release();
+    lock.release();
+    lock.release();
+    assert.ok(!existsSync(join(workingDir, '.sync.lock')));
+    const lock2 = TEST_GIT.acquireLock(workingDir);
+    assert.strictEqual(lock2.error, undefined);
+    lock2.release();
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('addAll stages all changes', () => {
+    if (!workingDir) return;
+    writeFileSync(join(workingDir, 'a.txt'), 'a', 'utf8');
+    writeFileSync(join(workingDir, 'b.txt'), 'b', 'utf8');
+    const result = TEST_GIT.addAll(workingDir);
+    assert.strictEqual(result.ok, true);
+  });
+
+  (GIT_INSTALLED ? it : it.skip)('pull works on up-to-date repo', () => {
+    if (!workingDir) return;
+    const result = TEST_GIT.pull(workingDir);
+    assert.strictEqual(result.ok, true);
+  });
+
+  describe('addRemote', () => {
+    (GIT_INSTALLED ? it : it.skip)('registers a new remote on a fresh repo', () => {
+      const dir = join(tmpdir(), `bizar-addremote-fresh-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const result = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(result, { ok: true, action: 'added' });
+
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: dir, encoding: 'utf8' }).trim();
+        assert.strictEqual(url, 'git@github.com:user/repo.git');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('is idempotent when same URL is set twice', () => {
+      const dir = join(tmpdir(), `bizar-addremote-idempotent-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const first = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(first, { ok: true, action: 'added' });
+
+        const second = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(second, { ok: true, action: 'unchanged' });
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('throws when remote exists with different URL and overwrite is false', () => {
+      const dir = join(tmpdir(), `bizar-addremote-noverwrite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.throws(
+          () => TEST_GIT.addRemote(dir, 'origin', 'git@github.com:other/repo.git'),
+          /already exists/,
+        );
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('overwrites remote URL when overwrite flag is set', () => {
+      const dir = join(tmpdir(), `bizar-addremote-overwrite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        const result = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:other/repo.git', { overwrite: true });
+        assert.deepEqual(result, { ok: true, action: 'updated' });
+
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: dir, encoding: 'utf8' }).trim();
+        assert.strictEqual(url, 'git@github.com:other/repo.git');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('lsRemote', () => {
+    (GIT_INSTALLED ? it : it.skip)('returns empty string for an unreachable remote', () => {
+      const dir = join(tmpdir(), `bizar-lsremote-unreachable-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@127.0.0.1:1/nope.git');
+        const result = TEST_GIT.lsRemote(dir, 'origin', { timeoutMs: 1000 });
+        assert.strictEqual(result, '');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('returns empty string when the remote name does not exist', () => {
+      const dir = join(tmpdir(), `bizar-lsremote-nonexistent-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const result = TEST_GIT.lsRemote(dir, 'nonexistent', { timeoutMs: 1000 });
+        assert.strictEqual(result, '');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
+});