@wopr-network/platform-core 1.12.2 → 1.13.1

package/dist/api/routes/activity.d.ts

@@ -0,0 +1,9 @@
+import { Hono } from "hono";
+import type { AuditEnv } from "../../audit/types.js";
+import type { DrizzleDb } from "../../db/index.js";
+/**
+ * Create activity feed routes.
+ *
+ * @param dbFactory - Factory returning the audit DB instance
+ */
+export declare function createActivityRoutes(dbFactory: () => DrizzleDb): Hono<AuditEnv>;

package/dist/api/routes/activity.js

@@ -0,0 +1,68 @@
+import { Hono } from "hono";
+import { DrizzleAuditLogRepository } from "../../audit/audit-log-repository.js";
+import { queryAuditLog } from "../../audit/query.js";
+/**
+ * Create activity feed routes.
+ *
+ * @param dbFactory - Factory returning the audit DB instance
+ */
+export function createActivityRoutes(dbFactory) {
+    const routes = new Hono();
+    /**
+     * GET /
+     *
+     * Returns recent activity events for the authenticated user.
+     * Query params:
+     *   - limit: max results (default 20, max 100)
+     */
+    routes.get("/", async (c) => {
+        const user = c.get("user");
+        if (!user)
+            return c.json({ error: "Unauthorized" }, 401);
+        const limitRaw = c.req.query("limit");
+        const limit = Math.min(Math.max(1, limitRaw ? Number.parseInt(limitRaw, 10) : 20), 100);
+        const db = dbFactory();
+        const rows = await queryAuditLog(new DrizzleAuditLogRepository(db), { userId: user.id, limit });
+        const events = rows.map((row) => ({
+            id: row.id,
+            timestamp: new Date(row.timestamp).toISOString(),
+            actor: row.user_id,
+            action: formatAction(row.action),
+            target: row.resource_id ?? row.resource_type,
+            targetHref: buildTargetHref(row.resource_type, row.resource_id ?? null),
+        }));
+        return c.json(events);
+    });
+    return routes;
+}
+function formatAction(action) {
+    const parts = action.split(".");
+    if (parts.length === 2) {
+        const [resource, verb] = parts;
+        const pastTense = {
+            start: "Started",
+            stop: "Stopped",
+            create: "Created",
+            delete: "Deleted",
+            update: "Updated",
+            restart: "Restarted",
+        };
+        return `${pastTense[verb] ?? verb} ${resource}`;
+    }
+    return action;
+}
+function buildTargetHref(resourceType, resourceId) {
+    if (!resourceId)
+        return "/dashboard";
+    switch (resourceType) {
+        case "instance":
+        case "bot":
+            return `/instances/${resourceId}`;
+        case "snapshot":
+            return `/instances/${resourceId}`;
+        case "key":
+            return "/settings";
+        default:
+            return "/dashboard";
+    }
+}

package/dist/api/routes/admin-audit-helper.d.ts

@@ -0,0 +1,7 @@
+import type { AuditEntry } from "../../admin/audit-log.js";
+/** Minimal interface for admin audit logging in route factories. */
+export interface AdminAuditLogger {
+    log(entry: AuditEntry): void | Promise<void>;
+}
+/** Safely log an admin audit entry — never throws. */
+export declare function safeAuditLog(logger: (() => AdminAuditLogger) | undefined, entry: AuditEntry): void;

package/dist/api/routes/admin-audit-helper.js

@@ -0,0 +1,13 @@
+/** Safely log an admin audit entry — never throws. */
+export function safeAuditLog(logger, entry) {
+    if (!logger)
+        return;
+    try {
+        void Promise.resolve(logger().log(entry)).catch(() => {
+            /* audit must not break request */
+        });
+    }
+    catch {
+        /* audit must not break request */
+    }
+}

package/dist/api/routes/admin-audit.d.ts

