greybull 0.1.0

package/README.md

@@ -0,0 +1,70 @@
+# greybull
+
+Command-line tool for the [Greybull](https://dash.greybull.nl) portal — manage DNS records and domains from your terminal.
+
+```bash
+npx greybull dns zones
+# or install it
+npm install -g greybull
+```
+
+## Login
+
+```bash
+greybull login
+```
+
+Opens your browser, asks you to approve, and stores a scoped API key
+(`dns:read`, `dns:write`, `domains:read`) in `~/.config/greybull/config.json`
+(mode `0600`).
+
+Alternatives:
+
+```bash
+greybull login --with-key          # paste an API key instead of using the browser
+GREYBULL_API_KEY=ck_... greybull …  # env var, for CI / headless (no stored state)
+```
+
+Create keys manually at <https://dash.greybull.nl/api-settings>.
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `greybull login` / `logout` / `whoami` | Authentication |
+| `greybull dns zones` | List your DNS zones |
+| `greybull dns list <zone> [--type T] [--name N]` | List records |
+| `greybull dns add <zone> <type> <name> <content> [--ttl N] [--priority N]` | Add a record |
+| `greybull dns update <zone> <type> <name> <old> <new> [--ttl N] [--priority N] [--new-name X]` | Change one record |
+| `greybull dns delete <zone> <type> <name> <content> [--priority N]` | Delete one record |
+| `greybull domains list` | List registered domains |
+| `greybull domains check <query> [--tlds nl,com]` | Check availability |
+
+Global flags: `--json` (raw JSON output), `--api-url <url>` (or `GREYBULL_API_URL`, for self-hosted/dev).
+
+## Examples
+
+```bash
+greybull dns list example.nl --type TXT
+greybull dns add example.nl TXT @ '"v=spf1 include:_spf.example.com -all"'
+greybull dns add example.nl MX @ mail.example.nl --priority 10
+greybull dns update example.nl A www 203.0.113.10 203.0.113.20
+greybull dns delete example.nl TXT _acme-challenge '"token123"'
+greybull domains check mycompany --tlds nl,com,io
+```
+
+## Record semantics
+
+Record operations are **sibling-safe**: they touch only the specific record you
+name (identified by name + type + exact content), never the whole record set. Two
+TXT records at the same name stay independent — updating or deleting one leaves the
+other alone. That's why `update` and `delete` require the exact current content.
+
+TXT content usually needs quoting (`'"..."'`); the CLI warns if it looks unquoted.
+DNS validation errors come straight from PowerDNS so you see the real reason.
+
+## Config & environment
+
+- `~/.config/greybull/config.json` — `{ "apiKey": "...", "apiUrl": "..." }`, `0600`.
+- `GREYBULL_API_KEY` — overrides the stored key.
+- `GREYBULL_API_URL` — overrides the base URL (default `https://dash.greybull.nl`).

package/dist/index.js

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_API_URL = "https://dash.greybull.nl";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "greybull");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") return {};
+    process.stderr.write(`Warning: could not read ${CONFIG_PATH}, ignoring it.
+`);
+    return {};
+  }
+}
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs.chmodSync(CONFIG_PATH, 384);
+}
+function clearApiKey() {
+  const config = loadConfig();
+  delete config.apiKey;
+  saveConfig(config);
+}
+function configPath() {
+  return CONFIG_PATH;
+}
+function resolveApiKey() {
+  return process.env.GREYBULL_API_KEY || loadConfig().apiKey || null;
+}
+function stripTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function resolveApiUrl(flagValue) {
+  const url = process.env.GREYBULL_API_URL || flagValue || loadConfig().apiUrl || DEFAULT_API_URL;
+  return stripTrailingSlash(url);
+}
+
+// src/commands/auth.ts
+import http from "http";
+import os2 from "os";
+import readline from "readline/promises";
+
+// src/browser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/pkce.ts
+import crypto from "crypto";
+function randomToken(bytes = 32) {
+  return crypto.randomBytes(bytes).toString("base64url");
+}
+function codeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+function createPkce() {
+  const verifier = randomToken(32);
+  return {
+    state: randomToken(16),
+    verifier,
+    challenge: codeChallenge(verifier)
+  };
+}
+
+// src/http.ts
+var ApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+var VERSION = "0.1.0";
+function buildRequest(opts) {
+  const url = new URL(opts.apiUrl.replace(/\/+$/, "") + opts.path);
+  if (opts.query) {
+    for (const [key, value] of Object.entries(opts.query)) {
+      if (value !== void 0 && value !== "") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const headers = {
+    "User-Agent": `greybull-cli/${VERSION}`,
+    Accept: "application/json"
+  };
+  if (opts.apiKey) headers["X-API-Key"] = opts.apiKey;
+  let body;
+  if (opts.body !== void 0) {
+    body = JSON.stringify(opts.body);
+    headers["Content-Type"] = "application/json";
+  }
+  return { method: opts.method, url: url.toString(), headers, body };
+}
+async function performRequest(spec, apiKey) {
+  const headers = { ...spec.headers };
+  if (apiKey) headers["X-API-Key"] = apiKey;
+  let res;
+  try {
+    res = await fetch(spec.url, {
+      method: spec.method,
+      headers,
+      body: spec.body,
+      signal: AbortSignal.timeout(3e4)
+    });
+  } catch {
+    throw new ApiError(`Could not reach ${new URL(spec.url).origin}`, 0);
+  }
+  const text = await res.text();
+  let json;
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+    json = {};
+  }
+  if (!res.ok) {
+    throw new ApiError(json?.error || res.statusText || "Request failed", res.status);
+  }
+  return json;
+}
+async function apiRequest(opts) {
+  const { apiKey, ...rest } = opts;
+  return performRequest(buildRequest(rest), apiKey);
+}
+
+// src/output.ts
+function formatTable(headers, rows) {
+  if (rows.length === 0) return "(none)";
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const line = (cells) => cells.map((c, i) => (c ?? "").padEnd(widths[i])).join("  ").trimEnd();
+  return [line(headers), ...rows.map(line)].join("\n");
+}
+function fail(error, opts) {
+  let message = error instanceof Error ? error.message : String(error);
+  if (error instanceof ApiError) {
+    if (error.status === 401) {
+      message += `
+Run 'greybull login' to authenticate (or set GREYBULL_API_KEY).`;
+    } else if (error.status === 403) {
+      message += `
+Your API key is missing a required scope \u2014 create one with DNS/domain permissions at ${opts.apiUrl}/api-settings.`;
+    }
+  }
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+
+// src/commands/auth.ts
+function persist(apiKey, ctx2) {
+  const config = { apiKey };
+  if (ctx2.apiUrl !== DEFAULT_API_URL) config.apiUrl = ctx2.apiUrl;
+  saveConfig(config);
+}
+async function validateAndSave(apiKey, ctx2) {
+  const profile = await apiRequest({
+    apiUrl: ctx2.apiUrl,
+    apiKey,
+    method: "GET",
+    path: "/api/v1/profile"
+  });
+  persist(apiKey, ctx2);
+  process.stdout.write(`Logged in as ${profile.data.email}
+`);
+}
+async function loginWithKey(ctx2, providedKey) {
+  let apiKey = providedKey;
+  if (!apiKey) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    apiKey = (await rl.question("API key (ck_...): ")).trim();
+    rl.close();
+  }
+  if (!apiKey) fail(new Error("No API key provided"), ctx2);
+  try {
+    await validateAndSave(apiKey, ctx2);
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 401) {
+      fail(new Error("That API key was rejected."), ctx2);
+    }
+    fail(err, ctx2);
+  }
+}
+async function loginWithBrowser(ctx2) {
+  const pkce = createPkce();
+  const deviceName = os2.hostname();
+  const { code } = await new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const returnedState = url.searchParams.get("state");
+      const returnedCode = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      if (error || !returnedCode || returnedState !== pkce.state) {
+        res.end(page("Login failed", "You can close this tab and try again."));
+        server.close();
+        reject(new Error(error === "access_denied" ? "Authorization was declined." : "Login failed."));
+        return;
+      }
+      res.end(page("Logged in", "You can close this tab and return to your terminal."));
+      server.close();
+      resolve({ code: returnedCode });
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      const redirectUri = `http://127.0.0.1:${port}/callback`;
+      const authorizeUrl = new URL("/cli/authorize", ctx2.apiUrl);
+      authorizeUrl.searchParams.set("redirect_uri", redirectUri);
+      authorizeUrl.searchParams.set("state", pkce.state);
+      authorizeUrl.searchParams.set("code_challenge", pkce.challenge);
+      authorizeUrl.searchParams.set("name", deviceName);
+      process.stdout.write("Opening your browser to authorize the CLI\u2026\n");
+      const opened = openBrowser(authorizeUrl.toString());
+      if (!opened) {
+        process.stdout.write(`Open this URL to continue:
+  ${authorizeUrl.toString()}
+`);
+      } else {
+        process.stdout.write(`If it doesn't open, visit:
+  ${authorizeUrl.toString()}
+`);
+      }
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Timed out waiting for browser authorization."));
+    }, 12e4).unref();
+  }).catch((err) => {
+    fail(err, ctx2);
+  });
+  const result = await apiRequest({
+    apiUrl: ctx2.apiUrl,
+    method: "POST",
+    path: "/api/cli/token",
+    body: { code, code_verifier: pkce.verifier }
+  }).catch((err) => fail(err, ctx2));
+  persist(result.apiKey, ctx2);
+  process.stdout.write(`Logged in as ${result.email}
+`);
+}
+function logout() {
+  if (!resolveApiKey()) {
+    process.stdout.write("Not logged in.\n");
+    return;
+  }
+  clearApiKey();
+  process.stdout.write(`Logged out. Removed the stored key from ${configPath()}.
+`);
+}
+async function whoami(ctx2) {
+  if (!ctx2.apiKey) fail(new ApiError("Not logged in", 401), ctx2);
+  const profile = await apiRequest({
+    apiUrl: ctx2.apiUrl,
+    apiKey: ctx2.apiKey,
+    method: "GET",
+    path: "/api/v1/profile"
+  }).catch((err) => fail(err, ctx2));
+  if (ctx2.json) {
+    process.stdout.write(JSON.stringify(profile.data, null, 2) + "\n");
+  } else {
+    const name = profile.data.name ? ` (${profile.data.name})` : "";
+    process.stdout.write(`${profile.data.email}${name}
+`);
+  }
+}
+function page(title, body) {
+  return `<!doctype html><meta charset="utf-8"><title>${title}</title>
+<body style="font-family:system-ui;display:flex;height:100vh;align-items:center;justify-content:center;margin:0">
+<div style="text-align:center"><h1 style="font-size:1.25rem">${title}</h1><p style="color:#666">${body}</p></div>`;
+}
+
+// src/commands/dns.ts
+var RECORD_TYPES = ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"];
+function buildListRecords(apiUrl, zone, opts) {
+  return buildRequest({
+    apiUrl,
+    method: "GET",
+    path: `/api/v1/dns/zones/${encodeURIComponent(zone)}/records`,
+    query: { name: opts.name, type: opts.type }
+  });
+}
+function buildAddRecord(apiUrl, zone, type, name, content, opts) {
+  return buildRequest({
+    apiUrl,
+    method: "POST",
+    path: `/api/v1/dns/zones/${encodeURIComponent(zone)}/records`,
+    body: {
+      name,
+      type: type.toUpperCase(),
+      content,
+      ...opts.ttl !== void 0 ? { ttl: opts.ttl } : {},
+      ...opts.priority !== void 0 ? { priority: opts.priority } : {}
+    }
+  });
+}
+function buildUpdateRecord(apiUrl, zone, original, updated) {
+  return buildRequest({
+    apiUrl,
+    method: "PUT",
+    path: `/api/v1/dns/zones/${encodeURIComponent(zone)}/records`,
+    body: {
+      original: {
+        name: original.name,
+        type: original.type,
+        content: original.content,
+        ...original.priority !== void 0 ? { priority: original.priority } : {}
+      },
+      updated
+    }
+  });
+}
+function buildDeleteRecord(apiUrl, zone, type, name, content, opts) {
+  return buildRequest({
+    apiUrl,
+    method: "DELETE",
+    path: `/api/v1/dns/zones/${encodeURIComponent(zone)}/records`,
+    query: { name, type: type.toUpperCase(), content, priority: opts.priority }
+  });
+}
+function assertType(type, ctx2) {
+  const upper = type.toUpperCase();
+  if (!RECORD_TYPES.includes(upper)) {
+    fail(new Error(`Invalid record type '${type}'. Valid types: ${RECORD_TYPES.join(", ")}`), ctx2);
+  }
+  return upper;
+}
+async function zonesCmd(ctx2) {
+  const res = await apiRequest({ apiUrl: ctx2.apiUrl, apiKey: ctx2.apiKey, method: "GET", path: "/api/v1/dns/zones" }).catch((err) => fail(err, ctx2));
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  const rows = res.data.map((z) => [z.name, z.kind, String(z.serial)]);
+  process.stdout.write(formatTable(["ZONE", "KIND", "SERIAL"], rows) + "\n");
+}
+async function listCmd(ctx2, zone, opts) {
+  const type = opts.type ? assertType(opts.type, ctx2) : void 0;
+  const spec = buildListRecords(ctx2.apiUrl, zone, { type, name: opts.name });
+  const res = await runSpec(spec, ctx2);
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  const rows = res.data.map((r) => [
+    r.name,
+    r.type,
+    r.content,
+    String(r.ttl),
+    r.priority !== void 0 ? String(r.priority) : ""
+  ]);
+  process.stdout.write(formatTable(["NAME", "TYPE", "CONTENT", "TTL", "PRIO"], rows) + "\n");
+}
+async function addCmd(ctx2, zone, type, name, content, opts) {
+  const upperType = assertType(type, ctx2);
+  if (upperType === "TXT" && !content.startsWith('"')) {
+    process.stderr.write(`Note: TXT content usually needs quotes, e.g. '"v=spf1 ..."'. Sending as given.
+`);
+  }
+  const spec = buildAddRecord(ctx2.apiUrl, zone, upperType, name, content, {
+    ttl: opts.ttl ? parseInt(opts.ttl) : void 0,
+    priority: opts.priority ? parseInt(opts.priority) : void 0
+  });
+  const res = await runSpec(spec, ctx2);
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  process.stdout.write(`Added ${upperType} ${name} \u2192 ${content}
+`);
+}
+async function updateCmd(ctx2, zone, type, name, oldContent, newContent, opts) {
+  const upperType = assertType(type, ctx2);
+  const priority = opts.priority ? parseInt(opts.priority) : void 0;
+  const listRes = await runSpec(buildListRecords(ctx2.apiUrl, zone, { type: upperType, name }), ctx2);
+  const match = listRes.data.find(
+    (r) => r.content === oldContent && (priority === void 0 || r.priority === priority)
+  );
+  if (!match) {
+    fail(new Error(`No ${upperType} record '${name}' with content ${oldContent} found. Run 'greybull dns list ${zone}'.`), ctx2);
+  }
+  const spec = buildUpdateRecord(ctx2.apiUrl, zone, match, {
+    name: opts.newName ?? name,
+    type: upperType,
+    content: newContent,
+    ttl: opts.ttl ? parseInt(opts.ttl) : match.ttl,
+    ...opts.priority ? { priority } : match.priority !== void 0 ? { priority: match.priority } : {}
+  });
+  const res = await runSpec(spec, ctx2);
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  process.stdout.write(`Updated ${upperType} ${name}
+`);
+}
+async function deleteCmd(ctx2, zone, type, name, content, opts) {
+  const upperType = assertType(type, ctx2);
+  const spec = buildDeleteRecord(ctx2.apiUrl, zone, upperType, name, content, {
+    priority: opts.priority ? parseInt(opts.priority) : void 0
+  });
+  await runSpec(spec, ctx2);
+  if (ctx2.json) return void process.stdout.write(JSON.stringify({ deleted: true }, null, 2) + "\n");
+  process.stdout.write(`Deleted ${upperType} ${name} \u2192 ${content}
+`);
+}
+function runSpec(spec, ctx2) {
+  return performRequest(spec, ctx2.apiKey).catch((err) => fail(err, ctx2));
+}
+
+// src/commands/domains.ts
+async function domainsListCmd(ctx2) {
+  const res = await apiRequest({
+    apiUrl: ctx2.apiUrl,
+    apiKey: ctx2.apiKey,
+    method: "GET",
+    path: "/api/v1/domains"
+  }).catch((err) => fail(err, ctx2));
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  const rows = res.data.map((d) => [
+    d.name,
+    d.status ?? "",
+    d.registrar ?? "",
+    d.expiresAt ? new Date(d.expiresAt).toISOString().slice(0, 10) : "",
+    d.autoRenew ? "yes" : "no"
+  ]);
+  process.stdout.write(
+    formatTable(["DOMAIN", "STATUS", "REGISTRAR", "EXPIRES", "AUTO-RENEW"], rows) + "\n"
+  );
+}
+async function domainsCheckCmd(ctx2, query, opts) {
+  const res = await apiRequest({
+    apiUrl: ctx2.apiUrl,
+    apiKey: ctx2.apiKey,
+    method: "GET",
+    path: "/api/v1/domains/search",
+    query: { q: query, tlds: opts.tlds }
+  }).catch((err) => fail(err, ctx2));
+  if (ctx2.json) return void process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+  const rows = res.data.map((r) => [
+    r.domain,
+    r.available ? "available" : "taken",
+    r.available && r.price !== void 0 ? `${r.price} ${r.currency ?? ""}`.trim() : ""
+  ]);
+  process.stdout.write(formatTable(["DOMAIN", "AVAILABLE", "PRICE"], rows) + "\n");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("greybull").description("Manage Greybull DNS records and domains from the command line").version("0.1.0").option("--json", "output raw JSON", false).option("--api-url <url>", "portal base URL (or set GREYBULL_API_URL)");
+function ctx(requireAuth = true) {
+  const opts = program.opts();
+  const apiUrl = resolveApiUrl(opts.apiUrl);
+  const apiKey = resolveApiKey() ?? void 0;
+  if (requireAuth && !apiKey) {
+    fail(new Error("Not logged in. Run 'greybull login' first."), { apiUrl });
+  }
+  return { apiUrl, apiKey, json: opts.json };
+}
+function loginCtx() {
+  const opts = program.opts();
+  const apiUrl = resolveApiUrl(opts.apiUrl);
+  return { apiUrl, apiUrlExplicit: Boolean(opts.apiUrl || process.env.GREYBULL_API_URL) };
+}
+program.command("login").description("Log in via the browser (or --with-key to paste an API key)").option("--with-key", "authenticate by pasting an API key instead of the browser", false).option("--api-key <key>", "provide the API key non-interactively (implies --with-key)").action(async (opts) => {
+  if (opts.withKey || opts.apiKey) {
+    await loginWithKey(loginCtx(), opts.apiKey);
+  } else {
+    await loginWithBrowser(loginCtx());
+  }
+});
+program.command("logout").description("Remove the stored API key").action(() => logout());
+program.command("whoami").description("Show the authenticated account").action(async () => {
+  await whoami(ctx());
+});
+var dns = program.command("dns").description("Manage DNS records");
+dns.command("zones").description("List your DNS zones").action(async () => {
+  await zonesCmd(ctx());
+});
+dns.command("list <zone>").description("List records in a zone").option("--type <type>", "filter by record type").option("--name <name>", "filter by record name").action(async (zone, opts) => {
+  await listCmd(ctx(), zone, opts);
+});
+dns.command("add <zone> <type> <name> <content>").description("Add a record (siblings with the same name+type are preserved)").option("--ttl <seconds>", "TTL in seconds (default 3600)").option("--priority <n>", "priority (MX/SRV)").action(async (zone, type, name, content, opts) => {
+  await addCmd(ctx(), zone, type, name, content, opts);
+});
+dns.command("update <zone> <type> <name> <old-content> <new-content>").description("Change one record; siblings are preserved, TTL kept unless --ttl given").option("--ttl <seconds>", "new TTL in seconds").option("--priority <n>", "match/set priority (MX/SRV)").option("--new-name <name>", "rename the record").action(async (zone, type, name, oldContent, newContent, opts) => {
+  await updateCmd(ctx(), zone, type, name, oldContent, newContent, opts);
+});
+dns.command("delete <zone> <type> <name> <content>").description("Delete one specific record (content required \u2014 sibling-safe)").option("--priority <n>", "priority (MX/SRV)").action(async (zone, type, name, content, opts) => {
+  await deleteCmd(ctx(), zone, type, name, content, opts);
+});
+var domains = program.command("domains").description("Manage domains");
+domains.command("list").description("List your registered domains").action(async () => {
+  await domainsListCmd(ctx());
+});
+domains.command("check <query>").description("Check domain availability").option("--tlds <list>", "comma-separated TLDs for a bare label, e.g. nl,com").action(async (query, opts) => {
+  await domainsCheckCmd(ctx(), query, opts);
+});
+program.parseAsync().catch((err) => {
+  process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "greybull",
+  "version": "0.1.0",
+  "description": "Command-line tool for the Greybull portal — manage DNS records and domains",
+  "type": "module",
+  "bin": {
+    "greybull": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.bouwhuis.net/greybull/greybull-dash.git",
+    "directory": "cli"
+  },
+  "keywords": [
+    "greybull",
+    "dns",
+    "cli"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.0"
+  }
+}