@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/state/audit.js

@@ -0,0 +1,73 @@
+/**
+ * Audit log helpers.
+ *
+ * Refactored from SQLiteAdapter.logAuditEvent and getAuditLogs.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Persist an audit event.
+ */
+export function logAuditEvent(event, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO audit_logs (id, timestamp, user_id, action, resource_type, resource_id, input, output, status, duration_ms, metadata)
+    VALUES (?, CURRENT_TIMESTAMP, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(event.id, event.userId || null, event.action, event.resourceType || null, event.resourceId || null, event.input ? JSON.stringify(event.input) : null, event.output ? JSON.stringify(event.output) : null, event.status, event.durationMs || null, event.metadata ? JSON.stringify(event.metadata) : null);
+}
+/**
+ * Query audit logs with optional filters.
+ */
+export function getAuditLogs(filter, db) {
+    const d = db || getDb();
+    let query = 'SELECT * FROM audit_logs';
+    const params = [];
+    const conditions = [];
+    if (filter?.userId) {
+        conditions.push('user_id = ?');
+        params.push(filter.userId);
+    }
+    if (filter?.action) {
+        conditions.push('action = ?');
+        params.push(filter.action);
+    }
+    if (filter?.resourceType) {
+        conditions.push('resource_type = ?');
+        params.push(filter.resourceType);
+    }
+    if (filter?.status) {
+        conditions.push('status = ?');
+        params.push(filter.status);
+    }
+    if (filter?.startDate) {
+        conditions.push('timestamp >= ?');
+        params.push(filter.startDate.toISOString());
+    }
+    if (filter?.endDate) {
+        conditions.push('timestamp <= ?');
+        params.push(filter.endDate.toISOString());
+    }
+    if (conditions.length > 0) {
+        query += ` WHERE ${conditions.join(' AND ')}`;
+    }
+    query += ' ORDER BY timestamp DESC LIMIT ? OFFSET ?';
+    params.push(filter?.limit || 100, filter?.offset || 0);
+    const stmt = d.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        timestamp: row.timestamp,
+        userId: row.user_id,
+        action: row.action,
+        resourceType: row.resource_type,
+        resourceId: row.resource_id,
+        input: row.input ? JSON.parse(row.input) : null,
+        output: row.output ? JSON.parse(row.output) : null,
+        status: row.status,
+        durationMs: row.duration_ms,
+        metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    }));
+}

package/dist/src/state/billing.js

