@schedulespark/observability 0.0.2-beta-1-0-0

package/dist/alerts/notifier.d.ts

@@ -0,0 +1,15 @@
+import type { NotificationChannel } from "./types.js";
+import type { CaptureInput } from "../core/index.js";
+import type { RecordEventResult, StorageHandle } from "../storage/index.js";
+/**
+ * Wraps storage's `recordEvent` so newly created issues and reopened
+ * ("regression") issues are announced to every configured notification channel.
+ */
+export interface Notifier {
+    recordEvent: (handle: StorageHandle, input: CaptureInput, projectId?: string) => Promise<RecordEventResult>;
+}
+/**
+ * Creates a notifier bound to a set of channels. With no channels configured, this
+ * behaves exactly like calling storage's `recordEvent` directly.
+ */
+export declare function createNotifier(channels: NotificationChannel[]): Notifier;

package/dist/alerts/notifier.js

@@ -0,0 +1,31 @@
+import { recordEvent } from "../storage/index.js";
+import { dispatchAlert } from "./dispatch.js";
+/**
+ * Creates a notifier bound to a set of channels. With no channels configured, this
+ * behaves exactly like calling storage's `recordEvent` directly.
+ */
+export function createNotifier(channels) {
+    return {
+        async recordEvent(handle, input, projectId) {
+            const result = await recordEvent(handle, input, projectId);
+            const alert = toAlert(result);
+            if (alert) {
+                dispatchAlert(channels, alert);
+            }
+            return result;
+        }
+    };
+}
+/**
+ * Maps a record-event result to the alert it should raise, if any. Repeat
+ * occurrences of an already-unresolved issue raise nothing.
+ */
+function toAlert(result) {
+    if (result.isNewIssue) {
+        return { kind: "new_issue", issue: result.issue, event: result.event };
+    }
+    if (result.isRegression) {
+        return { kind: "regression", issue: result.issue, event: result.event };
+    }
+    return undefined;
+}

package/dist/alerts/spike.d.ts

@@ -0,0 +1,25 @@
+import type { NotificationChannel } from "./types.js";
+import type { StorageHandle } from "../storage/index.js";
+/**
+ * Options for the spike monitor.
+ */
+export interface SpikeMonitorOptions {
+    channels: NotificationChannel[];
+    thresholdCount?: number;
+    windowMinutes?: number;
+    checkIntervalMs?: number;
+}
+/**
+ * A running spike monitor.
+ */
+export interface SpikeMonitor {
+    stop: () => void;
+}
+/**
+ * Periodically checks the error rate over a rolling window and notifies channels
+ * once it crosses a threshold, with a cooldown (one window's length) between
+ * repeated alerts so a sustained spike doesn't re-notify on every check. State is
+ * kept in memory only, so each process/instance monitors independently — fine for a
+ * single-instance self-hosted setup, an undercount risk with multiple instances.
+ */
+export declare function startSpikeMonitor(handle: StorageHandle, options: SpikeMonitorOptions): SpikeMonitor;

package/dist/alerts/spike.js

@@ -0,0 +1,41 @@
+import { countEventsSince } from "../storage/index.js";
+import { dispatchAlert } from "./dispatch.js";
+const DEFAULT_THRESHOLD_COUNT = 20;
+const DEFAULT_WINDOW_MINUTES = 5;
+const DEFAULT_CHECK_INTERVAL_MS = 60_000;
+/**
+ * Periodically checks the error rate over a rolling window and notifies channels
+ * once it crosses a threshold, with a cooldown (one window's length) between
+ * repeated alerts so a sustained spike doesn't re-notify on every check. State is
+ * kept in memory only, so each process/instance monitors independently — fine for a
+ * single-instance self-hosted setup, an undercount risk with multiple instances.
+ */
+export function startSpikeMonitor(handle, options) {
+    const thresholdCount = options.thresholdCount ?? DEFAULT_THRESHOLD_COUNT;
+    const windowMinutes = options.windowMinutes ?? DEFAULT_WINDOW_MINUTES;
+    let lastAlertedAt = 0;
+    const timer = setInterval(() => {
+        void checkForSpike({ handle, options, thresholdCount, windowMinutes, lastAlertedAt }).then((alertedAt) => {
+            lastAlertedAt = alertedAt;
+        });
+    }, options.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS);
+    timer.unref();
+    return { stop: () => { clearInterval(timer); } };
+}
+/**
+ * Runs one spike check, returning the (possibly updated) `lastAlertedAt` timestamp.
+ */
+async function checkForSpike(ctx) {
+    try {
+        const count = await countEventsSince(ctx.handle, "error", ctx.windowMinutes);
+        const cooledDown = Date.now() - ctx.lastAlertedAt > ctx.windowMinutes * 60_000;
+        if (count >= ctx.thresholdCount && cooledDown) {
+            dispatchAlert(ctx.options.channels, { kind: "spike", count, windowMinutes: ctx.windowMinutes });
+            return Date.now();
+        }
+    }
+    catch (error) {
+        console.error("[observability] spike monitor check failed", error);
+    }
+    return ctx.lastAlertedAt;
+}

