@online5880/opensession 0.1.1 → 0.1.3

package/test/cli-compatibility.test.js

@@ -0,0 +1,63 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLI_PATH = path.resolve(__dirname, '../src/cli.js');
+
+function runCli(args) {
+  return spawnSync(process.execPath, [CLI_PATH, ...args], {
+    encoding: 'utf8',
+    env: process.env
+  });
+}
+
+test('start command help keeps required compatibility flags', () => {
+  const result = runCli(['start', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--project-key <projectKey>/);
+  assert.match(result.stdout, /--project-name <projectName>/);
+  assert.match(result.stdout, /--actor <actor>/);
+});
+
+test('resume command help keeps required compatibility flags', () => {
+  const result = runCli(['resume', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--session-id <sessionId>/);
+  assert.match(result.stdout, /--actor <actor>/);
+});
+
+test('approve command help keeps required compatibility flags', () => {
+  const result = runCli(['approve', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--session-id <sessionId>/);
+  assert.match(result.stdout, /--project-key <projectKey>/);
+  assert.match(result.stdout, /--project <projectKey>/);
+  assert.match(result.stdout, /--actor <actor>/);
+  assert.match(result.stdout, /--note <note>/);
+  assert.match(result.stdout, /--idempotency-key <idempotencyKey>/);
+});
+
+test('status command help keeps both project-key and project alias', () => {
+  const result = runCli(['status', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--project-key <projectKey>/);
+  assert.match(result.stdout, /--project <projectKey>/);
+});
+
+test('log command help keeps session and limit flags', () => {
+  const result = runCli(['log', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--session-id <sessionId>/);
+  assert.match(result.stdout, /--limit <limit>/);
+});
+
+test('logs alias resolves to log command help', () => {
+  const result = runCli(['logs', '--help']);
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /Show session event log/);
+  assert.match(result.stdout, /--session-id <sessionId>/);
+});

package/test/config-secrets.test.js

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const fixtureRoot = path.join(os.tmpdir(), `opensession-config-test-${process.pid}-${Date.now()}`);
+const fixtureHome = path.join(fixtureRoot, 'home');
+const configFile = path.join(fixtureHome, '.opensession', 'config.json');
+
+test('writeConfig persists encrypted secret and readConfig decrypts it', async () => {
+  await fs.mkdir(fixtureHome, { recursive: true });
+  const prevHome = process.env.HOME;
+  const prevUserProfile = process.env.USERPROFILE;
+  process.env.HOME = fixtureHome;
+  process.env.USERPROFILE = fixtureHome;
+
+  try {
+    const configModule = await import(`../src/config.js?fixture=${Date.now()}`);
+
+    await configModule.writeConfig({
+      supabaseUrl: 'https://example.supabase.co',
+      supabaseAnonKey: 'sb_secret_plaintext_for_test',
+      actor: 'tester'
+    });
+
+    const raw = await fs.readFile(configFile, 'utf8');
+    assert.doesNotMatch(raw, /sb_secret_plaintext_for_test/);
+    assert.match(raw, /"supabaseAnonKeyEnc"\s*:\s*"enc:v1:/);
+
+    const loaded = await configModule.readConfig();
+    assert.equal(loaded.supabaseAnonKey, 'sb_secret_plaintext_for_test');
+    assert.equal(loaded.supabaseUrl, 'https://example.supabase.co');
+    assert.equal(loaded.actor, 'tester');
+  } finally {
+    if (prevHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = prevHome;
+    }
+    if (prevUserProfile === undefined) {
+      delete process.env.USERPROFILE;
+    } else {
+      process.env.USERPROFILE = prevUserProfile;
+    }
+  }
+});

package/test/idempotency.test.js

@@ -0,0 +1,30 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { releaseResumeOperation, reserveResumeOperation } from '../src/idempotency.js';
+
+test('reserveResumeOperation persists generated id for retry and restart safety', () => {
+  const initial = {};
+  const first = reserveResumeOperation(initial, 'session-1', 'alice');
+  assert.equal(typeof first.operationId, 'string');
+  assert.ok(first.operationId.length > 0);
+  assert.equal(first.nextConfig.pendingResumeOperations['session-1:alice'], first.operationId);
+
+  const afterRestart = reserveResumeOperation(first.nextConfig, 'session-1', 'alice');
+  assert.equal(afterRestart.operationId, first.operationId);
+  assert.equal(afterRestart.nextConfig, first.nextConfig);
+});
+
+test('releaseResumeOperation clears pending key and next reservation gets new id', () => {
+  const reserved = reserveResumeOperation({}, 'session-2', 'bob');
+  const cleared = releaseResumeOperation(reserved.nextConfig, 'session-2', 'bob');
+  assert.equal(cleared.pendingResumeOperations['session-2:bob'], undefined);
+
+  const next = reserveResumeOperation(cleared, 'session-2', 'bob');
+  assert.notEqual(next.operationId, reserved.operationId);
+});
+
+test('explicit operation id is stored and reused as provided', () => {
+  const reserved = reserveResumeOperation({}, 'session-3', 'carol', 'resume-op-123');
+  assert.equal(reserved.operationId, 'resume-op-123');
+  assert.equal(reserved.nextConfig.pendingResumeOperations['session-3:carol'], 'resume-op-123');
+});

package/test/supabase-append-event.test.js

@@ -0,0 +1,133 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { appendEvent } from '../src/supabase.js';
+
+function createMockClient({ insertResponses, existingResponses }) {
+  const state = {
+    inserts: [],
+    selects: []
+  };
+
+  const takeInsert = () => insertResponses.shift() ?? { data: null, error: new Error('missing insert response') };
+  const takeExisting = () => existingResponses.shift() ?? { data: null, error: null };
+
+  const client = {
+    from(table) {
+      return {
+        insert(payload) {
+          state.inserts.push({ table, payload });
+          return {
+            select() {
+              return {
+                async single() {
+                  return takeInsert();
+                }
+              };
+            }
+          };
+        },
+        select(columns) {
+          const record = { table, columns, filters: [], limit: null };
+          state.selects.push(record);
+          const query = {
+            eq(column, value) {
+              record.filters.push({ column, value });
+              return query;
+            },
+            limit(value) {
+              record.limit = value;
+              return query;
+            },
+            async maybeSingle() {
+              return takeExisting();
+            }
+          };
+          return query;
+        }
+      };
+    }
+  };
+
+  return { client, state };
+}
+
+test('appendEvent writes idempotency_key with payload idempotencyKey', async () => {
+  const inserted = {
+    id: 'event-1',
+    session_id: 'session-1',
+    type: 'resumed',
+    payload: { actor: 'alice', idempotencyKey: 'resume-op-1' },
+    created_at: '2026-03-13T00:00:00.000Z'
+  };
+  const mock = createMockClient({
+    insertResponses: [{ data: inserted, error: null }],
+    existingResponses: []
+  });
+
+  const event = await appendEvent(
+    mock.client,
+    'session-1',
+    'resumed',
+    { actor: 'alice' },
+    { idempotencyKey: 'resume-op-1' }
+  );
+
+  assert.equal(event.id, 'event-1');
+  assert.equal(mock.state.inserts.length, 1);
+  assert.equal(mock.state.inserts[0].payload.idempotency_key, 'resume-op-1');
+  assert.equal(mock.state.inserts[0].payload.payload.idempotencyKey, 'resume-op-1');
+});
+
+test('appendEvent returns existing row after unique violation conflict', async () => {
+  const conflictError = { code: '23505', message: 'duplicate key value violates unique constraint' };
+  const existing = {
+    id: 'event-2',
+    session_id: 'session-2',
+    type: 'resumed',
+    payload: { actor: 'bob', idempotencyKey: 'resume-op-2' },
+    created_at: '2026-03-13T00:01:00.000Z'
+  };
+  const mock = createMockClient({
+    insertResponses: [{ data: null, error: conflictError }],
+    existingResponses: [{ data: existing, error: null }]
+  });
+
+  const event = await appendEvent(
+    mock.client,
+    'session-2',
+    'resumed',
+    { actor: 'bob' },
+    { idempotencyKey: 'resume-op-2' }
+  );
+
+  assert.equal(event.id, 'event-2');
+  assert.equal(mock.state.selects.length, 1);
+  assert.deepEqual(
+    mock.state.selects[0].filters,
+    [
+      { column: 'session_id', value: 'session-2' },
+      { column: 'type', value: 'resumed' },
+      { column: 'idempotency_key', value: 'resume-op-2' }
+    ]
+  );
+});
+
+test('appendEvent throws original conflict when existing row cannot be loaded', async () => {
+  const conflictError = { code: '23505', message: 'duplicate key value violates unique constraint' };
+  const mock = createMockClient({
+    insertResponses: [{ data: null, error: conflictError }],
+    existingResponses: [{ data: null, error: null }]
+  });
+
+  await assert.rejects(
+    () =>
+      appendEvent(
+        mock.client,
+        'session-3',
+        'resumed',
+        { actor: 'carol' },
+        { idempotencyKey: 'resume-op-3' }
+      ),
+    (error) => error === conflictError
+  );
+});