@hasna/shortlinks 0.1.22 → 0.1.24

package/dist/cli/index.js

@@ -33,7 +33,7 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = import.meta.require;
 
-// node_modules/commander/lib/error.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -57,7 +57,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// node_modules/commander/lib/argument.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -136,7 +136,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// node_modules/commander/lib/help.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -486,7 +486,7 @@ ${itemIndentStr}`);
   exports.stripColor = stripColor;
 });
 
-// node_modules/commander/lib/option.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -664,7 +664,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// node_modules/commander/lib/suggestSimilar.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -737,7 +737,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// node_modules/commander/lib/command.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("events").EventEmitter;
   var childProcess = __require("child_process");
@@ -979,7 +979,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          }
+          } else {}
         };
       }
       return this;
@@ -2047,7 +2047,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// node_modules/commander/index.js
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/index.js
 var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -2067,1557 +2067,948 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// node_modules/@hasna/events/dist/commander.js
-import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { createHmac, timingSafeEqual } from "crypto";
-import { randomUUID } from "crypto";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-function getPathValue(input, path) {
-  return path.split(".").reduce((value, part) => {
-    if (value && typeof value === "object" && part in value) {
-      return value[part];
-    }
-    return;
-  }, input);
+// src/runtime.ts
+var SHORTLINKS_RUNTIME_ENV = {
+  store: "HASNA_SHORTLINKS_STORE",
+  databaseUrl: "HASNA_SHORTLINKS_DATABASE_URL",
+  databaseSsl: "HASNA_SHORTLINKS_DATABASE_SSL"
+};
+var SHORTLINKS_RUNTIME_FALLBACK_ENV = {
+  store: "SHORTLINKS_STORE",
+  databaseUrl: "SHORTLINKS_DATABASE_URL",
+  databaseSsl: "SHORTLINKS_DATABASE_SSL"
+};
+var CANONICAL_SHORTLINKS_POSTGRES_CLUSTER = "hasna-xyz-infra-apps-prod-postgres";
+var CANONICAL_SHORTLINKS_POSTGRES_DATABASE = "shortlinks";
+var CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH = "hasna/xyz/opensource/shortlinks/prod/postgres";
+function getCanonicalShortlinksPostgresConfig() {
+  return {
+    cluster: CANONICAL_SHORTLINKS_POSTGRES_CLUSTER,
+    database: CANONICAL_SHORTLINKS_POSTGRES_DATABASE,
+    runtimeSecretPath: CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH,
+    primaryEnv: SHORTLINKS_RUNTIME_ENV.databaseUrl,
+    fallbackEnv: SHORTLINKS_RUNTIME_FALLBACK_ENV.databaseUrl
+  };
 }
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
+function parseShortlinksStoreMode(value) {
+  const normalized = clean(value)?.toLowerCase();
+  if (!normalized)
+    return "local";
+  if (normalized === "local" || normalized === "postgres")
+    return normalized;
+  if (normalized === "pg")
+    return "postgres";
+  throw new Error(`${SHORTLINKS_RUNTIME_ENV.store} must be local or postgres`);
 }
-function matchString(value, matcher) {
-  if (matcher === undefined)
-    return true;
-  if (value === undefined)
-    return false;
-  const matchers = Array.isArray(matcher) ? matcher : [matcher];
-  return matchers.some((item) => wildcardToRegExp(item).test(value));
+function getShortlinksStoreMode(env = process.env) {
+  return parseShortlinksStoreMode(readRuntimeEnv(env, "store").value);
 }
-function matchRecord(input, matcher) {
-  if (!matcher)
-    return true;
-  return Object.entries(matcher).every(([path, expected]) => {
-    const actual = getPathValue(input, path);
-    if (typeof expected === "string" || Array.isArray(expected)) {
-      return matchString(actual === undefined ? undefined : String(actual), expected);
-    }
-    return actual === expected;
-  });
+function getShortlinksDatabaseUrl(env = process.env) {
+  return readRuntimeEnv(env, "databaseUrl").value;
 }
-function eventMatchesFilter(event, filter) {
-  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+function getShortlinksDatabaseSsl(env = process.env) {
+  return parseBoolean(readRuntimeEnv(env, "databaseSsl").value, true);
 }
-function channelMatchesEvent(channel, event) {
-  if (!channel.enabled)
-    return false;
-  if (!channel.filters || channel.filters.length === 0)
-    return true;
-  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+function getShortlinksRuntimeEnvName(env, key) {
+  const primary = SHORTLINKS_RUNTIME_ENV[key];
+  if (clean(env[primary]))
+    return primary;
+  return SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
 }
-var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
-var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
-function getEventsDataDir(override) {
-  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join(homedir(), ".hasna", "events");
+function loadShortlinksRuntimeConfig(env = process.env) {
+  const mode = getShortlinksStoreMode(env);
+  const databaseUrl = getShortlinksDatabaseUrl(env);
+  return {
+    service: "shortlinks",
+    mode,
+    ...databaseUrl ? {
+      database: {
+        provider: "postgres",
+        url: databaseUrl,
+        ssl: getShortlinksDatabaseSsl(env)
+      }
+    } : {}
+  };
 }
-
-class JsonEventsStore {
-  dataDir;
-  channelsPath;
-  eventsPath;
-  deliveriesPath;
-  constructor(dataDir = getEventsDataDir()) {
-    this.dataDir = dataDir;
-    this.channelsPath = join(dataDir, "channels.json");
-    this.eventsPath = join(dataDir, "events.json");
-    this.deliveriesPath = join(dataDir, "deliveries.json");
-  }
-  async init() {
-    await mkdir(this.dataDir, { recursive: true, mode: 448 });
-    await chmod(this.dataDir, 448).catch(() => {
-      return;
-    });
-    await this.ensureArrayFile(this.channelsPath);
-    await this.ensureArrayFile(this.eventsPath);
-    await this.ensureArrayFile(this.deliveriesPath);
-  }
-  async addChannel(channel) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const index = channels.findIndex((item) => item.id === channel.id);
-    if (index >= 0) {
-      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
-    } else {
-      channels.push(channel);
-    }
-    await this.writeJson(this.channelsPath, channels);
-    return index >= 0 ? channels[index] : channel;
-  }
-  async listChannels() {
-    await this.init();
-    return this.readJson(this.channelsPath, []);
-  }
-  async getChannel(id) {
-    const channels = await this.listChannels();
-    return channels.find((channel) => channel.id === id);
-  }
-  async removeChannel(id) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const next = channels.filter((channel) => channel.id !== id);
-    await this.writeJson(this.channelsPath, next);
-    return next.length !== channels.length;
-  }
-  async appendEvent(event) {
-    await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
-    return event;
-  }
-  async listEvents() {
-    await this.init();
-    return this.readJson(this.eventsPath, []);
-  }
-  async findEventByIdentity(identity) {
-    const events = await this.listEvents();
-    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
-  }
-  async appendDelivery(result) {
-    await this.init();
-    const deliveries = await this.readJson(this.deliveriesPath, []);
-    deliveries.push(result);
-    await this.writeJson(this.deliveriesPath, deliveries);
-    return result;
-  }
-  async listDeliveries() {
-    await this.init();
-    return this.readJson(this.deliveriesPath, []);
+function assertShortlinksPostgresConfig(config) {
+  if (config.mode !== "postgres")
+    return;
+  if (!config.database?.url) {
+    throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseUrl} is required when ${SHORTLINKS_RUNTIME_ENV.store}=postgres`);
   }
-  async exportData() {
-    return {
-      channels: await this.listChannels(),
-      events: await this.listEvents(),
-      deliveries: await this.listDeliveries()
-    };
+}
+function getShortlinksRuntimeStatus(env = process.env) {
+  const issues = [];
+  const warnings = [];
+  let config;
+  try {
+    config = loadShortlinksRuntimeConfig(env);
+  } catch (error) {
+    issues.push(error instanceof Error ? error.message : String(error));
+    config = { service: "shortlinks", mode: "local" };
   }
-  async ensureArrayFile(path) {
-    if (!existsSync(path)) {
-      await writeFile(path, `[]
-`, { encoding: "utf-8", mode: 384 });
-    }
-    await chmod(path, 384).catch(() => {
-      return;
-    });
+  try {
+    assertShortlinksPostgresConfig(config);
+  } catch (error) {
+    issues.push(error instanceof Error ? error.message : String(error));
   }
-  async readJson(path, fallback) {
-    try {
-      const raw = await readFile(path, "utf-8");
-      if (!raw.trim())
-        return fallback;
-      return JSON.parse(raw);
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return fallback;
-      throw error;
-    }
+  if (config.mode === "local" && config.database?.url) {
+    warnings.push(`${SHORTLINKS_RUNTIME_ENV.store}=local ignores configured Postgres database settings`);
   }
-  async writeJson(path, value) {
-    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
-`, { encoding: "utf-8", mode: 384 });
-    await rename(tempPath, path);
-    await chmod(path, 384).catch(() => {
-      return;
-    });
+  return {
+    ok: issues.length === 0,
+    service: "shortlinks",
+    mode: config.mode,
+    local_default: config.mode === "local",
+    postgres_enabled: config.mode === "postgres",
+    database: {
+      configured: Boolean(config.database?.url),
+      provider: config.database?.provider ?? null,
+      redacted_url: redactDatabaseUrl(config.database?.url),
+      ssl: config.database?.ssl ?? null
+    },
+    env: runtimeEnvStatus(env),
+    canonical: getCanonicalShortlinksPostgresConfig(),
+    issues,
+    warnings,
+    no_network: true
+  };
+}
+function redactDatabaseUrl(value) {
+  if (!value)
+    return null;
+  try {
+    const url = new URL(value);
+    if (url.username)
+      url.username = "***";
+    if (url.password)
+      url.password = "***";
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (isSensitiveQueryKey(key))
+        url.searchParams.set(key, "***");
+    }
+    return url.toString();
+  } catch {
+    return "(redacted)";
   }
 }
-var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
-function buildSignatureBase(timestamp, body) {
-  return `${timestamp}.${body}`;
+function runtimeEnvStatus(env) {
+  return Object.fromEntries(Object.entries(SHORTLINKS_RUNTIME_ENV).map(([key, name]) => {
+    const activeName = getShortlinksRuntimeEnvName(env, key);
+    return [
+      key,
+      {
+        name,
+        active_name: activeName,
+        configured: Boolean(clean(env[activeName]))
+      }
+    ];
+  }));
 }
-function signPayload(secret, timestamp, body) {
-  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
-  return `sha256=${digest}`;
+function readRuntimeEnv(env, key) {
+  const primary = SHORTLINKS_RUNTIME_ENV[key];
+  const primaryValue = clean(env[primary]);
+  if (primaryValue)
+    return { name: primary, value: primaryValue };
+  const fallback = SHORTLINKS_RUNTIME_FALLBACK_ENV[key];
+  return { name: fallback, value: clean(env[fallback]) };
 }
-function now() {
-  return new Date().toISOString();
+function parseBoolean(value, fallback) {
+  const normalized = clean(value)?.toLowerCase();
+  if (!normalized)
+    return fallback;
+  if (["1", "true", "yes", "on"].includes(normalized))
+    return true;
+  if (["0", "false", "no", "off"].includes(normalized))
+    return false;
+  throw new Error(`${SHORTLINKS_RUNTIME_ENV.databaseSsl} must be true or false`);
 }
-function truncate(value, max = 4096) {
-  return value.length > max ? `${value.slice(0, max)}...` : value;
+function isSensitiveQueryKey(key) {
+  return /(?:^|[_-])(pass(?:word)?|pwd|secret|token|credential|auth|api[_-]?key|access[_-]?key)(?:$|[_-])/i.test(key);
 }
-function buildWebhookRequest(event, channel) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const body = JSON.stringify(event);
-  const timestamp = event.time;
-  const headers = {
-    "Content-Type": "application/json",
-    "User-Agent": "@hasna/events",
-    "X-Hasna-Event-Id": event.id,
-    "X-Hasna-Event-Type": event.type,
-    "X-Hasna-Timestamp": timestamp,
-    ...channel.webhook.headers
-  };
-  if (channel.webhook.secret) {
-    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
-  }
-  return { body, headers };
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
 }
-async function dispatchWebhook(event, channel, options = {}) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const startedAt = now();
-  const { body, headers } = buildWebhookRequest(event, channel);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+
+// src/pg-store.ts
+import { createHash } from "crypto";
+
+// src/config.ts
+import { existsSync, linkSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var SERVICE_NAME = "shortlinks";
+var DEFAULT_DATA_DIR = join(homedir(), ".hasna", SERVICE_NAME);
+function getDataDir() {
+  return resolve(process.env.SHORTLINKS_HOME || DEFAULT_DATA_DIR);
+}
+function ensureDataDir() {
+  const dir = getDataDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getConfigPath() {
+  return join(ensureDataDir(), "config.json");
+}
+function getClickSaltPath() {
+  return join(ensureDataDir(), "click-salt");
+}
+function getDatabasePath(explicitPath) {
+  if (explicitPath)
+    return resolve(explicitPath);
+  if (process.env.SHORTLINKS_DB)
+    return resolve(process.env.SHORTLINKS_DB);
+  return join(ensureDataDir(), `${SERVICE_NAME}.db`);
+}
+function readClickSaltFile(path) {
   try {
-    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
-      method: "POST",
-      headers,
-      body,
-      signal: controller.signal
-    });
-    const responseBody = truncate(await response.text());
-    return {
-      attempt: 1,
-      status: response.ok ? "success" : "failed",
-      startedAt,
-      completedAt: now(),
-      responseStatus: response.status,
-      responseBody,
-      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
-    };
-  } catch (error) {
-    return {
-      attempt: 1,
-      status: "failed",
-      startedAt,
-      completedAt: now(),
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timeout);
+    const saved = readFileSync(path, "utf-8").trim();
+    return saved || null;
+  } catch {
+    return null;
   }
 }
-async function dispatchCommand(event, channel) {
-  if (!channel.command)
-    throw new Error(`Channel ${channel.id} has no command config`);
-  const startedAt = now();
-  const eventJson = JSON.stringify(event);
-  const env = {
-    ...process.env,
-    ...channel.command.env,
-    HASNA_CHANNEL_ID: channel.id,
-    HASNA_EVENT_ID: event.id,
-    HASNA_EVENT_TYPE: event.type,
-    HASNA_EVENT_SOURCE: event.source,
-    HASNA_EVENT_SUBJECT: event.subject ?? "",
-    HASNA_EVENT_SEVERITY: event.severity,
-    HASNA_EVENT_TIME: event.time,
-    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
-    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
-    HASNA_EVENT_JSON: eventJson
-  };
-  return new Promise((resolve) => {
-    const child = spawn(channel.command.command, channel.command.args ?? [], {
-      cwd: channel.command.cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
-    child.stdin.end(eventJson);
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => {
-      clearTimeout(timeout);
-      resolve({
-        attempt: 1,
-        status: "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: error.message
-      });
-    });
-    child.on("close", (code, signal) => {
-      clearTimeout(timeout);
-      const success = code === 0;
-      resolve({
-        attempt: 1,
-        status: success ? "success" : "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
-      });
-    });
-  });
-}
-async function dispatchChannel(event, channel, options = {}) {
-  if (channel.transport === "webhook")
-    return dispatchWebhook(event, channel, options);
-  if (channel.transport === "command")
-    return dispatchCommand(event, channel);
-  return {
-    attempt: 1,
-    status: "skipped",
-    startedAt: now(),
-    completedAt: now(),
-    error: `Unsupported transport: ${channel.transport}`
-  };
-}
-function createDeliveryResult(event, channel, attempts) {
-  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
-  return {
-    id: randomUUID(),
-    eventId: event.id,
-    channelId: channel.id,
-    transport: channel.transport,
-    status,
-    attempts,
-    createdAt: attempts[0]?.startedAt ?? now(),
-    completedAt: attempts.at(-1)?.completedAt ?? now()
-  };
-}
-function createEvent(input) {
-  return {
-    id: input.id ?? randomUUID2(),
-    source: input.source,
-    type: input.type,
-    time: normalizeTime(input.time),
-    subject: input.subject,
-    severity: input.severity ?? "info",
-    data: input.data ?? {},
-    message: input.message,
-    dedupeKey: input.dedupeKey,
-    schemaVersion: input.schemaVersion ?? "1.0",
-    metadata: input.metadata ?? {}
-  };
+function clickSaltError(path, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return new Error(`Could not initialize click salt at ${path}. Set SHORTLINKS_CLICK_SALT or fix data directory permissions. ${detail}`);
 }
-
-class EventsClient {
-  store;
-  redactors;
-  transportOptions;
-  constructor(options = {}) {
-    this.store = options.store ?? new JsonEventsStore(options.dataDir);
-    this.redactors = options.redactors ?? [];
-    this.transportOptions = { fetchImpl: options.fetchImpl };
-  }
-  async addChannel(input) {
-    const timestamp = new Date().toISOString();
-    return this.store.addChannel({
-      ...input,
-      createdAt: input.createdAt ?? timestamp,
-      updatedAt: input.updatedAt ?? timestamp
-    });
-  }
-  async listChannels() {
-    return this.store.listChannels();
-  }
-  async removeChannel(id) {
-    return this.store.removeChannel(id);
-  }
-  async emit(input, options = {}) {
-    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
-    if (options.dedupe !== false) {
-      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return { event: existing, deliveries: [], deduped: true };
-      }
+function getClickSalt() {
+  const explicit = process.env.SHORTLINKS_CLICK_SALT?.trim();
+  if (explicit)
+    return explicit;
+  const path = getClickSaltPath();
+  const saved = readClickSaltFile(path);
+  if (saved)
+    return saved;
+  const generated = randomBytes(32).toString("hex");
+  const tempPath = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tempPath, `${generated}
+`, { flag: "wx", mode: 384 });
+    try {
+      linkSync(tempPath, path);
+      return generated;
+    } catch (error) {
+      const winner = readClickSaltFile(path);
+      if (winner)
+        return winner;
+      throw clickSaltError(path, error);
+    } finally {
+      try {
+        unlinkSync(tempPath);
+      } catch {}
     }
-    await this.store.appendEvent(event);
-    const deliveries = options.deliver === false ? [] : await this.deliver(event);
-    return { event, deliveries, deduped: false };
-  }
-  async listEvents() {
-    return this.store.listEvents();
+  } catch (error) {
+    const winner = readClickSaltFile(path);
+    if (winner)
+      return winner;
+    throw clickSaltError(path, error);
   }
-  async listDeliveries() {
-    return this.store.listDeliveries();
+}
+function loadConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
   }
-  async deliver(event) {
-    const channels = await this.store.listChannels();
-    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
-    const deliveries = [];
-    for (const channel of selected) {
-      const eventForChannel = await this.applyRedaction(event, channel);
-      const result = await this.deliverWithRetry(eventForChannel, channel);
-      await this.store.appendDelivery(result);
-      deliveries.push(result);
+}
+function saveConfig(config) {
+  const path = getConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+function updateConfig(patch) {
+  const next = {
+    ...loadConfig(),
+    ...patch,
+    cloudflare: {
+      ...loadConfig().cloudflare,
+      ...patch.cloudflare
     }
-    return deliveries;
+  };
+  saveConfig(next);
+  return next;
+}
+function normalizeHostname(input) {
+  const raw = input.trim().toLowerCase();
+  if (!raw)
+    throw new Error("Domain is required.");
+  const withProtocol = raw.includes("://") ? raw : `https://${raw}`;
+  let hostname;
+  try {
+    hostname = new URL(withProtocol).hostname;
+  } catch {
+    throw new Error(`Invalid domain: ${input}`);
   }
-  async testChannel(id, input = {}) {
-    const channel = await this.store.getChannel(id);
-    if (!channel)
-      throw new Error(`Channel not found: ${id}`);
-    const event = createEvent({
-      source: input.source ?? "hasna.events",
-      type: input.type ?? "events.test",
-      subject: input.subject ?? id,
-      severity: input.severity ?? "info",
-      data: input.data ?? { test: true },
-      message: input.message ?? "Hasna events test delivery",
-      dedupeKey: input.dedupeKey,
-      schemaVersion: input.schemaVersion,
-      metadata: input.metadata,
-      time: input.time,
-      id: input.id
-    });
-    const eventForChannel = await this.applyRedaction(event, channel);
-    const result = await this.deliverWithRetry(eventForChannel, channel);
-    await this.store.appendDelivery(result);
-    return result;
+  hostname = hostname.replace(/\.$/, "");
+  const labels = hostname.split(".");
+  const labelsAreValid = labels.every((label) => label.length >= 1 && label.length <= 63 && /^[a-z0-9-]+$/.test(label) && !label.startsWith("-") && !label.endsWith("-"));
+  if (hostname.length > 253 || !labelsAreValid) {
+    throw new Error(`Invalid domain: ${input}`);
   }
-  async replay(options = {}) {
-    const events = (await this.store.listEvents()).filter((event) => {
-      if (options.eventId && event.id !== options.eventId)
-        return false;
-      if (options.source && event.source !== options.source)
-        return false;
-      if (options.type && event.type !== options.type)
-        return false;
-      return true;
-    });
-    if (options.dryRun)
-      return { events, deliveries: [] };
-    const deliveries = [];
-    for (const event of events) {
-      deliveries.push(...await this.deliver(event));
-    }
-    return { events, deliveries };
+  return hostname;
+}
+function formatShortUrl(hostname, slug, publicBaseUrl) {
+  if (publicBaseUrl) {
+    const base = publicBaseUrl.endsWith("/") ? publicBaseUrl : `${publicBaseUrl}/`;
+    return new URL(slug, base).toString();
   }
-  async applyRedaction(event, channel) {
-    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
-    for (const redactor of this.redactors) {
-      next = await redactor(next, channel);
-    }
-    return next;
+  return `https://${hostname}/${slug}`;
+}
+
+// src/database.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+function now() {
+  return new Date().toISOString();
+}
+function makeId(prefix) {
+  const bytes = crypto.getRandomValues(new Uint8Array(12));
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${prefix}_${hex}`;
+}
+var SQLITE_MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS domains (
+    id TEXT PRIMARY KEY,
+    hostname TEXT NOT NULL UNIQUE,
+    provider TEXT NOT NULL DEFAULT 'manual',
+    default_domain INTEGER NOT NULL DEFAULT 0,
+    cloudflare_zone_id TEXT,
+    cloudflare_account_id TEXT,
+    cloudflare_worker_name TEXT,
+    origin_url TEXT,
+    notes TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS links (
+    id TEXT PRIMARY KEY,
+    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    slug TEXT NOT NULL,
+    destination_url TEXT NOT NULL,
+    title TEXT,
+    active INTEGER NOT NULL DEFAULT 1,
+    expires_at TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(domain_id, slug)
+  );
+
+  CREATE TABLE IF NOT EXISTS clicks (
+    id TEXT PRIMARY KEY,
+    link_id TEXT NOT NULL REFERENCES links(id) ON DELETE CASCADE,
+    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
+    slug TEXT NOT NULL,
+    clicked_at TEXT NOT NULL,
+    ip_hash TEXT,
+    user_agent TEXT,
+    referer TEXT,
+    country TEXT,
+    city TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    machine_id TEXT,
+    synced_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_domains_hostname ON domains(hostname);
+  CREATE INDEX IF NOT EXISTS idx_domains_default ON domains(default_domain);
+  CREATE INDEX IF NOT EXISTS idx_links_domain_slug ON links(domain_id, slug);
+  CREATE INDEX IF NOT EXISTS idx_links_active ON links(active);
+  CREATE INDEX IF NOT EXISTS idx_links_updated ON links(updated_at);
+  CREATE INDEX IF NOT EXISTS idx_clicks_link ON clicks(link_id);
+  CREATE INDEX IF NOT EXISTS idx_clicks_domain ON clicks(domain_id);
+  CREATE INDEX IF NOT EXISTS idx_clicks_clicked_at ON clicks(clicked_at);
+  CREATE INDEX IF NOT EXISTS idx_clicks_updated ON clicks(updated_at);
+  `
+];
+
+class ShortlinksDatabase {
+  db;
+  path;
+  constructor(path) {
+    this.path = getDatabasePath(path);
+    mkdirSync2(dirname2(this.path), { recursive: true });
+    this.db = new Database(this.path);
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.applyMigrations();
   }
-  async deliverWithRetry(event, channel) {
-    const policy = normalizeRetryPolicy(channel.retry);
-    const attempts = [];
-    for (let index = 0;index < policy.maxAttempts; index += 1) {
-      const attempt = await dispatchChannel(event, channel, this.transportOptions);
-      attempt.attempt = index + 1;
-      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
-        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
-      }
-      attempts.push(attempt);
-      if (attempt.status !== "failed")
-        break;
-      if (attempt.nextBackoffMs)
-        await Bun.sleep(attempt.nextBackoffMs);
+  close() {
+    this.db.close();
+  }
+  applyMigrations() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        id INTEGER PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      );
+    `);
+    for (let i = 0;i < SQLITE_MIGRATIONS.length; i += 1) {
+      const id = i + 1;
+      const applied = this.db.query("SELECT id FROM _migrations WHERE id = ?").get(id);
+      if (applied)
+        continue;
+      const migration = SQLITE_MIGRATIONS[i];
+      const apply = this.db.transaction(() => {
+        this.db.exec(migration);
+        this.db.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(id, now());
+      });
+      apply();
     }
-    return createDeliveryResult(event, channel, attempts);
   }
 }
-function redactPaths(event, paths, replacement = "[REDACTED]") {
-  if (paths.length === 0)
-    return event;
-  const copy = structuredClone(event);
-  for (const path of paths) {
-    setPath(copy, path, replacement);
+
+// src/machine.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { hostname } from "os";
+import { join as join2 } from "path";
+
+// src/slug.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var SLUG_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var DEFAULT_SLUG_LENGTH = 7;
+function randomToken(length = DEFAULT_SLUG_LENGTH) {
+  if (length < 1 || length > 128)
+    throw new Error("Token length must be between 1 and 128.");
+  const bytes = randomBytes2(length);
+  let out = "";
+  for (let i = 0;i < length; i += 1) {
+    out += SLUG_ALPHABET[bytes[i] % SLUG_ALPHABET.length];
   }
-  return copy;
+  return out;
 }
-function sanitizeChannelForOutput(channel) {
-  const copy = structuredClone(channel);
-  if (copy.webhook?.secret)
-    copy.webhook.secret = "[REDACTED]";
-  if (copy.command?.env) {
-    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
+function normalizeSlug(slug) {
+  const normalized = slug.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalized)
+    throw new Error("Slug is required.");
+  if (!/^[A-Za-z0-9_-]{1,96}$/.test(normalized)) {
+    throw new Error("Slug can only contain letters, numbers, underscores, and dashes.");
   }
-  return copy;
-}
-function sanitizeChannelsForOutput(channels) {
-  return channels.map(sanitizeChannelForOutput);
-}
-function redactSensitiveKeys(event, replacement = "[REDACTED]") {
-  return redactValue(event, replacement);
+  return normalized;
 }
-function shouldRedactKey(key) {
-  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+
+// src/machine.ts
+function getMachineId() {
+  const path = join2(ensureDataDir(), "machine-id");
+  if (existsSync2(path)) {
+    const existing = readFileSync2(path, "utf-8").trim();
+    if (existing)
+      return existing;
+  }
+  const safeHost = hostname().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const id = `${safeHost || "machine"}-${randomToken(8).toLowerCase()}`;
+  writeFileSync2(path, `${id}
+`);
+  return id;
 }
-function redactValue(value, replacement) {
-  if (Array.isArray(value))
-    return value.map((item) => redactValue(item, replacement));
-  if (!value || typeof value !== "object")
+
+// src/pg-store.ts
+function parseJsonObject(value) {
+  if (!value)
+    return {};
+  if (typeof value === "object" && !Array.isArray(value))
     return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
-  ]));
-}
-function setPath(input, path, replacement) {
-  const parts = path.split(".");
-  let cursor = input;
-  for (const part of parts.slice(0, -1)) {
-    const next = cursor[part];
-    if (!next || typeof next !== "object")
-      return;
-    cursor = next;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
   }
-  const last = parts.at(-1);
-  if (last && last in cursor)
-    cursor[last] = replacement;
 }
-function normalizeTime(value) {
-  if (!value)
-    return new Date().toISOString();
-  return value instanceof Date ? value.toISOString() : value;
+async function loadPgPool() {
+  const importer = new Function("specifier", "return import(specifier)");
+  const module = await importer("pg");
+  return module.Pool;
 }
-function normalizeRetryPolicy(policy) {
+function toPostgresSql(sql) {
+  let index = 0;
+  return sql.replace(/\?/g, () => `$${++index}`);
+}
+function createPgPoolConfig(connectionString, options = {}) {
+  const ssl = options.ssl ?? true;
   return {
-    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
-    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
-    multiplier: Math.max(1, policy?.multiplier ?? 2)
+    connectionString,
+    ...ssl ? { ssl: { rejectUnauthorized: true } } : { ssl: false }
   };
 }
-function parseJsonObject(value, fallback) {
-  if (!value)
-    return fallback;
-  const parsed = JSON.parse(value);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Expected a JSON object");
+
+class PgPoolAdapter {
+  pool;
+  constructor(pool) {
+    this.pool = pool;
   }
-  return parsed;
-}
-function parseHeaders(values) {
-  if (!values?.length)
-    return;
-  const headers = {};
-  for (const value of values) {
-    const separator = value.indexOf("=");
-    if (separator === -1)
-      throw new Error(`Invalid header, expected name=value: ${value}`);
-    headers[value.slice(0, separator)] = value.slice(separator + 1);
+  static async create(connectionString, options = {}) {
+    const Pool = await loadPgPool();
+    return new PgPoolAdapter(new Pool(createPgPoolConfig(connectionString, options)));
+  }
+  async get(sql, ...params) {
+    const result = await this.pool.query(toPostgresSql(sql), params);
+    return result.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(toPostgresSql(sql), params);
+    return result.rows;
+  }
+  async run(sql, ...params) {
+    return this.pool.query(toPostgresSql(sql), params);
+  }
+  async close() {
+    await this.pool.end();
   }
-  return headers;
 }
-function parseFilter(options) {
-  const filter2 = {};
-  if (options.source)
-    filter2.source = options.source;
-  if (options.type)
-    filter2.type = options.type;
-  if (options.subject)
-    filter2.subject = options.subject;
-  if (options.severity)
-    filter2.severity = options.severity;
-  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
-}
-function createClient(options) {
-  if (options.createClient)
-    return options.createClient();
-  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
-}
-function print(value, json, text) {
-  if (json)
-    console.log(JSON.stringify(value, null, 2));
-  else
-    console.log(text);
+function toIsoString(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  return String(value);
 }
-function hasJsonOption(options) {
-  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
+function nullableIso(value) {
+  if (value === null || value === undefined)
+    return null;
+  return toIsoString(value);
 }
-function wantsJson(actionOptions, command) {
-  return hasJsonOption(actionOptions) || hasJsonOption(command);
+function domainFromRow(row) {
+  return {
+    ...row,
+    default_domain: Boolean(row.default_domain),
+    synced_at: nullableIso(row.synced_at),
+    created_at: toIsoString(row.created_at),
+    updated_at: toIsoString(row.updated_at),
+    metadata: parseJsonObject(row.metadata)
+  };
 }
-function registerWebhookCommands(program, options) {
-  const webhooks = program.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
-    const timestamp = new Date().toISOString();
-    const channel = {
-      id: actionOptions.id,
-      name: actionOptions.name,
-      enabled: !actionOptions.disabled,
-      transport: actionOptions.transport,
-      filters: parseFilter(actionOptions),
-      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
-      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
-      createdAt: timestamp,
-      updatedAt: timestamp
-    };
-    if (actionOptions.transport === "webhook") {
-      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
-    } else if (actionOptions.transport === "command") {
-      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
-    } else {
-      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
-    }
-    const saved = await createClient(options).addChannel(channel);
-    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
-  });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    const channels = await createClient(options).listChannels();
-    if (wantsJson(actionOptions, command)) {
-      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
-      return;
-    }
-    if (!channels.length) {
-      console.log("No channels configured.");
-      return;
-    }
-    for (const channel of channels) {
-      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
-    }
-  });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const removed = await createClient(options).removeChannel(id);
-    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
-  });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
-    const result = await createClient(options).testChannel(id, {
-      source: options.source,
-      type: actionOptions.type,
-      subject: actionOptions.subject ?? id,
-      message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true })
-    });
-    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
-  });
-  return webhooks;
+function linkFromRow(row) {
+  return {
+    ...row,
+    active: Boolean(row.active),
+    expires_at: nullableIso(row.expires_at),
+    synced_at: nullableIso(row.synced_at),
+    created_at: toIsoString(row.created_at),
+    updated_at: toIsoString(row.updated_at),
+    metadata: parseJsonObject(row.metadata),
+    short_url: formatShortUrl(row.hostname, row.slug)
+  };
 }
-function registerEventCommands(program, options) {
-  const events = program.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
-  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
-    const result = await createClient(options).emit({
-      source: actionOptions.source ?? options.source,
-      type,
-      subject: actionOptions.subject,
-      severity: actionOptions.severity,
-      message: actionOptions.message,
-      dedupeKey: actionOptions.dedupeKey,
-      data: parseJsonObject(actionOptions.data, {}),
-      metadata: parseJsonObject(actionOptions.metadata, {})
-    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
-    print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
-  });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    let rows = await createClient(options).listEvents();
-    if (actionOptions.source)
-      rows = rows.filter((event) => event.source === actionOptions.source);
-    if (actionOptions.type)
-      rows = rows.filter((event) => event.type === actionOptions.type);
-    if (actionOptions.limit)
-      rows = rows.slice(-actionOptions.limit);
-    if (wantsJson(actionOptions, command)) {
-      console.log(JSON.stringify(rows, null, 2));
-      return;
-    }
-    if (!rows.length) {
-      console.log("No events recorded.");
-      return;
-    }
-    for (const event of rows)
-      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
-  });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
-    const result = await createClient(options).replay({
-      eventId: actionOptions.id,
-      source: actionOptions.source,
-      type: actionOptions.type,
-      dryRun: actionOptions.dryRun
-    });
-    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
-  });
-  return events;
+function validateDestinationUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid destination URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Destination URL must start with http:// or https://.");
+  }
+  return parsed.toString();
 }
-function registerEventsCommands(program, options) {
-  registerWebhookCommands(program, options);
-  registerEventCommands(program, options);
+function isoOrNull(input) {
+  if (!input)
+    return null;
+  const date = new Date(input);
+  if (Number.isNaN(date.getTime()))
+    throw new Error(`Invalid date: ${input}`);
+  return date.toISOString();
 }
-function parseNumber(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed))
-    throw new Error(`Expected a number, got ${value}`);
-  return parsed;
+function clickFromRow(row) {
+  return {
+    ...row,
+    clicked_at: toIsoString(row.clicked_at),
+    synced_at: nullableIso(row.synced_at),
+    created_at: toIsoString(row.created_at),
+    updated_at: toIsoString(row.updated_at),
+    metadata: parseJsonObject(row.metadata)
+  };
 }
-function collectValues(value, previous) {
-  previous.push(value);
-  return previous;
+function createKitPgAdapter(client) {
+  return {
+    async get(sql, ...params) {
+      return client.get(toPostgresSql(sql), params);
+    },
+    async all(sql, ...params) {
+      return client.many(toPostgresSql(sql), params);
+    },
+    async run(sql, ...params) {
+      return client.query(toPostgresSql(sql), params);
+    }
+  };
 }
 
-// node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
+class PgShortlinksStore {
+  pg;
+  constructor(pg) {
+    this.pg = pg;
   }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
+  static async fromConnectionString(connectionString, options = {}) {
+    return new PgShortlinksStore(await PgPoolAdapter.create(connectionString, options));
+  }
+  static fromQueryClient(client) {
+    return new PgShortlinksStore(createKitPgAdapter(client));
+  }
+  static async fromEnv(env = process.env) {
+    const connectionString = getShortlinksDatabaseUrl(env);
+    if (!connectionString) {
+      throw new Error("HASNA_SHORTLINKS_DATABASE_URL is required when shortlinks uses the postgres store");
     }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
+    return PgShortlinksStore.fromConnectionString(connectionString, { ssl: getShortlinksDatabaseSsl(env) });
   }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
+  async close() {
+    await this.pg.close?.();
+  }
+  async addDomain(input) {
+    const hostname2 = normalizeHostname(input.hostname);
+    const timestamp = now();
+    const machineId = getMachineId();
+    const existing = await this.getDomain(hostname2);
+    const id = existing?.id || makeId("dom");
+    if (input.defaultDomain) {
+      await this.pg.run("UPDATE domains SET default_domain = 0, updated_at = ? WHERE default_domain = 1", timestamp);
     }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    await this.pg.run(`
+      INSERT INTO domains (
+        id, hostname, provider, default_domain, cloudflare_zone_id, cloudflare_account_id,
+        cloudflare_worker_name, origin_url, notes, metadata, machine_id, synced_at, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
+      ON CONFLICT(hostname) DO UPDATE SET
+        provider = excluded.provider,
+        default_domain = excluded.default_domain,
+        cloudflare_zone_id = COALESCE(excluded.cloudflare_zone_id, domains.cloudflare_zone_id),
+        cloudflare_account_id = COALESCE(excluded.cloudflare_account_id, domains.cloudflare_account_id),
+        cloudflare_worker_name = COALESCE(excluded.cloudflare_worker_name, domains.cloudflare_worker_name),
+        origin_url = COALESCE(excluded.origin_url, domains.origin_url),
+        notes = COALESCE(excluded.notes, domains.notes),
+        metadata = excluded.metadata,
+        machine_id = excluded.machine_id,
+        synced_at = NULL,
+        updated_at = excluded.updated_at
+    `, id, hostname2, input.provider || existing?.provider || "manual", input.defaultDomain ?? existing?.default_domain ? 1 : 0, input.cloudflareZoneId || existing?.cloudflare_zone_id || null, input.cloudflareAccountId || existing?.cloudflare_account_id || null, input.cloudflareWorkerName || existing?.cloudflare_worker_name || null, input.originUrl || existing?.origin_url || null, input.notes || existing?.notes || null, JSON.stringify(input.metadata || existing?.metadata || {}), machineId, existing?.created_at || timestamp, timestamp);
+    return await this.getDomain(hostname2);
   }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
+  async listDomains() {
+    const rows = await this.pg.all(`
+      SELECT * FROM domains
+      ORDER BY default_domain DESC, hostname ASC
+    `);
+    return rows.map(domainFromRow);
   }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
+  async getDomain(hostnameOrId) {
+    const normalized = hostnameOrId.includes(".") || hostnameOrId.includes("://") ? normalizeHostname(hostnameOrId) : hostnameOrId;
+    const row = await this.pg.get(`
+      SELECT * FROM domains WHERE hostname = ? OR id = ? LIMIT 1
+    `, normalized, hostnameOrId);
+    return row ? domainFromRow(row) : null;
   }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
+  async getDefaultDomain() {
+    const row = await this.pg.get(`
+      SELECT * FROM domains ORDER BY default_domain DESC, created_at ASC LIMIT 1
+    `);
+    return row ? domainFromRow(row) : null;
   }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
+  async createLink(input) {
+    const domain = input.domain ? await this.getDomain(input.domain) : await this.getDefaultDomain();
+    if (!domain) {
+      throw new Error("No domain configured. Run `shortlinks domain add <domain> --default` first.");
     }
-    if (hasFlag("color=256")) {
-      return 2;
+    const destinationUrl = validateDestinationUrl(input.destinationUrl);
+    const timestamp = now();
+    const machineId = getMachineId();
+    const expiresAt = isoOrNull(input.expiresAt);
+    const slug = input.slug ? normalizeSlug(input.slug) : await this.generateAvailableSlug(domain.id, input.slugLength || DEFAULT_SLUG_LENGTH);
+    try {
+      await this.pg.run(`
+        INSERT INTO links (
+          id, domain_id, slug, destination_url, title, active, expires_at, metadata,
+          machine_id, synced_at, created_at, updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, 1, ?, ?, ?, NULL, ?, ?)
+      `, makeId("lnk"), domain.id, slug, destinationUrl, input.title || null, expiresAt, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("unique") || message.includes("duplicate")) {
+        throw new Error(`Slug already exists for ${domain.hostname}: ${slug}`);
+      }
+      throw error;
     }
+    return await this.getLink(domain.hostname, slug);
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+  async listLinks(options = {}) {
+    const params = [];
+    let where = "WHERE 1 = 1";
+    if (options.domain) {
+      where += " AND d.hostname = ?";
+      params.push(normalizeHostname(options.domain));
     }
-    return 1;
+    if (options.activeOnly)
+      where += " AND l.active = 1";
+    params.push(options.limit || 100);
+    const rows = await this.pg.all(`
+      SELECT l.*, d.hostname
+      FROM links l
+      JOIN domains d ON d.id = l.domain_id
+      ${where}
+      ORDER BY l.created_at DESC
+      LIMIT ?
+    `, ...params);
+    return rows.map(linkFromRow);
   }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
+  async getLink(domainOrSlug, maybeSlug) {
+    const slug = normalizeSlug(maybeSlug || domainOrSlug);
+    const params = [slug];
+    let domainClause = "";
+    if (maybeSlug) {
+      domainClause = "AND d.hostname = ?";
+      params.push(normalizeHostname(domainOrSlug));
     }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    const row = await this.pg.get(`
+      SELECT l.*, d.hostname
+      FROM links l
+      JOIN domains d ON d.id = l.domain_id
+      WHERE l.slug = ? ${domainClause}
+      ORDER BY d.default_domain DESC, l.created_at ASC
+      LIMIT 1
+    `, ...params);
+    return row ? linkFromRow(row) : null;
   }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
+  async totalStats() {
+    const row = await this.pg.get(`
+      SELECT
+        (SELECT COUNT(*)::int FROM domains) AS domains,
+        (SELECT COUNT(*)::int FROM links) AS links,
+        (SELECT COUNT(*)::int FROM clicks) AS clicks
+    `);
+    return row;
   }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
+  async resolve(hostname2, slug) {
+    const normalizedHost = normalizeHostname(hostname2);
+    const normalizedSlug = normalizeSlug(slug);
+    const row = await this.pg.get(`
+      SELECT l.*, d.hostname
+      FROM links l
+      JOIN domains d ON d.id = l.domain_id
+      WHERE d.hostname = ? AND l.slug = ?
+      LIMIT 1
+    `, normalizedHost, normalizedSlug);
+    if (row)
+      return linkFromRow(row);
+    const fallback = await this.pg.get(`
+      SELECT l.*, d.hostname
+      FROM links l
+      JOIN domains d ON d.id = l.domain_id
+      WHERE d.default_domain = 1 AND l.slug = ?
+      ORDER BY d.created_at ASC
+      LIMIT 1
+    `, normalizedSlug);
+    return fallback ? linkFromRow(fallback) : null;
   }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
+  async setLinkActive(domainOrSlug, maybeSlugOrActive, maybeActive) {
+    const active = typeof maybeSlugOrActive === "boolean" ? maybeSlugOrActive : Boolean(maybeActive);
+    const link = typeof maybeSlugOrActive === "boolean" ? await this.getLink(domainOrSlug) : await this.getLink(domainOrSlug, maybeSlugOrActive);
+    if (!link)
+      throw new Error("Link not found.");
+    const timestamp = now();
+    await this.pg.run(`
+      UPDATE links SET active = ?, updated_at = ?, synced_at = NULL WHERE id = ?
+    `, active ? 1 : 0, timestamp, link.id);
+    return await this.getLink(link.hostname, link.slug);
   }
-  if (env.TERM === "wezterm") {
-    return 3;
+  async deleteLink(domainOrSlug, maybeSlug) {
+    const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
+    if (!link)
+      throw new Error("Link not found.");
+    await this.pg.run("DELETE FROM links WHERE id = ?", link.id);
+    return link;
   }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
+  async recordClick(link, input = {}) {
+    const timestamp = now();
+    const machineId = getMachineId();
+    const ipHash = input.ip ? this.hashIp(input.ip) : null;
+    const id = makeId("clk");
+    await this.pg.run(`
+      INSERT INTO clicks (
+        id, link_id, domain_id, slug, clicked_at, ip_hash, user_agent, referer,
+        country, city, metadata, machine_id, synced_at, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
+    `, id, link.id, link.domain_id, link.slug, timestamp, ipHash, input.userAgent || null, input.referer || null, input.country || null, input.city || null, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
+    const row = await this.pg.get("SELECT * FROM clicks WHERE id = ?", id);
+    return clickFromRow(row);
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
+  async getStats(domainOrSlug, maybeSlug) {
+    const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
+    if (!link)
+      throw new Error("Link not found.");
+    const summary = await this.pg.get(`
+      SELECT COUNT(*)::int AS clicks, MAX(clicked_at) AS last_clicked_at FROM clicks WHERE link_id = ?
+    `, link.id);
+    const topReferrers = await this.pg.all(`
+      SELECT referer, COUNT(*)::int AS clicks
+      FROM clicks
+      WHERE link_id = ?
+      GROUP BY referer
+      ORDER BY clicks DESC
+      LIMIT 10
+    `, link.id);
+    const topUserAgents = await this.pg.all(`
+      SELECT user_agent, COUNT(*)::int AS clicks
+      FROM clicks
+      WHERE link_id = ?
+      GROUP BY user_agent
+      ORDER BY clicks DESC
+      LIMIT 10
+    `, link.id);
+    return {
+      link,
+      clicks: summary.clicks,
+      last_clicked_at: nullableIso(summary.last_clicked_at),
+      top_referrers: topReferrers,
+      top_user_agents: topUserAgents
+    };
   }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
+  hashIp(ip) {
+    return createHash("sha256").update(`${getClickSalt()}:${ip}`).digest("hex");
   }
-  if ("COLORTERM" in env) {
-    return 1;
+  async generateAvailableSlug(domainId, length) {
+    for (let attempt = 0;attempt < 32; attempt += 1) {
+      const slug = randomToken(length);
+      const exists = await this.pg.get(`
+        SELECT 1 FROM links WHERE domain_id = ? AND slug = ? LIMIT 1
+      `, domainId, slug);
+      if (!exists)
+        return slug;
+    }
+    throw new Error("Could not generate an unused slug after 32 attempts.");
   }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
 }
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
+async function applyPostgresMigrations(connectionString, migrations, options = {}) {
+  const Pool = await loadPgPool();
+  const pool = new Pool(createPgPoolConfig(connectionString, options));
+  const client = await pool.connect();
+  const run = (sql, ...params) => client.query(toPostgresSql(sql), params);
+  const get = async (sql, ...params) => {
+    const result = await run(sql, ...params);
+    return result.rows[0] ?? null;
+  };
+  const applied = [];
+  const skipped = [];
+  try {
+    await run("BEGIN");
+    await run(`
+      SELECT pg_advisory_xact_lock(hashtext(?))
+    `, "shortlinks:migrations");
+    await run(`
+      CREATE TABLE IF NOT EXISTS _shortlinks_migrations (
+        id INTEGER PRIMARY KEY,
+        service TEXT NOT NULL DEFAULT 'shortlinks',
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+    for (let i = 0;i < migrations.length; i += 1) {
+      const id = i + 1;
+      const existing = await get("SELECT id FROM _shortlinks_migrations WHERE id = ? LIMIT 1", id);
+      if (existing) {
+        skipped.push(id);
+        continue;
+      }
+      await run(migrations[i]);
+      await run("INSERT INTO _shortlinks_migrations (id, service, applied_at) VALUES (?, ?, now())", id, "shortlinks");
+      applied.push(id);
+    }
+    await run("COMMIT");
+    return { service: "shortlinks", applied, skipped };
+  } catch (error) {
+    try {
+      await run("ROLLBACK");
+    } catch {}
+    throw error;
+  } finally {
+    client.release();
+    await pool.end();
   }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
 }
 
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
+// src/store.ts
+import { createHash as createHash2 } from "crypto";
+function parseJsonObject2(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
   }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
 }
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
+function domainFromRow2(row) {
+  return {
+    ...row,
+    default_domain: Boolean(row.default_domain),
+    metadata: parseJsonObject2(row.metadata)
   };
 }
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
+function linkFromRow2(row) {
+  const config = loadConfig();
+  const publicBaseUrl = config.defaultDomain === row.hostname ? config.publicBaseUrl : undefined;
+  return {
+    ...row,
+    active: Boolean(row.active),
+    metadata: parseJsonObject2(row.metadata),
+    short_url: formatShortUrl(row.hostname, row.slug, publicBaseUrl)
   };
 }
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
+function clickFromRow2(row) {
   return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
+    ...row,
+    metadata: parseJsonObject2(row.metadata)
   };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// src/cli/index.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
-import { fileURLToPath } from "url";
-import { spawnSync as spawnSync3 } from "child_process";
-
-// src/store.ts
-import { createHash } from "crypto";
-
-// src/database.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-
-// src/config.ts
-import { existsSync as existsSync2, linkSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { randomBytes } from "crypto";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2, resolve } from "path";
-var SERVICE_NAME = "shortlinks";
-var DEFAULT_DATA_DIR = join2(homedir2(), ".hasna", SERVICE_NAME);
-function getDataDir() {
-  return resolve(process.env.SHORTLINKS_HOME || DEFAULT_DATA_DIR);
-}
-function ensureDataDir() {
-  const dir = getDataDir();
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function getConfigPath() {
-  return join2(ensureDataDir(), "config.json");
-}
-function getClickSaltPath() {
-  return join2(ensureDataDir(), "click-salt");
-}
-function getDatabasePath(explicitPath) {
-  if (explicitPath)
-    return resolve(explicitPath);
-  if (process.env.SHORTLINKS_DB)
-    return resolve(process.env.SHORTLINKS_DB);
-  return join2(ensureDataDir(), `${SERVICE_NAME}.db`);
 }
-function readClickSaltFile(path) {
+function validateDestinationUrl2(url) {
+  let parsed;
   try {
-    const saved = readFileSync(path, "utf-8").trim();
-    return saved || null;
+    parsed = new URL(url);
   } catch {
-    return null;
-  }
-}
-function clickSaltError(path, error) {
-  const detail = error instanceof Error ? error.message : String(error);
-  return new Error(`Could not initialize click salt at ${path}. Set SHORTLINKS_CLICK_SALT or fix data directory permissions. ${detail}`);
-}
-function getClickSalt() {
-  const explicit = process.env.SHORTLINKS_CLICK_SALT?.trim();
-  if (explicit)
-    return explicit;
-  const path = getClickSaltPath();
-  const saved = readClickSaltFile(path);
-  if (saved)
-    return saved;
-  const generated = randomBytes(32).toString("hex");
-  const tempPath = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  try {
-    writeFileSync(tempPath, `${generated}
-`, { flag: "wx", mode: 384 });
-    try {
-      linkSync(tempPath, path);
-      return generated;
-    } catch (error) {
-      const winner = readClickSaltFile(path);
-      if (winner)
-        return winner;
-      throw clickSaltError(path, error);
-    } finally {
-      try {
-        unlinkSync(tempPath);
-      } catch {}
-    }
-  } catch (error) {
-    const winner = readClickSaltFile(path);
-    if (winner)
-      return winner;
-    throw clickSaltError(path, error);
+    throw new Error(`Invalid destination URL: ${url}`);
   }
-}
-function loadConfig() {
-  const path = getConfigPath();
-  if (!existsSync2(path))
-    return {};
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Destination URL must start with http:// or https://.");
   }
+  return parsed.toString();
 }
-function saveConfig(config) {
-  const path = getConfigPath();
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
-`);
-}
-function updateConfig(patch) {
-  const next = {
-    ...loadConfig(),
-    ...patch,
-    cloudflare: {
-      ...loadConfig().cloudflare,
-      ...patch.cloudflare
-    }
-  };
-  saveConfig(next);
-  return next;
+function isoOrNull2(input) {
+  if (!input)
+    return null;
+  const date = new Date(input);
+  if (Number.isNaN(date.getTime()))
+    throw new Error(`Invalid date: ${input}`);
+  return date.toISOString();
 }
-function normalizeHostname(input) {
-  const raw = input.trim().toLowerCase();
-  if (!raw)
-    throw new Error("Domain is required.");
-  const withProtocol = raw.includes("://") ? raw : `https://${raw}`;
-  let hostname;
-  try {
-    hostname = new URL(withProtocol).hostname;
-  } catch {
-    throw new Error(`Invalid domain: ${input}`);
-  }
-  hostname = hostname.replace(/\.$/, "");
-  const labels = hostname.split(".");
-  const labelsAreValid = labels.every((label) => label.length >= 1 && label.length <= 63 && /^[a-z0-9-]+$/.test(label) && !label.startsWith("-") && !label.endsWith("-"));
-  if (hostname.length > 253 || !labelsAreValid) {
-    throw new Error(`Invalid domain: ${input}`);
+
+class ShortlinksStore {
+  database;
+  constructor(dbPath) {
+    this.database = new ShortlinksDatabase(dbPath);
   }
-  return hostname;
-}
-function formatShortUrl(hostname, slug, publicBaseUrl) {
-  if (publicBaseUrl) {
-    const base = publicBaseUrl.endsWith("/") ? publicBaseUrl : `${publicBaseUrl}/`;
-    return new URL(slug, base).toString();
-  }
-  return `https://${hostname}/${slug}`;
-}
-
-// src/database.ts
-function now2() {
-  return new Date().toISOString();
-}
-function makeId(prefix) {
-  const bytes = crypto.getRandomValues(new Uint8Array(12));
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `${prefix}_${hex}`;
-}
-var SQLITE_MIGRATIONS = [
-  `
-  CREATE TABLE IF NOT EXISTS domains (
-    id TEXT PRIMARY KEY,
-    hostname TEXT NOT NULL UNIQUE,
-    provider TEXT NOT NULL DEFAULT 'manual',
-    default_domain INTEGER NOT NULL DEFAULT 0,
-    cloudflare_zone_id TEXT,
-    cloudflare_account_id TEXT,
-    cloudflare_worker_name TEXT,
-    origin_url TEXT,
-    notes TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS links (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    destination_url TEXT NOT NULL,
-    title TEXT,
-    active INTEGER NOT NULL DEFAULT 1,
-    expires_at TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    UNIQUE(domain_id, slug)
-  );
-
-  CREATE TABLE IF NOT EXISTS clicks (
-    id TEXT PRIMARY KEY,
-    link_id TEXT NOT NULL REFERENCES links(id) ON DELETE CASCADE,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    clicked_at TEXT NOT NULL,
-    ip_hash TEXT,
-    user_agent TEXT,
-    referer TEXT,
-    country TEXT,
-    city TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_domains_hostname ON domains(hostname);
-  CREATE INDEX IF NOT EXISTS idx_domains_default ON domains(default_domain);
-  CREATE INDEX IF NOT EXISTS idx_links_domain_slug ON links(domain_id, slug);
-  CREATE INDEX IF NOT EXISTS idx_links_active ON links(active);
-  CREATE INDEX IF NOT EXISTS idx_links_updated ON links(updated_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_link ON clicks(link_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_domain ON clicks(domain_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_clicked_at ON clicks(clicked_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_updated ON clicks(updated_at);
-  `
-];
-
-class ShortlinksDatabase {
-  db;
-  path;
-  constructor(path) {
-    this.path = getDatabasePath(path);
-    mkdirSync2(dirname2(this.path), { recursive: true });
-    this.db = new Database(this.path);
-    this.db.exec("PRAGMA foreign_keys = ON;");
-    this.applyMigrations();
-  }
-  close() {
-    this.db.close();
-  }
-  applyMigrations() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS _migrations (
-        id INTEGER PRIMARY KEY,
-        applied_at TEXT NOT NULL
-      );
-    `);
-    for (let i = 0;i < SQLITE_MIGRATIONS.length; i += 1) {
-      const id = i + 1;
-      const applied = this.db.query("SELECT id FROM _migrations WHERE id = ?").get(id);
-      if (applied)
-        continue;
-      const migration = SQLITE_MIGRATIONS[i];
-      const apply = this.db.transaction(() => {
-        this.db.exec(migration);
-        this.db.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(id, now2());
-      });
-      apply();
-    }
-  }
-}
-
-// src/machine.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { hostname } from "os";
-import { join as join3 } from "path";
-
-// src/slug.ts
-import { randomBytes as randomBytes2 } from "crypto";
-var SLUG_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var DEFAULT_SLUG_LENGTH = 7;
-function randomToken(length = DEFAULT_SLUG_LENGTH) {
-  if (length < 1 || length > 128)
-    throw new Error("Token length must be between 1 and 128.");
-  const bytes = randomBytes2(length);
-  let out = "";
-  for (let i = 0;i < length; i += 1) {
-    out += SLUG_ALPHABET[bytes[i] % SLUG_ALPHABET.length];
-  }
-  return out;
-}
-function normalizeSlug(slug) {
-  const normalized = slug.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-  if (!normalized)
-    throw new Error("Slug is required.");
-  if (!/^[A-Za-z0-9_-]{1,96}$/.test(normalized)) {
-    throw new Error("Slug can only contain letters, numbers, underscores, and dashes.");
-  }
-  return normalized;
-}
-
-// src/machine.ts
-function getMachineId() {
-  const path = join3(ensureDataDir(), "machine-id");
-  if (existsSync3(path)) {
-    const existing = readFileSync2(path, "utf-8").trim();
-    if (existing)
-      return existing;
-  }
-  const safeHost = hostname().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  const id = `${safeHost || "machine"}-${randomToken(8).toLowerCase()}`;
-  writeFileSync2(path, `${id}
-`);
-  return id;
-}
-
-// src/store.ts
-function parseJsonObject2(value) {
-  if (!value)
-    return {};
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function domainFromRow(row) {
-  return {
-    ...row,
-    default_domain: Boolean(row.default_domain),
-    metadata: parseJsonObject2(row.metadata)
-  };
-}
-function linkFromRow(row) {
-  const config = loadConfig();
-  const publicBaseUrl = config.defaultDomain === row.hostname ? config.publicBaseUrl : undefined;
-  return {
-    ...row,
-    active: Boolean(row.active),
-    metadata: parseJsonObject2(row.metadata),
-    short_url: formatShortUrl(row.hostname, row.slug, publicBaseUrl)
-  };
-}
-function clickFromRow(row) {
-  return {
-    ...row,
-    metadata: parseJsonObject2(row.metadata)
-  };
-}
-function validateDestinationUrl(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`Invalid destination URL: ${url}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error("Destination URL must start with http:// or https://.");
-  }
-  return parsed.toString();
-}
-function isoOrNull(input) {
-  if (!input)
-    return null;
-  const date = new Date(input);
-  if (Number.isNaN(date.getTime()))
-    throw new Error(`Invalid date: ${input}`);
-  return date.toISOString();
-}
-
-class ShortlinksStore {
-  database;
-  constructor(dbPath) {
-    this.database = new ShortlinksDatabase(dbPath);
-  }
-  close() {
-    this.database.close();
+  close() {
+    this.database.close();
   }
   addDomain(input) {
     const hostname2 = normalizeHostname(input.hostname);
-    const timestamp = now2();
+    const timestamp = now();
     const machineId = getMachineId();
     const existing = this.getDomain(hostname2);
     const id = existing?.id || makeId("dom");
@@ -3651,14 +3042,14 @@ class ShortlinksStore {
       SELECT * FROM domains
       ORDER BY default_domain DESC, hostname ASC
     `).all();
-    return rows.map(domainFromRow);
+    return rows.map(domainFromRow2);
   }
   getDomain(hostnameOrId) {
     const normalized = hostnameOrId.includes(".") || hostnameOrId.includes("://") ? normalizeHostname(hostnameOrId) : hostnameOrId;
     const row = this.database.db.query(`
       SELECT * FROM domains WHERE hostname = ? OR id = ? LIMIT 1
     `).get(normalized, hostnameOrId);
-    return row ? domainFromRow(row) : null;
+    return row ? domainFromRow2(row) : null;
   }
   getDefaultDomain() {
     const config = loadConfig();
@@ -3670,17 +3061,17 @@ class ShortlinksStore {
     const row = this.database.db.query(`
       SELECT * FROM domains ORDER BY default_domain DESC, created_at ASC LIMIT 1
     `).get();
-    return row ? domainFromRow(row) : null;
+    return row ? domainFromRow2(row) : null;
   }
   createLink(input) {
     const domain = input.domain ? this.getDomain(input.domain) : this.getDefaultDomain();
     if (!domain) {
       throw new Error("No domain configured. Run `shortlinks domain add <domain> --default` first.");
     }
-    const destinationUrl = validateDestinationUrl(input.destinationUrl);
-    const timestamp = now2();
+    const destinationUrl = validateDestinationUrl2(input.destinationUrl);
+    const timestamp = now();
     const machineId = getMachineId();
-    const expiresAt = isoOrNull(input.expiresAt);
+    const expiresAt = isoOrNull2(input.expiresAt);
     const slug = input.slug ? normalizeSlug(input.slug) : this.generateAvailableSlug(domain.id, input.slugLength || DEFAULT_SLUG_LENGTH);
     try {
       this.database.db.query(`
@@ -3718,7 +3109,7 @@ class ShortlinksStore {
       ORDER BY l.created_at DESC
       LIMIT ?
     `).all(...params);
-    return rows.map(linkFromRow);
+    return rows.map(linkFromRow2);
   }
   getLink(domainOrSlug, maybeSlug) {
     const slug = normalizeSlug(maybeSlug || domainOrSlug);
@@ -3736,7 +3127,7 @@ class ShortlinksStore {
       ORDER BY d.default_domain DESC, l.created_at ASC
       LIMIT 1
     `).get(...params);
-    return row ? linkFromRow(row) : null;
+    return row ? linkFromRow2(row) : null;
   }
   resolve(hostname2, slug) {
     const normalizedSlug = normalizeSlug(slug);
@@ -3749,7 +3140,7 @@ class ShortlinksStore {
       LIMIT 1
     `).get(normalizedHost, normalizedSlug);
     if (row)
-      return linkFromRow(row);
+      return linkFromRow2(row);
     const fallback = this.getDefaultDomain();
     if (!fallback || fallback.hostname === normalizedHost)
       return null;
@@ -3760,7 +3151,7 @@ class ShortlinksStore {
     const link = typeof maybeSlugOrActive === "boolean" ? this.getLink(domainOrSlug) : this.getLink(domainOrSlug, maybeSlugOrActive);
     if (!link)
       throw new Error("Link not found.");
-    const timestamp = now2();
+    const timestamp = now();
     this.database.db.query(`
       UPDATE links SET active = ?, updated_at = ?, synced_at = NULL WHERE id = ?
     `).run(active ? 1 : 0, timestamp, link.id);
@@ -3774,7 +3165,7 @@ class ShortlinksStore {
     return link;
   }
   recordClick(link, input = {}) {
-    const timestamp = now2();
+    const timestamp = now();
     const machineId = getMachineId();
     const ipHash = input.ip ? this.hashIp(input.ip) : null;
     const id = makeId("clk");
@@ -3786,7 +3177,7 @@ class ShortlinksStore {
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
     `).run(id, link.id, link.domain_id, link.slug, timestamp, ipHash, input.userAgent || null, input.referer || null, input.country || null, input.city || null, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
     const row = this.database.db.query("SELECT * FROM clicks WHERE id = ?").get(id);
-    return clickFromRow(row);
+    return clickFromRow2(row);
   }
   getStats(domainOrSlug, maybeSlug) {
     const link = maybeSlug ? this.getLink(domainOrSlug, maybeSlug) : this.getLink(domainOrSlug);
@@ -3840,562 +3231,1647 @@ class ShortlinksStore {
     throw new Error("Could not generate an unused slug after 32 attempts.");
   }
   hashIp(ip) {
-    return createHash("sha256").update(`${getClickSalt()}:${ip}`).digest("hex");
+    return createHash2("sha256").update(`${getClickSalt()}:${ip}`).digest("hex");
   }
 }
 
-// src/pg-store.ts
-import { createHash as createHash2 } from "crypto";
-function parseJsonObject3(value) {
-  if (!value)
-    return {};
-  if (typeof value === "object" && !Array.isArray(value))
-    return value;
-  try {
-    const parsed = JSON.parse(String(value));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
+// src/server.ts
+var REDIRECT_ALLOW_HEADER = "GET, HEAD";
+function json(data, status = 200, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("content-type", "application/json; charset=utf-8");
+  return new Response(JSON.stringify(data, null, 2), {
+    status,
+    headers: responseHeaders
+  });
 }
-function toIsoString(value) {
-  if (value instanceof Date)
-    return value.toISOString();
-  return String(value);
+function getHost(request, fallback) {
+  const forwarded = request.headers.get("x-forwarded-host");
+  const host = forwarded || request.headers.get("host") || fallback || "";
+  return host.split(",")[0].trim().split(":")[0];
 }
-function nullableIso(value) {
-  if (value === null || value === undefined)
-    return null;
-  return toIsoString(value);
+function getClientIp(request) {
+  const forwarded = request.headers.get("x-forwarded-for");
+  if (forwarded)
+    return forwarded.split(",")[0].trim();
+  return request.headers.get("cf-connecting-ip") || request.headers.get("x-real-ip");
 }
-function domainFromRow2(row) {
-  return {
-    ...row,
-    default_domain: Boolean(row.default_domain),
-    synced_at: nullableIso(row.synced_at),
-    created_at: toIsoString(row.created_at),
-    updated_at: toIsoString(row.updated_at),
-    metadata: parseJsonObject3(row.metadata)
+function isExpired(link) {
+  return Boolean(link.expires_at && new Date(link.expires_at).getTime() <= Date.now());
+}
+function logRecordClickError(link) {
+  console.error(`[shortlinks] Click analytics recording failed for ${link.hostname}/${link.slug}.`);
+}
+function createShortlinksHandler(options = {}) {
+  const store = options.store || new ShortlinksStore(options.dbPath);
+  const redirectStatus = options.redirectStatus || 302;
+  return async (request) => {
+    const url = new URL(request.url);
+    if (url.pathname === "/healthz") {
+      return json({ ok: true, service: "shortlinks", stats: await store.totalStats() });
+    }
+    if (url.pathname === "/" || url.pathname === "") {
+      return json({ service: "shortlinks", ok: true });
+    }
+    let slug = "";
+    try {
+      slug = decodeURIComponent(url.pathname.replace(/^\/+/, "").split("/")[0] || "");
+    } catch {
+      return json({ error: "Invalid slug." }, 400);
+    }
+    if (!slug)
+      return json({ error: "Missing slug." }, 404);
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      return json({ error: "Method not allowed." }, 405, { allow: REDIRECT_ALLOW_HEADER });
+    }
+    const host = getHost(request, options.defaultHost);
+    if (!host)
+      return json({ error: "Missing Host header." }, 400);
+    let link = null;
+    try {
+      link = await store.resolve(host, slug);
+    } catch {
+      return json({ error: "Shortlink not found.", slug, host }, 404);
+    }
+    if (!link)
+      return json({ error: "Shortlink not found.", slug, host }, 404);
+    if (!link.active)
+      return json({ error: "Shortlink is disabled.", slug, host }, 410);
+    if (isExpired(link))
+      return json({ error: "Shortlink is expired.", slug, host }, 410);
+    if (request.method === "GET") {
+      try {
+        await store.recordClick(link, {
+          ip: getClientIp(request),
+          userAgent: request.headers.get("user-agent"),
+          referer: request.headers.get("referer"),
+          country: request.headers.get("cf-ipcountry"),
+          metadata: {
+            path: url.pathname,
+            query: url.search
+          }
+        });
+      } catch (error) {
+        if (options.onRecordClickError) {
+          try {
+            await options.onRecordClickError(error, { link, request });
+          } catch {
+            logRecordClickError(link);
+          }
+        } else {
+          logRecordClickError(link);
+        }
+      }
+    }
+    return Response.redirect(link.destination_url, redirectStatus);
   };
 }
-function linkFromRow2(row) {
+function serveShortlinks(options = {}) {
+  const host = options.host || "127.0.0.1";
+  const port = options.port || 8787;
+  const fetch2 = createShortlinksHandler(options);
+  return Bun.serve({ hostname: host, port, fetch: fetch2 });
+}
+
+// src/cloudflare.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+function createCloudflarePlan(input) {
+  const hostname2 = normalizeHostname(input.hostname);
+  const target = normalizeHostname(input.target);
+  const workerName = input.workerName || "shortlinks";
+  const proxied = input.proxied ?? true;
   return {
-    ...row,
-    active: Boolean(row.active),
-    expires_at: nullableIso(row.expires_at),
-    synced_at: nullableIso(row.synced_at),
-    created_at: toIsoString(row.created_at),
-    updated_at: toIsoString(row.updated_at),
-    metadata: parseJsonObject3(row.metadata),
-    short_url: formatShortUrl(row.hostname, row.slug)
+    hostname: hostname2,
+    target,
+    proxied,
+    workerName,
+    origin: input.origin,
+    dnsRecord: {
+      type: "CNAME",
+      name: hostname2,
+      content: target,
+      proxied
+    },
+    wranglerCommand: `wrangler deploy cloudflare/${workerName}.js --name ${workerName}`
   };
 }
-function validateDestinationUrl2(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`Invalid destination URL: ${url}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error("Destination URL must start with http:// or https://.");
+function generateWorkerScript() {
+  return `export default {
+  async fetch(request, env) {
+    const origin = env.SHORTLINKS_ORIGIN;
+    if (!origin) {
+      return new Response("SHORTLINKS_ORIGIN is not configured", { status: 500 });
+    }
+
+    const incoming = new URL(request.url);
+    const upstream = new URL(incoming.pathname + incoming.search, origin);
+    const headers = new Headers(request.headers);
+    headers.set("x-forwarded-host", incoming.host);
+    headers.set("x-shortlinks-worker", "cloudflare");
+
+    return fetch(upstream.toString(), {
+      method: request.method,
+      headers,
+      body: request.method === "GET" || request.method === "HEAD" ? undefined : request.body,
+      redirect: "manual"
+    });
   }
-  return parsed.toString();
+};
+`;
 }
-function isoOrNull2(input) {
-  if (!input)
-    return null;
-  const date = new Date(input);
-  if (Number.isNaN(date.getTime()))
-    throw new Error(`Invalid date: ${input}`);
-  return date.toISOString();
+function writeWorkerFiles(options = {}) {
+  const outDir = options.outDir || "cloudflare";
+  const workerName = options.workerName || "shortlinks";
+  mkdirSync3(outDir, { recursive: true });
+  const workerPath = join3(outDir, `${workerName}.js`);
+  const wranglerPath = join3(outDir, "wrangler.example.toml");
+  writeFileSync3(workerPath, generateWorkerScript());
+  writeFileSync3(wranglerPath, `name = "${workerName}"
+main = "${workerName}.js"
+compatibility_date = "2026-05-01"
+
+[vars]
+SHORTLINKS_ORIGIN = "${options.origin || "https://shortlinks.example.com"}"
+`);
+  return { workerPath, wranglerPath };
 }
-function clickFromRow2(row) {
-  return {
-    ...row,
-    clicked_at: toIsoString(row.clicked_at),
-    synced_at: nullableIso(row.synced_at),
-    created_at: toIsoString(row.created_at),
-    updated_at: toIsoString(row.updated_at),
-    metadata: parseJsonObject3(row.metadata)
-  };
+function cloudflareAuthHeaders(token) {
+  const apiToken = token || process.env.CLOUDFLARE_API_TOKEN;
+  if (apiToken)
+    return { authorization: `Bearer ${apiToken}` };
+  const apiKey = process.env.CLOUDFLARE_API_KEY;
+  const email = process.env.CLOUDFLARE_EMAIL;
+  if (apiKey && email) {
+    return {
+      "x-auth-key": apiKey,
+      "x-auth-email": email
+    };
+  }
+  throw new Error("Cloudflare auth is required: set CLOUDFLARE_API_TOKEN, or CLOUDFLARE_API_KEY plus CLOUDFLARE_EMAIL.");
 }
-
-class PgShortlinksStore {
-  pg;
-  constructor(pg) {
-    this.pg = pg;
+async function cloudflareRequest(token, path, init = {}) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4${path}`, {
+    ...init,
+    headers: {
+      ...cloudflareAuthHeaders(token),
+      "content-type": "application/json",
+      ...init.headers || {}
+    }
+  });
+  const body = await response.json();
+  if (!response.ok || body.success === false) {
+    const message = body.errors?.map((e) => e.message).join("; ") || response.statusText;
+    throw new Error(`Cloudflare API failed: ${message}`);
   }
-  static async fromConnectionString(connectionString) {
-    const { PgAdapterAsync } = await import("@hasna/cloud");
-    return new PgShortlinksStore(new PgAdapterAsync(connectionString));
+  return body.result;
+}
+function candidateZones(hostname2) {
+  const parts = normalizeHostname(hostname2).split(".");
+  const candidates = [];
+  for (let i = 0;i < parts.length - 1; i += 1) {
+    candidates.push(parts.slice(i).join("."));
   }
-  static async fromCloud(service = "shortlinks") {
-    const { getConnectionString } = await import("@hasna/cloud");
-    return PgShortlinksStore.fromConnectionString(getConnectionString(service));
+  return candidates;
+}
+async function findCloudflareZoneId(hostname2, token) {
+  for (const zone of candidateZones(hostname2)) {
+    const result = await cloudflareRequest(token, `/zones?name=${encodeURIComponent(zone)}`);
+    if (result[0]?.id)
+      return result[0].id;
   }
-  async close() {
-    await this.pg.close?.();
+  throw new Error(`Could not find a Cloudflare zone for ${hostname2}. Pass --zone-id explicitly.`);
+}
+async function upsertCloudflareDnsRecord(options) {
+  const token = options.token || process.env.CLOUDFLARE_API_TOKEN;
+  const plan = createCloudflarePlan({
+    hostname: options.hostname,
+    target: options.target,
+    origin: process.env.SHORTLINKS_ORIGIN || "https://shortlinks.example.com",
+    proxied: options.proxied
+  });
+  if (options.dryRun)
+    return plan;
+  const zoneId = options.zoneId || await findCloudflareZoneId(plan.hostname, token);
+  const existing = await cloudflareRequest(token, `/zones/${zoneId}/dns_records?type=CNAME&name=${encodeURIComponent(plan.hostname)}`);
+  const payload = JSON.stringify(plan.dnsRecord);
+  if (existing[0]?.id) {
+    const updated = await cloudflareRequest(token, `/zones/${zoneId}/dns_records/${existing[0].id}`, {
+      method: "PUT",
+      body: payload
+    });
+    return { id: updated.id, action: "updated" };
   }
-  async addDomain(input) {
-    const hostname2 = normalizeHostname(input.hostname);
-    const timestamp = now2();
-    const machineId = getMachineId();
-    const existing = await this.getDomain(hostname2);
-    const id = existing?.id || makeId("dom");
-    if (input.defaultDomain) {
-      await this.pg.run("UPDATE domains SET default_domain = 0, updated_at = ? WHERE default_domain = 1", timestamp);
+  const created = await cloudflareRequest(token, `/zones/${zoneId}/dns_records`, {
+    method: "POST",
+    body: payload
+  });
+  return { id: created.id, action: "created" };
+}
+
+// node_modules/.pnpm/@hasna+events@0.1.13/node_modules/@hasna/events/dist/commander.js
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+import { createHmac, timingSafeEqual } from "crypto";
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+function getPathValue(input, path) {
+  return path.split(".").reduce((value, part) => {
+    if (value && typeof value === "object" && part in value) {
+      return value[part];
+    }
+    return;
+  }, input);
+}
+function getFieldValues(input, path) {
+  const values = [];
+  const push = (value) => {
+    if (!values.some((item) => Object.is(item, value)))
+      values.push(value);
+  };
+  if (path.includes(".") && path in input)
+    push(input[path]);
+  const nestedValue = getPathValue(input, path);
+  if (nestedValue !== undefined || !path.includes("."))
+    push(nestedValue);
+  return values;
+}
+function wildcardToRegExp(pattern, options = {}) {
+  let body = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        body += ".*";
+        index += 1;
+      } else {
+        body += options.segmentSafe ? "[^/]*" : ".*";
+      }
+    } else {
+      body += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
     }
-    await this.pg.run(`
-      INSERT INTO domains (
-        id, hostname, provider, default_domain, cloudflare_zone_id, cloudflare_account_id,
-        cloudflare_worker_name, origin_url, notes, metadata, machine_id, synced_at, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
-      ON CONFLICT(hostname) DO UPDATE SET
-        provider = excluded.provider,
-        default_domain = excluded.default_domain,
-        cloudflare_zone_id = COALESCE(excluded.cloudflare_zone_id, domains.cloudflare_zone_id),
-        cloudflare_account_id = COALESCE(excluded.cloudflare_account_id, domains.cloudflare_account_id),
-        cloudflare_worker_name = COALESCE(excluded.cloudflare_worker_name, domains.cloudflare_worker_name),
-        origin_url = COALESCE(excluded.origin_url, domains.origin_url),
-        notes = COALESCE(excluded.notes, domains.notes),
-        metadata = excluded.metadata,
-        machine_id = excluded.machine_id,
-        synced_at = NULL,
-        updated_at = excluded.updated_at
-    `, id, hostname2, input.provider || existing?.provider || "manual", input.defaultDomain ?? existing?.default_domain ? 1 : 0, input.cloudflareZoneId || existing?.cloudflare_zone_id || null, input.cloudflareAccountId || existing?.cloudflare_account_id || null, input.cloudflareWorkerName || existing?.cloudflare_worker_name || null, input.originUrl || existing?.origin_url || null, input.notes || existing?.notes || null, JSON.stringify(input.metadata || existing?.metadata || {}), machineId, existing?.created_at || timestamp, timestamp);
-    return await this.getDomain(hostname2);
   }
-  async listDomains() {
-    const rows = await this.pg.all(`
-      SELECT * FROM domains
-      ORDER BY default_domain DESC, hostname ASC
-    `);
-    return rows.map(domainFromRow2);
+  return new RegExp(`^${body}$`);
+}
+function matchString(value, matcher, options = {}) {
+  if (matcher === undefined)
+    return true;
+  if (value === undefined)
+    return false;
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.some((item) => wildcardToRegExp(item, options).test(value));
+}
+function matchRecord(input, matcher) {
+  if (!matcher)
+    return true;
+  return Object.entries(matcher).every(([path, expected]) => {
+    const actualValues = getFieldValues(input, path);
+    return matchField(actualValues, expected, path);
+  });
+}
+function matchField(actualValues, expected, path) {
+  if (isNegativeMatcher(expected)) {
+    return !actualValues.some((actual) => matchPositiveField(actual, expected.not, path));
   }
-  async getDomain(hostnameOrId) {
-    const normalized = hostnameOrId.includes(".") || hostnameOrId.includes("://") ? normalizeHostname(hostnameOrId) : hostnameOrId;
-    const row = await this.pg.get(`
-      SELECT * FROM domains WHERE hostname = ? OR id = ? LIMIT 1
-    `, normalized, hostnameOrId);
-    return row ? domainFromRow2(row) : null;
+  return actualValues.some((actual) => matchPositiveField(actual, expected, path));
+}
+function matchPositiveField(actual, expected, path) {
+  if (typeof expected === "string" || Array.isArray(expected)) {
+    return stringCandidates(actual).some((candidate) => matchString(candidate, expected, {
+      segmentSafe: path.endsWith("_path") || path.endsWith(".path")
+    }));
   }
-  async getDefaultDomain() {
-    const row = await this.pg.get(`
-      SELECT * FROM domains ORDER BY default_domain DESC, created_at ASC LIMIT 1
-    `);
-    return row ? domainFromRow2(row) : null;
+  if (Array.isArray(actual)) {
+    return actual.some((item) => item === expected);
   }
-  async createLink(input) {
-    const domain = input.domain ? await this.getDomain(input.domain) : await this.getDefaultDomain();
-    if (!domain) {
-      throw new Error("No domain configured. Run `shortlinks domain add <domain> --default` first.");
-    }
-    const destinationUrl = validateDestinationUrl2(input.destinationUrl);
-    const timestamp = now2();
-    const machineId = getMachineId();
-    const expiresAt = isoOrNull2(input.expiresAt);
-    const slug = input.slug ? normalizeSlug(input.slug) : await this.generateAvailableSlug(domain.id, input.slugLength || DEFAULT_SLUG_LENGTH);
-    try {
-      await this.pg.run(`
-        INSERT INTO links (
-          id, domain_id, slug, destination_url, title, active, expires_at, metadata,
-          machine_id, synced_at, created_at, updated_at
-        )
-        VALUES (?, ?, ?, ?, ?, 1, ?, ?, ?, NULL, ?, ?)
-      `, makeId("lnk"), domain.id, slug, destinationUrl, input.title || null, expiresAt, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("unique") || message.includes("duplicate")) {
-        throw new Error(`Slug already exists for ${domain.hostname}: ${slug}`);
-      }
-      throw error;
-    }
-    return await this.getLink(domain.hostname, slug);
+  return actual === expected;
+}
+function stringCandidates(actual) {
+  if (actual === undefined)
+    return [];
+  if (Array.isArray(actual)) {
+    return actual.flatMap((item) => isPrimitiveFieldValue(item) ? [String(item)] : []);
   }
-  async listLinks(options = {}) {
-    const params = [];
-    let where = "WHERE 1 = 1";
-    if (options.domain) {
-      where += " AND d.hostname = ?";
-      params.push(normalizeHostname(options.domain));
-    }
-    if (options.activeOnly)
-      where += " AND l.active = 1";
-    params.push(options.limit || 100);
-    const rows = await this.pg.all(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      ${where}
-      ORDER BY l.created_at DESC
-      LIMIT ?
-    `, ...params);
-    return rows.map(linkFromRow2);
+  return [String(actual)];
+}
+function isPrimitiveFieldValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isNegativeMatcher(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && "not" in value);
+}
+function eventMatchesFilter(event, filter) {
+  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
+}
+function channelMatchesEvent(channel, event) {
+  if (!channel.enabled)
+    return false;
+  if (!channel.filters || channel.filters.length === 0)
+    return true;
+  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
+}
+var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR";
+var HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME";
+function getEventsDataDir(override) {
+  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join4(homedir2(), ".hasna", "events");
+}
+function getActiveEventsDirEnv() {
+  if (process.env[HASNA_EVENTS_DIR_ENV])
+    return HASNA_EVENTS_DIR_ENV;
+  if (process.env[HASNA_EVENTS_HOME_ENV])
+    return HASNA_EVENTS_HOME_ENV;
+  return null;
+}
+
+class JsonEventsStore {
+  dataDir;
+  channelsPath;
+  eventsPath;
+  deliveriesPath;
+  constructor(dataDir = getEventsDataDir()) {
+    this.dataDir = dataDir;
+    this.channelsPath = join4(dataDir, "channels.json");
+    this.eventsPath = join4(dataDir, "events.json");
+    this.deliveriesPath = join4(dataDir, "deliveries.json");
   }
-  async getLink(domainOrSlug, maybeSlug) {
-    const slug = normalizeSlug(maybeSlug || domainOrSlug);
-    const params = [slug];
-    let domainClause = "";
-    if (maybeSlug) {
-      domainClause = "AND d.hostname = ?";
-      params.push(normalizeHostname(domainOrSlug));
+  async init() {
+    await mkdir(this.dataDir, { recursive: true, mode: 448 });
+    await chmod(this.dataDir, 448).catch(() => {
+      return;
+    });
+    await this.ensureArrayFile(this.channelsPath);
+    await this.ensureArrayFile(this.eventsPath);
+    await this.ensureArrayFile(this.deliveriesPath);
+  }
+  async addChannel(channel) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const index = channels.findIndex((item) => item.id === channel.id);
+    if (index >= 0) {
+      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
+    } else {
+      channels.push(channel);
     }
-    const row = await this.pg.get(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE l.slug = ? ${domainClause}
-      ORDER BY d.default_domain DESC, l.created_at ASC
-      LIMIT 1
-    `, ...params);
-    return row ? linkFromRow2(row) : null;
+    await this.writeJson(this.channelsPath, channels);
+    return index >= 0 ? channels[index] : channel;
   }
-  async totalStats() {
-    const row = await this.pg.get(`
-      SELECT
-        (SELECT COUNT(*)::int FROM domains) AS domains,
-        (SELECT COUNT(*)::int FROM links) AS links,
-        (SELECT COUNT(*)::int FROM clicks) AS clicks
-    `);
-    return row;
+  async listChannels() {
+    await this.init();
+    return this.readJson(this.channelsPath, []);
   }
-  async resolve(hostname2, slug) {
-    const normalizedHost = normalizeHostname(hostname2);
-    const normalizedSlug = normalizeSlug(slug);
-    const row = await this.pg.get(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE d.hostname = ? AND l.slug = ?
-      LIMIT 1
-    `, normalizedHost, normalizedSlug);
-    if (row)
-      return linkFromRow2(row);
-    const fallback = await this.pg.get(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE d.default_domain = 1 AND l.slug = ?
-      ORDER BY d.created_at ASC
-      LIMIT 1
-    `, normalizedSlug);
-    return fallback ? linkFromRow2(fallback) : null;
+  async getChannel(id) {
+    const channels = await this.listChannels();
+    return channels.find((channel) => channel.id === id);
   }
-  async setLinkActive(domainOrSlug, maybeSlugOrActive, maybeActive) {
-    const active = typeof maybeSlugOrActive === "boolean" ? maybeSlugOrActive : Boolean(maybeActive);
-    const link = typeof maybeSlugOrActive === "boolean" ? await this.getLink(domainOrSlug) : await this.getLink(domainOrSlug, maybeSlugOrActive);
-    if (!link)
-      throw new Error("Link not found.");
-    const timestamp = now2();
-    await this.pg.run(`
-      UPDATE links SET active = ?, updated_at = ?, synced_at = NULL WHERE id = ?
-    `, active ? 1 : 0, timestamp, link.id);
-    return await this.getLink(link.hostname, link.slug);
+  async removeChannel(id) {
+    await this.init();
+    const channels = await this.readJson(this.channelsPath, []);
+    const next = channels.filter((channel) => channel.id !== id);
+    await this.writeJson(this.channelsPath, next);
+    return next.length !== channels.length;
   }
-  async deleteLink(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    await this.pg.run("DELETE FROM links WHERE id = ?", link.id);
-    return link;
+  async appendEvent(event) {
+    await this.init();
+    const events = await this.readJson(this.eventsPath, []);
+    events.push(event);
+    await this.writeJson(this.eventsPath, events);
+    return event;
   }
-  async recordClick(link, input = {}) {
-    const timestamp = now2();
-    const machineId = getMachineId();
-    const ipHash = input.ip ? this.hashIp(input.ip) : null;
-    const id = makeId("clk");
-    await this.pg.run(`
-      INSERT INTO clicks (
-        id, link_id, domain_id, slug, clicked_at, ip_hash, user_agent, referer,
-        country, city, metadata, machine_id, synced_at, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
-    `, id, link.id, link.domain_id, link.slug, timestamp, ipHash, input.userAgent || null, input.referer || null, input.country || null, input.city || null, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
-    const row = await this.pg.get("SELECT * FROM clicks WHERE id = ?", id);
-    return clickFromRow2(row);
+  async listEvents() {
+    await this.init();
+    return this.readJson(this.eventsPath, []);
   }
-  async getStats(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? await this.getLink(domainOrSlug, maybeSlug) : await this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    const summary = await this.pg.get(`
-      SELECT COUNT(*)::int AS clicks, MAX(clicked_at) AS last_clicked_at FROM clicks WHERE link_id = ?
-    `, link.id);
-    const topReferrers = await this.pg.all(`
-      SELECT referer, COUNT(*)::int AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY referer
-      ORDER BY clicks DESC
-      LIMIT 10
-    `, link.id);
-    const topUserAgents = await this.pg.all(`
-      SELECT user_agent, COUNT(*)::int AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY user_agent
-      ORDER BY clicks DESC
-      LIMIT 10
-    `, link.id);
+  async findEventByIdentity(identity) {
+    const events = await this.listEvents();
+    return events.find((event) => identity.id !== undefined && event.id === identity.id || identity.dedupeKey !== undefined && event.dedupeKey === identity.dedupeKey);
+  }
+  async appendDelivery(result) {
+    await this.init();
+    const deliveries = await this.readJson(this.deliveriesPath, []);
+    deliveries.push(result);
+    await this.writeJson(this.deliveriesPath, deliveries);
+    return result;
+  }
+  async listDeliveries() {
+    await this.init();
+    return this.readJson(this.deliveriesPath, []);
+  }
+  async exportData() {
     return {
-      link,
-      clicks: summary.clicks,
-      last_clicked_at: nullableIso(summary.last_clicked_at),
-      top_referrers: topReferrers,
-      top_user_agents: topUserAgents
+      channels: await this.listChannels(),
+      events: await this.listEvents(),
+      deliveries: await this.listDeliveries()
     };
   }
-  hashIp(ip) {
-    return createHash2("sha256").update(`${getClickSalt()}:${ip}`).digest("hex");
+  async ensureArrayFile(path) {
+    if (!existsSync3(path)) {
+      await writeFile(path, `[]
+`, { encoding: "utf-8", mode: 384 });
+    }
+    await chmod(path, 384).catch(() => {
+      return;
+    });
   }
-  async generateAvailableSlug(domainId, length) {
-    for (let attempt = 0;attempt < 32; attempt += 1) {
-      const slug = randomToken(length);
-      const exists = await this.pg.get(`
-        SELECT 1 FROM links WHERE domain_id = ? AND slug = ? LIMIT 1
-      `, domainId, slug);
-      if (!exists)
-        return slug;
+  async readJson(path, fallback) {
+    try {
+      const raw = await readFile(path, "utf-8");
+      if (!raw.trim())
+        return fallback;
+      return JSON.parse(raw);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return fallback;
+      throw error;
     }
-    throw new Error("Could not generate an unused slug after 32 attempts.");
+  }
+  async writeJson(path, value) {
+    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf-8", mode: 384 });
+    await rename(tempPath, path);
+    await chmod(path, 384).catch(() => {
+      return;
+    });
   }
 }
-
-// src/server.ts
-var REDIRECT_ALLOW_HEADER = "GET, HEAD";
-function json(data, status = 200, headers) {
-  const responseHeaders = new Headers(headers);
-  responseHeaders.set("content-type", "application/json; charset=utf-8");
-  return new Response(JSON.stringify(data, null, 2), {
+async function getEventsStatus(dataDir) {
+  const store = new JsonEventsStore(dataDir);
+  await store.init();
+  const [channels, events, deliveries] = await Promise.all([
+    store.listChannels(),
+    store.listEvents(),
+    store.listDeliveries()
+  ]);
+  const transports = channels.reduce((counts, channel) => {
+    counts[channel.transport] = (counts[channel.transport] ?? 0) + 1;
+    return counts;
+  }, {});
+  return {
+    service: "events",
+    schemaVersion: "1.0",
+    dataDir: store.dataDir,
+    env: {
+      primary: HASNA_EVENTS_DIR_ENV,
+      fallback: HASNA_EVENTS_HOME_ENV,
+      active: getActiveEventsDirEnv()
+    },
+    files: {
+      channels: statusFile(store.dataDir, "channels.json", channels.length),
+      events: statusFile(store.dataDir, "events.json", events.length),
+      deliveries: statusFile(store.dataDir, "deliveries.json", deliveries.length)
+    },
+    counts: {
+      channels: channels.length,
+      enabledChannels: channels.filter((channel) => channel.enabled).length,
+      disabledChannels: channels.filter((channel) => !channel.enabled).length,
+      events: events.length,
+      deliveries: deliveries.length
+    },
+    transports,
+    safety: {
+      includesEventPayloads: false,
+      includesWebhookSecrets: false,
+      listOutputsRedactSecrets: true,
+      statusOutputIsMetadataOnly: true
+    }
+  };
+}
+function statusFile(dataDir, fileName, records) {
+  const path = join4(dataDir, fileName);
+  return { path, exists: existsSync3(path), records };
+}
+var DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
+function buildSignatureBase(timestamp, body) {
+  return `${timestamp}.${body}`;
+}
+function signPayload(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
+  return `sha256=${digest}`;
+}
+function now2() {
+  return new Date().toISOString();
+}
+function truncate(value, max = 4096) {
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+function buildWebhookRequest(event, channel) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const body = JSON.stringify(event);
+  const timestamp = event.time;
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@hasna/events",
+    "X-Hasna-Event-Id": event.id,
+    "X-Hasna-Event-Type": event.type,
+    "X-Hasna-Timestamp": timestamp,
+    ...channel.webhook.headers
+  };
+  if (channel.webhook.secret) {
+    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
+  }
+  return { body, headers };
+}
+async function dispatchWebhook(event, channel, options = {}) {
+  if (!channel.webhook)
+    throw new Error(`Channel ${channel.id} has no webhook config`);
+  const startedAt = now2();
+  const { body, headers } = buildWebhookRequest(event, channel);
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
+  try {
+    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const responseBody = truncate(await response.text());
+    return {
+      attempt: 1,
+      status: response.ok ? "success" : "failed",
+      startedAt,
+      completedAt: now2(),
+      responseStatus: response.status,
+      responseBody,
+      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      attempt: 1,
+      status: "failed",
+      startedAt,
+      completedAt: now2(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function dispatchCommand(event, channel) {
+  if (!channel.command)
+    throw new Error(`Channel ${channel.id} has no command config`);
+  const startedAt = now2();
+  const eventJson = JSON.stringify(event);
+  const env = {
+    ...process.env,
+    ...channel.command.env,
+    HASNA_CHANNEL_ID: channel.id,
+    HASNA_EVENT_ID: event.id,
+    HASNA_EVENT_TYPE: event.type,
+    HASNA_EVENT_SOURCE: event.source,
+    HASNA_EVENT_SUBJECT: event.subject ?? "",
+    HASNA_EVENT_SEVERITY: event.severity,
+    HASNA_EVENT_TIME: event.time,
+    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
+    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
+    HASNA_EVENT_JSON: eventJson
+  };
+  return new Promise((resolve2) => {
+    const child = spawn(channel.command.command, channel.command.args ?? [], {
+      cwd: channel.command.cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
+    child.stdin.end(eventJson);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve2({
+        attempt: 1,
+        status: "failed",
+        startedAt,
+        completedAt: now2(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: error.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const success = code === 0;
+      resolve2({
+        attempt: 1,
+        status: success ? "success" : "failed",
+        startedAt,
+        completedAt: now2(),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
+      });
+    });
+  });
+}
+async function dispatchChannel(event, channel, options = {}) {
+  if (channel.transport === "webhook")
+    return dispatchWebhook(event, channel, options);
+  if (channel.transport === "command")
+    return dispatchCommand(event, channel);
+  return {
+    attempt: 1,
+    status: "skipped",
+    startedAt: now2(),
+    completedAt: now2(),
+    error: `Unsupported transport: ${channel.transport}`
+  };
+}
+function createDeliveryResult(event, channel, attempts) {
+  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
+  return {
+    id: randomUUID(),
+    eventId: event.id,
+    channelId: channel.id,
+    transport: channel.transport,
     status,
-    headers: responseHeaders
+    attempts,
+    createdAt: attempts[0]?.startedAt ?? now2(),
+    completedAt: attempts.at(-1)?.completedAt ?? now2()
+  };
+}
+function createEvent(input) {
+  return {
+    id: input.id ?? randomUUID2(),
+    source: input.source,
+    type: input.type,
+    time: normalizeTime(input.time),
+    subject: input.subject,
+    severity: input.severity ?? "info",
+    data: input.data ?? {},
+    message: input.message,
+    dedupeKey: input.dedupeKey,
+    schemaVersion: input.schemaVersion ?? "1.0",
+    metadata: input.metadata ?? {}
+  };
+}
+
+class EventsClient {
+  store;
+  redactors;
+  transportOptions;
+  constructor(options = {}) {
+    this.store = options.store ?? new JsonEventsStore(options.dataDir);
+    this.redactors = options.redactors ?? [];
+    this.transportOptions = { fetchImpl: options.fetchImpl };
+  }
+  async addChannel(input) {
+    const timestamp = new Date().toISOString();
+    return this.store.addChannel({
+      ...input,
+      createdAt: input.createdAt ?? timestamp,
+      updatedAt: input.updatedAt ?? timestamp
+    });
+  }
+  async listChannels() {
+    return this.store.listChannels();
+  }
+  async removeChannel(id) {
+    return this.store.removeChannel(id);
+  }
+  async emit(input, options = {}) {
+    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
+    if (options.dedupe !== false) {
+      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
+      if (existing) {
+        return { event: existing, deliveries: [], deduped: true };
+      }
+    }
+    await this.store.appendEvent(event);
+    const deliveries = options.deliver === false ? [] : await this.deliver(event);
+    return { event, deliveries, deduped: false };
+  }
+  async listEvents() {
+    return this.store.listEvents();
+  }
+  async listDeliveries() {
+    return this.store.listDeliveries();
+  }
+  async deliver(event) {
+    const channels = await this.store.listChannels();
+    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
+    const deliveries = [];
+    for (const channel of selected) {
+      const eventForChannel = await this.applyRedaction(event, channel);
+      const result = await this.deliverWithRetry(eventForChannel, channel);
+      await this.store.appendDelivery(result);
+      deliveries.push(result);
+    }
+    return deliveries;
+  }
+  async matchChannel(id, input = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const event = createEvent({
+      source: input.source ?? "hasna.events",
+      type: input.type ?? "events.test",
+      subject: input.subject ?? id,
+      severity: input.severity ?? "info",
+      data: input.data ?? { test: true },
+      message: input.message ?? "Hasna events test delivery",
+      dedupeKey: input.dedupeKey,
+      schemaVersion: input.schemaVersion,
+      metadata: input.metadata,
+      time: input.time,
+      id: input.id
+    });
+    const matched = channelMatchesEvent(channel, event);
+    return {
+      channelId: channel.id,
+      matched,
+      event,
+      filters: channel.filters,
+      reason: matched ? undefined : channel.enabled ? "event did not match channel filters" : "channel is disabled"
+    };
+  }
+  async testChannel(id, input = {}, options = {}) {
+    const channel = await this.store.getChannel(id);
+    if (!channel)
+      throw new Error(`Channel not found: ${id}`);
+    const match = await this.matchChannel(id, input);
+    const event = match.event;
+    if (options.honorFilters && !match.matched) {
+      const timestamp = new Date().toISOString();
+      const result2 = createDeliveryResult(event, channel, [{
+        attempt: 1,
+        status: "skipped",
+        startedAt: timestamp,
+        completedAt: timestamp,
+        error: match.reason
+      }]);
+      result2.metadata = { reason: "filter_mismatch" };
+      await this.store.appendDelivery(result2);
+      return result2;
+    }
+    const eventForChannel = await this.applyRedaction(event, channel);
+    const result = await this.deliverWithRetry(eventForChannel, channel);
+    await this.store.appendDelivery(result);
+    return result;
+  }
+  async replay(options = {}) {
+    const events = (await this.store.listEvents()).filter((event) => {
+      if (options.eventId && event.id !== options.eventId)
+        return false;
+      if (options.source && event.source !== options.source)
+        return false;
+      if (options.type && event.type !== options.type)
+        return false;
+      return true;
+    });
+    if (options.dryRun)
+      return { events, deliveries: [] };
+    const deliveries = [];
+    for (const event of events) {
+      deliveries.push(...await this.deliver(event));
+    }
+    return { events, deliveries };
+  }
+  async applyRedaction(event, channel) {
+    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
+    for (const redactor of this.redactors) {
+      next = await redactor(next, channel);
+    }
+    return next;
+  }
+  async deliverWithRetry(event, channel) {
+    const policy = normalizeRetryPolicy(channel.retry);
+    const attempts = [];
+    for (let index = 0;index < policy.maxAttempts; index += 1) {
+      const attempt = await dispatchChannel(event, channel, this.transportOptions);
+      attempt.attempt = index + 1;
+      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
+        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
+      }
+      attempts.push(attempt);
+      if (attempt.status !== "failed")
+        break;
+      if (attempt.nextBackoffMs)
+        await Bun.sleep(attempt.nextBackoffMs);
+    }
+    return createDeliveryResult(event, channel, attempts);
+  }
+}
+function redactPaths(event, paths, replacement = "[REDACTED]") {
+  if (paths.length === 0)
+    return event;
+  const copy = structuredClone(event);
+  for (const path of paths) {
+    setPath(copy, path, replacement);
+  }
+  return copy;
+}
+function sanitizeChannelForOutput(channel) {
+  const copy = structuredClone(channel);
+  if (copy.webhook?.secret)
+    copy.webhook.secret = "[REDACTED]";
+  if (copy.command?.env) {
+    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
+  }
+  return copy;
+}
+function sanitizeChannelsForOutput(channels) {
+  return channels.map(sanitizeChannelForOutput);
+}
+function redactSensitiveKeys(event, replacement = "[REDACTED]") {
+  return redactValue(event, replacement);
+}
+function shouldRedactKey(key) {
+  return /secret|token|password|api[_-]?key|authorization/i.test(key);
+}
+function redactValue(value, replacement) {
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item, replacement));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
+  ]));
+}
+function setPath(input, path, replacement) {
+  const parts = path.split(".");
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const next = cursor[part];
+    if (!next || typeof next !== "object")
+      return;
+    cursor = next;
+  }
+  const last = parts.at(-1);
+  if (last && last in cursor)
+    cursor[last] = replacement;
+}
+function normalizeTime(value) {
+  if (!value)
+    return new Date().toISOString();
+  return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeRetryPolicy(policy) {
+  return {
+    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
+    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
+    multiplier: Math.max(1, policy?.multiplier ?? 2)
+  };
+}
+function parseFieldMatchers(values, label, typed = false) {
+  if (!values?.length)
+    return;
+  const result = {};
+  for (const value of values) {
+    const parsed = parseMatcherExpression(value, label);
+    const path = parsed.path;
+    if (path in result)
+      throw new Error(`Duplicate ${label} filter path: ${path}`);
+    const matcherValue = typed ? parseTypedMatcherValue(parsed.rawValue, label) : parsed.rawValue;
+    result[path] = parsed.negated ? { not: matcherValue } : matcherValue;
+  }
+  return result;
+}
+function parseFilterOptions(options) {
+  const filter2 = {};
+  if (options.source)
+    filter2.source = options.source;
+  if (options.type)
+    filter2.type = options.type;
+  if (options.subject)
+    filter2.subject = options.subject;
+  if (options.severity)
+    filter2.severity = options.severity;
+  const data = mergeMatchers(parseFieldMatchers(options.data, "data"), parseFieldMatchers(options.dataJson, "data-json", true));
+  const metadata = mergeMatchers(parseFieldMatchers(options.metadata, "metadata"), parseFieldMatchers(options.metadataJson, "metadata-json", true));
+  if (Object.keys(data).length > 0)
+    filter2.data = data;
+  if (Object.keys(metadata).length > 0)
+    filter2.metadata = metadata;
+  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
+}
+function mergeMatchers(...records) {
+  const result = {};
+  for (const record of records) {
+    if (!record)
+      continue;
+    for (const [path, value] of Object.entries(record)) {
+      if (path in result)
+        throw new Error(`Duplicate filter path: ${path}`);
+      result[path] = value;
+    }
+  }
+  return result;
+}
+function parseTypedMatcherValue(value, label) {
+  const parsed = JSON.parse(value);
+  if (parsed === null || typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean" || Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+    return parsed;
+  }
+  throw new Error(`${label} filter JSON values must be string, string[], number, boolean, or null`);
+}
+function parseMatcherExpression(value, label) {
+  const negativeSeparator = value.indexOf("!=");
+  if (negativeSeparator > 0) {
+    return {
+      path: value.slice(0, negativeSeparator),
+      rawValue: value.slice(negativeSeparator + 2),
+      negated: true
+    };
+  }
+  const separator = value.indexOf("=");
+  if (separator <= 0)
+    throw new Error(`Invalid ${label} filter, expected path=value or path!=value: ${value}`);
+  return {
+    path: value.slice(0, separator),
+    rawValue: value.slice(separator + 1),
+    negated: false
+  };
+}
+function parseJsonObject3(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object");
+  }
+  return parsed;
+}
+function parseHeaders(values) {
+  if (!values?.length)
+    return;
+  const headers = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    if (separator === -1)
+      throw new Error(`Invalid header, expected name=value: ${value}`);
+    headers[value.slice(0, separator)] = value.slice(separator + 1);
+  }
+  return headers;
+}
+function createClient(options) {
+  if (options.createClient)
+    return options.createClient();
+  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
+}
+function print(value, json2, text) {
+  if (json2)
+    console.log(JSON.stringify(value, null, 2));
+  else
+    console.log(text);
+}
+function hasJsonOption(options) {
+  return Boolean(options?.json || options?.opts?.().json || options?.optsWithGlobals?.().json || options?.parent?.opts?.().json || options?.parent?.optsWithGlobals?.().json);
+}
+function wantsJson(actionOptions, command) {
+  return hasJsonOption(actionOptions) || hasJsonOption(command);
+}
+function registerChannelCommands(program, options) {
+  const channels = program.command(options.channelsCommandName ?? "channels").description("Manage Hasna event channels");
+  channels.command("add").description("Add or replace a channel").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--data <path=value...>", "Event data field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--metadata <path=value...>", "Event metadata field filter; string values, path!=value negatives, array-member matching, dot paths, * segment wildcard, ** recursive wildcard", collectValues, []).option("--data-json <path=json...>", "Event data field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--metadata-json <path=json...>", "Event metadata field filter with typed JSON value; path!=json negatives supported", collectValues, []).option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions, command) => {
+    const timestamp = new Date().toISOString();
+    const channel = {
+      id: actionOptions.id,
+      name: actionOptions.name,
+      enabled: !actionOptions.disabled,
+      transport: actionOptions.transport,
+      filters: parseFilterOptions(actionOptions),
+      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
+      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    if (actionOptions.transport === "webhook") {
+      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
+    } else if (actionOptions.transport === "command") {
+      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
+    } else {
+      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
+    }
+    const saved = await createClient(options).addChannel(channel);
+    print(sanitizeChannelForOutput(saved), wantsJson(actionOptions, command), `Added ${saved.transport} channel ${saved.id}`);
+  });
+  channels.command("list").description("List configured channels").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const channels2 = await createClient(options).listChannels();
+    if (wantsJson(actionOptions, command)) {
+      console.log(JSON.stringify(sanitizeChannelsForOutput(channels2), null, 2));
+      return;
+    }
+    if (!channels2.length) {
+      console.log("No channels configured.");
+      return;
+    }
+    for (const channel of channels2) {
+      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
+    }
+  });
+  channels.command("status").description("Show events channel storage status").option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const status = await getEventsStatus(options.dataDir);
+    print(status, wantsJson(actionOptions, command), `events dataDir: ${status.dataDir}`);
+  });
+  channels.command("remove").description("Remove a channel").argument("<id>", "Channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const removed = await createClient(options).removeChannel(id);
+    print({ removed }, wantsJson(actionOptions, command), removed ? `Removed ${id}` : `Channel not found: ${id}`);
+  });
+  channels.command("test").description("Send a test event to one channel").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--honor-filters", "Skip delivery when the sample event does not match channel filters", false).option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const result = await createClient(options).testChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject3(actionOptions.data, { test: true }),
+      metadata: parseJsonObject3(actionOptions.metadata, {})
+    }, { honorFilters: actionOptions.honorFilters });
+    print(result, wantsJson(actionOptions, command), `${result.status}: ${result.channelId}`);
+  });
+  channels.command("match").description("Check whether a sample event matches one channel without delivering").argument("<id>", "Channel identifier").option("--source <source>", "Event source override").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events match preview").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions, command) => {
+    const result = await createClient(options).matchChannel(id, {
+      source: actionOptions.source ?? options.source,
+      type: actionOptions.type,
+      subject: actionOptions.subject ?? id,
+      message: actionOptions.message,
+      data: parseJsonObject3(actionOptions.data, { test: true }),
+      metadata: parseJsonObject3(actionOptions.metadata, {})
+    });
+    print(result, wantsJson(actionOptions, command), `${result.matched ? "matched" : "skipped"}: ${result.channelId}`);
+  });
+  return channels;
+}
+function registerEventCommands(program, options) {
+  const events = program.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
+  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions, command) => {
+    const result = await createClient(options).emit({
+      source: actionOptions.source ?? options.source,
+      type,
+      subject: actionOptions.subject,
+      severity: actionOptions.severity,
+      message: actionOptions.message,
+      dedupeKey: actionOptions.dedupeKey,
+      data: parseJsonObject3(actionOptions.data, {}),
+      metadata: parseJsonObject3(actionOptions.metadata, {})
+    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
+    print(result, wantsJson(actionOptions, command), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
+  });
+  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    let rows = await createClient(options).listEvents();
+    if (actionOptions.source)
+      rows = rows.filter((event) => event.source === actionOptions.source);
+    if (actionOptions.type)
+      rows = rows.filter((event) => event.type === actionOptions.type);
+    if (actionOptions.limit)
+      rows = rows.slice(-actionOptions.limit);
+    if (wantsJson(actionOptions, command)) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    if (!rows.length) {
+      console.log("No events recorded.");
+      return;
+    }
+    for (const event of rows)
+      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
+  });
+  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions, command) => {
+    const result = await createClient(options).replay({
+      eventId: actionOptions.id,
+      source: actionOptions.source,
+      type: actionOptions.type,
+      dryRun: actionOptions.dryRun
+    });
+    print(result, wantsJson(actionOptions, command), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
+  });
+  return events;
+}
+function registerEventsCommands(program, options) {
+  registerChannelCommands(program, options);
+  registerEventCommands(program, options);
+}
+function parseNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed))
+    throw new Error(`Expected a number, got ${value}`);
+  return parsed;
+}
+function collectValues(value, previous) {
+  previous.push(value);
+  return previous;
+}
+
+// node_modules/.pnpm/commander@13.1.0/node_modules/commander/esm.mjs
+var import__ = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  Command,
+  Argument,
+  Option,
+  Help
+} = import__.default;
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
   });
+  return styles;
 }
-function getHost(request, fallback) {
-  const forwarded = request.headers.get("x-forwarded-host");
-  const host = forwarded || request.headers.get("host") || fallback || "";
-  return host.split(",")[0].trim().split(":")[0];
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-function getClientIp(request) {
-  const forwarded = request.headers.get("x-forwarded-for");
-  if (forwarded)
-    return forwarded.split(",")[0].trim();
-  return request.headers.get("cf-connecting-ip") || request.headers.get("x-real-ip");
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
 }
-function isExpired(link) {
-  return Boolean(link.expires_at && new Date(link.expires_at).getTime() <= Date.now());
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
 }
-function logRecordClickError(link) {
-  console.error(`[shortlinks] Click analytics recording failed for ${link.hostname}/${link.slug}.`);
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
 }
-function createShortlinksHandler(options = {}) {
-  const store = options.store || new ShortlinksStore(options.dbPath);
-  const redirectStatus = options.redirectStatus || 302;
-  return async (request) => {
-    const url = new URL(request.url);
-    if (url.pathname === "/healthz") {
-      return json({ ok: true, service: "shortlinks", stats: await store.totalStats() });
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    if (url.pathname === "/" || url.pathname === "") {
-      return json({ service: "shortlinks", ok: true });
+    if (hasFlag("color=256")) {
+      return 2;
     }
-    let slug = "";
-    try {
-      slug = decodeURIComponent(url.pathname.replace(/^\/+/, "").split("/")[0] || "");
-    } catch {
-      return json({ error: "Invalid slug." }, 400);
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
-    if (!slug)
-      return json({ error: "Missing slug." }, 404);
-    if (request.method !== "GET" && request.method !== "HEAD") {
-      return json({ error: "Method not allowed." }, 405, { allow: REDIRECT_ALLOW_HEADER });
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
     }
-    const host = getHost(request, options.defaultHost);
-    if (!host)
-      return json({ error: "Missing Host header." }, 400);
-    let link = null;
-    try {
-      link = await store.resolve(host, slug);
-    } catch {
-      return json({ error: "Shortlink not found.", slug, host }, 404);
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
     }
-    if (!link)
-      return json({ error: "Shortlink not found.", slug, host }, 404);
-    if (!link.active)
-      return json({ error: "Shortlink is disabled.", slug, host }, 410);
-    if (isExpired(link))
-      return json({ error: "Shortlink is expired.", slug, host }, 410);
-    if (request.method === "GET") {
-      try {
-        await store.recordClick(link, {
-          ip: getClientIp(request),
-          userAgent: request.headers.get("user-agent"),
-          referer: request.headers.get("referer"),
-          country: request.headers.get("cf-ipcountry"),
-          metadata: {
-            path: url.pathname,
-            query: url.search
-          }
-        });
-      } catch (error) {
-        if (options.onRecordClickError) {
-          try {
-            await options.onRecordClickError(error, { link, request });
-          } catch {
-            logRecordClickError(link);
-          }
-        } else {
-          logRecordClickError(link);
-        }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
       }
     }
-    return Response.redirect(link.destination_url, redirectStatus);
-  };
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
 }
-function serveShortlinks(options = {}) {
-  const host = options.host || "127.0.0.1";
-  const port = options.port || 8787;
-  const fetch2 = createShortlinksHandler(options);
-  return Bun.serve({ hostname: host, port, fetch: fetch2 });
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
 }
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
 
-// src/cloudflare.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
-function createCloudflarePlan(input) {
-  const hostname2 = normalizeHostname(input.hostname);
-  const target = normalizeHostname(input.target);
-  const workerName = input.workerName || "shortlinks";
-  const proxied = input.proxied ?? true;
-  return {
-    hostname: hostname2,
-    target,
-    proxied,
-    workerName,
-    origin: input.origin,
-    dnsRecord: {
-      type: "CNAME",
-      name: hostname2,
-      content: target,
-      proxied
-    },
-    wranglerCommand: `wrangler deploy cloudflare/${workerName}.js --name ${workerName}`
-  };
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
 }
-function generateWorkerScript() {
-  return `export default {
-  async fetch(request, env) {
-    const origin = env.SHORTLINKS_ORIGIN;
-    if (!origin) {
-      return new Response("SHORTLINKS_ORIGIN is not configured", { status: 500 });
-    }
-
-    const incoming = new URL(request.url);
-    const upstream = new URL(incoming.pathname + incoming.search, origin);
-    const headers = new Headers(request.headers);
-    headers.set("x-forwarded-host", incoming.host);
-    headers.set("x-shortlinks-worker", "cloudflare");
 
-    return fetch(upstream.toString(), {
-      method: request.method,
-      headers,
-      body: request.method === "GET" || request.method === "HEAD" ? undefined : request.body,
-      redirect: "manual"
-    });
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
   }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
 };
-`;
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
 }
-function writeWorkerFiles(options = {}) {
-  const outDir = options.outDir || "cloudflare";
-  const workerName = options.workerName || "shortlinks";
-  mkdirSync3(outDir, { recursive: true });
-  const workerPath = join4(outDir, `${workerName}.js`);
-  const wranglerPath = join4(outDir, "wrangler.example.toml");
-  writeFileSync3(workerPath, generateWorkerScript());
-  writeFileSync3(wranglerPath, `name = "${workerName}"
-main = "${workerName}.js"
-compatibility_date = "2026-05-01"
-
-[vars]
-SHORTLINKS_ORIGIN = "${options.origin || "https://shortlinks.example.com"}"
-`);
-  return { workerPath, wranglerPath };
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
 }
-function cloudflareAuthHeaders(token) {
-  const apiToken = token || process.env.CLOUDFLARE_API_TOKEN;
-  if (apiToken)
-    return { authorization: `Bearer ${apiToken}` };
-  const apiKey = process.env.CLOUDFLARE_API_KEY;
-  const email = process.env.CLOUDFLARE_EMAIL;
-  if (apiKey && email) {
-    return {
-      "x-auth-key": apiKey,
-      "x-auth-email": email
-    };
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
   }
-  throw new Error("Cloudflare auth is required: set CLOUDFLARE_API_TOKEN, or CLOUDFLARE_API_KEY plus CLOUDFLARE_EMAIL.");
-}
-async function cloudflareRequest(token, path, init = {}) {
-  const response = await fetch(`https://api.cloudflare.com/client/v4${path}`, {
-    ...init,
-    headers: {
-      ...cloudflareAuthHeaders(token),
-      "content-type": "application/json",
-      ...init.headers || {}
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
     }
-  });
-  const body = await response.json();
-  if (!response.ok || body.success === false) {
-    const message = body.errors?.map((e) => e.message).join("; ") || response.statusText;
-    throw new Error(`Cloudflare API failed: ${message}`);
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
   }
-  return body.result;
-}
-function candidateZones(hostname2) {
-  const parts = normalizeHostname(hostname2).split(".");
-  const candidates = [];
-  for (let i = 0;i < parts.length - 1; i += 1) {
-    candidates.push(parts.slice(i).join("."));
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
   }
-  return candidates;
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
 }
-async function findCloudflareZoneId(hostname2, token) {
-  for (const zone of candidateZones(hostname2)) {
-    const result = await cloudflareRequest(token, `/zones?name=${encodeURIComponent(zone)}`);
-    if (result[0]?.id)
-      return result[0].id;
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
   }
-  throw new Error(`Could not find a Cloudflare zone for ${hostname2}. Pass --zone-id explicitly.`);
-}
-async function upsertCloudflareDnsRecord(options) {
-  const token = options.token || process.env.CLOUDFLARE_API_TOKEN;
-  const plan = createCloudflarePlan({
-    hostname: options.hostname,
-    target: options.target,
-    origin: process.env.SHORTLINKS_ORIGIN || "https://shortlinks.example.com",
-    proxied: options.proxied
-  });
-  if (options.dryRun)
-    return plan;
-  const zoneId = options.zoneId || await findCloudflareZoneId(plan.hostname, token);
-  const existing = await cloudflareRequest(token, `/zones/${zoneId}/dns_records?type=CNAME&name=${encodeURIComponent(plan.hostname)}`);
-  const payload = JSON.stringify(plan.dnsRecord);
-  if (existing[0]?.id) {
-    const updated = await cloudflareRequest(token, `/zones/${zoneId}/dns_records/${existing[0].id}`, {
-      method: "PUT",
-      body: payload
-    });
-    return { id: updated.id, action: "updated" };
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
   }
-  const created = await cloudflareRequest(token, `/zones/${zoneId}/dns_records`, {
-    method: "POST",
-    body: payload
-  });
-  return { id: created.id, action: "created" };
-}
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/cli/index.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+import { fileURLToPath } from "url";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/domains-cli.ts
 import { spawnSync } from "child_process";
@@ -4578,14 +5054,20 @@ function withStore(fn) {
 }
 function storeMode() {
   const opts = program2.opts();
-  const value = String(opts.cloud ? "cloud" : opts.store || process.env.SHORTLINKS_STORE || "local").toLowerCase();
-  if (value !== "local" && value !== "cloud")
-    throw new Error(`Unknown store mode: ${value}`);
-  return value;
+  return parseShortlinksStoreMode(opts.store || process.env.HASNA_SHORTLINKS_STORE || process.env.SHORTLINKS_STORE || "local");
+}
+function runtimeEnv() {
+  const opts = program2.opts();
+  return opts.store ? { ...process.env, HASNA_SHORTLINKS_STORE: opts.store } : process.env;
+}
+function localStatsIfDatabaseExists(dbPath) {
+  if (!existsSync4(dbPath))
+    return null;
+  return withStore((store) => store.totalStats());
 }
 async function withRuntimeStore(fn) {
-  if (storeMode() === "cloud") {
-    const store2 = await PgShortlinksStore.fromCloud("shortlinks");
+  if (storeMode() === "postgres") {
+    const store2 = await PgShortlinksStore.fromEnv();
     try {
       return await fn(store2);
     } finally {
@@ -4606,7 +5088,7 @@ function commandExists(command) {
   const result = spawnSync3("which", [command], { encoding: "utf-8" });
   return result.status === 0;
 }
-program2.name("shortlinks").description("CLI-only shortlink manager with custom domains, click tracking, Cloudflare helpers, and cloud sync").version(getPackageVersion()).option("--db <path>", "SQLite database path").option("--store <mode>", "Data store mode: cloud or local", process.env.SHORTLINKS_STORE || "local").option("--cloud", "Use the shortlinks PostgreSQL database directly").option("-j, --json", "Output JSON for agents and scripts");
+program2.name("shortlinks").description("CLI-only shortlink manager with custom domains, click tracking, Cloudflare helpers, and app-owned Postgres runtime support").version(getPackageVersion()).option("--db <path>", "SQLite database path").option("--store <mode>", "Data store mode: local or postgres", process.env.HASNA_SHORTLINKS_STORE || process.env.SHORTLINKS_STORE || "local").option("-j, --json", "Output JSON for agents and scripts");
 program2.command("init").description("Initialize local shortlinks storage").option("--domain <hostname>", "Add a default shortlink domain").option("--public-base-url <url>", "Public URL base for generated links").option("-j, --json", "Output JSON").action(async (opts) => {
   try {
     const result = await withRuntimeStore(async (store) => {
@@ -4866,9 +5348,9 @@ program2.command("stats [slug]").description("Show overall stats or stats for a
     handleError(error);
   }
 });
-program2.command("serve").description("Run the redirect server that records clicks").option("--host <host>", "Bind host", "127.0.0.1").option("--port <port>", "Port", "8787").option("--default-host <hostname>", "Fallback host if the request has no Host header").option("--cloud", "Serve directly from the shortlinks PostgreSQL database").action(async (opts) => {
+program2.command("serve").description("Run the redirect server that records clicks").option("--host <host>", "Bind host", "127.0.0.1").option("--port <port>", "Port", "8787").option("--default-host <hostname>", "Fallback host if the request has no Host header").action(async (opts) => {
   try {
-    const store = opts.cloud || storeMode() === "cloud" ? await PgShortlinksStore.fromCloud("shortlinks") : undefined;
+    const store = storeMode() === "postgres" ? await PgShortlinksStore.fromEnv() : undefined;
     const server = serveShortlinks({
       store,
       dbPath: program2.opts().db,
@@ -4876,7 +5358,7 @@ program2.command("serve").description("Run the redirect server that records clic
       port: Number(opts.port),
       defaultHost: opts.defaultHost
     });
-    const mode = store ? "cloud" : "local";
+    const mode = store ? "postgres" : "local";
     console.log(source_default.green(`shortlinks redirect server listening on http://${server.hostname}:${server.port} (${mode})`));
   } catch (error) {
     handleError(error);
@@ -4922,65 +5404,68 @@ cfCmd.command("dns <hostname>").description("Create or update the Cloudflare CNA
     handleError(error);
   }
 });
-var cloudCmd = program2.command("cloud").description("@hasna/cloud sync helpers");
-cloudCmd.command("migrate").description("Apply shortlinks PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("-j, --json", "Output JSON").action(async (opts) => {
+var postgresCmd = program2.command("postgres").description("Shortlinks-owned PostgreSQL runtime helpers");
+postgresCmd.command("migrate").description("Apply shortlinks PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("--no-ssl", "Disable PostgreSQL TLS only for local development").option("--dry-run", "Show migration settings without opening a network connection").option("-j, --json", "Output JSON").action(async (opts) => {
   try {
-    const { getConnectionString, applyPgMigrations } = await import("@hasna/cloud");
-    const conn = opts.connectionString || getConnectionString("shortlinks");
-    const result = await applyPgMigrations(conn, PG_MIGRATIONS, "shortlinks");
+    const conn = opts.connectionString || getShortlinksDatabaseUrl();
+    if (!conn)
+      throw new Error("HASNA_SHORTLINKS_DATABASE_URL or --connection-string is required.");
+    const ssl = opts.ssl === false ? false : getShortlinksDatabaseSsl();
+    if (opts.dryRun) {
+      const result2 = {
+        service: "shortlinks",
+        dry_run: true,
+        no_network: true,
+        database: {
+          configured: true,
+          redacted_url: redactDatabaseUrl(conn),
+          ssl
+        },
+        migrations: PG_MIGRATIONS.length
+      };
+      print2(result2, opts, () => console.log(JSON.stringify(result2, null, 2)));
+      return;
+    }
+    const result = await applyPostgresMigrations(conn, PG_MIGRATIONS, { ssl });
     print2(result, opts, () => console.log(JSON.stringify(result, null, 2)));
   } catch (error) {
     handleError(error);
   }
 });
-async function syncCloud(direction, opts) {
-  const {
-    getCloudConfig,
-    getConnectionString,
-    SqliteAdapter,
-    PgAdapterAsync,
-    listSqliteTables,
-    listPgTables,
-    syncPush,
-    syncPull
-  } = await import("@hasna/cloud");
-  const config = getCloudConfig();
-  if (config.mode === "local")
-    throw new Error("Cloud mode is local. Run `cloud setup` first.");
-  const local = new SqliteAdapter(getDatabasePath(program2.opts().db));
-  const remote = new PgAdapterAsync(getConnectionString("shortlinks"));
+postgresCmd.command("status").description("Show local and PostgreSQL runtime configuration health without opening network connections").option("-j, --json", "Output JSON").action((opts) => {
   try {
-    const requestedTables = opts.tables ? opts.tables.split(",").map((t) => t.trim()).filter(Boolean) : null;
-    const localTables = requestedTables || listSqliteTables(local).filter((t) => !t.startsWith("_"));
-    const remoteTables = requestedTables || await listPgTables(remote).catch(() => localTables);
-    const tables = [...new Set(direction === "pull" ? remoteTables : direction === "push" ? localTables : [...localTables, ...remoteTables])];
-    const results = [];
-    if (direction === "pull" || direction === "sync") {
-      results.push({ direction: "pull", tables: await syncPull(remote, local, { tables }) });
-    }
-    if (direction === "push" || direction === "sync") {
-      results.push({ direction: "push", tables: await syncPush(local, remote, { tables }) });
-    }
-    print2({ service: "shortlinks", results }, opts, () => console.log(JSON.stringify({ service: "shortlinks", results }, null, 2)));
-  } finally {
-    local.close?.();
-    await remote.close?.();
+    const dbPath = getDatabasePath(program2.opts().db);
+    const data = {
+      ...getShortlinksRuntimeStatus(runtimeEnv()),
+      service: "shortlinks",
+      db_path: dbPath,
+      db_exists: existsSync4(dbPath)
+    };
+    print2(data, opts, () => console.log(JSON.stringify(data, null, 2)));
+  } catch (error) {
+    handleError(error);
   }
-}
-for (const direction of ["push", "pull", "sync"]) {
-  cloudCmd.command(direction).description(`${direction === "sync" ? "Bidirectionally sync" : direction === "push" ? "Push" : "Pull"} shortlinks data ${direction === "pull" ? "from" : "to"} PostgreSQL`).option("--tables <tables>", "Comma-separated table names").option("-j, --json", "Output JSON").action((opts) => syncCloud(direction, opts).catch(handleError));
-}
-cloudCmd.command("status").description("Show local and cloud configuration health").option("-j, --json", "Output JSON").action(async (opts) => {
+});
+postgresCmd.command("plan").description("Render a dry-run PostgreSQL setup plan").option("--schema-sql", "Include migration SQL").option("-j, --json", "Output JSON").action((opts) => {
   try {
-    const { getCloudConfig } = await import("@hasna/cloud");
-    const stats = withStore((store) => store.totalStats());
-    const config = getCloudConfig();
+    const status = getShortlinksRuntimeStatus(runtimeEnv());
     const data = {
+      ok: status.ok,
       service: "shortlinks",
-      db_path: getDatabasePath(program2.opts().db),
-      local: stats,
-      cloud_mode: config.mode,
-      rds_host: config.rds?.host || null
+      dry_run: true,
+      no_network: true,
+      status,
+      postgres: {
+        required: status.mode === "postgres",
+        configured: status.database.configured,
+        schema_sql: opts.schemaSql ? PG_MIGRATIONS : []
+      },
+      steps: [
+        "Read local SQLite state",
+        status.mode === "postgres" ? "Prepare direct shortlinks Postgres runtime" : "Keep serving from local SQLite",
+        "Run migrations with shortlinks postgres migrate before serving from Postgres",
+        "Report planned changes without opening network connections"
+      ]
     };
     print2(data, opts, () => console.log(JSON.stringify(data, null, 2)));
   } catch (error) {
@@ -5025,23 +5510,26 @@ localCmd.command("setup <domain>").description("Record local domain mapping with
 });
 program2.command("doctor").description("Check local shortlinks tooling and integration readiness").option("-j, --json", "Output JSON").action(async (opts) => {
   try {
-    const mode = storeMode();
-    const stats = await withRuntimeStore((store) => store.totalStats());
+    const runtime = getShortlinksRuntimeStatus(runtimeEnv());
+    const dbPath = getDatabasePath(program2.opts().db);
     const data = {
       service: "shortlinks",
-      store: mode,
+      ok: runtime.ok,
+      store: runtime.mode,
       data_dir: getDataDir(),
       config_path: getConfigPath(),
-      db_path: getDatabasePath(program2.opts().db),
-      db_exists: existsSync4(getDatabasePath(program2.opts().db)),
-      stats,
+      db_path: dbPath,
+      db_exists: existsSync4(dbPath),
+      stats: localStatsIfDatabaseExists(dbPath),
+      runtime,
+      no_network: true,
       commands: {
         domains: commandExists("domains"),
-        cloud: commandExists("cloud"),
         wrangler: commandExists("wrangler"),
         secrets: commandExists("secrets")
       },
       environment: {
+        shortlinks_database_url_present: Boolean(getShortlinksDatabaseUrl(runtimeEnv())),
         cloudflare_api_token_present: Boolean(process.env.CLOUDFLARE_API_TOKEN),
         cloudflare_api_key_present: Boolean(process.env.CLOUDFLARE_API_KEY),
         cloudflare_email_present: Boolean(process.env.CLOUDFLARE_EMAIL),