package/dist/alerts/types.d.ts

@@ -0,0 +1,38 @@
+import type { CapturedEvent, Issue } from "../core/index.js";
+/**
+ * Fired the first time a fingerprint is ever seen.
+ */
+export interface NewIssueAlert {
+    kind: "new_issue";
+    issue: Issue;
+    event: CapturedEvent;
+}
+/**
+ * Fired when a previously-resolved issue receives a new event (auto-reopened).
+ */
+export interface RegressionAlert {
+    kind: "regression";
+    issue: Issue;
+    event: CapturedEvent;
+}
+/**
+ * Fired when the error rate over a rolling window crosses a configured threshold.
+ */
+export interface SpikeAlert {
+    kind: "spike";
+    count: number;
+    windowMinutes: number;
+}
+/**
+ * Payload delivered to a notification channel.
+ */
+export type Alert = NewIssueAlert | RegressionAlert | SpikeAlert;
+/**
+ * A destination for alert notifications (webhook, Slack, email, ...). Implementations
+ * must never throw past the notifier — failures are caught and logged so a broken
+ * channel can't block event capture.
+ */
+export interface NotificationChannel {
+    name: string;
+    notify: (alert: Alert) => Promise<void>;
+}

package/dist/alerts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/alerts/webhook.d.ts

@@ -0,0 +1,14 @@
+import type { NotificationChannel } from "./types.js";
+/**
+ * Creates a channel that POSTs a generic JSON payload describing the alert to any
+ * webhook URL.
+ */
+export declare function webhookChannel(url: string, options?: {
+    name?: string;
+}): NotificationChannel;
+/**
+ * Creates a channel formatted for Slack (or Slack-compatible) incoming webhooks.
+ */
+export declare function slackWebhookChannel(url: string, options?: {
+    dashboardUrl?: string;
+}): NotificationChannel;

package/dist/alerts/webhook.js

@@ -0,0 +1,59 @@
+import { alertIssueLink, summarizeAlert } from "./format.js";
+/**
+ * Creates a channel that POSTs a generic JSON payload describing the alert to any
+ * webhook URL.
+ */
+export function webhookChannel(url, options = {}) {
+    return {
+        name: options.name ?? "webhook",
+        notify: (alert) => postJson(url, toWebhookPayload(alert))
+    };
+}
+/**
+ * Creates a channel formatted for Slack (or Slack-compatible) incoming webhooks.
+ */
+export function slackWebhookChannel(url, options = {}) {
+    return {
+        name: "slack",
+        notify: (alert) => postJson(url, { text: toSlackText(alert, options.dashboardUrl) })
+    };
+}
+/**
+ * Builds the generic JSON body sent to a webhook channel.
+ */
+function toWebhookPayload(alert) {
+    if (alert.kind === "spike") {
+        return { kind: alert.kind, count: alert.count, windowMinutes: alert.windowMinutes };
+    }
+    return {
+        kind: alert.kind,
+        issueId: alert.issue.id,
+        title: alert.issue.title,
+        level: alert.issue.level,
+        message: alert.event.message,
+        firstSeen: alert.issue.firstSeen
+    };
+}
+/**
+ * Formats a Slack message for an alert, linking to the dashboard when a base URL is
+ * configured (issue-scoped alerts only — a spike has no single issue to link to).
+ */
+function toSlackText(alert, dashboardUrl) {
+    const emoji = alert.kind === "spike" ? ":chart_with_upwards_trend:" : ":rotating_light:";
+    const link = alertIssueLink(alert, dashboardUrl);
+    return `${emoji} ${summarizeAlert(alert)}${link ? ` <${link}|View>` : ""}`;
+}
+/**
+ * POSTs a JSON body to a webhook URL, throwing on a non-2xx response so the caller's
+ * error handling (never propagated back to event capture) can log it.
+ */
+async function postJson(url, body) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+        throw new Error(`webhook responded with status ${String(response.status)}`);
+    }
+}

