npm - clipr-cli - Versions diffs - 0.0.5 - Mend

clipr-cli 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/api-KFVDRB2Q.js +90 -0
package/dist/api-KFVDRB2Q.js.map +1 -0
package/dist/api-LBSFNXNQ.js +88 -0
package/dist/api-LBSFNXNQ.js.map +1 -0
package/dist/api.d.ts +86 -0
package/dist/api.js +165 -0
package/dist/api.js.map +1 -0
package/dist/chunk-I7CHG5Z3.js +92 -0
package/dist/chunk-I7CHG5Z3.js.map +1 -0
package/dist/github-OYIAPRKM.js +155 -0
package/dist/github-OYIAPRKM.js.map +1 -0
package/dist/github-PSGU4YYI.js +157 -0
package/dist/github-PSGU4YYI.js.map +1 -0
package/dist/index.d.ts +2 -0
package/dist/index.js +698 -0
package/dist/index.js.map +1 -0
package/dist/json-adapter-5YGDHNVJ.js +8 -0
package/dist/json-adapter-5YGDHNVJ.js.map +1 -0
package/package.json +76 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,698 @@
+#!/usr/bin/env node
+import {
+  JsonBackendAdapter
+} from "./chunk-I7CHG5Z3.js";
+// src/index.ts
+import { resolve as resolve3 } from "path";
+import { DEFAULT_DB_PATH as DEFAULT_DB_PATH2, loadConfig } from "@clipr/core";
+import { Command } from "commander";
+// src/commands/build.ts
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { appendUtm, hasUtm } from "@clipr/core";
+// src/utils/output.ts
+import pc from "picocolors";
+function success(msg) {
+  console.log(pc.green("\u2713"), msg);
+}
+function error(msg) {
+  console.error(pc.red("\u2717"), msg);
+}
+function info(msg) {
+  console.log(pc.cyan("\u2139"), msg);
+}
+function dim(msg) {
+  return pc.dim(msg);
+}
+// src/commands/build.ts
+function buildRedirectHtml(entry) {
+  const target = hasUtm(entry.utm) ? appendUtm(entry.url, entry.utm) : entry.url;
+  const escaped = target.replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="0;url=${escaped}">
+<title>Redirecting...</title>
+<link rel="canonical" href="${escaped}">
+</head>
+<body>
+<script>window.location.replace("${target.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}")</script>
+<noscript><a href="${escaped}">Click here</a></noscript>
+</body>
+</html>
+`;
+}
+async function build(opts) {
+  const inputPath = opts.input ?? "urls.json";
+  const outputDir = opts.output ?? "dist";
+  if (!existsSync(inputPath)) {
+    error(`Input file not found: ${inputPath}`);
+    info("Run `clipr init` to create a urls.json database, or specify --input <path>.");
+    process.exit(1);
+  }
+  let db;
+  try {
+    const raw = await readFile(inputPath, "utf-8");
+    db = JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(`Failed to parse ${inputPath}: ${msg}`);
+    process.exit(1);
+  }
+  const entries = Object.values(db.urls);
+  if (entries.length === 0) {
+    info("No URLs to build. Add some with `clipr shorten <url>`.");
+    return;
+  }
+  mkdirSync(outputDir, { recursive: true });
+  info(`Building ${entries.length} redirect page${entries.length === 1 ? "" : "s"}...`);
+  let built = 0;
+  for (const entry of entries) {
+    if (entry.expiresAt && new Date(entry.expiresAt) < /* @__PURE__ */ new Date()) {
+      console.log(`  ${dim(`skip "${entry.slug}" (expired)`)}`);
+      continue;
+    }
+    const slugDir = join(outputDir, entry.slug);
+    mkdirSync(slugDir, { recursive: true });
+    const html = buildRedirectHtml(entry);
+    await writeFile(join(slugDir, "index.html"), html);
+    built++;
+  }
+  const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>clipr</title>
+</head>
+<body>
+<p>${built} redirect${built === 1 ? "" : "s"} active.</p>
+</body>
+</html>
+`;
+  await writeFile(join(outputDir, "index.html"), indexHtml);
+  success(`Built ${built} redirect page${built === 1 ? "" : "s"} to ${outputDir}/`);
+}
+// src/commands/config.ts
+async function config(key, value, backend) {
+  if (key === "baseUrl") {
+    if (value === void 0) {
+      const current = await backend.getBaseUrl();
+      console.log(current || dim("(not set)"));
+    } else {
+      await backend.setBaseUrl(value);
+      success(`baseUrl set to "${value}"`);
+    }
+    return;
+  }
+  error(`Unknown config key "${key}". Available keys: baseUrl`);
+  process.exit(1);
+}
+// src/commands/delete.ts
+async function del(slug, backend) {
+  const deleted = await backend.delete(slug);
+  if (deleted) {
+    success(`Deleted slug "${slug}"`);
+  } else {
+    error(`Slug "${slug}" not found`);
+    process.exit(1);
+  }
+}
+// src/commands/deploy.ts
+import { execFile } from "child_process";
+import { writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function deploy(backend, opts) {
+  if (!/^[a-f0-9]{32}$/.test(opts.namespaceId)) {
+    error("Invalid namespace ID format. Expected 32-character hex string.");
+    process.exit(1);
+  }
+  const entries = await backend.list();
+  if (entries.length === 0) {
+    info("No URLs to deploy. Run `clipr shorten <url>` first.");
+    return;
+  }
+  const kvPairs = entries.map((entry) => ({
+    key: entry.slug,
+    value: JSON.stringify(entry)
+  }));
+  kvPairs.push({
+    key: "_index",
+    value: JSON.stringify(entries.map((e) => e.slug))
+  });
+  const tmpFile = join2(tmpdir(), `clipr-deploy-${Date.now()}.json`);
+  await writeFile2(tmpFile, JSON.stringify(kvPairs, null, 2));
+  info(`Deploying ${entries.length} URL${entries.length === 1 ? "" : "s"} to KV...`);
+  try {
+    const args = ["kv", "bulk", "put", tmpFile, "--namespace-id", opts.namespaceId];
+    if (opts.preview) {
+      args.push("--preview");
+    }
+    const { stdout, stderr } = await exec("npx", ["wrangler", ...args]);
+    if (stdout) console.log(dim(stdout.trim()));
+    if (stderr && !stderr.includes("deprecated")) console.error(dim(stderr.trim()));
+    success(`Deployed ${entries.length} URL${entries.length === 1 ? "" : "s"} to Cloudflare KV`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(`Deploy failed: ${msg}`);
+    info("Make sure wrangler is installed and you are logged in (`npx wrangler login`)");
+    process.exit(1);
+  }
+}
+// src/commands/edit.ts
+import { normalizeSlug, validateSlug } from "@clipr/core";
+async function edit(slug, backend, opts) {
+  const updates = {};
+  if (opts.url) {
+    updates.url = opts.url;
+  }
+  if (opts.slug) {
+    const newSlug = normalizeSlug(opts.slug);
+    const result = validateSlug(newSlug);
+    if (!result.valid) {
+      error(`Invalid slug: ${result.reason}`);
+      process.exit(1);
+    }
+    updates.slug = newSlug;
+  }
+  if (opts.tags) {
+    updates.tags = opts.tags.split(",").map((t) => t.trim());
+  }
+  if (opts.expires) {
+    updates.expiresAt = new Date(opts.expires).toISOString();
+  }
+  if (opts.description) {
+    updates.description = opts.description;
+  }
+  if (Object.keys(updates).length === 0) {
+    error("No updates specified. Use --url, --slug, --tags, --expires, or --description.");
+    process.exit(1);
+  }
+  try {
+    const updated = await backend.update(slug, updates);
+    success(`Updated "${slug}"${updates.slug ? ` \u2192 "${updated.slug}"` : ""}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+    process.exit(1);
+  }
+}
+// src/commands/export.ts
+import { writeFile as writeFile3 } from "fs/promises";
+function toCsv(entries) {
+  const header = "slug,url,description,createdAt,expiresAt,tags";
+  const rows = entries.map((e) => {
+    const desc = (e.description ?? "").replace(/,/g, ";");
+    const tags = (e.tags ?? []).join(";");
+    return `${e.slug},${e.url},${desc},${e.createdAt},${e.expiresAt ?? ""},${tags}`;
+  });
+  return `${[header, ...rows].join("\n")}
+`;
+}
+async function exportUrls(backend, opts) {
+  const entries = await backend.list();
+  if (entries.length === 0) {
+    info("No URLs to export.");
+    return;
+  }
+  const format = opts.format ?? "json";
+  let output;
+  if (format === "csv") {
+    output = toCsv(entries);
+  } else {
+    output = `${JSON.stringify(entries, null, 2)}
+`;
+  }
+  if (opts.output) {
+    await writeFile3(opts.output, output);
+    success(`Exported ${entries.length} URL${entries.length === 1 ? "" : "s"} to ${opts.output}`);
+  } else {
+    process.stdout.write(output);
+    if (process.stderr.isTTY) {
+      info(`${dim(`${entries.length} URL${entries.length === 1 ? "" : "s"} exported`)}`);
+    }
+  }
+}
+// src/commands/import.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve } from "path";
+function parseCsv(content) {
+  const lines = content.trim().split("\n");
+  if (lines.length < 2) return [];
+  const header = lines[0]?.split(",").map((h) => h.trim().toLowerCase());
+  const slugIdx = header.indexOf("slug");
+  const urlIdx = header.indexOf("url");
+  const descIdx = header.indexOf("description");
+  const expiresIdx = header.indexOf("expiresat");
+  const tagsIdx = header.indexOf("tags");
+  if (slugIdx === -1 || urlIdx === -1) {
+    throw new Error('CSV must have "slug" and "url" columns');
+  }
+  return lines.slice(1).map((line) => {
+    const cols = line.split(",").map((c) => c.trim());
+    const entry = {
+      slug: cols[slugIdx],
+      url: cols[urlIdx]
+    };
+    if (descIdx !== -1 && cols[descIdx]) entry.description = cols[descIdx];
+    if (expiresIdx !== -1 && cols[expiresIdx]) entry.expiresAt = cols[expiresIdx];
+    if (tagsIdx !== -1 && cols[tagsIdx])
+      entry.tags = cols[tagsIdx]?.split(";").map((t) => t.trim());
+    return entry;
+  });
+}
+async function importUrls(file, backend, opts) {
+  let content;
+  try {
+    const resolvedPath = resolve(file);
+    content = await readFile2(resolvedPath, "utf-8");
+  } catch {
+    error(`Cannot read file: ${file}`);
+    process.exit(1);
+  }
+  const format = opts.format ?? (file.endsWith(".csv") ? "csv" : "json");
+  let entries;
+  try {
+    if (format === "csv") {
+      entries = parseCsv(content);
+    } else {
+      const parsed = JSON.parse(content);
+      entries = Array.isArray(parsed) ? parsed : parsed.urls ?? Object.values(parsed);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(`Failed to parse ${format.toUpperCase()} file: ${msg}`);
+    process.exit(1);
+  }
+  if (entries.length === 0) {
+    info("No entries found in import file.");
+    return;
+  }
+  info(`Importing ${entries.length} URL${entries.length === 1 ? "" : "s"}...`);
+  let imported = 0;
+  let skipped = 0;
+  for (const entry of entries) {
+    if (!entry.slug || !entry.url) {
+      skipped++;
+      continue;
+    }
+    try {
+      await backend.create(entry.slug, entry.url, {
+        description: entry.description,
+        expiresAt: entry.expiresAt,
+        tags: entry.tags
+      });
+      imported++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`  ${dim(`skip "${entry.slug}": ${msg}`)}`);
+      skipped++;
+    }
+  }
+  success(`Imported ${imported} URL${imported === 1 ? "" : "s"}`);
+  if (skipped > 0) {
+    info(`${skipped} entr${skipped === 1 ? "y" : "ies"} skipped (conflicts or invalid)`);
+  }
+}
+// src/commands/info.ts
+import { appendUtm as appendUtm2, hasUtm as hasUtm2 } from "@clipr/core";
+import pc2 from "picocolors";
+async function info2(slug, backend) {
+  const entry = await backend.get(slug);
+  if (!entry) {
+    error(`Slug "${slug}" not found`);
+    process.exit(1);
+  }
+  const baseUrl = await backend.getBaseUrl();
+  const shortUrl = baseUrl ? `${baseUrl}/${entry.slug}` : entry.slug;
+  const redirectUrl = hasUtm2(entry.utm) ? appendUtm2(entry.url, entry.utm) : entry.url;
+  console.log();
+  console.log(`  ${pc2.bold("Slug:")}       ${pc2.cyan(entry.slug)}`);
+  console.log(`  ${pc2.bold("Short URL:")}  ${shortUrl}`);
+  console.log(`  ${pc2.bold("Target:")}     ${entry.url}`);
+  if (redirectUrl !== entry.url) {
+    console.log(`  ${pc2.bold("Redirect:")}   ${dim(redirectUrl)}`);
+  }
+  if (entry.description) {
+    console.log(`  ${pc2.bold("Note:")}       ${entry.description}`);
+  }
+  console.log(`  ${pc2.bold("Created:")}    ${entry.createdAt}`);
+  if (entry.expiresAt) {
+    console.log(`  ${pc2.bold("Expires:")}    ${entry.expiresAt}`);
+  }
+  if (hasUtm2(entry.utm)) {
+    console.log(`  ${pc2.bold("UTM:")}`);
+    for (const [key, value] of Object.entries(entry.utm)) {
+      if (value) console.log(`    ${dim(key)}: ${value}`);
+    }
+  }
+  console.log();
+}
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { writeFile as writeFile4 } from "fs/promises";
+import { DB_VERSION } from "@clipr/core";
+async function init(dbPath, opts) {
+  if (existsSync2(dbPath) && !opts.force) {
+    error(`${dbPath} already exists. Use --force to overwrite.`);
+    process.exit(1);
+  }
+  const db = {
+    version: DB_VERSION,
+    counter: 0,
+    baseUrl: opts.baseUrl ?? "",
+    urls: {}
+  };
+  await writeFile4(dbPath, `${JSON.stringify(db, null, 2)}
+`);
+  success(`Created ${dbPath}`);
+  if (opts.baseUrl) {
+    info(`Base URL set to ${dim(opts.baseUrl)}`);
+  } else {
+    info(`Set a base URL with: clipr config baseUrl https://your-domain.com`);
+  }
+}
+// src/commands/list.ts
+import pc3 from "picocolors";
+async function list(backend) {
+  const entries = await backend.list();
+  if (entries.length === 0) {
+    info("No shortened URLs yet. Run `clipr shorten <url>` to create one.");
+    return;
+  }
+  const baseUrl = await backend.getBaseUrl();
+  console.log(dim(`
+  ${entries.length} shortened URL${entries.length === 1 ? "" : "s"}:
+`));
+  for (const entry of entries) {
+    const short = baseUrl ? `${baseUrl}/${entry.slug}` : entry.slug;
+    console.log(`  ${pc3.bold(pc3.cyan(short))}`);
+    console.log(`    \u2192 ${entry.url}`);
+    if (entry.description) {
+      console.log(`    ${dim(entry.description)}`);
+    }
+    if (entry.expiresAt) {
+      console.log(`    ${dim(`expires: ${entry.expiresAt}`)}`);
+    }
+    console.log();
+  }
+}
+// src/commands/qr.ts
+import { writeFile as writeFile5 } from "fs/promises";
+// src/utils/qr.ts
+import QRCode from "qrcode";
+async function generateQR(url, format = "svg", size = 256) {
+  if (format === "svg") {
+    return QRCode.toString(url, {
+      type: "svg",
+      width: size,
+      margin: 2
+    });
+  }
+  return QRCode.toBuffer(url, {
+    type: "png",
+    width: size,
+    margin: 2
+  });
+}
+// src/commands/qr.ts
+async function qr(slug, backend, opts) {
+  const result = await backend.resolve(slug);
+  if (!result) {
+    error(`Slug "${slug}" not found`);
+    process.exit(1);
+  }
+  const entries = await backend.list({ search: slug, limit: 1 });
+  const entry = entries.find((e) => e.slug === slug);
+  const urlToEncode = result.url;
+  const format = opts.format ?? "svg";
+  const size = opts.size ? parseInt(opts.size, 10) : 256;
+  if (Number.isNaN(size) || size < 64 || size > 4096) {
+    error("Size must be between 64 and 4096 pixels");
+    process.exit(1);
+  }
+  try {
+    const qrData = await generateQR(urlToEncode, format, size);
+    if (opts.output) {
+      await writeFile5(opts.output, qrData);
+      success(`QR code saved to ${opts.output}`);
+    } else {
+      if (typeof qrData === "string") {
+        console.log(qrData);
+      } else {
+        process.stdout.write(qrData);
+      }
+    }
+    if (entry) {
+      info(`QR code for slug "${slug}" \u2192 ${entry.url}`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(`Failed to generate QR code: ${msg}`);
+    process.exit(1);
+  }
+}
+// src/commands/shorten.ts
+import {
+  generateRandomSlug,
+  hasUtm as hasUtm3,
+  normalizeSlug as normalizeSlug2,
+  validateSlug as validateSlug2,
+  validateUrl
+} from "@clipr/core";
+async function shorten(url, backend, opts) {
+  const urlResult = validateUrl(url);
+  if (!urlResult.valid) {
+    error(`Invalid URL: ${urlResult.reason}`);
+    process.exit(1);
+  }
+  let slug;
+  if (opts.slug) {
+    slug = normalizeSlug2(opts.slug);
+    const slugResult = validateSlug2(slug);
+    if (!slugResult.valid) {
+      error(`Invalid slug: ${slugResult.reason}`);
+      process.exit(1);
+    }
+  } else {
+    slug = generateRandomSlug();
+    while (await backend.has(slug)) {
+      slug = generateRandomSlug();
+    }
+  }
+  const utm = {};
+  if (opts.utm_source) utm.utm_source = opts.utm_source;
+  if (opts.utm_medium) utm.utm_medium = opts.utm_medium;
+  if (opts.utm_campaign) utm.utm_campaign = opts.utm_campaign;
+  if (opts.utm_term) utm.utm_term = opts.utm_term;
+  if (opts.utm_content) utm.utm_content = opts.utm_content;
+  const entry = {
+    slug,
+    url,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...opts.description && { description: opts.description },
+    ...opts.expires && { expiresAt: new Date(opts.expires).toISOString() },
+    ...hasUtm3(utm) && { utm }
+  };
+  await backend.set(entry);
+  const baseUrl = await backend.getBaseUrl();
+  const shortUrl = baseUrl ? `${baseUrl}/${slug}` : slug;
+  success(`Shortened ${dim(url)}`);
+  console.log(`  ${shortUrl}`);
+}
+// src/commands/stats.ts
+import pc4 from "picocolors";
+async function stats(slug, backend, opts) {
+  try {
+    const data = await backend.getStats(slug);
+    if (data === null) {
+      error("Stats are not available in the current backend mode.");
+      info(
+        'Click analytics require the Workers API backend. Deploy with `clipr deploy` and set mode to "api".'
+      );
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${pc4.bold("Stats for")} ${pc4.cyan(slug)}`);
+    console.log(`  ${pc4.bold("Total clicks:")} ${data.total}`);
+    if (Object.keys(data.daily).length > 0) {
+      console.log();
+      console.log(`  ${pc4.bold("Daily clicks:")}`);
+      const sorted = Object.entries(data.daily).sort(([a], [b]) => a.localeCompare(b));
+      for (const [date, count] of sorted) {
+        const bar = "\u2588".repeat(Math.min(count, 40));
+        console.log(`    ${dim(date)} ${bar} ${count}`);
+      }
+    }
+    if (Object.keys(data.geo).length > 0) {
+      console.log();
+      console.log(`  ${pc4.bold("Top countries:")}`);
+      const sorted = Object.entries(data.geo).sort(([, a], [, b]) => b - a).slice(0, 10);
+      for (const [country, count] of sorted) {
+        console.log(`    ${country}: ${count}`);
+      }
+    }
+    if (Object.keys(data.referrer).length > 0) {
+      console.log();
+      console.log(`  ${pc4.bold("Top referrers:")}`);
+      const sorted = Object.entries(data.referrer).sort(([, a], [, b]) => b - a).slice(0, 10);
+      for (const [ref, count] of sorted) {
+        console.log(`    ${ref || dim("(direct)")}: ${count}`);
+      }
+    }
+    if (Object.keys(data.device).length > 0) {
+      console.log();
+      console.log(`  ${pc4.bold("Devices:")}`);
+      for (const [device, count] of Object.entries(data.device)) {
+        console.log(`    ${device}: ${count}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    error(msg);
+    process.exit(1);
+  }
+}
+// src/factory.ts
+async function createBackend(config2) {
+  switch (config2.mode) {
+    case "github": {
+      if (!config2.github) {
+        throw new Error(
+          "GitHub backend requires github config. Run `clipr config` to set owner, repo, branch, path, and token."
+        );
+      }
+      const { GitHubBackend } = await import("./github-PSGU4YYI.js");
+      return new GitHubBackend(config2.github, config2.baseUrl);
+    }
+    case "api": {
+      if (!config2.api) {
+        throw new Error(
+          "API backend requires api config. Run `clipr config` to set baseUrl and token."
+        );
+      }
+      const { ApiBackend } = await import("./api-KFVDRB2Q.js");
+      return new ApiBackend(config2.api, config2.baseUrl);
+    }
+    default: {
+      return new JsonBackendAdapter(config2.dbPath, config2.baseUrl);
+    }
+  }
+}
+// src/utils/context.ts
+import { resolve as resolve2 } from "path";
+import { DEFAULT_DB_PATH, JsonBackend } from "@clipr/core";
+function createBackend2(dbPath) {
+  const resolved = resolve2(dbPath ?? DEFAULT_DB_PATH);
+  return new JsonBackend(resolved);
+}
+// src/index.ts
+var program = new Command();
+async function resolveBackend(globalOpts) {
+  if (globalOpts.db) {
+    const { JsonBackendAdapter: JsonBackendAdapter2 } = await import("./json-adapter-5YGDHNVJ.js");
+    const dbPath = resolve3(globalOpts.db);
+    return new JsonBackendAdapter2(dbPath, "");
+  }
+  const config2 = loadConfig();
+  return createBackend(config2);
+}
+program.name("clipr").description("Shorten, manage, and track URLs").version("0.0.1").option("--db <path>", "path to urls.json database file");
+program.command("shorten").description("Shorten a URL").argument("<url>", "URL to shorten").option("-s, --slug <slug>", "custom slug (random if omitted)").option("-d, --description <text>", "description for the link").option("--utm-source <value>", "UTM source").option("--utm-medium <value>", "UTM medium").option("--utm-campaign <value>", "UTM campaign").option("--utm-term <value>", "UTM term").option("--utm-content <value>", "UTM content").option("--expires <date>", "expiration date (ISO 8601)").action(async (url, opts) => {
+  const backend = createBackend2(program.opts().db);
+  await shorten(url, backend, {
+    slug: opts.slug,
+    description: opts.description,
+    utm_source: opts.utmSource,
+    utm_medium: opts.utmMedium,
+    utm_campaign: opts.utmCampaign,
+    utm_term: opts.utmTerm,
+    utm_content: opts.utmContent,
+    expires: opts.expires
+  });
+});
+program.command("list").alias("ls").description("List all shortened URLs").action(async () => {
+  const backend = createBackend2(program.opts().db);
+  await list(backend);
+});
+program.command("delete").alias("rm").description("Delete a shortened URL").argument("<slug>", "slug to delete").action(async (slug) => {
+  const backend = createBackend2(program.opts().db);
+  await del(slug, backend);
+});
+program.command("info").description("Show details for a slug").argument("<slug>", "slug to inspect").action(async (slug) => {
+  const backend = createBackend2(program.opts().db);
+  await info2(slug, backend);
+});
+program.command("config").description("Get or set configuration").argument("<key>", "config key (e.g. baseUrl)").argument("[value]", "value to set (omit to read)").action(async (key, value) => {
+  const backend = createBackend2(program.opts().db);
+  await config(key, value, backend);
+});
+program.command("init").description("Initialize a new urls.json database").option("-b, --base-url <url>", "base URL for short links").option("-f, --force", "overwrite existing database").action(async (opts) => {
+  const dbPath = resolve3(program.opts().db ?? DEFAULT_DB_PATH2);
+  await init(dbPath, { baseUrl: opts.baseUrl, force: opts.force });
+});
+program.command("deploy").description("Deploy URLs to Cloudflare KV").requiredOption("--namespace-id <id>", "Cloudflare KV namespace ID").option("--preview", "deploy to preview KV namespace").action(async (opts) => {
+  const backend = createBackend2(program.opts().db);
+  await deploy(backend, {
+    namespaceId: opts.namespaceId,
+    preview: opts.preview
+  });
+});
+program.command("edit").description("Edit an existing shortened URL").argument("<slug>", "slug to edit").option("--url <url>", "new target URL").option("--slug <slug>", "new slug").option("--tags <tags>", "comma-separated tags").option("--expires <date>", "expiration date (ISO 8601)").option("--description <text>", "description").action(async (slug, opts) => {
+  const backend = await resolveBackend(program.opts());
+  await edit(slug, backend, opts);
+});
+program.command("stats").description("Show click analytics for a slug").argument("<slug>", "slug to inspect").option("--json", "output raw JSON").option("--period <period>", "time period (e.g. 7d, 30d)").action(async (slug, opts) => {
+  const backend = await resolveBackend(program.opts());
+  await stats(slug, backend, opts);
+});
+program.command("qr").description("Generate a QR code for a slug").argument("<slug>", "slug to generate QR for").option("-o, --output <file>", "output file path").option("-f, --format <format>", "output format (svg|png)", "svg").option("-s, --size <px>", "image size in pixels", "256").action(async (slug, opts) => {
+  const backend = await resolveBackend(program.opts());
+  await qr(slug, backend, opts);
+});
+program.command("import").description("Import URLs from a file").argument("<file>", "input file path (JSON or CSV)").option("-f, --format <format>", "file format (json|csv)").action(async (file, opts) => {
+  const backend = await resolveBackend(program.opts());
+  await importUrls(file, backend, opts);
+});
+program.command("export").description("Export all URLs to a file").option("-f, --format <format>", "output format (json|csv)", "json").option("-o, --output <file>", "output file path (stdout if omitted)").action(async (opts) => {
+  const backend = await resolveBackend(program.opts());
+  await exportUrls(backend, opts);
+});
+program.command("build").description("Build static HTML redirect pages").option("-i, --input <path>", "path to urls.json", "urls.json").option("-o, --output <dir>", "output directory", "dist").action(async (opts) => {
+  await build({ input: opts.input, output: opts.output });
+});
+program.parseAsync().catch((err) => {
+  error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map