@hasna/shortlinks 0.1.0

package/dist/cloudflare.d.ts

@@ -0,0 +1,43 @@
+export interface CloudflareSetupPlan {
+    hostname: string;
+    target: string;
+    proxied: boolean;
+    workerName: string;
+    origin: string;
+    dnsRecord: {
+        type: "CNAME";
+        name: string;
+        content: string;
+        proxied: boolean;
+    };
+    wranglerCommand: string;
+}
+export interface CloudflareDnsOptions {
+    hostname: string;
+    target: string;
+    token?: string;
+    zoneId?: string;
+    proxied?: boolean;
+    dryRun?: boolean;
+}
+export declare function createCloudflarePlan(input: {
+    hostname: string;
+    target: string;
+    origin: string;
+    workerName?: string;
+    proxied?: boolean;
+}): CloudflareSetupPlan;
+export declare function generateWorkerScript(): string;
+export declare function writeWorkerFiles(options?: {
+    outDir?: string;
+    workerName?: string;
+    origin?: string;
+}): {
+    workerPath: string;
+    wranglerPath: string;
+};
+export declare function findCloudflareZoneId(hostname: string, token: string): Promise<string>;
+export declare function upsertCloudflareDnsRecord(options: CloudflareDnsOptions): Promise<CloudflareSetupPlan | {
+    id: string;
+    action: "created" | "updated";
+}>;

package/dist/cloudflare.js

@@ -0,0 +1,156 @@
+// @bun
+// src/cloudflare.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/config.ts
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var SERVICE_NAME = "shortlinks";
+var DEFAULT_DATA_DIR = join(homedir(), ".hasna", SERVICE_NAME);
+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;
+}
+
+// src/cloudflare.ts
+function createCloudflarePlan(input) {
+  const hostname = normalizeHostname(input.hostname);
+  const target = normalizeHostname(input.target);
+  const workerName = input.workerName || "shortlinks";
+  const proxied = input.proxied ?? true;
+  return {
+    hostname,
+    target,
+    proxied,
+    workerName,
+    origin: input.origin,
+    dnsRecord: {
+      type: "CNAME",
+      name: hostname,
+      content: target,
+      proxied
+    },
+    wranglerCommand: `wrangler deploy cloudflare/${workerName}.js --name ${workerName}`
+  };
+}
+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"
+    });
+  }
+};
+`;
+}
+function writeWorkerFiles(options = {}) {
+  const outDir = options.outDir || "cloudflare";
+  const workerName = options.workerName || "shortlinks";
+  mkdirSync(outDir, { recursive: true });
+  const workerPath = join2(outDir, `${workerName}.js`);
+  const wranglerPath = join2(outDir, "wrangler.example.toml");
+  writeFileSync(workerPath, generateWorkerScript());
+  writeFileSync(wranglerPath, `name = "${workerName}"
+main = "${workerName}.js"
+compatibility_date = "2026-05-01"
+
+[vars]
+SHORTLINKS_ORIGIN = "${options.origin || "https://shortlinks.example.com"}"
+`);
+  return { workerPath, wranglerPath };
+}
+async function cloudflareRequest(token, path, init = {}) {
+  const response = await fetch(`https://api.cloudflare.com/client/v4${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${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}`);
+  }
+  return body.result;
+}
+function candidateZones(hostname) {
+  const parts = normalizeHostname(hostname).split(".");
+  const candidates = [];
+  for (let i = 0;i < parts.length - 1; i += 1) {
+    candidates.push(parts.slice(i).join("."));
+  }
+  return candidates;
+}
+async function findCloudflareZoneId(hostname, token) {
+  for (const zone of candidateZones(hostname)) {
+    const result = await cloudflareRequest(token, `/zones?name=${encodeURIComponent(zone)}`);
+    if (result[0]?.id)
+      return result[0].id;
+  }
+  throw new Error(`Could not find a Cloudflare zone for ${hostname}. 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;
+  if (!token)
+    throw new Error("CLOUDFLARE_API_TOKEN is required unless --dry-run is used.");
+  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" };
+  }
+  const created = await cloudflareRequest(token, `/zones/${zoneId}/dns_records`, {
+    method: "POST",
+    body: payload
+  });
+  return { id: created.id, action: "created" };
+}
+export {
+  writeWorkerFiles,
+  upsertCloudflareDnsRecord,
+  generateWorkerScript,
+  findCloudflareZoneId,
+  createCloudflarePlan
+};

package/dist/cloudflare.test.d.ts

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

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+export declare const SERVICE_NAME = "shortlinks";
+export declare const DEFAULT_DATA_DIR: string;
+export interface ShortlinksConfig {
+    defaultDomain?: string;
+    publicBaseUrl?: string;
+    cloudflare?: {
+        accountId?: string;
+        workerName?: string;
+        origin?: string;
+    };
+}
+export declare function getDataDir(): string;
+export declare function ensureDataDir(): string;
+export declare function getConfigPath(): string;
+export declare function getDatabasePath(explicitPath?: string): string;
+export declare function loadConfig(): ShortlinksConfig;
+export declare function saveConfig(config: ShortlinksConfig): void;
+export declare function updateConfig(patch: ShortlinksConfig): ShortlinksConfig;
+export declare function normalizeHostname(input: string): string;
+export declare function formatShortUrl(hostname: string, slug: string, publicBaseUrl?: string): string;

package/dist/database.d.ts

@@ -0,0 +1,11 @@
+import { Database } from "bun:sqlite";
+export declare function now(): string;
+export declare function makeId(prefix: string): string;
+export declare const SQLITE_MIGRATIONS: string[];
+export declare class ShortlinksDatabase {
+    readonly db: Database;
+    readonly path: string;
+    constructor(path?: string);
+    close(): void;
+    private applyMigrations;
+}

package/dist/domains-cli.d.ts

@@ -0,0 +1,10 @@
+export type DomainsAction = "check" | "buy" | "setup";
+export declare function buildDomainsArgs(action: DomainsAction, domain: string): string[];
+export declare function runDomains(action: DomainsAction, domain: string, options?: {
+    dryRun?: boolean;
+}): {
+    command: string;
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { ShortlinksDatabase, SQLITE_MIGRATIONS, makeId, now } from "./database.js";
+export { ShortlinksStore } from "./store.js";
+export { createShortlinksHandler, serveShortlinks } from "./server.js";
+export { createCloudflarePlan, generateWorkerScript, writeWorkerFiles, upsertCloudflareDnsRecord } from "./cloudflare.js";
+export { PG_MIGRATIONS } from "./pg-migrations.js";
+export { formatShortUrl, getConfigPath, getDataDir, getDatabasePath, loadConfig, normalizeHostname, saveConfig } from "./config.js";
+export { normalizeSlug, randomToken } from "./slug.js";
+export type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";