@thinkingai/ae-cli 1.0.1 → 1.0.3

package/README.md

@@ -50,10 +50,13 @@ After selecting a host, ae-cli automatically checks if the token is valid. If no
 
 ```bash
 # TE meta domain (metadata and governance)
-ae-cli te_meta +list_events --project_id 1
+ae-cli analysis_meta +list_events --project_id 1
 
 # Table output
-ae-cli te_meta +list_events --project_id 1 --format table
+ae-cli analysis_meta +list_events --project_id 1 --format table
+
+# Raw API call
+ae-cli api GET /v1/ta/event/catalog/listEvent --params '{"projectId": 1}'
 ```
 
 ## Authentication
@@ -80,13 +83,13 @@ ae-cli auth logout
 
 | Domain | Commands | Description |
 |--------|----------|-------------|
-| `te_analysis` | 31 | Analysis workflows: alerts, reports, dashboards, ad-hoc/drilldown, clusters/tags, metadata/metrics, project tools, entity details, analysis schema |
-| `te_audience` | 14 | Audience operations: clusters, tags, and cluster/tag definition schema |
-| `te_meta` | 20 | Metadata governance: events/properties, metrics, virtual metadata, project config, tracking plan, mark times, resource links |
-| `te_engage` | 40+ | Hermes Engage MCP: channels, tasks, configs, flows, strategies |
+| `analysis` | 31 | Analysis workflows: alerts, reports, dashboards, ad-hoc/drilldown, clusters/tags, metadata/metrics, project tools, entity details, analysis schema |
+| `analysis_audience` | 14 | Audience operations: clusters, tags, and cluster/tag definition schema |
+| `analysis_meta` | 20 | Metadata governance: events/properties, metrics, virtual metadata, project config, tracking plan, mark times, resource links |
+| `engage` | 40+ | Hermes Engage MCP: channels, tasks, configs, flows, strategies |
 | `te_dataops` | 50+ | Data warehouse management: repos, datatables, flows, IDE queries, integration, operations |
 | `te_community` | 30+ | Community analysis: posts search, sentiment analysis, topic trends, livestream data |
-| `te_common` | 2 | Cross-module common constraints: resource link completion, project ID gate |
+| `analysis_common` | 2 | Cross-module common constraints: resource link completion, project ID gate |
 | `operation` | 11 | Tasks, flows, channels, space navigation |
 
 ### Global Options
@@ -117,7 +120,7 @@ ae-cli auth logout
 Install them with:
 
 ```bash
-npx skills add ThinkingAIAgenticEngine/ae-cli -g -y
+npx skills add http://10.27.249.150:8888/te-ai/te-cli.git#release/6.0 te-ai/ae-cli -g -y
 ```
 
 ## Skill Details
@@ -147,7 +150,7 @@ Metadata and tracking-plan governance:
 - **Mark Times**: date markers management
 - **Entity Catalog**: entity listing
 
-### te-engage (40+ tools)
+### engage (40+ tools)
 
 Hermes Engage MCP capabilities:
 - **Channels**: channel management, config channels, approval management
@@ -218,10 +221,10 @@ src/
 ## Verification Scripts
 
 ```bash
-npm run verify:te-analysis-tools
-npm run verify:te-audience-tools
-npm run verify:te-meta-tools
-npm run verify:te-common-tools
+npm run verify:analysis-tools
+npm run verify:analysis-audience-tools
+npm run verify:analysis-meta-tools
+npm run verify:analysis-common-tools
 ```
 
 ## License

package/dist/auth-BQC5DBE7.js

@@ -0,0 +1,19 @@
+import {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  loadToken,
+  resolveHost,
+  saveToken,
+  setTokenManual
+} from "./chunk-3CDLNXTD.js";
+import "./chunk-EBFUVWIZ.js";
+export {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  loadToken,
+  resolveHost,
+  saveToken,
+  setTokenManual
+};

package/dist/auth-DXKYLMO7.js