package/dist/browser/client.d.ts

@@ -0,0 +1,26 @@
+import type { BreadcrumbInput, EventContext, EventLevel } from "../core/index.js";
+/**
+ * Options for initializing the browser observability client.
+ */
+export interface BrowserClientOptions {
+    ingestUrl: string;
+    apiKey?: string;
+    environment?: string;
+    release?: string;
+    captureGlobalErrors?: boolean;
+    autoBreadcrumbs?: boolean;
+}
+/**
+ * The browser SDK's public capture API.
+ */
+export interface BrowserClient {
+    captureException: (error: unknown, context?: EventContext) => void;
+    captureMessage: (message: string, level?: EventLevel, context?: EventContext) => void;
+    addBreadcrumb: (breadcrumb: BreadcrumbInput) => void;
+}
+/**
+ * Initializes the browser client. By default also installs `window.onerror` and
+ * `unhandledrejection` listeners so uncaught client-side errors are reported without
+ * any extra wiring, and wraps `window.fetch` to auto-record a breadcrumb per request.
+ */
+export declare function init(options: BrowserClientOptions): BrowserClient;

package/dist/browser/client.js

@@ -0,0 +1,131 @@
+import { captureInputSchema, createBreadcrumbBuffer } from "../core/index.js";
+const DEFAULT_CAPTURE_GLOBAL_ERRORS = true;
+const DEFAULT_AUTO_BREADCRUMBS = true;
+/**
+ * Initializes the browser client. By default also installs `window.onerror` and
+ * `unhandledrejection` listeners so uncaught client-side errors are reported without
+ * any extra wiring, and wraps `window.fetch` to auto-record a breadcrumb per request.
+ */
+export function init(options) {
+    const breadcrumbs = createBreadcrumbBuffer();
+    const client = {
+        captureException(error, context) {
+            send(options, { ...buildExceptionInput(error, mergeContext(context, options)), breadcrumbs: breadcrumbs.snapshot() });
+        },
+        captureMessage(message, level = "info", context) {
+            send(options, { level, message, context: mergeContext(context, options), breadcrumbs: breadcrumbs.snapshot() });
+        },
+        addBreadcrumb(breadcrumb) {
+            breadcrumbs.add({ ...breadcrumb, data: breadcrumb.data ? redactBreadcrumbData(breadcrumb.data) : undefined });
+        }
+    };
+    if (options.captureGlobalErrors ?? DEFAULT_CAPTURE_GLOBAL_ERRORS) {
+        registerGlobalHandlers(client);
+    }
+    if (options.autoBreadcrumbs ?? DEFAULT_AUTO_BREADCRUMBS) {
+        registerFetchBreadcrumbs(breadcrumbs, options.ingestUrl);
+    }
+    return client;
+}
+const BREADCRUMB_SECRET_KEY_PATTERN = /authorization|cookie|password|secret|token|api[-_]?key/i;
+/**
+ * Redacts secret-looking keys from breadcrumb `data` before it's buffered — the same
+ * risk `context.extra` has, and the same key-pattern the Node SDK's `redact.ts` uses.
+ * Duplicated here (rather than shared) since this is the only place the browser SDK
+ * needs it.
+ */
+function redactBreadcrumbData(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        result[key] = BREADCRUMB_SECRET_KEY_PATTERN.test(key) ? "[redacted]" : value;
+    }
+    return result;
+}
+/**
+ * Wraps `window.fetch` once so every request auto-records a `"fetch"` breadcrumb —
+ * the single highest-value default breadcrumb source, mirroring Sentry's own. Skips
+ * the SDK's own ingestion POSTs, which would otherwise bury every capture's real
+ * breadcrumb trail under "POST <ingestUrl> → 202" from reporting itself.
+ */
+function registerFetchBreadcrumbs(breadcrumbs, ingestUrl) {
+    const originalFetch = window.fetch.bind(window);
+    window.fetch = async (...args) => {
+        const url = describeFetchUrl(args[0]);
+        if (url === ingestUrl) {
+            return originalFetch(...args);
+        }
+        const method = (args[1]?.method ?? "GET").toUpperCase();
+        try {
+            const response = await originalFetch(...args);
+            breadcrumbs.add({ category: "fetch", message: `${method} ${url}`, data: { status: response.status } });
+            return response;
+        }
+        catch (error) {
+            breadcrumbs.add({ category: "fetch", message: `${method} ${url}`, level: "error", data: { failed: true } });
+            throw error;
+        }
+    };
+}
+/**
+ * Renders a `fetch` call's first argument (URL string, `URL`, or `Request`) as a
+ * plain string for the breadcrumb message.
+ */
+function describeFetchUrl(input) {
+    if (typeof input === "string") {
+        return input;
+    }
+    return input instanceof URL ? input.toString() : input.url;
+}
+/**
+ * Fills in `environment`/`release` on a context object from client defaults.
+ */
+function mergeContext(context, options) {
+    return {
+        ...context,
+        environment: context?.environment ?? options.environment,
+        release: context?.release ?? options.release
+    };
+}
+/**
+ * Builds a capture payload from a thrown value.
+ */
+function buildExceptionInput(error, context) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    return {
+        level: "error",
+        message: normalized.message || "Unknown error",
+        errorType: normalized.name,
+        stackTrace: normalized.stack,
+        context
+    };
+}
+/**
+ * Validates and fire-and-forget POSTs a capture payload to the ingestion endpoint.
+ */
+function send(options, input) {
+    const parsed = captureInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return;
+    }
+    const headers = { "content-type": "application/json" };
+    if (options.apiKey) {
+        headers.authorization = `Bearer ${options.apiKey}`;
+    }
+    fetch(options.ingestUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(parsed.data),
+        keepalive: true
+    }).catch(() => undefined);
+}
+/**
+ * Installs `window.onerror`/`unhandledrejection` listeners that report to the client.
+ */
+function registerGlobalHandlers(client) {
+    window.addEventListener("error", (event) => {
+        client.captureException(event.error ?? new Error(event.message));
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+        client.captureException(event.reason);
+    });
+}