@@ -0,0 +1,13 @@
+import { Hono } from "hono";
+import type { AdminAuditLog } from "../../admin/index.js";
+import type { AuthEnv } from "../../auth/index.js";
+/**
+ * Create admin audit API routes with an injectable audit log service.
+ *
+ * Routes:
+ *   GET / — query admin audit log entries with filters
+ *   GET /export — export filtered entries as CSV
+ *
+ * @param auditLogFactory - factory returning an AdminAuditLog instance
+ */
+export declare function createAdminAuditApiRoutes(auditLogFactory: () => AdminAuditLog): Hono<AuthEnv>;

package/dist/api/routes/admin-audit.js

@@ -0,0 +1,61 @@
+import { Hono } from "hono";
+function parseIntParam(value) {
+    if (value == null || value === "")
+        return undefined;
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Create admin audit API routes with an injectable audit log service.
+ *
+ * Routes:
+ *   GET / — query admin audit log entries with filters
+ *   GET /export — export filtered entries as CSV
+ *
+ * @param auditLogFactory - factory returning an AdminAuditLog instance
+ */
+export function createAdminAuditApiRoutes(auditLogFactory) {
+    const routes = new Hono();
+    routes.get("/", async (c) => {
+        const filters = {
+            admin: c.req.query("admin") ?? undefined,
+            action: c.req.query("action") ?? undefined,
+            category: c.req.query("category") ?? undefined,
+            tenant: c.req.query("tenant") ?? undefined,
+            from: parseIntParam(c.req.query("from")),
+            to: parseIntParam(c.req.query("to")),
+            limit: parseIntParam(c.req.query("limit")),
+            offset: parseIntParam(c.req.query("offset")),
+        };
+        try {
+            const result = await auditLogFactory().query(filters);
+            return c.json(result);
+        }
+        catch {
+            return c.json({ error: "Internal server error" }, 500);
+        }
+    });
+    routes.get("/export", async (c) => {
+        const filters = {
+            admin: c.req.query("admin") ?? undefined,
+            action: c.req.query("action") ?? undefined,
+            category: c.req.query("category") ?? undefined,
+            tenant: c.req.query("tenant") ?? undefined,
+            from: parseIntParam(c.req.query("from")),
+            to: parseIntParam(c.req.query("to")),
+        };
+        try {
+            const csv = await auditLogFactory().exportCsv(filters);
+            return new Response(csv, {
+                headers: {
+                    "Content-Type": "text/csv",
+                    "Content-Disposition": 'attachment; filename="audit-log.csv"',
+                },
+            });
+        }
+        catch {
+            return c.json({ error: "Internal server error" }, 500);
+        }
+    });
+    return routes;
+}

package/dist/api/routes/admin-backups.d.ts

@@ -0,0 +1,19 @@
+import { Hono } from "hono";
+import type { AuthEnv } from "../../auth/index.js";
+import type { IBackupStatusStore } from "../../backup/backup-status-store.js";
+import type { SpacesClient } from "../../backup/spaces-client.js";
+import type { AdminAuditLogger } from "./admin-audit-helper.js";
+/**
+ * Validate that a remotePath belongs to the given container.
+ * Normalizes the path, rejects traversal segments, and checks that the containerId
+ * appears as the leading non-empty segment.
+ */
+export declare function isRemotePathOwnedBy(remotePath: string, containerId: string): boolean;
+/**
+ * Create admin backup routes.
+ *
+ * @param storeFactory - factory for the backup status store
+ * @param spacesFactory - factory for the S3/Spaces client
+ * @param auditLogger - optional admin audit logger
+ */
+export declare function createAdminBackupRoutes(storeFactory: () => IBackupStatusStore, spacesFactory: () => SpacesClient, auditLogger?: () => AdminAuditLogger): Hono<AuthEnv>;

package/dist/api/routes/admin-backups.js

@@ -0,0 +1,116 @@
+import { Hono } from "hono";
+import { logger } from "../../config/logger.js";
+import { safeAuditLog } from "./admin-audit-helper.js";
+/**
+ * Validate that a remotePath belongs to the given container.
+ * Normalizes the path, rejects traversal segments, and checks that the containerId
+ * appears as the leading non-empty segment.
+ */
+export function isRemotePathOwnedBy(remotePath, containerId) {
+    const normalized = remotePath.replace(/\\/g, "/");
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return false;
+    if (segments.some((s) => s === ".." || s === "."))
+        return false;
+    return segments[0] === containerId;
+}
+/**
+ * Create admin backup routes.
+ *
+ * @param storeFactory - factory for the backup status store
+ * @param spacesFactory - factory for the S3/Spaces client
+ * @param auditLogger - optional admin audit logger
+ */
+export function createAdminBackupRoutes(storeFactory, spacesFactory, auditLogger) {
+    const routes = new Hono();
+    routes.get("/", async (c) => {
+        const store = storeFactory();
+        const staleOnly = c.req.query("stale") === "true";
+        const entries = staleOnly ? await store.listStale() : await store.listAll();
+        return c.json({
+            backups: entries,
+            total: entries.length,
+            staleCount: entries.filter((e) => e.isStale).length,
+        });
+    });
+    routes.get("/alerts/stale", async (c) => {
+        const store = storeFactory();
+        const stale = await store.listStale();
+        return c.json({
+            alerts: stale.map((e) => ({
+                containerId: e.containerId,
+                nodeId: e.nodeId,
+                lastBackupAt: e.lastBackupAt,
+                lastBackupSuccess: e.lastBackupSuccess,
+                lastBackupError: e.lastBackupError,
+            })),
+            count: stale.length,
+        });
+    });
+    routes.get("/:containerId", async (c) => {
+        const store = storeFactory();
+        const containerId = c.req.param("containerId");
+        const entry = await store.get(containerId);
+        if (!entry) {
+            return c.json({ error: "No backup status found for this container" }, 404);
+        }
+        return c.json(entry);
+    });
+    routes.get("/:containerId/snapshots", async (c) => {
+        const store = storeFactory();
+        const containerId = c.req.param("containerId");
+        const entry = await store.get(containerId);
+        if (!entry) {
+            return c.json({ error: "No backup status found for this container" }, 404);
+        }
+        try {
+            const spaces = spacesFactory();
+            const prefix = `nightly/${entry.nodeId}/${containerId}/`;
+            const objects = await spaces.list(prefix);
+            return c.json({
+                containerId,
+                snapshots: objects.map((o) => ({
+                    path: o.path,
+                    date: o.date,
+                    sizeMb: Math.round((o.size / (1024 * 1024)) * 100) / 100,
+                })),
+            });
+        }
+        catch (err) {
+            logger.error(`Failed to list snapshots for ${containerId}`, { err });
+            return c.json({ error: "Failed to list backup snapshots" }, 500);
+        }
+    });
+    routes.post("/:containerId/restore", async (c) => {
+        const containerId = c.req.param("containerId");
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        if (!body.remotePath) {
+            return c.json({ error: "remotePath is required" }, 400);
+        }
+        if (!isRemotePathOwnedBy(body.remotePath, containerId)) {
+            return c.json({ error: "remotePath does not belong to this container" }, 403);
+        }
+        safeAuditLog(auditLogger, {
+            adminUser: c.get("user")?.id ?? "unknown",
+            action: "backup.restore",
+            category: "config",
+            details: { containerId, remotePath: body.remotePath, targetNodeId: body.targetNodeId ?? "auto" },
+            outcome: "success",
+        });
+        return c.json({
+            ok: true,
+            message: `Restore initiated for ${containerId} from ${body.remotePath}`,
+            containerId,
+            remotePath: body.remotePath,
+            targetNodeId: body.targetNodeId ?? "auto",
+        });
+    });
+    return routes;
+}

package/dist/api/routes/admin-compliance.d.ts

@@ -0,0 +1,9 @@
+import { Hono } from "hono";
+import type { EvidenceCollector } from "../../compliance/evidence-collector.js";
+/**
+ * Create admin compliance routes.
+ *
+ * GET /evidence?from=ISO&to=ISO — Generate SOC 2 evidence report for the given period.
+ * Defaults to last 90 days if no params provided.
+ */
+export declare function createAdminComplianceRoutes(getCollector: () => EvidenceCollector): Hono;

package/dist/api/routes/admin-compliance.js

@@ -0,0 +1,27 @@
+import { Hono } from "hono";
+/**
+ * Create admin compliance routes.
+ *
+ * GET /evidence?from=ISO&to=ISO — Generate SOC 2 evidence report for the given period.
+ * Defaults to last 90 days if no params provided.
+ */
+export function createAdminComplianceRoutes(getCollector) {
+    const routes = new Hono();
+    routes.get("/evidence", async (c) => {
+        const now = new Date();
+        const ninetyDaysAgo = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
+        const fromParam = c.req.query("from");
+        const toParam = c.req.query("to");
+        if (fromParam !== undefined && Number.isNaN(new Date(fromParam).getTime())) {
+            return c.json({ error: "Invalid 'from' date" }, 400);
+        }
+        if (toParam !== undefined && Number.isNaN(new Date(toParam).getTime())) {
+            return c.json({ error: "Invalid 'to' date" }, 400);
+        }
+        const from = fromParam ?? ninetyDaysAgo.toISOString();
+        const to = toParam ?? now.toISOString();
+        const report = await getCollector().collect({ from, to });
+        return c.json(report);
+    });
+    return routes;
+}

package/dist/api/routes/admin-credits.d.ts

@@ -0,0 +1,9 @@
+import { Hono } from "hono";
+import type { AuthEnv } from "../../auth/index.js";
+import type { ICreditLedger } from "../../credits/index.js";
+import type { AdminAuditLogger } from "./admin-audit-helper.js";
+/**
+ * Create admin credit API routes.
+ * Pass a ledger directly or a factory for lazy init.
+ */
+export declare function createAdminCreditApiRoutes(ledgerOrFactory: ICreditLedger | (() => ICreditLedger), auditLogger?: () => AdminAuditLogger): Hono<AuthEnv>;

package/dist/api/routes/admin-credits.js

@@ -0,0 +1,255 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { Credit, InsufficientBalanceError } from "../../credits/index.js";
+import { safeAuditLog } from "./admin-audit-helper.js";
+const tenantIdSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[a-zA-Z0-9_-]+$/);
+const TENANT_ID_ERROR = "tenantId must be 1-128 alphanumeric characters, hyphens, or underscores";
+function parseTenantId(c) {
+    const result = tenantIdSchema.safeParse(c.req.param("tenantId"));
+    if (!result.success)
+        return { ok: false };
+    return { ok: true, tenant: result.data };
+}
+function parseIntParam(value) {
+    if (value == null || value === "")
+        return undefined;
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : undefined;
+}
+/**
+ * Create admin credit API routes.
+ * Pass a ledger directly or a factory for lazy init.
+ */
+export function createAdminCreditApiRoutes(ledgerOrFactory, auditLogger) {
+    const ledgerFactory = typeof ledgerOrFactory === "function" ? ledgerOrFactory : () => ledgerOrFactory;
+    const routes = new Hono();
+    routes.post("/:tenantId/grant", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const amountCents = body.amount_cents;
+        const reason = body.reason;
+        if (typeof amountCents !== "number" || !Number.isInteger(amountCents) || amountCents <= 0) {
+            return c.json({ error: "amount_cents must be a positive integer" }, 400);
+        }
+        if (typeof reason !== "string" || !reason.trim()) {
+            return c.json({ error: "reason is required and must be non-empty" }, 400);
+        }
+        try {
+            const user = c.get("user");
+            const adminUser = user?.id ?? "unknown";
+            let result;
+            try {
+                result = await ledger.credit(tenant, Credit.fromCents(amountCents), "admin_grant", reason, undefined, undefined, adminUser);
+            }
+            catch (err) {
+                safeAuditLog(auditLogger, {
+                    adminUser,
+                    action: "credits.grant",
+                    category: "credits",
+                    targetTenant: tenant,
+                    details: { amount_cents: amountCents, reason, error: String(err) },
+                    outcome: "failure",
+                });
+                throw err;
+            }
+            safeAuditLog(auditLogger, {
+                adminUser,
+                action: "credits.grant",
+                category: "credits",
+                targetTenant: tenant,
+                details: { amount_cents: amountCents, reason },
+                outcome: "success",
+            });
+            return c.json(result, 201);
+        }
+        catch (err) {
+            return c.json({ error: err instanceof Error ? err.message : "Internal server error" }, 500);
+        }
+    });
+    routes.post("/:tenantId/refund", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const amountCents = body.amount_cents;
+        const reason = body.reason;
+        if (typeof amountCents !== "number" || !Number.isInteger(amountCents) || amountCents <= 0) {
+            return c.json({ error: "amount_cents must be a positive integer" }, 400);
+        }
+        if (typeof reason !== "string" || !reason.trim()) {
+            return c.json({ error: "reason is required and must be non-empty" }, 400);
+        }
+        try {
+            const user = c.get("user");
+            const adminUser = user?.id ?? "unknown";
+            let result;
+            try {
+                result = await ledger.credit(tenant, Credit.fromCents(amountCents), "admin_grant", reason);
+            }
+            catch (err) {
+                safeAuditLog(auditLogger, {
+                    adminUser,
+                    action: "credits.refund",
+                    category: "credits",
+                    targetTenant: tenant,
+                    details: { amount_cents: amountCents, reason, error: String(err) },
+                    outcome: "failure",
+                });
+                throw err;
+            }
+            safeAuditLog(auditLogger, {
+                adminUser,
+                action: "credits.refund",
+                category: "credits",
+                targetTenant: tenant,
+                details: { amount_cents: amountCents, reason },
+                outcome: "success",
+            });
+            return c.json(result, 201);
+        }
+        catch (err) {
+            if (err instanceof InsufficientBalanceError) {
+                return c.json({ error: err.message, current_balance: err.currentBalance }, 400);
+            }
+            return c.json({ error: err instanceof Error ? err.message : "Internal server error" }, 500);
+        }
+    });
+    routes.post("/:tenantId/correction", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        let body;
+        try {
+            body = (await c.req.json());
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const amountCents = body.amount_cents;
+        const reason = body.reason;
+        if (typeof amountCents !== "number" || !Number.isInteger(amountCents) || amountCents === 0) {
+            return c.json({ error: "amount_cents must be a non-zero integer" }, 400);
+        }
+        if (typeof reason !== "string" || !reason.trim()) {
+            return c.json({ error: "reason is required and must be non-empty" }, 400);
+        }
+        try {
+            const user = c.get("user");
+            const adminUser = user?.id ?? "unknown";
+            let result;
+            try {
+                if (amountCents >= 0) {
+                    result = await ledger.credit(tenant, Credit.fromCents(amountCents), "promo", reason);
+                }
+                else {
+                    result = await ledger.debit(tenant, Credit.fromCents(Math.abs(amountCents)), "correction", reason);
+                }
+            }
+            catch (err) {
+                safeAuditLog(auditLogger, {
+                    adminUser,
+                    action: "credits.correction",
+                    category: "credits",
+                    targetTenant: tenant,
+                    details: { amount_cents: amountCents, reason, error: String(err) },
+                    outcome: "failure",
+                });
+                throw err;
+            }
+            safeAuditLog(auditLogger, {
+                adminUser,
+                action: "credits.correction",
+                category: "credits",
+                targetTenant: tenant,
+                details: { amount_cents: amountCents, reason },
+                outcome: "success",
+            });
+            return c.json(result, 201);
+        }
+        catch (err) {
+            if (err instanceof InsufficientBalanceError) {
+                return c.json({ error: err.message, current_balance: err.currentBalance }, 400);
+            }
+            return c.json({ error: err instanceof Error ? err.message : "Internal server error" }, 500);
+        }
+    });
+    routes.get("/:tenantId/balance", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        try {
+            const balance = await ledger.balance(tenant);
+            return c.json({ tenant, balance_credits: balance });
+        }
+        catch {
+            return c.json({ error: "Internal server error" }, 500);
+        }
+    });
+    routes.get("/:tenantId/transactions", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        const typeParam = c.req.query("type");
+        const filters = {
+            type: typeParam,
+            limit: parseIntParam(c.req.query("limit")),
+            offset: parseIntParam(c.req.query("offset")),
+        };
+        try {
+            const entries = await ledger.history(tenant, filters);
+            return c.json({ entries, total: entries.length });
+        }
+        catch {
+            return c.json({ error: "Internal server error" }, 500);
+        }
+    });
+    routes.get("/:tenantId/adjustments", async (c) => {
+        const ledger = ledgerFactory();
+        const parsed = parseTenantId(c);
+        if (!parsed.ok)
+            return c.json({ error: TENANT_ID_ERROR }, 400);
+        const tenant = parsed.tenant;
+        const typeParam = c.req.query("type");
+        const filters = {
+            type: typeParam,
+            limit: parseIntParam(c.req.query("limit")),
+            offset: parseIntParam(c.req.query("offset")),
+        };
+        try {
+            const entries = await ledger.history(tenant, filters);
+            return c.json({ entries, total: entries.length });
+        }
+        catch {
+            return c.json({ error: "Internal server error" }, 500);
+        }
+    });
+    return routes;
+}

