@hasna/shortlinks 0.1.7 → 0.1.9

package/dist/local.d.ts

@@ -1,27 +0,0 @@
-export interface LocalSetupPlan {
-    domain: string;
-    targetHost: string;
-    port: number;
-    hostsEntry: string;
-    caddySnippet: string;
-    certPath: string;
-    keyPath: string;
-    machinesCommand: string;
-    sudoRequired: boolean;
-}
-export declare function createLocalSetupPlan(input: {
-    domain: string;
-    port?: number;
-    targetHost?: string;
-    certDir?: string;
-}): LocalSetupPlan;
-export declare function registerMachinesDns(input: {
-    domain: string;
-    port?: number;
-    targetHost?: string;
-}): {
-    command: string;
-    status: number | null;
-    stdout: string;
-    stderr: string;
-};

package/dist/machine.d.ts

@@ -1 +0,0 @@
-export declare function getMachineId(): string;

package/dist/pg-migrations.d.ts

@@ -1 +0,0 @@
-export declare const PG_MIGRATIONS: string[];

package/dist/server.d.ts

@@ -1,12 +0,0 @@
-import { ShortlinksStore } from "./store.js";
-export interface ShortlinksHandlerOptions {
-    store?: ShortlinksStore;
-    dbPath?: string;
-    defaultHost?: string;
-    redirectStatus?: 301 | 302 | 307 | 308;
-}
-export declare function createShortlinksHandler(options?: ShortlinksHandlerOptions): (request: Request) => Response | Promise<Response>;
-export declare function serveShortlinks(options?: ShortlinksHandlerOptions & {
-    host?: string;
-    port?: number;
-}): Bun.Server<undefined>;

package/dist/server.js