@@ -0,0 +1,126 @@
+/**
+ * Billing / usage tracking helpers.
+ *
+ * Refactored from the billing-service database adapter
+ * (services/billing-service/src/db/adapter.ts) into standalone functions
+ * that operate against the unified Nimbus database.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Subscription helpers
+// ---------------------------------------------------------------------------
+/**
+ * Create a new subscription.
+ */
+export function createSubscription(id, teamId, plan = 'free', status = 'active', currentPeriodStart, currentPeriodEnd, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO subscriptions (id, team_id, plan, status, current_period_start, current_period_end, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `);
+    stmt.run(id, teamId, plan, status, currentPeriodStart || null, currentPeriodEnd || null);
+}
+/**
+ * Retrieve a subscription by team id.
+ */
+export function getSubscription(teamId, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM subscriptions WHERE team_id = ?');
+    const row = stmt.get(teamId);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        teamId: row.team_id,
+        plan: row.plan,
+        status: row.status,
+        currentPeriodStart: row.current_period_start,
+        currentPeriodEnd: row.current_period_end,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Update plan, status, or period boundaries of an existing subscription.
+ */
+export function updateSubscription(teamId, updates, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    UPDATE subscriptions
+    SET plan = COALESCE(?, plan),
+        status = COALESCE(?, status),
+        current_period_start = COALESCE(?, current_period_start),
+        current_period_end = COALESCE(?, current_period_end),
+        updated_at = CURRENT_TIMESTAMP
+    WHERE team_id = ?
+  `);
+    stmt.run(updates.plan || null, updates.status || null, updates.currentPeriodStart || null, updates.currentPeriodEnd || null, teamId);
+}
+// ---------------------------------------------------------------------------
+// Usage helpers
+// ---------------------------------------------------------------------------
+/**
+ * Record a single usage event.
+ */
+export function recordUsage(id, type, quantity, unit = 'tokens', costUsd, teamId, userId, metadata, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO usage (id, team_id, user_id, type, quantity, unit, cost_usd, metadata, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `);
+    stmt.run(id, teamId || null, userId || null, type, quantity, unit, costUsd ?? 0, metadata ? JSON.stringify(metadata) : null);
+}
+/**
+ * Retrieve usage records for a team within a date range.
+ */
+export function getUsage(teamId, since, until, limit = 100, offset = 0, db) {
+    const d = db || getDb();
+    const untilDate = until || new Date();
+    const stmt = d.prepare(`
+    SELECT * FROM usage
+    WHERE team_id = ?
+      AND created_at >= ?
+      AND created_at <= ?
+    ORDER BY created_at DESC
+    LIMIT ? OFFSET ?
+  `);
+    const rows = stmt.all(teamId, since.toISOString(), untilDate.toISOString(), limit, offset);
+    return rows.map(row => ({
+        id: row.id,
+        teamId: row.team_id,
+        userId: row.user_id,
+        type: row.type,
+        quantity: row.quantity,
+        unit: row.unit,
+        costUsd: row.cost_usd,
+        metadata: row.metadata ? JSON.parse(row.metadata) : null,
+        createdAt: row.created_at,
+    }));
+}
+/**
+ * Aggregate usage by type for a team within a date range.
+ */
+export function getUsageSummary(teamId, since, until, db) {
+    const d = db || getDb();
+    const untilDate = until || new Date();
+    const stmt = d.prepare(`
+    SELECT
+      type,
+      SUM(quantity) as total_quantity,
+      SUM(cost_usd) as total_cost,
+      COUNT(*) as count
+    FROM usage
+    WHERE team_id = ?
+      AND created_at >= ?
+      AND created_at <= ?
+    GROUP BY type
+  `);
+    const rows = stmt.all(teamId, since.toISOString(), untilDate.toISOString());
+    return rows.map(row => ({
+        type: row.type,
+        totalQuantity: row.total_quantity,
+        totalCost: row.total_cost,
+        count: row.count,
+    }));
+}

package/dist/src/state/checkpoints.js

@@ -0,0 +1,81 @@
+/**
+ * Checkpoint save / restore helpers for resumable operations.
+ *
+ * Refactored from SQLiteAdapter.saveCheckpoint, getCheckpoint,
+ * getLatestCheckpoint, listCheckpoints, and deleteCheckpoints.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Persist or overwrite a checkpoint for a given operation and step.
+ */
+export function saveCheckpoint(id, operationId, step, state, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT OR REPLACE INTO checkpoints (id, operation_id, step, state, created_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `);
+    stmt.run(id, operationId, step, JSON.stringify(state));
+}
+/**
+ * Retrieve a single checkpoint by its id.
+ */
+export function getCheckpoint(id, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM checkpoints WHERE id = ?');
+    const row = stmt.get(id);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        operationId: row.operation_id,
+        step: row.step,
+        state: JSON.parse(row.state),
+        createdAt: row.created_at,
+    };
+}
+/**
+ * Retrieve the most recent checkpoint (highest step) for an operation.
+ */
+export function getLatestCheckpoint(operationId, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    SELECT * FROM checkpoints WHERE operation_id = ? ORDER BY step DESC LIMIT 1
+  `);
+    const row = stmt.get(operationId);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        operationId: row.operation_id,
+        step: row.step,
+        state: JSON.parse(row.state),
+        createdAt: row.created_at,
+    };
+}
+/**
+ * List all checkpoints for an operation ordered by step ascending.
+ */
+export function listCheckpoints(operationId, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    SELECT id, step, created_at FROM checkpoints WHERE operation_id = ? ORDER BY step ASC
+  `);
+    return stmt.all(operationId).map(row => ({
+        id: row.id,
+        step: row.step,
+        createdAt: row.created_at,
+    }));
+}
+/**
+ * Delete all checkpoints associated with an operation.
+ */
+export function deleteCheckpoints(operationId, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('DELETE FROM checkpoints WHERE operation_id = ?');
+    stmt.run(operationId);
+}

package/dist/src/state/config.js