@@ -0,0 +1,81 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  resolveHost,
+  setTokenManual
+} from "./chunk-3CDLNXTD.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./chunk-EBFUVWIZ.js";
+
+// src/commands/auth.ts
+function registerAuth(program) {
+  const auth = program.command("auth").description("Authentication management");
+  auth.command("login").description("Login to TE (auto-extract token from Chrome on macOS)").action(async () => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    try {
+      const token = await getToken(host);
+      process.stderr.write(`[ae-cli] Authenticated to ${host}
+`);
+      printOutput({ authenticated: true, host, token: token.slice(0, 8) + "..." }, program.opts().format || "json");
+    } catch (err) {
+      printError("auth", err.message);
+      process.exit(1);
+    }
+  });
+  auth.command("set-token <token>").description("Manually set authentication token for active host").action((token) => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.hosts[host]) {
+      config.hosts[host] = { label: host };
+      if (!config.activeHost) {
+        config.activeHost = host;
+      }
+      saveConfig(config);
+      process.stderr.write(`[ae-cli] Config saved for ${host}
+`);
+      printOutput({ saved: true, config }, program.opts().format || "json");
+    }
+    setTokenManual(token, host);
+    process.stderr.write(`[ae-cli] Token saved for ${host}
+`);
+    printOutput({ saved: true, host }, program.opts().format || "json");
+  });
+  auth.command("status").description("Show current authentication status").action(() => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printOutput({ authenticated: false, host: "(none)", hint: "Run: ae-cli config set-host" }, program.opts().format || "json");
+      return;
+    }
+    const status = getAuthStatus(host);
+    printOutput(status, program.opts().format || "json");
+  });
+  auth.command("logout").description("Clear stored token for active host").action(() => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    clearToken(host);
+    process.stderr.write(`[ae-cli] Token cleared for ${host}
+`);
+    printOutput({ cleared: true, host }, program.opts().format || "json");
+  });
+}
+export {
+  registerAuth
+};

package/dist/chunk-3CDLNXTD.js

