@davvidbaker/flambe-cli 0.1.0

package/test/local.test.mjs

@@ -0,0 +1,136 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { run } from '../src/cli.mjs';
+import { listenLocal } from '../src/local/serve.mjs';
+import { LocalStore } from '../src/local/store.mjs';
+
+async function withServer(fn) {
+  const directory = mkdtempSync(join(tmpdir(), 'flambe-local-'));
+  const dbPath = join(directory, 'local.sqlite');
+  const { server, store, port } = await listenLocal({
+    host: '127.0.0.1',
+    port: 0,
+    dbPath,
+    staticDir: null,
+  });
+  const origin = `http://127.0.0.1:${port}`;
+  const { rawToken, traceId } = store.credentials();
+
+  try {
+    await fn({ origin, rawToken, traceId, store, dbPath, directory });
+  } finally {
+    server.close();
+    store.close();
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test('local server binds loopback, seeds a token, and round-trips CLI activity events', async () => {
+  await withServer(async ({ origin, rawToken, traceId }) => {
+    const health = await fetch(`${origin}/api/health`);
+    assert.equal(health.status, 200);
+    assert.deepEqual(await health.json(), { status: 'ok' });
+
+    const headers = {
+      authorization: `Bearer ${rawToken}`,
+      'content-type': 'application/json',
+      'x-flambe-agent-id': 'cursor:test',
+      'x-flambe-agent-name': 'Grok',
+    };
+
+    const begin = await fetch(`${origin}/api/activities`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        trace_id: traceId,
+        thread_id: 1,
+        activity: { name: 'Keep work on this laptop' },
+        event: { timestamp_integer: 1_788_360_000_123, phase: 'B' },
+      }),
+    });
+    assert.equal(begin.status, 201);
+    const created = await begin.json();
+    const activityId = created.data.activity.id;
+
+    const end = await fetch(`${origin}/api/events`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        trace_id: traceId,
+        activity_id: activityId,
+        event: { timestamp_integer: 1_788_360_000_999, phase: 'E', message: 'stayed local' },
+      }),
+    });
+    assert.equal(end.status, 201);
+
+    const trace = await fetch(`${origin}/api/traces/${traceId}`, { headers }).then(r => r.json());
+    assert.equal(trace.data.events.length, 2);
+    assert.equal(trace.data.events[0].activity.name, 'Keep work on this laptop');
+    assert.equal(trace.data.events[0].activity.agent_name, 'Grok');
+    assert.equal(trace.data.events[1].phase, 'E');
+  });
+});
+
+test('login on the local server sets a session cookie and serves the user dashboard', async () => {
+  await withServer(async ({ origin }) => {
+    const login = await fetch(`${origin}/auth/identity/callback`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ email: 'anyone@local', password: 'ignored' }),
+    });
+    assert.equal(login.status, 200);
+    const setCookie = login.headers.get('set-cookie');
+    assert.match(setCookie, /flambe_user=1/);
+    const { data } = await login.json();
+    assert.equal(data.username, 'local');
+
+    const user = await fetch(`${origin}/api/users/${data.id}`, {
+      headers: { cookie: setCookie.split(';')[0] },
+    });
+    assert.equal(user.status, 200);
+    const dashboard = await user.json();
+    assert.equal(dashboard.data.traces[0].name, 'Main');
+  });
+});
+
+test('export writes a remappable bundle without tokens', async () => {
+  const directory = mkdtempSync(join(tmpdir(), 'flambe-export-'));
+  const dbPath = join(directory, 'local.sqlite');
+  const store = new LocalStore(dbPath);
+  try {
+    store.createActivity(1, {
+      traceId: 1,
+      threadId: 1,
+      activity: { name: 'Company work' },
+      event: { timestamp_integer: 1000, phase: 'B' },
+      agentId: 'agent-1',
+      agentName: 'Grok',
+    });
+    const out = join(directory, 'out.json');
+    const chunks = [];
+    await run(['export', out, '--db', dbPath], {
+      env: {},
+      stdout: { write: chunk => chunks.push(chunk) },
+    });
+    const bundle = JSON.parse(readFileSync(out, 'utf8'));
+    assert.equal(bundle.format, 'flambe-local-export');
+    assert.equal(bundle.version, 1);
+    assert.equal(bundle.traces[0].activities[0].name, 'Company work');
+    assert.ok(bundle.traces[0].export_id);
+    assert.equal(JSON.stringify(bundle).includes('flb_'), false);
+  } finally {
+    store.close();
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test('refuses a non-loopback bind', () => {
+  assert.throws(
+    () => listenLocal({ host: '0.0.0.0', port: 0, dbPath: join(tmpdir(), 'no.sqlite') }),
+    /loopback only/,
+  );
+});

package/test/queue.test.mjs

@@ -0,0 +1,135 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { FlambeQueue, MAX_FLUSH_ATTEMPTS } from '../src/queue.mjs';
+
+const BASE = 'http://flambe.test';
+const TRACE = 3;
+
+function seed(entries) {
+  const directory = mkdtempSync(join(tmpdir(), 'flambe-queue-'));
+  const path = join(directory, 'queue.json');
+  writeFileSync(path, JSON.stringify({
+    version: 1,
+    entries: entries.map(entry => ({ baseUrl: BASE, traceId: TRACE, ...entry })),
+    aliases: {},
+  }));
+  const queue = new FlambeQueue({ baseUrl: BASE, traceId: TRACE, path });
+  return { directory, path, queue };
+}
+
+function serverError(status) {
+  const error = new Error(`server said ${status}`);
+  error.status = status;
+  error.retryable = status >= 500;
+  return error;
+}
+
+function networkError() {
+  const error = new TypeError('network unavailable');
+  error.retryable = true; // no .status -- server never answered
+  return error;
+}
+
+function endEntry(activityId) {
+  return { type: 'end', activityId, message: `close ${activityId}`, timestamp: 1 };
+}
+
+test('a permanently 500ing entry is dropped after MAX_FLUSH_ATTEMPTS, unblocking the rest', async () => {
+  const { path, queue } = seed([endEntry('217'), endEntry('218')]);
+  const warns = [];
+  let good = 0;
+  const handlers = {
+    async end({ activityId }) {
+      if (activityId === '217') throw serverError(500); // the varchar(255) case
+      good += 1;
+    },
+    async start() {}, async suspend() {}, async resume() {},
+  };
+
+  try {
+    for (let i = 0; i < MAX_FLUSH_ATTEMPTS; i += 1) {
+      await queue.flush(handlers, { warn: message => warns.push(message) });
+    }
+
+    // 217 dropped after the attempt cap; 218 then flushed; queue file removed.
+    assert.equal(good, 1);
+    assert.equal(existsSync(path), false);
+    assert.ok(warns.some(w => /stalled on end \(activity 217\).*attempt 1\//.test(w)));
+    assert.ok(warns.some(w => /dropping offline queue entry end \(activity 217\)/.test(w)));
+    // the payload is printed so nothing is lost silently
+    assert.ok(warns.some(w => w.includes('"activityId":"217"')));
+  } finally {
+    rmSync(path, { force: true });
+  }
+});
+
+test('an unreachable server never ages out an entry and keeps queue order', async () => {
+  const { path, queue } = seed([endEntry('217')]);
+  const warns = [];
+  const handlers = {
+    async end() { throw networkError(); },
+    async start() {}, async suspend() {}, async resume() {},
+  };
+
+  try {
+    for (let i = 0; i < MAX_FLUSH_ATTEMPTS + 3; i += 1) {
+      await queue.flush(handlers, { warn: message => warns.push(message) });
+    }
+
+    const state = JSON.parse(readFileSync(path, 'utf8'));
+    assert.equal(state.entries.length, 1);            // still there
+    assert.equal(state.entries[0].attempts, undefined); // connectivity failures don't count
+    assert.ok(warns.every(w => /server unreachable/.test(w)));
+  } finally {
+    rmSync(path, { force: true });
+  }
+});
+
+test('a 4xx entry is dropped immediately, loudly, and later entries still flush', async () => {
+  const { path, queue } = seed([endEntry('217'), endEntry('218')]);
+  const warns = [];
+  let good = 0;
+  const handlers = {
+    async end({ activityId }) {
+      if (activityId === '217') throw serverError(400);
+      good += 1;
+    },
+    async start() {}, async suspend() {}, async resume() {},
+  };
+
+  try {
+    await queue.flush(handlers, { warn: message => warns.push(message) }); // a single pass suffices
+
+    assert.equal(good, 1);
+    assert.equal(existsSync(path), false);
+    assert.ok(warns.some(w => /dropping offline queue entry end \(activity 217\) after 1 attempt/.test(w)));
+  } finally {
+    rmSync(path, { force: true });
+  }
+});
+
+test('entries for a different server are left untouched', async () => {
+  const { path, queue } = seed([{ type: 'end', activityId: '9', message: 'x', timestamp: 1 }]);
+  // Rewrite the one entry to belong to another base URL.
+  const state = JSON.parse(readFileSync(path, 'utf8'));
+  state.entries[0].baseUrl = 'http://other.test';
+  writeFileSync(path, JSON.stringify(state));
+
+  const handlers = {
+    async end() { throw new Error('should not be called'); },
+    async start() {}, async suspend() {}, async resume() {},
+  };
+
+  try {
+    await queue.flush(handlers, { warn() {} });
+    const after = JSON.parse(readFileSync(path, 'utf8'));
+    assert.equal(after.entries.length, 1);
+    assert.equal(after.entries[0].baseUrl, 'http://other.test');
+  } finally {
+    rmSync(path, { force: true });
+  }
+});