@@ -1,611 +0,0 @@
-// @bun
-// 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, mkdirSync, readFileSync, writeFileSync } from "fs";
-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 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 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 {};
-  }
-}
-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 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(/\.$/, "");
-  if (!/^[a-z0-9.-]+$/.test(hostname) || hostname.includes("..")) {
-    throw new Error(`Invalid domain: ${input}`);
-  }
-  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 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();
-  }
-  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();
-    }
-  }
-}
-
-// 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 } 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 = randomBytes(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 = 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;
-}
-
-// src/store.ts
-function parseJsonObject(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: parseJsonObject(row.metadata)
-  };
-}
-function linkFromRow(row) {
-  const config = loadConfig();
-  const publicBaseUrl = config.defaultDomain === row.hostname ? config.publicBaseUrl : undefined;
-  return {
-    ...row,
-    active: Boolean(row.active),
-    metadata: parseJsonObject(row.metadata),
-    short_url: formatShortUrl(row.hostname, row.slug, publicBaseUrl)
-  };
-}
-function clickFromRow(row) {
-  return {
-    ...row,
-    metadata: parseJsonObject(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();
-  }
-  addDomain(input) {
-    const hostname2 = normalizeHostname(input.hostname);
-    const timestamp = now();
-    const machineId = getMachineId();
-    const existing = this.getDomain(hostname2);
-    const id = existing?.id || makeId("dom");
-    if (input.defaultDomain) {
-      this.database.db.query("UPDATE domains SET default_domain = 0, updated_at = ?, synced_at = NULL").run(timestamp);
-      updateConfig({ defaultDomain: hostname2, publicBaseUrl: `https://${hostname2}` });
-    }
-    this.database.db.query(`
-      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
-    `).run(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 this.getDomain(hostname2);
-  }
-  listDomains() {
-    const rows = this.database.db.query(`
-      SELECT * FROM domains
-      ORDER BY default_domain DESC, hostname ASC
-    `).all();
-    return rows.map(domainFromRow);
-  }
-  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;
-  }
-  getDefaultDomain() {
-    const config = loadConfig();
-    if (config.defaultDomain) {
-      const configured = this.getDomain(config.defaultDomain);
-      if (configured)
-        return configured;
-    }
-    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;
-  }
-  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 = now();
-    const machineId = getMachineId();
-    const expiresAt = isoOrNull(input.expiresAt);
-    const slug = input.slug ? normalizeSlug(input.slug) : this.generateAvailableSlug(domain.id, input.slugLength || DEFAULT_SLUG_LENGTH);
-    try {
-      this.database.db.query(`
-        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, ?, ?)
-      `).run(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")) {
-        throw new Error(`Slug already exists for ${domain.hostname}: ${slug}`);
-      }
-      throw error;
-    }
-    return this.getLink(domain.hostname, slug);
-  }
-  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 = this.database.db.query(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      ${where}
-      ORDER BY l.created_at DESC
-      LIMIT ?
-    `).all(...params);
-    return rows.map(linkFromRow);
-  }
-  getLink(domainOrSlug, maybeSlug) {
-    const slug = normalizeSlug(maybeSlug || domainOrSlug);
-    const params = [slug];
-    let domainClause = "";
-    if (maybeSlug) {
-      domainClause = "AND d.hostname = ?";
-      params.push(normalizeHostname(domainOrSlug));
-    }
-    const row = this.database.db.query(`
-      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
-    `).get(...params);
-    return row ? linkFromRow(row) : null;
-  }
-  resolve(hostname2, slug) {
-    const normalizedSlug = normalizeSlug(slug);
-    const normalizedHost = normalizeHostname(hostname2);
-    const row = this.database.db.query(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE d.hostname = ? AND l.slug = ?
-      LIMIT 1
-    `).get(normalizedHost, normalizedSlug);
-    if (row)
-      return linkFromRow(row);
-    const fallback = this.getDefaultDomain();
-    if (!fallback || fallback.hostname === normalizedHost)
-      return null;
-    return this.getLink(fallback.hostname, normalizedSlug);
-  }
-  setLinkActive(domainOrSlug, maybeSlugOrActive, maybeActive) {
-    const active = typeof maybeSlugOrActive === "boolean" ? maybeSlugOrActive : Boolean(maybeActive);
-    const link = typeof maybeSlugOrActive === "boolean" ? this.getLink(domainOrSlug) : this.getLink(domainOrSlug, maybeSlugOrActive);
-    if (!link)
-      throw new Error("Link not found.");
-    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);
-    return this.getLink(link.hostname, link.slug);
-  }
-  deleteLink(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? this.getLink(domainOrSlug, maybeSlug) : this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    this.database.db.query("DELETE FROM links WHERE id = ?").run(link.id);
-    return link;
-  }
-  recordClick(link, input = {}) {
-    const timestamp = now();
-    const machineId = getMachineId();
-    const ipHash = input.ip ? this.hashIp(input.ip) : null;
-    const id = makeId("clk");
-    this.database.db.query(`
-      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, ?, ?)
-    `).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);
-  }
-  getStats(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? this.getLink(domainOrSlug, maybeSlug) : this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    const summary = this.database.db.query(`
-      SELECT COUNT(*) AS clicks, MAX(clicked_at) AS last_clicked_at FROM clicks WHERE link_id = ?
-    `).get(link.id);
-    const topReferrers = this.database.db.query(`
-      SELECT referer, COUNT(*) AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY referer
-      ORDER BY clicks DESC
-      LIMIT 10
-    `).all(link.id);
-    const topUserAgents = this.database.db.query(`
-      SELECT user_agent, COUNT(*) AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY user_agent
-      ORDER BY clicks DESC
-      LIMIT 10
-    `).all(link.id);
-    return {
-      link,
-      clicks: summary.clicks,
-      last_clicked_at: summary.last_clicked_at,
-      top_referrers: topReferrers,
-      top_user_agents: topUserAgents
-    };
-  }
-  totalStats() {
-    const row = this.database.db.query(`
-      SELECT
-        (SELECT COUNT(*) FROM domains) AS domains,
-        (SELECT COUNT(*) FROM links) AS links,
-        (SELECT COUNT(*) FROM clicks) AS clicks
-    `).get();
-    return row;
-  }
-  generateAvailableSlug(domainId, length) {
-    for (let attempt = 0;attempt < 32; attempt += 1) {
-      const slug = randomToken(length);
-      const exists = this.database.db.query(`
-        SELECT 1 FROM links WHERE domain_id = ? AND slug = ? LIMIT 1
-      `).get(domainId, slug);
-      if (!exists)
-        return slug;
-    }
-    throw new Error("Could not generate an unused slug after 32 attempts.");
-  }
-  hashIp(ip) {
-    const salt = process.env.SHORTLINKS_CLICK_SALT || "shortlinks-local";
-    return createHash("sha256").update(`${salt}:${ip}`).digest("hex");
-  }
-}
-
-// src/server.ts
-function json(data, status = 200) {
-  return new Response(JSON.stringify(data, null, 2), {
-    status,
-    headers: { "content-type": "application/json; charset=utf-8" }
-  });
-}
-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 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 isExpired(link) {
-  return Boolean(link.expires_at && new Date(link.expires_at).getTime() <= Date.now());
-}
-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: 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);
-    const host = getHost(request, options.defaultHost);
-    if (!host)
-      return json({ error: "Missing Host header." }, 400);
-    let link = null;
-    try {
-      link = 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);
-    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
-      }
-    });
-    return Response.redirect(link.destination_url, redirectStatus);
-  };
-}
-function serveShortlinks(options = {}) {
-  const host = options.host || "127.0.0.1";
-  const port = options.port || 8787;
-  const fetch = createShortlinksHandler(options);
-  return Bun.serve({ hostname: host, port, fetch });
-}
-export {
-  serveShortlinks,
-  createShortlinksHandler
-};

package/dist/slug.d.ts

@@ -1,4 +0,0 @@
-export declare const SLUG_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-export declare const DEFAULT_SLUG_LENGTH = 7;
-export declare function randomToken(length?: number): string;
-export declare function normalizeSlug(slug: string): string;

package/dist/store.d.ts

@@ -1,30 +0,0 @@
-import { ShortlinksDatabase } from "./database.js";
-import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
-export declare class ShortlinksStore {
-    readonly database: ShortlinksDatabase;
-    constructor(dbPath?: string);
-    close(): void;
-    addDomain(input: AddDomainInput): Domain;
-    listDomains(): Domain[];
-    getDomain(hostnameOrId: string): Domain | null;
-    getDefaultDomain(): Domain | null;
-    createLink(input: CreateLinkInput): Link;
-    listLinks(options?: {
-        domain?: string;
-        activeOnly?: boolean;
-        limit?: number;
-    }): Link[];
-    getLink(domainOrSlug: string, maybeSlug?: string): Link | null;
-    resolve(hostname: string, slug: string): Link | null;
-    setLinkActive(domainOrSlug: string, maybeSlugOrActive: string | boolean, maybeActive?: boolean): Link;
-    deleteLink(domainOrSlug: string, maybeSlug?: string): Link;
-    recordClick(link: Link, input?: ClickInput): Click;
-    getStats(domainOrSlug: string, maybeSlug?: string): LinkStats;
-    totalStats(): {
-        domains: number;
-        links: number;
-        clicks: number;
-    };
-    private generateAvailableSlug;
-    private hashIp;
-}