package/dist/browser/index.d.ts

@@ -0,0 +1,3 @@
+export { init } from "./client.js";
+export type { BrowserClient, BrowserClientOptions } from "./client.js";
+export type { Breadcrumb, BreadcrumbInput } from "../core/index.js";

package/dist/browser/index.js

@@ -0,0 +1 @@
+export { init } from "./client.js";

package/dist/cli/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from "./index.js";
+runCli(process.argv.slice(2)).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/cli/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dispatches a CLI invocation to the matching subcommand.
+ */
+export declare function runCli(argv: string[]): Promise<void>;
+export { runMigrate } from "./migrate.js";
+export { runProjects } from "./projects.js";
+export { runPrune } from "./prune.js";
+export { runRollup } from "./rollup.js";
+export { runServe } from "./serve.js";
+export { runSourcemap } from "./sourcemap.js";

package/dist/cli/index.js

@@ -0,0 +1,45 @@
+import { runMigrate } from "./migrate.js";
+import { runProjects } from "./projects.js";
+import { runPrune } from "./prune.js";
+import { runRollup } from "./rollup.js";
+import { runServe } from "./serve.js";
+import { runSourcemap } from "./sourcemap.js";
+const USAGE = `Usage: schedulespark-observability <serve|migrate|prune|projects|sourcemap|rollup> [--db <connectionString>] [--schema <schema>]`;
+/**
+ * Dispatches a CLI invocation to the matching subcommand.
+ */
+export async function runCli(argv) {
+    const [command, ...rest] = argv;
+    if (command === "serve") {
+        await runServe(rest);
+        return;
+    }
+    if (command === "migrate") {
+        await runMigrate(rest);
+        return;
+    }
+    if (command === "prune") {
+        await runPrune(rest);
+        return;
+    }
+    if (command === "projects") {
+        await runProjects(rest);
+        return;
+    }
+    if (command === "sourcemap") {
+        await runSourcemap(rest);
+        return;
+    }
+    if (command === "rollup") {
+        await runRollup(rest);
+        return;
+    }
+    console.error(USAGE);
+    process.exitCode = 1;
+}
+export { runMigrate } from "./migrate.js";
+export { runProjects } from "./projects.js";
+export { runPrune } from "./prune.js";
+export { runRollup } from "./rollup.js";
+export { runServe } from "./serve.js";
+export { runSourcemap } from "./sourcemap.js";

