@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/openchamber-sessions/archive-store.js

@@ -0,0 +1,224 @@
+/**
+ * OpenChamber-owned session archive state.
+ *
+ * OpenCode 2.x still carries `SessionInfo.time.archived` on the wire (sessions
+ * migrated from v1 keep the flag) but has no route that sets or clears it, so
+ * archiving is an OpenChamber capability now. The state lives beside the
+ * OpenCode instance it describes — one JSON file per data dir,
+ * `{ [sessionID]: archivedAt | null }` — and the proxy folds it back onto the
+ * session records it serves: a number archives, `null` is an explicit
+ * unarchive that overrides what OpenCode still carries, and a session the file
+ * does not mention keeps whatever OpenCode says.
+ */
+
+import fsDefault from 'node:fs';
+import pathDefault from 'node:path';
+
+const ARCHIVE_FILE_NAME = 'sessions-archive.json';
+
+const asNonEmptyString = (value) => {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const asTimestamp = (value) => (Number.isSafeInteger(value) && value > 0 ? value : null);
+
+const asIdList = (ids) => {
+  if (!Array.isArray(ids)) return [];
+  const seen = new Set();
+  const result = [];
+  for (const value of ids) {
+    const id = asNonEmptyString(value);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    result.push(id);
+  }
+  return result;
+};
+
+/**
+ * @param {object} options
+ * @param {string} options.dataDir OpenChamber data directory for this instance.
+ * @param {typeof fsDefault.promises} [options.fsPromises]
+ * @param {typeof pathDefault} [options.path]
+ * @param {() => number} [options.now]
+ */
+export const createArchiveStore = ({
+  dataDir,
+  fsPromises = fsDefault.promises,
+  path = pathDefault,
+  now = Date.now,
+}) => {
+  const filePath = path.join(dataDir, ARCHIVE_FILE_NAME);
+
+  /** sessionID → archivedAt (ms). Authoritative once `loaded` is true. */
+  const entries = new Map();
+  let loaded = false;
+  let loadPromise = null;
+  /**
+   * Writes stay disabled until one load has told us what is already on disk.
+   * A failed read is not evidence that nothing is archived, and writing over
+   * a file we could not read would drop exactly the state we are protecting.
+   */
+  let writable = false;
+  /**
+   * One batch at a time: mutate memory, persist, roll back on failure.
+   * Serializing only the file write is not enough — a rollback that runs after
+   * a later batch has already committed would erase that batch's memory while
+   * its bytes stay on disk, and the next write would then erase the bytes too.
+   */
+  let transactionChain = Promise.resolve();
+  const runExclusive = (work) => {
+    const next = transactionChain.then(work, work);
+    transactionChain = next.then(() => undefined, () => undefined);
+    return next;
+  };
+
+  const snapshot = () => Object.fromEntries(entries);
+
+  const parseStored = (raw) => {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('archive file is not a JSON object');
+    }
+    const result = new Map();
+    for (const [sessionID, value] of Object.entries(parsed)) {
+      const id = asNonEmptyString(sessionID);
+      if (!id) continue;
+      if (value === null) {
+        result.set(id, null);
+        continue;
+      }
+      const archivedAt = asTimestamp(value);
+      if (archivedAt) result.set(id, archivedAt);
+    }
+    return result;
+  };
+
+  const readFile = async () => {
+    let raw;
+    try {
+      raw = await fsPromises.readFile(filePath, 'utf8');
+    } catch (error) {
+      // No file yet is the normal first run: nothing is archived, and writing
+      // is safe because there is no state to lose.
+      if (error?.code === 'ENOENT') return { ok: true, stored: new Map() };
+      console.warn('[openchamber-sessions] could not read the archive file:', error?.message ?? error);
+      return { ok: false, stored: null };
+    }
+
+    try {
+      return { ok: true, stored: parseStored(raw) };
+    } catch (error) {
+      // Malformed bytes are kept for the user instead of being overwritten on
+      // the next archive, and whatever this process already knows stays in
+      // memory rather than collapsing to "nothing archived".
+      const backup = `${filePath}.corrupt-${now()}`;
+      await fsPromises.rename(filePath, backup).catch(() => undefined);
+      console.warn(
+        `[openchamber-sessions] archive file was unreadable and was moved to ${backup}: ${error?.message ?? error}`,
+      );
+      return { ok: true, stored: new Map() };
+    }
+  };
+
+  const load = () => {
+    if (!loadPromise) {
+      loadPromise = readFile().then((result) => {
+        if (result.ok) {
+          // Merge rather than replace: an archive that happened while the first
+          // load was still running must survive it.
+          for (const [id, archivedAt] of result.stored) {
+            if (!entries.has(id)) entries.set(id, archivedAt);
+          }
+          loaded = true;
+          writable = true;
+        } else {
+          // Let a later call retry; until one succeeds the store answers reads
+          // from memory and refuses writes.
+          loadPromise = null;
+        }
+        return { ok: result.ok, entries: snapshot() };
+      });
+    }
+    return loadPromise;
+  };
+
+  /** Only ever called inside `runExclusive`, so two batches cannot interleave their renames. */
+  const persist = async () => {
+    const payload = JSON.stringify(snapshot());
+    await fsPromises.mkdir(dataDir, { recursive: true });
+    // Temp file in the same directory so the rename is atomic on one device:
+    // a reader sees either the previous file or the complete new one.
+    const tmpPath = `${filePath}.${process.pid}.tmp`;
+    await fsPromises.writeFile(tmpPath, payload, 'utf8');
+    await fsPromises.rename(tmpPath, filePath);
+  };
+
+  /** Applies a batch and rolls the memory back when the file write fails. */
+  const applyBatch = async (ids, archivedAt) => {
+    const targets = asIdList(ids);
+    if (targets.length === 0) return { applied: [], failedIds: [] };
+    return runExclusive(() => applyBatchExclusive(targets, archivedAt));
+  };
+
+  const applyBatchExclusive = async (targets, archivedAt) => {
+    const loadResult = await load();
+    if (!loadResult.ok || !writable) {
+      return { applied: [], failedIds: targets };
+    }
+
+    const previous = targets.map((id) => [id, entries.has(id) ? { value: entries.get(id) } : undefined]);
+    // `null` is kept as an entry on purpose: it tells the overlay to drop an
+    // archived stamp OpenCode still carries (migrated v1 sessions).
+    for (const id of targets) entries.set(id, archivedAt);
+
+    try {
+      await persist();
+    } catch (error) {
+      for (const [id, restore] of previous) {
+        if (restore === undefined) entries.delete(id);
+        else entries.set(id, restore.value);
+      }
+      console.warn('[openchamber-sessions] failed to persist archive state:', error?.message ?? error);
+      return { applied: [], failedIds: targets };
+    }
+
+    return { applied: targets, failedIds: [] };
+  };
+
+  const getAll = async () => {
+    await load();
+    return snapshot();
+  };
+
+  return {
+    load,
+    getAll,
+    list: getAll,
+    isLoaded: () => loaded,
+    isArchived: async (id) => {
+      const sessionID = asNonEmptyString(id);
+      if (!sessionID) return false;
+      await load();
+      return typeof entries.get(sessionID) === 'number';
+    },
+    archivedAt: async (id) => {
+      const sessionID = asNonEmptyString(id);
+      if (!sessionID) return null;
+      await load();
+      return entries.get(sessionID) ?? null;
+    },
+    archive: async (ids, archivedAt) => {
+      const stamp = asTimestamp(archivedAt) ?? now();
+      const { applied, failedIds } = await applyBatch(ids, stamp);
+      return { archived: applied.map((id) => ({ id, archivedAt: stamp })), failedIds };
+    },
+    unarchive: async (ids) => {
+      const { applied, failedIds } = await applyBatch(ids, null);
+      return { restored: applied.map((id) => ({ id, archivedAt: null })), failedIds };
+    },
+    filePath,
+  };
+};