package/dist/api/routes/admin-gpu.d.ts

@@ -0,0 +1,46 @@
+import { Hono } from "hono";
+import type { AuthEnv } from "../../auth/index.js";
+import type { AdminAuditLogger } from "./admin-audit-helper.js";
+/** Minimal interface for GPU node repository. */
+export interface IGpuNodeRepository {
+    list(): Promise<unknown[]>;
+    getById(nodeId: string): Promise<{
+        dropletId?: string | number | null;
+        status?: string;
+    } | null>;
+}
+/** Minimal interface for GPU node provisioner. */
+export interface IGpuNodeProvisioner {
+    provision(opts: {
+        region?: string;
+        size?: string;
+        name?: string;
+    }): Promise<{
+        nodeId: string;
+        dropletId?: string | number | null;
+        region?: string;
+        size?: string;
+        monthlyCostCents?: number;
+    }>;
+    destroy(nodeId: string): Promise<void>;
+}
+/** Minimal interface for DO API client. */
+export interface IDOClient {
+    listRegions(): Promise<unknown[]>;
+    listSizes(): Promise<unknown[]>;
+    rebootDroplet(dropletId: number): Promise<void>;
+}
+export interface AdminGpuDeps {
+    gpuNodeRepo: () => IGpuNodeRepository;
+    gpuNodeProvisioner: () => IGpuNodeProvisioner;
+    doClient: () => IDOClient;
+    auditLogger?: () => AdminAuditLogger;
+    logger?: {
+        error(msg: string, meta?: Record<string, unknown>): void;
+    };
+}
+/**
+ * Create admin GPU node management routes.
+ * Static routes (/regions, /sizes) are registered BEFORE parameterized routes (/:nodeId).
+ */
+export declare function createAdminGpuRoutes(deps: AdminGpuDeps): Hono<AuthEnv>;