package/dist/cli/migrate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `migrate` subcommand: applies any pending schema migrations and exits. Intended for
+ * production deploys, where migrating explicitly ahead of time is safer than the
+ * automatic on-`init()` migration the Node SDK does in development.
+ */
+export declare function runMigrate(argv: string[]): Promise<void>;

package/dist/cli/migrate.js

@@ -0,0 +1,14 @@
+import { closeStorage, initStorage } from "../storage/index.js";
+import { parseCommonOptions } from "./options.js";
+const MIGRATE_LOG_PREFIX = "[observability]";
+/**
+ * `migrate` subcommand: applies any pending schema migrations and exits. Intended for
+ * production deploys, where migrating explicitly ahead of time is safer than the
+ * automatic on-`init()` migration the Node SDK does in development.
+ */
+export async function runMigrate(argv) {
+    const options = parseCommonOptions(argv);
+    const handle = await initStorage(options);
+    console.error(`${MIGRATE_LOG_PREFIX} schema "${handle.schema}" is up to date`);
+    await closeStorage(handle);
+}

package/dist/cli/options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Common `--db`/`--schema` flags shared by every CLI subcommand.
+ */
+export interface CommonOptions {
+    connectionString: string;
+    schema?: string;
+}
+/**
+ * Resolves the database connection string from a `--db` flag or the
+ * `OBSERVABILITY_DATABASE_URL` environment variable, throwing a clear error if
+ * neither is set.
+ */
+export declare function parseCommonOptions(argv: string[]): CommonOptions;
+/**
+ * Narrows a parsed argument value to a string, ignoring booleans/arrays.
+ */
+export declare function valueAsString(value: unknown): string | undefined;

package/dist/cli/options.js

@@ -0,0 +1,28 @@
+import { parseArgs } from "node:util";
+/**
+ * Resolves the database connection string from a `--db` flag or the
+ * `OBSERVABILITY_DATABASE_URL` environment variable, throwing a clear error if
+ * neither is set.
+ */
+export function parseCommonOptions(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            db: { type: "string" },
+            schema: { type: "string" }
+        },
+        allowPositionals: true,
+        strict: false
+    });
+    const connectionString = valueAsString(values.db) ?? process.env.OBSERVABILITY_DATABASE_URL;
+    if (!connectionString) {
+        throw new Error("A database connection string is required: pass --db or set OBSERVABILITY_DATABASE_URL.");
+    }
+    return { connectionString, schema: valueAsString(values.schema) };
+}
+/**
+ * Narrows a parsed argument value to a string, ignoring booleans/arrays.
+ */
+export function valueAsString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/cli/projects.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `projects` subcommand: manages multi-project setups (`create --name X`, `list`).
+ * A fresh single-project install never needs this — every schema already has an
+ * auto-created `default` project.
+ */
+export declare function runProjects(argv: string[]): Promise<void>;

package/dist/cli/projects.js