@@ -0,0 +1,58 @@
+/**
+ * Config key-value store helpers.
+ *
+ * Refactored from SQLiteAdapter.setConfig, getConfig, and getAllConfig.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Set (insert or replace) a configuration value.
+ * The value is JSON-serialised before storage.
+ */
+export function setConfig(key, value, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT OR REPLACE INTO config (key, value, updated_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+  `);
+    stmt.run(key, JSON.stringify(value));
+}
+/**
+ * Retrieve a single configuration value by key.
+ * Returns `null` when the key does not exist.
+ */
+export function getConfig(key, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT value FROM config WHERE key = ?');
+    const row = stmt.get(key);
+    if (!row) {
+        return null;
+    }
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        // Corrupted config value — treat as missing
+        return null;
+    }
+}
+/**
+ * Retrieve every configuration entry as a flat key-value object.
+ */
+export function getAllConfig(db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT key, value FROM config');
+    const rows = stmt.all();
+    const config = {};
+    for (const row of rows) {
+        try {
+            config[row.key] = JSON.parse(row.value);
+        }
+        catch {
+            // Skip corrupted config entries
+        }
+    }
+    return config;
+}

package/dist/src/state/conversations.js

@@ -0,0 +1,7 @@
+/**
+ * Re-export conversation helpers from messages.ts for clarity.
+ *
+ * Consumers can import from either `./messages` or `./conversations`
+ * depending on which name reads better at the call-site.
+ */
+export { saveConversation, getConversation, listConversations, deleteConversation, } from './messages';

package/dist/src/state/credentials.js

@@ -0,0 +1,96 @@
+/**
+ * Auth token and device-code management helpers.
+ *
+ * Refactored from the auth-service database adapter
+ * (services/auth-service/src/db/adapter.ts) into standalone functions
+ * that operate against the unified Nimbus database.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Device Code helpers
+// ---------------------------------------------------------------------------
+/**
+ * Persist a new device code for the OAuth device-authorization flow.
+ */
+export function saveDeviceCode(deviceCode, userCode, expiresAt, clientId, scope, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO device_codes (device_code, user_code, client_id, scope, status, expires_at)
+    VALUES (?, ?, ?, ?, 'pending', ?)
+  `);
+    stmt.run(deviceCode, userCode, clientId || null, scope || null, expiresAt.toISOString());
+}
+/**
+ * Retrieve a device code record by its device_code value.
+ */
+export function getDeviceCode(deviceCode, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM device_codes WHERE device_code = ?');
+    const row = stmt.get(deviceCode);
+    if (!row) {
+        return null;
+    }
+    return {
+        deviceCode: row.device_code,
+        userCode: row.user_code,
+        clientId: row.client_id,
+        scope: row.scope,
+        status: row.status,
+        token: row.token,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+    };
+}
+/**
+ * Update the status (and optionally the associated token) of a device code.
+ */
+export function updateDeviceCodeStatus(deviceCode, status, token, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    UPDATE device_codes
+    SET status = ?, token = COALESCE(?, token)
+    WHERE device_code = ?
+  `);
+    stmt.run(status, token || null, deviceCode);
+}
+// ---------------------------------------------------------------------------
+// Token helpers
+// ---------------------------------------------------------------------------
+/**
+ * Persist an authentication token.
+ */
+export function saveToken(id, token, type = 'access', userId, expiresAt, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO tokens (id, user_id, token, type, expires_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, userId || null, token, type, expiresAt ? expiresAt.toISOString() : null);
+}
+/**
+ * Retrieve a token record by its token string value.
+ */
+export function getToken(token, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM tokens WHERE token = ?');
+    const row = stmt.get(token);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        userId: row.user_id,
+        token: row.token,
+        type: row.type,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+    };
+}
+/**
+ * Delete a token by its token string value.
+ */
+export function deleteToken(token, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('DELETE FROM tokens WHERE token = ?');
+    stmt.run(token);
+}

package/dist/src/state/db.js

@@ -0,0 +1,53 @@
+/**
+ * Database singleton for the Nimbus unified SQLite persistence layer.
+ *
+ * Provides a lazily-initialized, WAL-mode SQLite database stored at
+ * ~/.nimbus/nimbus.db (overridable via NIMBUS_DB_PATH).  An in-memory
+ * variant is available for tests.
+ */
+import { Database } from '../compat/sqlite';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { runMigrations } from './schema';
+let db = null;
+/**
+ * Return the shared Database instance, creating it on first call.
+ * The database file lives at `~/.nimbus/nimbus.db` unless the
+ * `NIMBUS_DB_PATH` environment variable points elsewhere.
+ */
+export function getDb() {
+    if (!db) {
+        const nimbusDir = path.join(os.homedir(), '.nimbus');
+        if (!fs.existsSync(nimbusDir)) {
+            fs.mkdirSync(nimbusDir, { recursive: true });
+        }
+        const dbPath = process.env.NIMBUS_DB_PATH || path.join(nimbusDir, 'nimbus.db');
+        db = new Database(dbPath);
+        db.exec('PRAGMA journal_mode=WAL');
+        db.exec('PRAGMA foreign_keys=ON');
+        runMigrations(db);
+    }
+    return db;
+}
+/**
+ * Create a throwaway in-memory database for unit / integration tests.
+ * Each call returns a fresh, fully-migrated instance.
+ */
+export function getTestDb() {
+    const testDb = new Database(':memory:');
+    testDb.exec('PRAGMA journal_mode=WAL');
+    testDb.exec('PRAGMA foreign_keys=ON');
+    runMigrations(testDb);
+    return testDb;
+}
+/**
+ * Close the shared database connection and clear the singleton so that
+ * a subsequent `getDb()` call will re-open it.
+ */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/src/state/index.js

@@ -0,0 +1,23 @@
+/**
+ * Nimbus unified SQLite persistence layer.
+ *
+ * Re-exports every public symbol from the individual domain modules so that
+ * consumers can do:
+ *
+ *   import { getDb, saveOperation, setConfig, ... } from '../state';
+ */
+// Database lifecycle
+export { getDb, getTestDb, closeDb } from './db';
+// Schema / migrations
+export { runMigrations } from './schema';
+// Domain modules
+export * from './sessions';
+export * from './messages';
+export * from './config';
+export * from './artifacts';
+export * from './audit';
+export * from './credentials';
+export * from './teams';
+export * from './billing';
+export * from './checkpoints';
+export * from './projects';

package/dist/src/state/messages.js

@@ -0,0 +1,76 @@
+/**
+ * Message / conversation CRUD helpers.
+ *
+ * Refactored from SQLiteAdapter.saveConversation, getConversation,
+ * listConversations, and deleteConversation.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Persist or update a conversation.  Uses INSERT ... ON CONFLICT to upsert.
+ */
+export function saveConversation(id, title, messages, model, metadata, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO conversations (id, title, messages, model, created_at, updated_at, metadata)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      title = excluded.title,
+      messages = excluded.messages,
+      model = excluded.model,
+      updated_at = CURRENT_TIMESTAMP,
+      metadata = excluded.metadata
+  `);
+    stmt.run(id, title, JSON.stringify(messages), model || null, metadata ? JSON.stringify(metadata) : null);
+}
+/**
+ * Retrieve a single conversation by id.
+ */
+export function getConversation(id, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM conversations WHERE id = ?');
+    const row = stmt.get(id);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        title: row.title,
+        messages: JSON.parse(row.messages),
+        model: row.model,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    };
+}
+/**
+ * List conversations ordered by most-recently updated first.
+ */
+export function listConversations(limit = 50, offset = 0, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    SELECT * FROM conversations
+    ORDER BY updated_at DESC
+    LIMIT ? OFFSET ?
+  `);
+    const rows = stmt.all(limit, offset);
+    return rows.map(row => ({
+        id: row.id,
+        title: row.title,
+        messages: JSON.parse(row.messages),
+        model: row.model,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    }));
+}
+/**
+ * Delete a conversation by id.
+ */
+export function deleteConversation(id, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('DELETE FROM conversations WHERE id = ?');
+    stmt.run(id);
+}

package/dist/src/state/projects.js

@@ -0,0 +1,92 @@
+/**
+ * Project CRUD helpers.
+ *
+ * Refactored from SQLiteAdapter.saveProject, getProject, getProjectByPath,
+ * listProjects, and deleteProject.
+ */
+import { getDb } from './db';
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Persist or update a project.  Uses INSERT ... ON CONFLICT to upsert.
+ */
+export function saveProject(id, name, projectPath, config, db) {
+    const d = db || getDb();
+    const stmt = d.prepare(`
+    INSERT INTO projects (id, name, path, config, last_scanned, created_at, updated_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    ON CONFLICT(id) DO UPDATE SET
+      name = excluded.name,
+      path = excluded.path,
+      config = excluded.config,
+      last_scanned = CURRENT_TIMESTAMP,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+    stmt.run(id, name, projectPath, JSON.stringify(config));
+}
+/**
+ * Retrieve a project by id.
+ */
+export function getProject(id, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM projects WHERE id = ?');
+    const row = stmt.get(id);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        path: row.path,
+        config: JSON.parse(row.config),
+        lastScanned: row.last_scanned,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Retrieve a project by its filesystem path.
+ */
+export function getProjectByPath(projectPath, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM projects WHERE path = ?');
+    const row = stmt.get(projectPath);
+    if (!row) {
+        return null;
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        path: row.path,
+        config: JSON.parse(row.config),
+        lastScanned: row.last_scanned,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * List all projects ordered by most-recently updated first.
+ */
+export function listProjects(db) {
+    const d = db || getDb();
+    const stmt = d.prepare('SELECT * FROM projects ORDER BY updated_at DESC');
+    const rows = stmt.all();
+    return rows.map(row => ({
+        id: row.id,
+        name: row.name,
+        path: row.path,
+        config: JSON.parse(row.config),
+        lastScanned: row.last_scanned,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    }));
+}
+/**
+ * Delete a project by id.
+ */
+export function deleteProject(id, db) {
+    const d = db || getDb();
+    const stmt = d.prepare('DELETE FROM projects WHERE id = ?');
+    stmt.run(id);
+}