@hasna/shortlinks 0.1.18 → 0.1.19

package/dist/pg-store.d.ts

@@ -9,15 +9,13 @@ export declare class PgShortlinksStore {
     private readonly pg;
     constructor(pg: PgAdapterLike);
     static fromConnectionString(connectionString: string): Promise<PgShortlinksStore>;
-    static fromStorage(service?: string): Promise<PgShortlinksStore>;
-    static fromCloud: typeof PgShortlinksStore.fromStorage;
+    static fromCloud(service?: string): Promise<PgShortlinksStore>;
     close(): Promise<void>;
     addDomain(input: AddDomainInput): Promise<Domain>;
     listDomains(): Promise<Domain[]>;
     getDomain(hostnameOrId: string): Promise<Domain | null>;
     getDefaultDomain(): Promise<Domain | null>;
     createLink(input: CreateLinkInput): Promise<Link>;
-    consumeLinkUse(link: Link): Promise<Link | null>;
     listLinks(options?: {
         domain?: string;
         activeOnly?: boolean;

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import type { AddDomainInput, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
+import type { ClickInput, Link } from "./types.js";
 export interface ShortlinksRuntimeStore {
     totalStats(): {
         domains: number;
@@ -11,29 +11,12 @@ export interface ShortlinksRuntimeStore {
     }>;
     resolve(hostname: string, slug: string): Link | null | Promise<Link | null>;
     recordClick(link: Link, input?: ClickInput): unknown | Promise<unknown>;
-    consumeLinkUse?(link: Link): Link | null | Promise<Link | null>;
-    createLink?(input: CreateLinkInput): Link | Promise<Link>;
-    listLinks?(input?: {
-        domain?: string;
-        activeOnly?: boolean;
-        limit?: number;
-    }): Link[] | Promise<Link[]>;
-    getLink?(hostnameOrSlug: string, slug?: string): Link | null | Promise<Link | null>;
-    setLinkActive?(hostnameOrSlug: string, slugOrActive: string | boolean, maybeActive?: boolean): Link | Promise<Link>;
-    deleteLink?(hostnameOrSlug: string, slug?: string): Link | Promise<Link>;
-    getStats?(hostnameOrSlug: string, slug?: string): LinkStats | Promise<LinkStats>;
-    addDomain?(input: AddDomainInput): Domain | Promise<Domain>;
-    listDomains?(): Domain[] | Promise<Domain[]>;
-    getDomain?(hostname: string): Domain | null | Promise<Domain | null>;
 }
 export interface ShortlinksHandlerOptions {
     store?: ShortlinksRuntimeStore;
     dbPath?: string;
     defaultHost?: string;
     redirectStatus?: 301 | 302 | 307 | 308;
-    reservedPathPrefixes?: string[];
-    apiPathPrefix?: string;
-    apiToken?: string | null;
 }
 export declare function createShortlinksHandler(options?: ShortlinksHandlerOptions): (request: Request) => Response | Promise<Response>;
 export declare function serveShortlinks(options?: ShortlinksHandlerOptions & {

package/dist/server.js

@@ -49,16 +49,11 @@ function saveConfig(config) {
 `);
 }
 function updateConfig(patch) {
-  const current = loadConfig();
   const next = {
-    ...current,
+    ...loadConfig(),
     ...patch,
-    api: {
-      ...current.api,
-      ...patch.api
-    },
     cloudflare: {
-      ...current.cloudflare,
+      ...loadConfig().cloudflare,
       ...patch.cloudflare
     }
   };
@@ -161,10 +156,6 @@ var SQLITE_MIGRATIONS = [
   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);
-  `,
-  `
-  ALTER TABLE links ADD COLUMN max_uses INTEGER;
-  ALTER TABLE links ADD COLUMN used_count INTEGER NOT NULL DEFAULT 0;
   `
 ];
 
@@ -271,8 +262,6 @@ function linkFromRow(row) {
   return {
     ...row,
     active: Boolean(row.active),
-    max_uses: row.max_uses ?? null,
-    used_count: row.used_count ?? 0,
     metadata: parseJsonObject(row.metadata),
     short_url: formatShortUrl(row.hostname, row.slug, publicBaseUrl)
   };
@@ -303,13 +292,6 @@ function isoOrNull(input) {
     throw new Error(`Invalid date: ${input}`);
   return date.toISOString();
 }
-function normalizeMaxUses(value) {
-  if (value === null || value === undefined)
-    return null;
-  if (!Number.isInteger(value) || value <= 0)
-    throw new Error("maxUses must be a positive integer.");
-  return value;
-}
 
 class ShortlinksStore {
   database;
@@ -385,16 +367,15 @@ class ShortlinksStore {
     const timestamp = now();
     const machineId = getMachineId();
     const expiresAt = isoOrNull(input.expiresAt);
-    const maxUses = normalizeMaxUses(input.maxUses);
     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, max_uses, used_count, metadata,
+          id, domain_id, slug, destination_url, title, active, expires_at, metadata,
           machine_id, synced_at, created_at, updated_at
         )
-        VALUES (?, ?, ?, ?, ?, 1, ?, ?, 0, ?, ?, NULL, ?, ?)
-      `).run(makeId("lnk"), domain.id, slug, destinationUrl, input.title || null, expiresAt, maxUses, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
+        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")) {
@@ -404,19 +385,6 @@ class ShortlinksStore {
     }
     return this.getLink(domain.hostname, slug);
   }
-  consumeLinkUse(link) {
-    const timestamp = now();
-    const result = this.database.db.query(`
-      UPDATE links
-      SET used_count = used_count + 1, updated_at = ?, synced_at = NULL
-      WHERE id = ?
-        AND active = 1
-        AND (max_uses IS NULL OR used_count < max_uses)
-    `).run(timestamp, link.id);
-    if (result.changes === 0)
-      return null;
-    return this.getLink(link.hostname, link.slug);
-  }
   listLinks(options = {}) {
     const params = [];
     let where = "WHERE 1 = 1";
@@ -564,231 +532,15 @@ class ShortlinksStore {
 }
 
 // src/server.ts
-function json(data, status = 200) {
+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: { "content-type": "application/json; charset=utf-8" }
-  });
-}
-function htmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function publicErrorPage(input) {
-  const detail = input.detail ? `<p class="detail">${htmlEscape(input.detail)}</p>` : "";
-  const slug = input.slug ? `<p class="slug">${htmlEscape(input.slug)}</p>` : "";
-  const body = `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>${htmlEscape(input.title)} - Shortlink</title>
-  <style>
-    :root { color-scheme: light dark; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
-    body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: #f5f7f8; color: #172026; }
-    main { width: min(92vw, 520px); border: 1px solid #d7dee3; border-radius: 8px; background: #fff; padding: 28px; box-shadow: 0 18px 48px rgb(23 32 38 / 10%); }
-    .status { display: inline-flex; align-items: center; min-height: 28px; padding: 0 10px; border-radius: 999px; background: #eef2f5; color: #46545f; font-size: 13px; font-weight: 700; }
-    h1 { margin: 18px 0 10px; font-size: 24px; line-height: 1.2; letter-spacing: 0; }
-    p { margin: 0; color: #46545f; line-height: 1.55; }
-    .detail { margin-top: 12px; color: #6a7780; font-size: 14px; }
-    .slug { margin-top: 18px; padding: 10px 12px; border: 1px solid #d7dee3; border-radius: 6px; background: #fafbfc; color: #172026; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace; overflow-wrap: anywhere; }
-    @media (prefers-color-scheme: dark) {
-      body { background: #101417; color: #f4f7f8; }
-      main { background: #171d21; border-color: #2b363d; box-shadow: none; }
-      .status { background: #263139; color: #cbd5db; }
-      p { color: #bac6cc; }
-      .detail { color: #8c9aa3; }
-      .slug { background: #101417; border-color: #2b363d; color: #f4f7f8; }
-    }
-  </style>
-</head>
-<body>
-  <main>
-    <div class="status">${input.status}</div>
-    <h1>${htmlEscape(input.title)}</h1>
-    <p>${htmlEscape(input.message)}</p>
-    ${detail}
-    ${slug}
-  </main>
-</body>
-</html>`;
-  return new Response(body, {
-    status: input.status,
-    headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }
-  });
-}
-function publicShortlinkError(kind, slug, host) {
-  if (kind === "disabled") {
-    return publicErrorPage({
-      title: "This shortlink is disabled",
-      message: "The owner has turned this shortlink off.",
-      detail: "Ask the sender for a new link if you still need access.",
-      status: 410,
-      slug: slug ? `${host ?? ""}/${slug}` : undefined
-    });
-  }
-  if (kind === "expired") {
-    return publicErrorPage({
-      title: "This shortlink has expired",
-      message: "The owner set an expiration time for this shortlink, and it is no longer available.",
-      detail: "Ask the sender to create a fresh link.",
-      status: 410,
-      slug: slug ? `${host ?? ""}/${slug}` : undefined
-    });
-  }
-  if (kind === "used") {
-    return publicErrorPage({
-      title: "This shortlink has already been used",
-      message: "The owner limited how many times this shortlink can be opened, and that limit has been reached.",
-      detail: "Ask the sender for a new link if you still need access.",
-      status: 410,
-      slug: slug ? `${host ?? ""}/${slug}` : undefined
-    });
-  }
-  if (kind === "reserved") {
-    return publicErrorPage({
-      title: "This path is reserved",
-      message: "This address is reserved for another has.na feature.",
-      status: 404,
-      slug
-    });
-  }
-  if (kind === "invalid") {
-    return publicErrorPage({
-      title: "Invalid shortlink",
-      message: "This shortlink address is not valid.",
-      status: 400
-    });
-  }
-  if (kind === "missing") {
-    return publicErrorPage({
-      title: "Missing shortlink",
-      message: "No shortlink slug was provided.",
-      status: 404
-    });
-  }
-  return publicErrorPage({
-    title: "Shortlink not found",
-    message: "This shortlink does not exist or is no longer available.",
-    detail: "Check the address or ask the sender for a new link.",
-    status: 404,
-    slug: slug ? `${host ?? ""}/${slug}` : undefined
+    headers: responseHeaders
   });
 }
-function apiToken(options) {
-  return options.apiToken || process.env.SHORTLINKS_API_TOKEN || process.env.HASNA_SHORTLINKS_API_TOKEN || null;
-}
-function requestToken(request) {
-  const auth = request.headers.get("authorization") || "";
-  const bearer = auth.toLowerCase().startsWith("bearer ") ? auth.slice(7).trim() : "";
-  return bearer || request.headers.get("x-shortlinks-token") || request.headers.get("x-api-key");
-}
-function isAuthorized(request, options) {
-  const token = apiToken(options);
-  if (!token)
-    return true;
-  return requestToken(request) === token;
-}
-async function readJsonBody(request) {
-  try {
-    const parsed = await request.json();
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function requireMethod(store, method) {
-  const fn = store[method];
-  if (typeof fn !== "function")
-    throw new Error(`Store does not support ${String(method)}.`);
-  return fn.bind(store);
-}
-async function handleApi(request, apiPath, store, options) {
-  if (apiPath === "/health") {
-    return json({ ok: true, service: "shortlinks", api_auth_required: Boolean(apiToken(options)), stats: await store.totalStats() });
-  }
-  if (!isAuthorized(request, options))
-    return json({ error: "Unauthorized" }, 401);
-  const url = new URL(request.url);
-  const segments = apiPath.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
-  try {
-    if (apiPath === "/links" && request.method === "GET") {
-      const listLinks = requireMethod(store, "listLinks");
-      return json(await listLinks({
-        domain: url.searchParams.get("domain") || undefined,
-        activeOnly: url.searchParams.get("active") === "true",
-        limit: Number(url.searchParams.get("limit") || "100")
-      }));
-    }
-    if (apiPath === "/links" && request.method === "POST") {
-      const body = await readJsonBody(request);
-      const destinationUrl = String(body.destination_url || body.url || "");
-      if (!destinationUrl)
-        return json({ error: "destination_url is required" }, 400);
-      const createLink = requireMethod(store, "createLink");
-      return json(await createLink({
-        destinationUrl,
-        domain: typeof body.domain === "string" ? body.domain : undefined,
-        slug: typeof body.slug === "string" ? body.slug : undefined,
-        title: typeof body.title === "string" ? body.title : undefined,
-        expiresAt: typeof body.expires_at === "string" ? body.expires_at : typeof body.expires === "string" ? body.expires : undefined,
-        maxUses: typeof body.max_uses === "number" ? body.max_uses : typeof body.maxUses === "number" ? body.maxUses : undefined,
-        slugLength: typeof body.length === "number" ? body.length : undefined
-      }), 201);
-    }
-    if (segments[0] === "links" && segments[1] && request.method === "GET") {
-      const getLink = requireMethod(store, "getLink");
-      const domain = url.searchParams.get("domain") || undefined;
-      const link = domain ? await getLink(domain, segments[1]) : await getLink(segments[1]);
-      return link ? json(link) : json({ error: "Link not found." }, 404);
-    }
-    if (segments[0] === "links" && segments[1] && request.method === "DELETE") {
-      const deleteLink = requireMethod(store, "deleteLink");
-      const domain = url.searchParams.get("domain") || undefined;
-      return json(domain ? await deleteLink(domain, segments[1]) : await deleteLink(segments[1]));
-    }
-    if (segments[0] === "links" && segments[1] && segments[2] === "active" && request.method === "POST") {
-      const body = await readJsonBody(request);
-      const setLinkActive = requireMethod(store, "setLinkActive");
-      const domain = url.searchParams.get("domain") || undefined;
-      const active = Boolean(body.active);
-      return json(domain ? await setLinkActive(domain, segments[1], active) : await setLinkActive(segments[1], active));
-    }
-    if (apiPath === "/stats" && request.method === "GET") {
-      return json(await store.totalStats());
-    }
-    if (segments[0] === "stats" && segments[1] && request.method === "GET") {
-      const getStats = requireMethod(store, "getStats");
-      const domain = url.searchParams.get("domain") || undefined;
-      return json(domain ? await getStats(domain, segments[1]) : await getStats(segments[1]));
-    }
-    if (apiPath === "/domains" && request.method === "GET") {
-      const listDomains = requireMethod(store, "listDomains");
-      return json(await listDomains());
-    }
-    if (apiPath === "/domains" && request.method === "POST") {
-      const body = await readJsonBody(request);
-      const hostname2 = String(body.hostname || "");
-      if (!hostname2)
-        return json({ error: "hostname is required" }, 400);
-      const addDomain = requireMethod(store, "addDomain");
-      return json(await addDomain({
-        hostname: hostname2,
-        provider: typeof body.provider === "string" ? body.provider : "manual",
-        defaultDomain: Boolean(body.default_domain || body.default),
-        originUrl: typeof body.origin_url === "string" ? body.origin_url : undefined,
-        notes: typeof body.notes === "string" ? body.notes : undefined
-      }), 201);
-    }
-    if (segments[0] === "domains" && segments[1] && request.method === "GET") {
-      const getDomain = requireMethod(store, "getDomain");
-      const domain = await getDomain(segments[1]);
-      return domain ? json(domain) : json({ error: "Domain not found." }, 404);
-    }
-  } catch (error) {
-    return json({ error: error instanceof Error ? error.message : String(error) }, 400);
-  }
-  return json({ error: "Not found." }, 404);
-}
 function getHost(request, fallback) {
   const forwarded = request.headers.get("x-forwarded-host");
   const host = forwarded || request.headers.get("host") || fallback || "";
@@ -806,14 +558,8 @@ function isExpired(link) {
 function createShortlinksHandler(options = {}) {
   const store = options.store || new ShortlinksStore(options.dbPath);
   const redirectStatus = options.redirectStatus || 302;
-  const reservedPathPrefixes = new Set((options.reservedPathPrefixes ?? ["a"]).map((prefix) => prefix.toLowerCase()));
-  const apiPathPrefix = (options.apiPathPrefix || process.env.SHORTLINKS_API_PATH_PREFIX || "/api").replace(/\/+$/, "") || "/api";
   return async (request) => {
     const url = new URL(request.url);
-    if (url.pathname === apiPathPrefix || url.pathname.startsWith(`${apiPathPrefix}/`)) {
-      const apiPath = url.pathname.slice(apiPathPrefix.length) || "/";
-      return handleApi(request, apiPath, store, options);
-    }
     if (url.pathname === "/healthz") {
       return json({ ok: true, service: "shortlinks", stats: await store.totalStats() });
     }
@@ -824,55 +570,40 @@ function createShortlinksHandler(options = {}) {
     try {
       slug = decodeURIComponent(url.pathname.replace(/^\/+/, "").split("/")[0] || "");
     } catch {
-      return publicShortlinkError("invalid", "");
+      return json({ error: "Invalid slug." }, 400);
     }
     if (!slug)
-      return publicShortlinkError("missing", "");
-    if (reservedPathPrefixes.has(slug.toLowerCase())) {
-      return publicShortlinkError("reserved", 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 publicErrorPage({
-        title: "Invalid shortlink request",
-        message: "This request did not include a host name.",
-        status: 400
-      });
+      return json({ error: "Missing Host header." }, 400);
     let link = null;
     try {
       link = await store.resolve(host, slug);
     } catch {
-      return publicShortlinkError("not_found", slug, host);
+      return json({ error: "Shortlink not found.", slug, host }, 404);
     }
     if (!link)
-      return publicShortlinkError("not_found", slug, host);
+      return json({ error: "Shortlink not found.", slug, host }, 404);
     if (!link.active)
-      return publicShortlinkError("disabled", slug, host);
+      return json({ error: "Shortlink is disabled.", slug, host }, 410);
     if (isExpired(link))
-      return publicShortlinkError("expired", slug, host);
-    if (link.max_uses !== null && link.used_count >= link.max_uses) {
-      return publicShortlinkError("used", slug, host);
-    }
-    if (request.method.toUpperCase() === "HEAD") {
-      return new Response(null, {
-        status: redirectStatus,
-        headers: { location: link.destination_url }
+      return json({ error: "Shortlink is expired.", slug, host }, 410);
+    if (request.method === "GET") {
+      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
+        }
       });
     }
-    const consumed = store.consumeLinkUse ? await store.consumeLinkUse(link) : link;
-    if (!consumed) {
-      return publicShortlinkError("used", slug, host);
-    }
-    await store.recordClick(consumed, {
-      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);
   };
 }

package/dist/store.d.ts

@@ -9,7 +9,6 @@ export declare class ShortlinksStore {
     getDomain(hostnameOrId: string): Domain | null;
     getDefaultDomain(): Domain | null;
     createLink(input: CreateLinkInput): Link;
-    consumeLinkUse(link: Link): Link | null;
     listLinks(options?: {
         domain?: string;
         activeOnly?: boolean;

package/dist/types.d.ts

@@ -23,8 +23,6 @@ export interface Link {
     title: string | null;
     active: boolean;
     expires_at: string | null;
-    max_uses: number | null;
-    used_count: number;
     metadata: Record<string, unknown>;
     machine_id: string | null;
     synced_at: string | null;
@@ -68,7 +66,6 @@ export interface CreateLinkInput {
     slug?: string;
     title?: string;
     expiresAt?: string;
-    maxUses?: number | null;
     metadata?: Record<string, unknown>;
     slugLength?: number;
 }

package/infra/aws-ec2-user-data.sh

@@ -4,15 +4,9 @@ set -euo pipefail
 export AWS_REGION="${AWS_REGION:-us-east-1}"
 export SHORTLINKS_HOME="/var/lib/shortlinks"
 export SHORTLINKS_PACKAGE="@hasna/shortlinks@latest"
-export RDS_SECRET_ID="${RDS_SECRET_ID:-}"
-export RDS_HOST="${RDS_HOST:-}"
-export RDS_USERNAME="${RDS_USERNAME:-}"
-export SHORTLINKS_DOMAIN="${SHORTLINKS_DOMAIN:-}"
-export ATTACHMENTS_ORIGIN="${ATTACHMENTS_ORIGIN:-}"
-export SHORTLINKS_API_PATH_PREFIX="${SHORTLINKS_API_PATH_PREFIX:-/_shortlinks/api}"
-
-: "${RDS_SECRET_ID:?Set RDS_SECRET_ID to the AWS Secrets Manager secret for the PostgreSQL database_url}"
-: "${SHORTLINKS_DOMAIN:?Set SHORTLINKS_DOMAIN to the public host served by Caddy}"
+export RDS_SECRET_ID="rds!db-7a451ce6-83a9-40fa-b24a-81e5d5943511"
+export RDS_HOST="hasnaxyz-prod-opensource.c4limg0qgqvk.us-east-1.rds.amazonaws.com"
+export RDS_USERNAME="hasna_admin"
 
 dnf update -y
 dnf install -y awscli jq tar gzip shadow-utils libcap
@@ -21,29 +15,28 @@ if ! id shortlinks >/dev/null 2>&1; then
   useradd --system --create-home --home-dir "${SHORTLINKS_HOME}" --shell /sbin/nologin shortlinks
 fi
 
-install -d -o shortlinks -g shortlinks "${SHORTLINKS_HOME}/.hasna/shortlinks/storage"
+install -d -o shortlinks -g shortlinks "${SHORTLINKS_HOME}/.hasna/cloud"
 install -d -o shortlinks -g shortlinks "${SHORTLINKS_HOME}/.hasna/shortlinks"
 
-if [ -n "${RDS_HOST}" ] && [ -n "${RDS_USERNAME}" ]; then
-cat > "${SHORTLINKS_HOME}/.hasna/shortlinks/storage/config.json" <<CLOUD_CONFIG
+cat > "${SHORTLINKS_HOME}/.hasna/cloud/config.json" <<CLOUD_CONFIG
 {
   "rds": {
     "host": "${RDS_HOST}",
     "port": 5432,
     "username": "${RDS_USERNAME}",
-    "password_env": "SHORTLINKS_CLOUD_DATABASE_PASSWORD",
+    "password_env": "HASNA_RDS_PASSWORD",
     "ssl": true
   },
   "mode": "hybrid",
+  "feedback_endpoint": "https://feedback.hasna.com/api/v1/feedback",
   "auto_sync_interval_minutes": 0,
   "sync": {
     "schedule_minutes": 0
   }
 }
 CLOUD_CONFIG
-chown shortlinks:shortlinks "${SHORTLINKS_HOME}/.hasna/shortlinks/storage/config.json"
-chmod 600 "${SHORTLINKS_HOME}/.hasna/shortlinks/storage/config.json"
-fi
+chown shortlinks:shortlinks "${SHORTLINKS_HOME}/.hasna/cloud/config.json"
+chmod 600 "${SHORTLINKS_HOME}/.hasna/cloud/config.json"
 
 su -s /bin/bash shortlinks -c 'curl -fsSL https://bun.sh/install | bash'
 su -s /bin/bash shortlinks -c "${SHORTLINKS_HOME}/.bun/bin/bun install -g ${SHORTLINKS_PACKAGE} --no-cache"
@@ -57,22 +50,14 @@ export HOME="/var/lib/shortlinks"
 export PATH="/var/lib/shortlinks/.bun/bin:/usr/local/bin:/usr/bin:/bin"
 export NODE_TLS_REJECT_UNAUTHORIZED="0"
 
-: "${RDS_SECRET_ID:?Set RDS_SECRET_ID to the AWS Secrets Manager secret for the PostgreSQL database_url}"
-
 secret_json="$(aws secretsmanager get-secret-value \
   --region "${AWS_REGION}" \
-  --secret-id "${RDS_SECRET_ID}" \
+  --secret-id "rds!db-7a451ce6-83a9-40fa-b24a-81e5d5943511" \
   --query SecretString \
   --output text)"
 
-export HASNA_SHORTLINKS_DATABASE_URL
-HASNA_SHORTLINKS_DATABASE_URL="$(jq -r '.database_url // empty' <<<"${secret_json}")"
-if [ -n "${HASNA_SHORTLINKS_DATABASE_URL}" ]; then
-  export SHORTLINKS_DATABASE_URL="${HASNA_SHORTLINKS_DATABASE_URL}"
-else
-  export SHORTLINKS_CLOUD_DATABASE_PASSWORD
-  SHORTLINKS_CLOUD_DATABASE_PASSWORD="$(jq -r '.password // empty' <<<"${secret_json}")"
-fi
+export HASNA_RDS_PASSWORD
+HASNA_RDS_PASSWORD="$(jq -r '.password' <<<"${secret_json}")"
 
 exec "$@"
 RUNNER
@@ -81,16 +66,6 @@ chown root:shortlinks /usr/local/bin/shortlinks-env-exec
 
 su -s /bin/bash shortlinks -c 'PATH=/var/lib/shortlinks/.bun/bin:$PATH shortlinks --version'
 
-cat > /etc/default/shortlinks <<SHORTLINKS_ENV
-AWS_REGION=${AWS_REGION}
-RDS_SECRET_ID=${RDS_SECRET_ID}
-SHORTLINKS_DOMAIN=${SHORTLINKS_DOMAIN}
-SHORTLINKS_STORE=remote
-SHORTLINKS_API_PATH_PREFIX=${SHORTLINKS_API_PATH_PREFIX}
-SHORTLINKS_ENV
-chmod 640 /etc/default/shortlinks
-chown root:shortlinks /etc/default/shortlinks
-
 caddy_version="$(curl -fsSL https://api.github.com/repos/caddyserver/caddy/releases/latest | jq -r '.tag_name // "v2.10.2"' | sed 's/^v//')"
 case "$(uname -m)" in
   aarch64|arm64) caddy_arch="arm64" ;;
@@ -115,8 +90,8 @@ Group=shortlinks
 WorkingDirectory=/var/lib/shortlinks
 Environment=HOME=/var/lib/shortlinks
 Environment=PATH=/var/lib/shortlinks/.bun/bin:/usr/local/bin:/usr/bin:/bin
-EnvironmentFile=/etc/default/shortlinks
-ExecStart=/usr/local/bin/shortlinks-env-exec shortlinks serve --remote --host 127.0.0.1 --port 8787 --default-host ${SHORTLINKS_DOMAIN} --api-path-prefix ${SHORTLINKS_API_PATH_PREFIX}
+Environment=SHORTLINKS_STORE=cloud
+ExecStart=/usr/local/bin/shortlinks-env-exec shortlinks serve --cloud --host 127.0.0.1 --port 8787 --default-host has.na
 Restart=always
 RestartSec=5
 
@@ -148,36 +123,12 @@ WantedBy=multi-user.target
 SERVICE
 
 install -d /etc/caddy
-if [ -n "${ATTACHMENTS_ORIGIN}" ]; then
-cat > /etc/caddy/Caddyfile <<CADDY
-${SHORTLINKS_DOMAIN} {
-  encode zstd gzip
-
-  handle /a/* {
-    reverse_proxy ${ATTACHMENTS_ORIGIN}
-  }
-
-  handle /api/* {
-    reverse_proxy ${ATTACHMENTS_ORIGIN}
-  }
-
-  handle /_shortlinks/* {
-    reverse_proxy 127.0.0.1:8787
-  }
-
-  handle {
-    reverse_proxy 127.0.0.1:8787
-  }
-}
-CADDY
-else
-cat > /etc/caddy/Caddyfile <<CADDY
-${SHORTLINKS_DOMAIN} {
+cat > /etc/caddy/Caddyfile <<'CADDY'
+has.na {
   encode zstd gzip
   reverse_proxy 127.0.0.1:8787
 }
 CADDY
-fi
 
 systemctl daemon-reload
 systemctl enable shortlinks.service caddy.service