@@ -0,0 +1,52 @@
+import { parseArgs } from "node:util";
+import { closeStorage, createProject, initStorage, listProjects } from "../storage/index.js";
+import { parseCommonOptions, valueAsString } from "./options.js";
+const USAGE = "Usage: schedulespark-observability projects <create|list> [--db <connectionString>] [--schema <schema>]";
+/**
+ * `projects` subcommand: manages multi-project setups (`create --name X`, `list`).
+ * A fresh single-project install never needs this — every schema already has an
+ * auto-created `default` project.
+ */
+export async function runProjects(argv) {
+    const [subcommand, ...rest] = argv;
+    if (subcommand === "create") {
+        await runProjectsCreate(rest);
+        return;
+    }
+    if (subcommand === "list") {
+        await runProjectsList(rest);
+        return;
+    }
+    console.error(USAGE);
+    process.exitCode = 1;
+}
+/**
+ * `projects create --name X`: creates a project and prints its generated API key.
+ */
+async function runProjectsCreate(argv) {
+    const common = parseCommonOptions(argv);
+    const { values } = parseArgs({
+        args: argv,
+        options: { name: { type: "string" } },
+        allowPositionals: true,
+        strict: false
+    });
+    const name = valueAsString(values.name);
+    if (!name) {
+        throw new Error("A project name is required: pass --name.");
+    }
+    const handle = await initStorage(common);
+    const project = await createProject(handle, name);
+    console.error(JSON.stringify(project, null, 2));
+    await closeStorage(handle);
+}
+/**
+ * `projects list`: prints every configured project.
+ */
+async function runProjectsList(argv) {
+    const common = parseCommonOptions(argv);
+    const handle = await initStorage(common);
+    const projects = await listProjects(handle);
+    console.error(JSON.stringify(projects, null, 2));
+    await closeStorage(handle);
+}

package/dist/cli/prune.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `prune` subcommand: deletes events older than the retention window (default 90
+ * days), keeping their issues intact, and separately prunes log lines (default 14
+ * days — logs are typically much higher-volume than events). A stopgap against
+ * unbounded table growth — intended to be run on a schedule (cron, Render cron job,
+ * etc.) since nothing prunes automatically.
+ */
+export declare function runPrune(argv: string[]): Promise<void>;

package/dist/cli/prune.js

@@ -0,0 +1,32 @@
+import { parseArgs } from "node:util";
+import { closeStorage, initStorage, pruneEvents, pruneLogs } from "../storage/index.js";
+import { parseCommonOptions, valueAsString } from "./options.js";
+const DEFAULT_RETENTION_DAYS = 90;
+const DEFAULT_LOG_RETENTION_DAYS = 14;
+/**
+ * `prune` subcommand: deletes events older than the retention window (default 90
+ * days), keeping their issues intact, and separately prunes log lines (default 14
+ * days — logs are typically much higher-volume than events). A stopgap against
+ * unbounded table growth — intended to be run on a schedule (cron, Render cron job,
+ * etc.) since nothing prunes automatically.
+ */
+export async function runPrune(argv) {
+    const common = parseCommonOptions(argv);
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            "older-than-days": { type: "string" },
+            "logs-older-than-days": { type: "string" }
+        },
+        allowPositionals: true,
+        strict: false
+    });
+    const olderThanDays = Number(valueAsString(values["older-than-days"]) ?? DEFAULT_RETENTION_DAYS);
+    const logsOlderThanDays = Number(valueAsString(values["logs-older-than-days"]) ?? DEFAULT_LOG_RETENTION_DAYS);
+    const handle = await initStorage(common);
+    const eventsResult = await pruneEvents(handle, olderThanDays);
+    console.error(`[observability] deleted ${String(eventsResult.deletedEvents)} events older than ${String(olderThanDays)} days`);
+    const logsResult = await pruneLogs(handle, logsOlderThanDays);
+    console.error(`[observability] deleted ${String(logsResult.deletedLogs)} logs older than ${String(logsOlderThanDays)} days`);
+    await closeStorage(handle);
+}

package/dist/cli/rollup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs the `rollup` CLI subcommand: aggregates raw metric points into hourly/daily
+ * buckets, then prunes raw points older than the retention window. Intended to be
+ * invoked on a schedule (e.g. a cron job), the same way `prune` is.
+ */
+export declare function runRollup(argv: string[]): Promise<void>;