@@ -0,0 +1,218 @@
+import {
+  extractHostname,
+  getActiveHost,
+  getConfigDir,
+  safeReadJsonFile
+} from "./chunk-EBFUVWIZ.js";
+
+// src/core/auth.ts
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+var TOKENS_FILE = path.join(getConfigDir(), "tokens.json");
+var LEGACY_DIR = path.join(process.env.HOME || "", ".te-mcp");
+var TOKEN_TTL_MS = 20 * 60 * 60 * 1e3;
+var OSASCRIPT_POLL_INTERVAL_MS = 2e3;
+var OSASCRIPT_POLL_TIMEOUT_MS = 6e4;
+function ensureDir() {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function resolveHost(hostOverride) {
+  if (hostOverride) return hostOverride;
+  return getActiveHost();
+}
+function loadAllTokens() {
+  try {
+    const legacyTokens = path.join(LEGACY_DIR, "tokens.json");
+    if (fs.existsSync(legacyTokens) && !fs.existsSync(TOKENS_FILE)) {
+      const data = safeReadJsonFile(legacyTokens);
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        const url = key.startsWith("http") ? key : `https://${key}`;
+        migrated[url] = val;
+      }
+      ensureDir();
+      fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+      return migrated;
+    }
+    if (fs.existsSync(TOKENS_FILE)) {
+      const data = safeReadJsonFile(TOKENS_FILE);
+      let needsMigration = false;
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        if (!key.startsWith("http")) {
+          migrated[`https://${key}`] = val;
+          needsMigration = true;
+        } else {
+          migrated[key] = val;
+        }
+      }
+      if (needsMigration) {
+        fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+        return migrated;
+      }
+      return data;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveAllTokens(tokens) {
+  ensureDir();
+  fs.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+}
+function loadToken(hostUrl) {
+  const tokens = loadAllTokens();
+  const entry = tokens[hostUrl];
+  if (!entry || !entry.token) return null;
+  if (entry.updatedAt) {
+    const age = Date.now() - new Date(entry.updatedAt).getTime();
+    if (age > TOKEN_TTL_MS) {
+      clearToken(hostUrl);
+      return null;
+    }
+  }
+  return { host: hostUrl, token: entry.token, updatedAt: entry.updatedAt };
+}
+function saveToken(token, hostUrl) {
+  const tokens = loadAllTokens();
+  tokens[hostUrl] = { token, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  saveAllTokens(tokens);
+}
+function clearToken(hostUrl) {
+  const tokens = loadAllTokens();
+  delete tokens[hostUrl];
+  saveAllTokens(tokens);
+}
+function setTokenManual(token, hostUrl) {
+  saveToken(token, hostUrl);
+}
+function getAuthStatus(hostUrl) {
+  if (process.env.TE_TOKEN) {
+    return { authenticated: true, host: hostUrl, source: "env:TE_TOKEN" };
+  }
+  const cached = loadToken(hostUrl);
+  if (cached) {
+    const ageMs = Date.now() - new Date(cached.updatedAt).getTime();
+    const hours = Math.round(ageMs / 36e5);
+    return { authenticated: true, host: hostUrl, tokenAge: `${hours}h ago`, source: "cache" };
+  }
+  return { authenticated: false, host: hostUrl };
+}
+function extractTokenViaOsascript(hostUrl) {
+  if (process.platform !== "darwin") return { token: null, error: "not_mac" };
+  const hostname = extractHostname(hostUrl);
+  const lines = [
+    'tell application "Google Chrome"',
+    "  repeat with w in windows",
+    "    repeat with t in tabs of w",
+    `      if URL of t contains "${hostname}" then`,
+    `        return execute t javascript "localStorage.getItem('ACCESS_TOKEN')"`,
+    "      end if",
+    "    end repeat",
+    "  end repeat",
+    '  return "NO_TAB_FOUND"',
+    "end tell"
+  ];
+  try {
+    const args = lines.flatMap((line) => ["-e", line]);
+    const result = execFileSync("osascript", args, { encoding: "utf8", timeout: 5e3 }).trim();
+    if (result === "NO_TAB_FOUND") return { token: null, error: "no_tab" };
+    if (!result || result === "missing value") return { token: null, error: "no_token" };
+    return { token: result.replace(/^["']|["']$/g, ""), error: null };
+  } catch (e) {
+    const msg = e.message || "";
+    if (msg.includes("not allowed") || msg.includes("assistive access") || msg.includes("(-1743)")) {
+      return { token: null, error: "no_js_permission" };
+    }
+    return { token: null, error: "no_tab" };
+  }
+}
+async function requestTokenViaOsascript(hostUrl) {
+  process.stderr.write(`[ae-cli] No TE tab found in Chrome. Opening ${hostUrl} ...
+`);
+  process.stderr.write(`[ae-cli] Please login, then your token will be captured automatically.
+`);
+  try {
+    const openScript = [
+      'tell application "Google Chrome"',
+      "  activate",
+      "  if (count of windows) > 0 then",
+      `    make new tab at end of tabs of window 1 with properties {URL:"${hostUrl}"}`,
+      "  else",
+      `    open location "${hostUrl}"`,
+      "  end if",
+      "end tell"
+    ];
+    execFileSync("osascript", openScript.flatMap((line) => ["-e", line]), { timeout: 5e3 });
+  } catch {
+    process.stderr.write(`[ae-cli] Could not open browser. Please open ${hostUrl} in Chrome manually.
+`);
+  }
+  const deadline = Date.now() + OSASCRIPT_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, OSASCRIPT_POLL_INTERVAL_MS));
+    const { token, error } = extractTokenViaOsascript(hostUrl);
+    if (token) {
+      process.stderr.write(`[ae-cli] Token captured from Chrome for ${hostUrl}.
+`);
+      return token;
+    }
+    if (error === "no_js_permission") return null;
+  }
+  process.stderr.write(`[ae-cli] Polling timed out after ${OSASCRIPT_POLL_TIMEOUT_MS / 1e3}s.
+`);
+  return null;
+}
+async function getToken(hostUrl) {
+  if (!hostUrl) {
+    throw new Error(
+      `No TE host configured.
+Run: ae-cli config set-host`
+    );
+  }
+  if (process.env.TE_TOKEN) {
+    return process.env.TE_TOKEN;
+  }
+  const cached = loadToken(hostUrl);
+  if (cached && cached.token) return cached.token;
+  const { token: osascriptToken, error } = extractTokenViaOsascript(hostUrl);
+  if (error === "no_js_permission") {
+    throw new Error(
+      `Chrome JavaScript from Apple Events is not enabled.
+Enable it: Chrome menu \u2192 View \u2192 Developer \u2192 Allow JavaScript from Apple Events`
+    );
+  }
+  if (error === "not_mac") {
+    throw new Error(
+      `Auto token extraction is only available on macOS + Chrome.
+Use: ae-cli auth set-token <token>`
+    );
+  }
+  if (osascriptToken) {
+    saveToken(osascriptToken, hostUrl);
+    return osascriptToken;
+  }
+  const polledToken = await requestTokenViaOsascript(hostUrl);
+  if (polledToken) {
+    saveToken(polledToken, hostUrl);
+    return polledToken;
+  }
+  throw new Error(
+    `Cannot obtain token for ${hostUrl}.
+Options:
+  1. ae-cli auth login (macOS + Chrome)
+  2. ae-cli auth set-token <token>`
+  );
+}
+
+export {
+  resolveHost,
+  loadToken,
+  saveToken,
+  clearToken,
+  setTokenManual,
+  getAuthStatus,
+  getToken
+};

package/dist/chunk-53FNNCZW.js

@@ -0,0 +1,174 @@
+import {
+  getToken
+} from "./chunk-3CDLNXTD.js";
+import {
+  getActiveHost,
+  getConfigDir,
+  safeJsonParse,
+  safeReadJsonFile
+} from "./chunk-EBFUVWIZ.js";
+
+// src/core/mcp.ts
+import fs from "fs";
+import path from "path";
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var JSONRPC_VERSION = "2.0";
+var serviceMappingMap = /* @__PURE__ */ new Map();
+registerMcpMapping("analysis", {
+  componentName: "analysis",
+  mappingPath: "analysis"
+});
+registerMcpMapping("te_analysis_extend", {
+  componentName: "analysis",
+  mappingPath: "analysis-extend"
+});
+function registerMcpMapping(serviceName, mapping) {
+  serviceMappingMap.set(serviceName, mapping);
+}
+function registerMcpMappings(mappings) {
+  for (const [serviceName, mapping] of Object.entries(mappings)) {
+    serviceMappingMap.set(serviceName, mapping);
+  }
+}
+function getMcpMapping(serviceName) {
+  const mapping = serviceMappingMap.get(serviceName);
+  if (!mapping) {
+    throw new Error(`MCP mapping not found for service: '${serviceName}'. Please register it using registerMcpMapping() first.`);
+  }
+  return mapping;
+}
+function buildMcpUrl(host, serviceName) {
+  const mapping = getMcpMapping(serviceName);
+  const base = host.replace(/\/+$/, "");
+  return `${base}/mcp/${mapping.componentName}/http/${mapping.mappingPath}`;
+}
+function resolveMcpUrl(mcpUrlOverride, host, serviceName) {
+  if (mcpUrlOverride) {
+    return mcpUrlOverride;
+  }
+  return buildMcpUrl(host, serviceName);
+}
+var requestIdCounter = 1;
+function genRequestId() {
+  return requestIdCounter++;
+}
+var MCP_TOKEN_FILE = path.join(getConfigDir(), "mcp-tokens.json");
+var MCP_TOKEN_GENERATE_PATH = "/v1/ta/mcp/token/generate";
+function loadMcpTokenStore() {
+  try {
+    if (fs.existsSync(MCP_TOKEN_FILE)) {
+      return safeReadJsonFile(MCP_TOKEN_FILE);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveMcpTokenStore(store) {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(MCP_TOKEN_FILE, JSON.stringify(store, null, 2));
+}
+async function generateMcpToken(hostUrl) {
+  const teToken = await getToken(hostUrl);
+  const base = hostUrl.replace(/\/+$/, "");
+  const url = `${base}${MCP_TOKEN_GENERATE_PATH}`;
+  const resp = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `bearer ${teToken}`
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`MCP token generate HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(await resp.text());
+  if (data.return_code !== 0) {
+    throw new Error(`MCP token generate error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  const mcpToken = data.data?.userSecret;
+  if (!mcpToken) {
+    throw new Error("MCP token generate error: empty userSecret in response");
+  }
+  return mcpToken;
+}
+async function getMcpToken(hostOverride) {
+  const hostUrl = hostOverride || getActiveHost();
+  const store = loadMcpTokenStore();
+  if (store[hostUrl]) {
+    return store[hostUrl];
+  }
+  const mcpToken = await generateMcpToken(hostUrl);
+  const updatedStore = { ...store, [hostUrl]: mcpToken };
+  saveMcpTokenStore(updatedStore);
+  return mcpToken;
+}
+async function mcpRequest(url, method, params = {}, hostOverride) {
+  const token = await getMcpToken(hostOverride);
+  const requestId = genRequestId();
+  const paramsWithMeta = {
+    ...params,
+    _meta: { progressToken: requestId }
+  };
+  const body = {
+    jsonrpc: JSONRPC_VERSION,
+    id: requestId,
+    method,
+    params: paramsWithMeta
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+    "mcp-token": token
+  };
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    throw new Error(`MCP HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(await resp.text());
+  if (data.error) {
+    throw new Error(`MCP error: ${data.error.message || JSON.stringify(data.error)}`);
+  }
+  return data.result;
+}
+async function callMcpTool(url, toolName, args = {}, hostOverride) {
+  const params = {
+    name: toolName,
+    arguments: args
+  };
+  const result = await mcpRequest(url, "tools/call", params, hostOverride);
+  return {
+    content: result.content.map((item) => {
+      if (item.type === "text") {
+        return { type: "text", text: item.text };
+      } else if (item.type === "image") {
+        return { type: "image", data: item.data, mimeType: item.mimeType };
+      } else {
+        return { type: "resource", ...item };
+      }
+    }),
+    isError: result.isError
+  };
+}
+function parseMcpResult(result) {
+  if (result.content.length > 0 && result.content[0].type === "text") {
+    const text = result.content[0].text || "";
+    try {
+      return safeJsonParse(text);
+    } catch {
+      return text;
+    }
+  }
+  return result;
+}
+
+export {
+  registerMcpMappings,
+  resolveMcpUrl,
+  callMcpTool,
+  parseMcpResult
+};

package/dist/chunk-EBFUVWIZ.js

@@ -0,0 +1,127 @@
+// src/core/json-utils.ts
+import fs from "fs";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var JSONbig = require2("json-bigint");
+var jsonParser = JSONbig({ storeAsString: true });
+function safeJsonParse(text) {
+  return jsonParser.parse(text);
+}
+function safeReadJsonFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return safeJsonParse(content);
+}
+
+// src/core/config.ts
+import fs2 from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!fs2.existsSync(CONFIG_DIR)) fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadConfig() {
+  try {
+    if (fs2.existsSync(CONFIG_FILE)) {
+      const raw = safeReadJsonFile(CONFIG_FILE);
+      if (raw.defaultHost && !raw.activeHost) {
+        const migrated = migrateConfig(raw);
+        saveConfig(migrated);
+        return migrated;
+      }
+      return raw;
+    }
+  } catch (err) {
+    console.error(`Error loading config: ${err.message}`);
+  }
+  return { activeHost: "", hosts: {} };
+}
+function migrateConfig(old) {
+  const hosts = {};
+  const oldHost = old.defaultHost;
+  if (old.hosts) {
+    for (const [key, val] of Object.entries(old.hosts)) {
+      const url = key.startsWith("http") ? key : `https://${key}`;
+      hosts[url] = val;
+    }
+  }
+  const activeHost = oldHost.startsWith("http") ? oldHost : `https://${oldHost}`;
+  if (!hosts[activeHost]) {
+    hosts[activeHost] = { label: "default" };
+  }
+  return { activeHost, hosts };
+}
+function saveConfig(config) {
+  ensureDir();
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getActiveHost() {
+  const config = loadConfig();
+  return config.activeHost;
+}
+function setActiveHost(url) {
+  const config = loadConfig();
+  if (!config.hosts[url]) {
+    throw new Error(`Host ${url} is not in the configured hosts list. Add it first.`);
+  }
+  config.activeHost = url;
+  saveConfig(config);
+}
+function addHost(url, label) {
+  const config = loadConfig();
+  config.hosts[url] = { label };
+  if (!config.activeHost) {
+    config.activeHost = url;
+  }
+  saveConfig(config);
+}
+function updateHostLabel(url, label) {
+  const config = loadConfig();
+  if (config.hosts[url]) {
+    config.hosts[url].label = label;
+    saveConfig(config);
+  }
+}
+function removeHost(url) {
+  const config = loadConfig();
+  delete config.hosts[url];
+  if (config.activeHost === url) {
+    const remaining = Object.keys(config.hosts);
+    config.activeHost = remaining.length > 0 ? remaining[0] : "";
+  }
+  saveConfig(config);
+}
+function listHosts() {
+  const config = loadConfig();
+  return Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function extractHostname(fullUrl) {
+  try {
+    const u = new URL(fullUrl);
+    return u.host;
+  } catch {
+    return fullUrl;
+  }
+}
+
+export {
+  safeJsonParse,
+  safeReadJsonFile,
+  loadConfig,
+  saveConfig,
+  getActiveHost,
+  setActiveHost,
+  addHost,
+  updateHostLabel,
+  removeHost,
+  listHosts,
+  getConfigDir,
+  extractHostname
+};