package/server/lib/openchamber-sessions/archive-store.test.js

@@ -0,0 +1,187 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createArchiveStore } from './archive-store.js';
+
+const tempDirs = [];
+
+const makeDataDir = () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-archive-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+const readFile = (dataDir) => fs.readFileSync(path.join(dataDir, 'sessions-archive.json'), 'utf8');
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+  vi.restoreAllMocks();
+});
+
+describe('createArchiveStore', () => {
+  it('starts empty when the file does not exist', async () => {
+    const store = createArchiveStore({ dataDir: makeDataDir() });
+    await expect(store.getAll()).resolves.toEqual({});
+    await expect(store.isArchived('ses_1')).resolves.toBe(false);
+    await expect(store.archivedAt('ses_1')).resolves.toBeNull();
+  });
+
+  it('archives a batch, persists it, and reads it back in a fresh store', async () => {
+    const dataDir = makeDataDir();
+    const store = createArchiveStore({ dataDir, now: () => 1_700_000 });
+
+    const result = await store.archive(['ses_1', 'ses_2']);
+    expect(result).toEqual({
+      archived: [
+        { id: 'ses_1', archivedAt: 1_700_000 },
+        { id: 'ses_2', archivedAt: 1_700_000 },
+      ],
+      failedIds: [],
+    });
+    expect(JSON.parse(readFile(dataDir))).toEqual({ ses_1: 1_700_000, ses_2: 1_700_000 });
+
+    const reopened = createArchiveStore({ dataDir });
+    await expect(reopened.getAll()).resolves.toEqual({ ses_1: 1_700_000, ses_2: 1_700_000 });
+    await expect(reopened.isArchived('ses_2')).resolves.toBe(true);
+  });
+
+  it('honours an explicit archivedAt and ignores a nonsense one', async () => {
+    const store = createArchiveStore({ dataDir: makeDataDir(), now: () => 42 });
+    await expect(store.archive(['ses_1'], 999)).resolves.toMatchObject({
+      archived: [{ id: 'ses_1', archivedAt: 999 }],
+    });
+    await expect(store.archive(['ses_2'], -5)).resolves.toMatchObject({
+      archived: [{ id: 'ses_2', archivedAt: 42 }],
+    });
+  });
+
+  it('unarchives a batch and records the explicit unarchive in the file', async () => {
+    const dataDir = makeDataDir();
+    const store = createArchiveStore({ dataDir, now: () => 1 });
+    await store.archive(['ses_1', 'ses_2']);
+
+    await expect(store.unarchive(['ses_1'])).resolves.toEqual({
+      restored: [{ id: 'ses_1', archivedAt: null }],
+      failedIds: [],
+    });
+    expect(JSON.parse(readFile(dataDir))).toEqual({ ses_1: null, ses_2: 1 });
+    await expect(store.isArchived('ses_1')).resolves.toBe(false);
+  });
+
+  it('ignores blank ids and collapses duplicates', async () => {
+    const store = createArchiveStore({ dataDir: makeDataDir(), now: () => 7 });
+    const result = await store.archive(['ses_1', ' ses_1 ', '', '   ', null, 5]);
+    expect(result.archived).toEqual([{ id: 'ses_1', archivedAt: 7 }]);
+    await expect(store.archive([])).resolves.toEqual({ archived: [], failedIds: [] });
+  });
+
+  it('writes atomically: the final file never contains a partial payload', async () => {
+    const dataDir = makeDataDir();
+    const seen = [];
+    const realRename = fs.promises.rename.bind(fs.promises);
+    const fsPromises = {
+      ...fs.promises,
+      writeFile: async (target, payload, encoding) => {
+        // The visible file must still be the previous one at this point.
+        seen.push(fs.existsSync(path.join(dataDir, 'sessions-archive.json'))
+          ? readFile(dataDir)
+          : null);
+        return fs.promises.writeFile(target, payload, encoding);
+      },
+      rename: realRename,
+    };
+    const store = createArchiveStore({ dataDir, fsPromises, now: () => 3 });
+
+    await store.archive(['ses_1']);
+    await store.archive(['ses_2']);
+
+    expect(seen).toEqual([null, JSON.stringify({ ses_1: 3 })]);
+    expect(JSON.parse(readFile(dataDir))).toEqual({ ses_1: 3, ses_2: 3 });
+  });
+
+  it('treats a malformed file as empty, keeps a backup, and still accepts writes', async () => {
+    const dataDir = makeDataDir();
+    fs.writeFileSync(path.join(dataDir, 'sessions-archive.json'), '{ not json', 'utf8');
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const store = createArchiveStore({ dataDir, now: () => 11 });
+    await expect(store.getAll()).resolves.toEqual({});
+    await expect(store.archive(['ses_1'])).resolves.toMatchObject({ failedIds: [] });
+    expect(JSON.parse(readFile(dataDir))).toEqual({ ses_1: 11 });
+    expect(fs.readdirSync(dataDir).some((name) => name.includes('sessions-archive.json.'))).toBe(true);
+  });
+
+  it('drops entries that are not positive timestamps', async () => {
+    const dataDir = makeDataDir();
+    fs.writeFileSync(
+      path.join(dataDir, 'sessions-archive.json'),
+      JSON.stringify({ ses_ok: 5, ses_zero: 0, ses_text: 'yesterday', ses_float: 1.5 }),
+      'utf8',
+    );
+    const store = createArchiveStore({ dataDir });
+    await expect(store.getAll()).resolves.toEqual({ ses_ok: 5 });
+  });
+
+  it('refuses to write when the file could not be read, so unknown state is never overwritten', async () => {
+    const dataDir = makeDataDir();
+    fs.writeFileSync(path.join(dataDir, 'sessions-archive.json'), '{}', 'utf8');
+    const unreadable = Object.assign(new Error('EACCES'), { code: 'EACCES' });
+    const fsPromises = {
+      ...fs.promises,
+      readFile: async () => { throw unreadable; },
+      writeFile: async () => { throw new Error('must not write'); },
+    };
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const store = createArchiveStore({ dataDir, fsPromises });
+    await expect(store.archive(['ses_1'])).resolves.toEqual({ archived: [], failedIds: ['ses_1'] });
+    expect(readFile(dataDir)).toBe('{}');
+  });
+
+  it('rolls memory back when persisting fails', async () => {
+    const dataDir = makeDataDir();
+    const fsPromises = {
+      ...fs.promises,
+      writeFile: async () => { throw new Error('disk full'); },
+    };
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const store = createArchiveStore({ dataDir, fsPromises, now: () => 1 });
+    await expect(store.archive(['ses_1'])).resolves.toEqual({ archived: [], failedIds: ['ses_1'] });
+    await expect(store.isArchived('ses_1')).resolves.toBe(false);
+  });
+
+  it('keeps a later successful batch when an earlier one fails and rolls back', async () => {
+    const dataDir = makeDataDir();
+    let failNext = true;
+    let releaseFailure;
+    const failureReleased = new Promise((resolve) => { releaseFailure = resolve; });
+    const fsPromises = {
+      ...fs.promises,
+      writeFile: async (...args) => {
+        if (failNext) {
+          failNext = false;
+          await failureReleased;
+          throw new Error('disk full');
+        }
+        return fs.promises.writeFile(...args);
+      },
+    };
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const store = createArchiveStore({ dataDir, fsPromises, now: () => 1 });
+
+    const failing = store.archive(['ses_1'], 10);
+    const succeeding = store.archive(['ses_1'], 20);
+    releaseFailure();
+
+    await expect(failing).resolves.toEqual({ archived: [], failedIds: ['ses_1'] });
+    await expect(succeeding).resolves.toEqual({ archived: [{ id: 'ses_1', archivedAt: 20 }], failedIds: [] });
+    // The failed batch's rollback must not undo what the later batch committed.
+    await expect(store.archivedAt('ses_1')).resolves.toBe(20);
+    expect(JSON.parse(readFile(dataDir))).toEqual({ ses_1: 20 });
+  });
+});

package/server/lib/openchamber-sessions/opencode-client.js

@@ -0,0 +1,22 @@
+import { OpenCode } from '@opencode/client';
+
+/**
+ * OpenCode rejects non-ASCII header values; the official client sends this
+ * header percent-encoded, so match that wire format (non-ASCII checkout paths
+ * such as "Masaüstü" otherwise fail every dispatched prompt). No directory
+ * means no header: OpenCode then answers from its default instance, which is
+ * enough for lookups keyed by session id.
+ */
+const buildDirectoryHeaders = (directory) => {
+  const headers = {};
+  if (directory) headers['x-opencode-directory'] = encodeURIComponent(directory);
+  return headers;
+};
+
+/** One directory-scoped `@opencode/client` for a session-route call. */
+export const createOpenCodeClient = ({ baseUrl, headers, directory }) => OpenCode.make({
+  baseUrl,
+  headers: { ...headers, ...buildDirectoryHeaders(directory) },
+  // Resolved per call so a test (or a runtime that swaps the global) is honoured.
+  fetch: (...args) => globalThis.fetch(...args),
+});