@online5880/opensession 0.1.0 → 0.1.3

package/src/config.js

@@ -1,32 +1,118 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import os from 'node:os';
-
-const CONFIG_DIR = path.join(os.homedir(), '.opensession');
-const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
-
-export async function readConfig() {
-  try {
-    const raw = await fs.readFile(CONFIG_PATH, 'utf8');
-    return JSON.parse(raw);
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return {};
-    }
-    throw error;
-  }
-}
-
-export async function writeConfig(config) {
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
-  return CONFIG_PATH;
-}
-
-export function getConfigPath() {
-  return CONFIG_PATH;
-}
-
-export function mergeConfig(base, patch) {
-  return { ...base, ...patch };
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+
+const CONFIG_DIR = path.join(os.homedir(), '.opensession');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const ENC_PREFIX = 'enc:v1';
+const ENC_ALGO = 'aes-256-gcm';
+const ENC_IV_BYTES = 12;
+
+function getKeyMaterial() {
+  return `${os.userInfo().username}|${os.hostname()}|${process.platform}|${process.arch}|opensession-config-v1`;
+}
+
+function deriveEncryptionKey() {
+  const salt = crypto.createHash('sha256').update(getKeyMaterial()).digest();
+  return crypto.scryptSync(getKeyMaterial(), salt, 32);
+}
+
+function encryptSecret(plainText) {
+  if (typeof plainText !== 'string' || plainText.length === 0) {
+    return null;
+  }
+  const iv = crypto.randomBytes(ENC_IV_BYTES);
+  const cipher = crypto.createCipheriv(ENC_ALGO, deriveEncryptionKey(), iv);
+  const encrypted = Buffer.concat([cipher.update(plainText, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${ENC_PREFIX}:${iv.toString('base64')}:${tag.toString('base64')}:${encrypted.toString('base64')}`;
+}
+
+function decryptSecret(payload) {
+  if (typeof payload !== 'string' || !payload.startsWith(`${ENC_PREFIX}:`)) {
+    return null;
+  }
+  const [, , ivBase64, tagBase64, cipherBase64] = payload.split(':');
+  if (!ivBase64 || !tagBase64 || !cipherBase64) {
+    return null;
+  }
+  const decipher = crypto.createDecipheriv(ENC_ALGO, deriveEncryptionKey(), Buffer.from(ivBase64, 'base64'));
+  decipher.setAuthTag(Buffer.from(tagBase64, 'base64'));
+  const decrypted = Buffer.concat([
+    decipher.update(Buffer.from(cipherBase64, 'base64')),
+    decipher.final()
+  ]);
+  return decrypted.toString('utf8');
+}
+
+function decodeSensitiveConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return {};
+  }
+  if (typeof config.supabaseAnonKey === 'string' && config.supabaseAnonKey.length > 0) {
+    return config;
+  }
+  if (typeof config.supabaseAnonKeyEnc !== 'string') {
+    return config;
+  }
+
+  try {
+    const decrypted = decryptSecret(config.supabaseAnonKeyEnc);
+    if (!decrypted) {
+      return config;
+    }
+    return {
+      ...config,
+      supabaseAnonKey: decrypted
+    };
+  } catch {
+    return config;
+  }
+}
+
+function encodeSensitiveConfig(config) {
+  if (!config || typeof config !== 'object') {
+    return {};
+  }
+  const next = { ...config };
+  const secret = typeof next.supabaseAnonKey === 'string' ? next.supabaseAnonKey.trim() : '';
+
+  if (secret.length > 0) {
+    const encrypted = encryptSecret(secret);
+    if (encrypted) {
+      next.supabaseAnonKeyEnc = encrypted;
+      delete next.supabaseAnonKey;
+    }
+  }
+
+  return next;
+}
+
+export async function readConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    return decodeSensitiveConfig(parsed);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {};
+    }
+    throw error;
+  }
+}
+
+export async function writeConfig(config) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  const serializableConfig = encodeSensitiveConfig(config);
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(serializableConfig, null, 2) + '\n', 'utf8');
+  return CONFIG_PATH;
+}
+
+export function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+export function mergeConfig(base, patch) {
+  return { ...base, ...patch };
+}

package/src/hook-server.js

@@ -0,0 +1,194 @@
+import http from 'node:http';
+import { dispatchAutomation } from './automation.js';
+import { appendEvent, ensureProject, getSession, listActiveSessions, startSession } from './supabase.js';
+
+const MAX_BODY_BYTES = 1024 * 1024;
+
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === 'object') {
+    const message = error.message;
+    const details = error.details;
+    const hint = error.hint;
+    const code = error.code;
+    const parts = [message, details, hint, code].filter(Boolean);
+    if (parts.length > 0) {
+      return parts.join(' | ');
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return 'Unknown object error';
+    }
+  }
+  return String(error);
+}
+
+function sendJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+
+async function readRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let total = 0;
+    const chunks = [];
+
+    req.on('data', (chunk) => {
+      total += chunk.length;
+      if (total > MAX_BODY_BYTES) {
+        reject(new Error('Request body too large (max 1MB).'));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8').trim();
+      if (!raw) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error('Invalid JSON body.'));
+      }
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+async function resolveSession({ client, projectKey, actor, requestedSessionId, autoStartSession }) {
+  const project = await ensureProject(client, projectKey, projectKey);
+
+  if (requestedSessionId) {
+    const existing = await getSession(client, requestedSessionId);
+    if (!existing) {
+      throw new Error(`Session not found: ${requestedSessionId}`);
+    }
+    return { project, session: existing, created: false };
+  }
+
+  const active = await listActiveSessions(client, project.id);
+  if (active.length > 0) {
+    return { project, session: active[0], created: false };
+  }
+
+  if (!autoStartSession) {
+    throw new Error('No active session found and autoStartSession is disabled.');
+  }
+
+  const created = await startSession(client, project.id, actor);
+  return { project, session: created, created: true };
+}
+
+export async function startHookServer({
+  host,
+  port,
+  secret,
+  projectKey,
+  actor,
+  autoStartSession,
+  fixedSessionId,
+  client,
+  automationConfig
+}) {
+  const sharedSecret = typeof secret === 'string' && secret.length > 0 ? secret : null;
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (req.method === 'GET' && req.url === '/health') {
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+
+      if (req.method !== 'POST' || req.url !== '/webhooks/event') {
+        sendJson(res, 404, { error: 'Not found' });
+        return;
+      }
+
+      if (sharedSecret) {
+        const provided = String(req.headers['x-opensession-secret'] ?? '');
+        if (provided !== sharedSecret) {
+          sendJson(res, 401, { error: 'Invalid secret' });
+          return;
+        }
+      }
+
+      const body = await readRequestBody(req);
+      const incomingProjectKey = typeof body.projectKey === 'string' && body.projectKey.trim().length > 0
+        ? body.projectKey.trim()
+        : projectKey;
+
+      if (!incomingProjectKey) {
+        sendJson(res, 400, { error: 'Missing project key. Provide body.projectKey or --project-key.' });
+        return;
+      }
+
+      const incomingActor = typeof body.actor === 'string' && body.actor.trim().length > 0
+        ? body.actor.trim()
+        : actor;
+      const source = typeof body.source === 'string' && body.source.trim().length > 0 ? body.source.trim() : 'custom';
+      const eventType = typeof body.eventType === 'string' && body.eventType.trim().length > 0
+        ? body.eventType.trim()
+        : `${source}.event`;
+
+      const { project, session, created } = await resolveSession({
+        client,
+        projectKey: incomingProjectKey,
+        actor: incomingActor,
+        requestedSessionId: body.sessionId ?? fixedSessionId,
+        autoStartSession
+      });
+
+      const payload = {
+        source,
+        receivedAt: new Date().toISOString(),
+        data: body.payload ?? body
+      };
+
+      const event = await appendEvent(client, session.id, eventType, payload);
+      const envelope = {
+        projectId: project.id,
+        projectKey: incomingProjectKey,
+        sessionId: session.id,
+        eventId: event.id,
+        eventType,
+        source,
+        actor: incomingActor,
+        createdSession: created,
+        payload
+      };
+
+      const automationResults = await dispatchAutomation(envelope, automationConfig);
+      sendJson(res, 202, {
+        ok: true,
+        projectKey: incomingProjectKey,
+        sessionId: session.id,
+        eventId: event.id,
+        eventType,
+        automationResults
+      });
+    } catch (error) {
+      sendJson(res, 500, { error: formatError(error) });
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, resolve);
+  });
+
+  return { server, url: `http://${host}:${port}` };
+}

package/src/idempotency.js

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto';
+
+function getPendingResumeMap(config) {
+  const value = config?.pendingResumeOperations;
+  if (!value || typeof value !== 'object') {
+    return {};
+  }
+  return value;
+}
+
+function getResumeSlot(sessionId, actor) {
+  return `${sessionId}:${actor}`;
+}
+
+export function reserveResumeOperation(config, sessionId, actor, requestedOperationId = null) {
+  const trimmedRequested = typeof requestedOperationId === 'string' && requestedOperationId.trim().length > 0
+    ? requestedOperationId.trim()
+    : null;
+  const slot = getResumeSlot(sessionId, actor);
+  const pending = getPendingResumeMap(config);
+
+  if (trimmedRequested) {
+    return {
+      operationId: trimmedRequested,
+      nextConfig: {
+        ...config,
+        pendingResumeOperations: {
+          ...pending,
+          [slot]: trimmedRequested
+        }
+      }
+    };
+  }
+
+  const existing = pending[slot];
+  if (typeof existing === 'string' && existing.trim().length > 0) {
+    return { operationId: existing, nextConfig: config };
+  }
+
+  const generated = randomUUID();
+  return {
+    operationId: generated,
+    nextConfig: {
+      ...config,
+      pendingResumeOperations: {
+        ...pending,
+        [slot]: generated
+      }
+    }
+  };
+}
+
+export function releaseResumeOperation(config, sessionId, actor) {
+  const slot = getResumeSlot(sessionId, actor);
+  const pending = getPendingResumeMap(config);
+  if (!(slot in pending)) {
+    return config;
+  }
+
+  const nextPending = { ...pending };
+  delete nextPending[slot];
+  return {
+    ...config,
+    pendingResumeOperations: nextPending
+  };
+}

package/src/metrics.js

@@ -0,0 +1,110 @@
+function toTimestamp(value) {
+  const time = Date.parse(value);
+  if (Number.isNaN(time)) {
+    return null;
+  }
+  return time;
+}
+
+export function startOfUtcWeek(dateLike) {
+  const date = new Date(dateLike);
+  const day = date.getUTCDay();
+  const daysFromMonday = (day + 6) % 7;
+  const start = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  start.setUTCDate(start.getUTCDate() - daysFromMonday);
+  return start;
+}
+
+export function addDaysUtc(dateLike, days) {
+  const date = new Date(dateLike);
+  date.setUTCDate(date.getUTCDate() + days);
+  return date;
+}
+
+export function computeKpis(sessions, events) {
+  const safeSessions = Array.isArray(sessions) ? sessions : [];
+  const safeEvents = Array.isArray(events) ? events : [];
+  const uniqueActors = new Set();
+
+  for (const session of safeSessions) {
+    if (session?.actor) {
+      uniqueActors.add(session.actor);
+    }
+  }
+
+  const resumedEvents = safeEvents.filter((event) => event?.type === 'resumed').length;
+  const totalSessions = safeSessions.length;
+  const totalEvents = safeEvents.length;
+
+  return {
+    totalSessions,
+    activeSessions: safeSessions.filter((session) => session?.status === 'active').length,
+    uniqueActors: uniqueActors.size,
+    totalEvents,
+    resumedEvents,
+    eventsPerSession: totalSessions === 0 ? 0 : totalEvents / totalSessions,
+    resumeRate: totalSessions === 0 ? 0 : resumedEvents / totalSessions
+  };
+}
+
+export function computeWeeklyTrend(sessions, events, weekCount = 6, now = new Date()) {
+  const safeWeekCount = Math.max(1, Math.min(26, Number.parseInt(String(weekCount), 10) || 6));
+  const safeSessions = Array.isArray(sessions) ? sessions : [];
+  const safeEvents = Array.isArray(events) ? events : [];
+  const currentWeekStart = startOfUtcWeek(now);
+  const firstWeekStart = addDaysUtc(currentWeekStart, (safeWeekCount - 1) * -7);
+
+  const buckets = [];
+  for (let i = 0; i < safeWeekCount; i += 1) {
+    const start = addDaysUtc(firstWeekStart, i * 7);
+    const end = addDaysUtc(start, 7);
+    buckets.push({
+      start,
+      end,
+      label: start.toISOString().slice(0, 10),
+      sessions: 0,
+      events: 0,
+      actors: new Set()
+    });
+  }
+
+  for (const session of safeSessions) {
+    const ts = toTimestamp(session?.started_at);
+    if (ts === null) {
+      continue;
+    }
+    const index = Math.floor((ts - firstWeekStart.getTime()) / (7 * 24 * 60 * 60 * 1000));
+    if (index < 0 || index >= buckets.length) {
+      continue;
+    }
+    buckets[index].sessions += 1;
+    if (session?.actor) {
+      buckets[index].actors.add(session.actor);
+    }
+  }
+
+  for (const event of safeEvents) {
+    const ts = toTimestamp(event?.created_at);
+    if (ts === null) {
+      continue;
+    }
+    const index = Math.floor((ts - firstWeekStart.getTime()) / (7 * 24 * 60 * 60 * 1000));
+    if (index < 0 || index >= buckets.length) {
+      continue;
+    }
+    buckets[index].events += 1;
+  }
+
+  return buckets.map((bucket) => ({
+    weekStart: bucket.label,
+    sessions: bucket.sessions,
+    uniqueActors: bucket.actors.size,
+    events: bucket.events
+  }));
+}
+
+export function formatSignedDelta(current, previous) {
+  const delta = current - previous;
+  const prefix = delta > 0 ? '+' : '';
+  return `${prefix}${delta}`;
+}