@cloud-cli/dns 2.0.3 → 2.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { init } from '@cloud-cli/cli';
+import { init, help } from "@cloud-cli/cli";
 interface DomainAndTarget {
     domain: string;
     target?: string;
@@ -19,5 +19,6 @@ declare const _default: {
     reload: typeof reload;
     get: typeof get;
     [init]: typeof addDnsConfig;
+    [help]: () => string;
 };
 export default _default;

package/dist/index.js

@@ -1,10 +1,10 @@
-import fs from 'node:fs';
-import { join } from 'node:path';
-import { exec } from '@cloud-cli/exec';
-import { getConfig, init } from '@cloud-cli/cli';
-const filePath = join(process.cwd(), 'configuration', 'hosts.conf');
+import fs from "node:fs";
+import { join } from "node:path";
+import { exec } from "@cloud-cli/exec";
+import { getConfig, init, help } from "@cloud-cli/cli";
+const filePath = join(process.cwd(), "configuration", "hosts.conf");
 const dnsConfig = {
-    defaultTarget: '127.0.0.1',
+    defaultTarget: "127.0.0.1",
 };
 function add(input) {
     let current = list();
@@ -26,27 +26,46 @@ function list() {
     if (!fs.existsSync(filePath)) {
         return [];
     }
-    const input = fs.readFileSync(filePath, 'utf8');
-    const entries = input.trim().split('\n').filter(Boolean).flatMap(parseDNSLine);
+    const input = fs.readFileSync(filePath, "utf8");
+    const entries = input.trim().split("\n").filter(Boolean).flatMap(parseDNSLine);
     return entries;
 }
 function get(options) {
     return list().filter((d) => d.domain === options.domain)[0] || null;
 }
 async function reload() {
-    const getPid = await exec('pidof', ['dnsmasq']);
-    const cmd = await exec('kill', ['-s', 'HUP', getPid.stdout.trim()]);
-    return cmd.ok || Promise.reject(new Error('Failed to reload'));
+    const getPid = await exec("pidof", ["dnsmasq"]);
+    const cmd = await exec("kill", ["-s", "HUP", getPid.stdout.trim()]);
+    return cmd.ok || Promise.reject(new Error("Failed to reload"));
 }
 function addDnsConfig() {
-    Object.assign(dnsConfig, getConfig('dns'));
+    Object.assign(dnsConfig, getConfig("dns"));
 }
 function save(list) {
-    let lines = list.map(next => next.target + ' ' + next.domain);
-    fs.writeFileSync(filePath, lines.join('\n').trim());
+    const lines = list.map((next) => next.target + " " + next.domain);
+    fs.writeFileSync(filePath, lines.join("\n").trim());
 }
 export function parseDNSLine(line) {
     const [ip, ...domains] = line.split(/\s+/);
     return domains.map((d) => ({ domain: d, target: ip }));
 }
-export default { add, remove, list, reload, get, [init]: addDnsConfig };
+export default {
+    add,
+    remove,
+    list,
+    reload,
+    get,
+    [init]: addDnsConfig,
+    [help]: () => `Manage DNS host entries
+
+Available commands:
+  dns.add --domain <domain> [--target <ip>] - Add a DNS entry (target defaults to 127.0.0.1)
+  dns.remove --domain <domain> - Remove a DNS entry
+  dns.list - List all DNS entries
+  dns.reload - Reload the DNS service
+  dns.get --domain <domain> - Get a DNS entry
+
+Options:
+  domain - Domain name
+  target - IP address (defaults to 127.0.0.1)`,
+};

package/dist/index.spec.js

@@ -1,90 +1,109 @@
-import dns, { parseDNSLine } from './index';
-import fs from 'fs';
-import { init } from '@cloud-cli/cli';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import dns, { parseDNSLine } from "./index";
+import fs from "fs";
+import { init, help } from "@cloud-cli/cli";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 const execMocks = vi.hoisted(() => ({
     exec: vi.fn(),
     getConfig: vi.fn(),
 }));
-vi.mock('get-port', () => ({ default: vi.fn().mockReturnValue(1234) }));
-vi.mock('@cloud-cli/exec', () => ({ exec: execMocks.exec }));
-vi.mock('@cloud-cli/cli', async (original) => {
+vi.mock("get-port", () => ({ default: vi.fn().mockReturnValue(1234) }));
+vi.mock("@cloud-cli/exec", () => ({ exec: execMocks.exec }));
+vi.mock("@cloud-cli/cli", async (original) => {
     const mod = await original();
     return {
         ...mod,
         getConfig: execMocks.getConfig,
+        help: mod.help,
     };
 });
 beforeEach(() => {
-    vi.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
-    vi.spyOn(fs, 'readFileSync').mockImplementation(() => '');
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => { });
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => "");
 });
-describe('dns', () => {
-    it('should parse a DNS configuration line', () => {
-        const line = '1.2.3.4     foo bar';
+describe("dns", () => {
+    it("should have a [help] Symbol export that is a function", () => {
+        expect(dns[help]).toBeDefined();
+        expect(typeof dns[help]).toBe("function");
+    });
+    it("should return a string help text", () => {
+        const helpText = dns[help]();
+        expect(typeof help).toBe("symbol");
+        expect(typeof helpText).toBe("string");
+        expect(helpText).toContain("DNS");
+        expect(helpText).toContain("dns.add --domain <domain>");
+        expect(helpText).toContain("dns.remove --domain <domain>");
+        expect(helpText).toContain("dns.list");
+        expect(helpText).toContain("dns.reload");
+        expect(helpText).toContain("dns.get --domain <domain>");
+    });
+    it('should not expose "help" as a normal command key', () => {
+        expect(Object.hasOwn(dns, "help")).toBe(false);
+    });
+    it("should parse a DNS configuration line", () => {
+        const line = "1.2.3.4     foo bar";
         const output = parseDNSLine(line);
         expect(output).toEqual([
-            { target: '1.2.3.4', domain: 'foo' },
-            { target: '1.2.3.4', domain: 'bar' },
+            { target: "1.2.3.4", domain: "foo" },
+            { target: "1.2.3.4", domain: "bar" },
         ]);
     });
-    it('should load entries from file', () => {
+    it("should load entries from file", () => {
         let fileExists = false;
         const buffer = `1.2.3.4 test\n5.6.7.8 foo`;
-        vi.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
-        vi.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
+        vi.spyOn(fs, "existsSync").mockImplementation(() => fileExists);
+        vi.spyOn(fs, "readFileSync").mockImplementation(() => buffer);
         expect(dns.list()).toEqual([]);
         fileExists = true;
         const list = dns.list();
         expect(list).toEqual([
-            { domain: 'test', target: '1.2.3.4' },
-            { domain: 'foo', target: '5.6.7.8' },
+            { domain: "test", target: "1.2.3.4" },
+            { domain: "foo", target: "5.6.7.8" },
         ]);
     });
-    it('should get a DNS entry by domain', () => {
+    it("should get a DNS entry by domain", () => {
         let fileExists = false;
         const buffer = `1.2.3.4 test.com\n5.6.7.8 foo.com`;
-        vi.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
-        vi.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
-        expect(dns.get({ domain: 'foo.com' })).toBe(null);
+        vi.spyOn(fs, "existsSync").mockImplementation(() => fileExists);
+        vi.spyOn(fs, "readFileSync").mockImplementation(() => buffer);
+        expect(dns.get({ domain: "foo.com" })).toBe(null);
         fileExists = true;
-        expect(dns.get({ domain: 'foo.com' })).toEqual({ domain: 'foo.com', target: '5.6.7.8' });
+        expect(dns.get({ domain: "foo.com" })).toEqual({ domain: "foo.com", target: "5.6.7.8" });
     });
-    it('should add and remove local DNS entries', () => {
-        let text = '';
-        vi.spyOn(fs, 'writeFileSync').mockImplementation((_file, value) => {
+    it("should add and remove local DNS entries", () => {
+        let text = "";
+        vi.spyOn(fs, "writeFileSync").mockImplementation((_file, value) => {
             text = value;
         });
-        vi.spyOn(fs, 'readFileSync').mockImplementation(() => text);
-        dns.add({ domain: 'foo', target: '2.3.4.5' });
-        dns.add({ domain: 'bar', target: '2.3.4.5' });
-        dns.add({ domain: 'baz' });
-        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo');
-        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo\n2.3.4.5 bar');
-        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo\n2.3.4.5 bar\n127.0.0.1 baz');
-        dns.remove({ domain: 'baz' });
-        expect(text).toBe('2.3.4.5 foo\n2.3.4.5 bar');
+        vi.spyOn(fs, "readFileSync").mockImplementation(() => text);
+        dns.add({ domain: "foo", target: "2.3.4.5" });
+        dns.add({ domain: "bar", target: "2.3.4.5" });
+        dns.add({ domain: "baz" });
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo");
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo\n2.3.4.5 bar");
+        expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo\n2.3.4.5 bar\n127.0.0.1 baz");
+        dns.remove({ domain: "baz" });
+        expect(text).toBe("2.3.4.5 foo\n2.3.4.5 bar");
     });
-    describe('reload', () => {
-        it('should reload the DNS service', async () => {
-            execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: '123' });
+    describe("reload", () => {
+        it("should reload the DNS service", async () => {
+            execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: "123" });
             execMocks.exec.mockResolvedValueOnce({ ok: true });
             await expect(dns.reload()).resolves.toBe(true);
-            expect(execMocks.exec).toHaveBeenCalledWith('pidof', ['dnsmasq']);
-            expect(execMocks.exec).toHaveBeenCalledWith('kill', ['-s', 'HUP', '123']);
+            expect(execMocks.exec).toHaveBeenCalledWith("pidof", ["dnsmasq"]);
+            expect(execMocks.exec).toHaveBeenCalledWith("kill", ["-s", "HUP", "123"]);
         });
-        it('should show error on reload', async () => {
-            execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: '123' });
-            execMocks.exec.mockResolvedValueOnce({ ok: false, stderr: 'error' });
-            await expect(dns.reload()).rejects.toEqual(new Error('Failed to reload'));
+        it("should show error on reload", async () => {
+            execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: "123" });
+            execMocks.exec.mockResolvedValueOnce({ ok: false, stderr: "error" });
+            await expect(dns.reload()).rejects.toEqual(new Error("Failed to reload"));
         });
     });
-    describe('dns configuration', () => {
-        it('should configure the default target', () => {
-            execMocks.getConfig.mockReturnValue({ defaultTarget: '1.1.2.2' });
+    describe("dns configuration", () => {
+        it("should configure the default target", () => {
+            execMocks.getConfig.mockReturnValue({ defaultTarget: "1.1.2.2" });
             dns[init]();
-            dns.add({ domain: 'bar' });
-            expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '1.1.2.2 bar');
+            dns.add({ domain: "bar" });
+            expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "1.1.2.2 bar");
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/dns",
-  "version": "2.0.3",
+  "version": "2.2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -27,6 +27,6 @@
     "@cloud-cli/exec": "^1.0.4"
   },
   "peerDependencies": {
-    "@cloud-cli/cli": "^2.0.0"
+    "@cloud-cli/cli": "^2.2.0"
   }
 }

package/src/index.spec.ts

@@ -1,111 +1,133 @@
-import dns, { parseDNSLine } from './index';
-import fs from 'fs';
-import { init } from '@cloud-cli/cli';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import dns, { parseDNSLine } from "./index";
+import fs from "fs";
+import { init, help } from "@cloud-cli/cli";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 
 const execMocks = vi.hoisted(() => ({
   exec: vi.fn(),
   getConfig: vi.fn(),
 }));
 
-vi.mock('get-port', () => ({ default: vi.fn().mockReturnValue(1234) }));
-vi.mock('@cloud-cli/exec', () => ({ exec: execMocks.exec }));
-vi.mock('@cloud-cli/cli', async (original) => {
+vi.mock("get-port", () => ({ default: vi.fn().mockReturnValue(1234) }));
+vi.mock("@cloud-cli/exec", () => ({ exec: execMocks.exec }));
+vi.mock("@cloud-cli/cli", async (original) => {
   const mod: any = await original();
   return {
     ...mod,
     getConfig: execMocks.getConfig,
+    help: mod.help,
   };
 });
 
 beforeEach(() => {
-  vi.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
-  vi.spyOn(fs, 'readFileSync').mockImplementation(() => '');
+  vi.spyOn(fs, "writeFileSync").mockImplementation(() => {});
+  vi.spyOn(fs, "readFileSync").mockImplementation(() => "");
 });
 
-describe('dns', () => {
-  it('should parse a DNS configuration line', () => {
-    const line = '1.2.3.4     foo bar';
+describe("dns", () => {
+  it("should have a [help] Symbol export that is a function", () => {
+    expect(dns[help]).toBeDefined();
+    expect(typeof dns[help]).toBe("function");
+  });
+
+  it("should return a string help text", () => {
+    const helpText = dns[help]();
+    expect(typeof help).toBe("symbol");
+    expect(typeof helpText).toBe("string");
+    expect(helpText).toContain("DNS");
+    expect(helpText).toContain("dns.add --domain <domain>");
+    expect(helpText).toContain("dns.remove --domain <domain>");
+    expect(helpText).toContain("dns.list");
+    expect(helpText).toContain("dns.reload");
+    expect(helpText).toContain("dns.get --domain <domain>");
+  });
+
+  it('should not expose "help" as a normal command key', () => {
+    expect(Object.hasOwn(dns, "help")).toBe(false);
+  });
+
+  it("should parse a DNS configuration line", () => {
+    const line = "1.2.3.4     foo bar";
     const output = parseDNSLine(line);
 
     expect(output).toEqual([
-      { target: '1.2.3.4', domain: 'foo' },
-      { target: '1.2.3.4', domain: 'bar' },
+      { target: "1.2.3.4", domain: "foo" },
+      { target: "1.2.3.4", domain: "bar" },
     ]);
   });
 
-  it('should load entries from file', () => {
+  it("should load entries from file", () => {
     let fileExists = false;
     const buffer = `1.2.3.4 test\n5.6.7.8 foo`;
-    vi.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
-    vi.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
+    vi.spyOn(fs, "existsSync").mockImplementation(() => fileExists);
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => buffer);
 
     expect(dns.list()).toEqual([]);
 
     fileExists = true;
     const list = dns.list();
     expect(list).toEqual([
-      { domain: 'test', target: '1.2.3.4' },
-      { domain: 'foo', target: '5.6.7.8' },
+      { domain: "test", target: "1.2.3.4" },
+      { domain: "foo", target: "5.6.7.8" },
     ]);
   });
 
-  it('should get a DNS entry by domain', () => {
+  it("should get a DNS entry by domain", () => {
     let fileExists = false;
     const buffer = `1.2.3.4 test.com\n5.6.7.8 foo.com`;
-    vi.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
-    vi.spyOn(fs, 'readFileSync').mockImplementation(() => buffer);
+    vi.spyOn(fs, "existsSync").mockImplementation(() => fileExists);
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => buffer);
 
-    expect(dns.get({ domain: 'foo.com' })).toBe(null);
+    expect(dns.get({ domain: "foo.com" })).toBe(null);
 
     fileExists = true;
-    expect(dns.get({ domain: 'foo.com' })).toEqual({ domain: 'foo.com', target: '5.6.7.8' });
+    expect(dns.get({ domain: "foo.com" })).toEqual({ domain: "foo.com", target: "5.6.7.8" });
   });
 
-  it('should add and remove local DNS entries', () => {
-    let text = '';
-    vi.spyOn(fs, 'writeFileSync').mockImplementation((_file, value: string) => {
+  it("should add and remove local DNS entries", () => {
+    let text = "";
+    vi.spyOn(fs, "writeFileSync").mockImplementation((_file, value: string) => {
       text = value;
     });
-    vi.spyOn(fs, 'readFileSync').mockImplementation(() => text);
+    vi.spyOn(fs, "readFileSync").mockImplementation(() => text);
 
-    dns.add({ domain: 'foo', target: '2.3.4.5' });
-    dns.add({ domain: 'bar', target: '2.3.4.5' });
-    dns.add({ domain: 'baz' });
+    dns.add({ domain: "foo", target: "2.3.4.5" });
+    dns.add({ domain: "bar", target: "2.3.4.5" });
+    dns.add({ domain: "baz" });
 
-    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo');
-    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo\n2.3.4.5 bar');
-    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '2.3.4.5 foo\n2.3.4.5 bar\n127.0.0.1 baz');
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo");
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo\n2.3.4.5 bar");
+    expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "2.3.4.5 foo\n2.3.4.5 bar\n127.0.0.1 baz");
 
-    dns.remove({ domain: 'baz' });
-    expect(text).toBe('2.3.4.5 foo\n2.3.4.5 bar');
+    dns.remove({ domain: "baz" });
+    expect(text).toBe("2.3.4.5 foo\n2.3.4.5 bar");
   });
 
-  describe('reload', () => {
-    it('should reload the DNS service', async () => {
-      execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: '123' } as any);
+  describe("reload", () => {
+    it("should reload the DNS service", async () => {
+      execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: "123" } as any);
       execMocks.exec.mockResolvedValueOnce({ ok: true } as any);
 
       await expect(dns.reload()).resolves.toBe(true);
-      expect(execMocks.exec).toHaveBeenCalledWith('pidof', ['dnsmasq']);
-      expect(execMocks.exec).toHaveBeenCalledWith('kill', ['-s', 'HUP', '123']);
+      expect(execMocks.exec).toHaveBeenCalledWith("pidof", ["dnsmasq"]);
+      expect(execMocks.exec).toHaveBeenCalledWith("kill", ["-s", "HUP", "123"]);
     });
 
-    it('should show error on reload', async () => {
-      execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: '123' } as any);
-      execMocks.exec.mockResolvedValueOnce({ ok: false, stderr: 'error' } as any);
+    it("should show error on reload", async () => {
+      execMocks.exec.mockResolvedValueOnce({ ok: true, stdout: "123" } as any);
+      execMocks.exec.mockResolvedValueOnce({ ok: false, stderr: "error" } as any);
 
-      await expect(dns.reload()).rejects.toEqual(new Error('Failed to reload'));
+      await expect(dns.reload()).rejects.toEqual(new Error("Failed to reload"));
     });
   });
 
-  describe('dns configuration', () => {
-    it('should configure the default target', () => {
-      execMocks.getConfig.mockReturnValue({ defaultTarget: '1.1.2.2' });
+  describe("dns configuration", () => {
+    it("should configure the default target", () => {
+      execMocks.getConfig.mockReturnValue({ defaultTarget: "1.1.2.2" });
       dns[init]();
-      dns.add({ domain: 'bar' });
+      dns.add({ domain: "bar" });
 
-      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), '1.1.2.2 bar');
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.any(String), "1.1.2.2 bar");
     });
   });
 });

package/src/index.ts

@@ -1,15 +1,15 @@
-import fs from 'node:fs';
-import { join } from 'node:path';
-import { exec } from '@cloud-cli/exec';
-import { getConfig, init } from '@cloud-cli/cli';
+import fs from "node:fs";
+import { join } from "node:path";
+import { exec } from "@cloud-cli/exec";
+import { getConfig, init, help } from "@cloud-cli/cli";
 
 interface DNSConfig {
   defaultTarget?: string;
 }
 
-const filePath = join(process.cwd(), 'configuration', 'hosts.conf');
+const filePath = join(process.cwd(), "configuration", "hosts.conf");
 const dnsConfig: DNSConfig = {
-  defaultTarget: '127.0.0.1',
+  defaultTarget: "127.0.0.1",
 };
 
 interface DomainAndTarget {
@@ -43,8 +43,8 @@ function list(): DomainAndTarget[] {
     return [];
   }
 
-  const input = fs.readFileSync(filePath, 'utf8');
-  const entries = input.trim().split('\n').filter(Boolean).flatMap(parseDNSLine);
+  const input = fs.readFileSync(filePath, "utf8");
+  const entries = input.trim().split("\n").filter(Boolean).flatMap(parseDNSLine);
 
   return entries;
 }
@@ -54,18 +54,18 @@ function get(options: { domain: string }): DomainAndTarget | null {
 }
 
 async function reload() {
-  const getPid = await exec('pidof', ['dnsmasq']);
-  const cmd = await exec('kill', ['-s', 'HUP', getPid.stdout.trim()]);
-  return cmd.ok || Promise.reject(new Error('Failed to reload'));
+  const getPid = await exec("pidof", ["dnsmasq"]);
+  const cmd = await exec("kill", ["-s", "HUP", getPid.stdout.trim()]);
+  return cmd.ok || Promise.reject(new Error("Failed to reload"));
 }
 
 function addDnsConfig() {
-  Object.assign(dnsConfig, getConfig('dns'));
+  Object.assign(dnsConfig, getConfig("dns"));
 }
 
 function save(list: DomainAndTarget[]) {
-  let lines = list.map(next => next.target + ' ' + next.domain);
-  fs.writeFileSync(filePath, lines.join('\n').trim());
+  const lines = list.map((next) => next.target + " " + next.domain);
+  fs.writeFileSync(filePath, lines.join("\n").trim());
 }
 
 export function parseDNSLine(line: string): DomainAndTarget[] {
@@ -73,4 +73,23 @@ export function parseDNSLine(line: string): DomainAndTarget[] {
   return domains.map((d) => ({ domain: d, target: ip }));
 }
 
-export default { add, remove, list, reload, get, [init]: addDnsConfig };
+export default {
+  add,
+  remove,
+  list,
+  reload,
+  get,
+  [init]: addDnsConfig,
+  [help]: () => `Manage DNS host entries
+
+Available commands:
+  dns.add --domain <domain> [--target <ip>] - Add a DNS entry (target defaults to 127.0.0.1)
+  dns.remove --domain <domain> - Remove a DNS entry
+  dns.list - List all DNS entries
+  dns.reload - Reload the DNS service
+  dns.get --domain <domain> - Get a DNS entry
+
+Options:
+  domain - Domain name
+  target - IP address (defaults to 127.0.0.1)`,
+};