zeuslock-dlp-cli 0.2.0

package/src/cli.js

@@ -0,0 +1,78 @@
+import { createRequire } from "node:module";
+import { Command } from "commander";
+
+import { createAgentsCommand } from "./commands/agents.js";
+import { createAnonymizeCommand } from "./commands/anonymize.js";
+import { createAuthCommand } from "./commands/auth.js";
+import { createDeployCommand } from "./commands/deploy.js";
+import { createExtensionsCommand } from "./commands/extensions.js";
+import { createHookCommand } from "./commands/hook.js";
+import { createIncidentsCommand } from "./commands/incidents.js";
+import { createKeysCommand } from "./commands/keys.js";
+import { createMcpCommand } from "./commands/mcp.js";
+import { createRulesCommand } from "./commands/rules.js";
+import { createScanCommand } from "./commands/scan.js";
+import { createShadowAiCommand } from "./commands/shadow-ai.js";
+import { createSiemCommand } from "./commands/siem.js";
+import { createStatusCommand } from "./commands/status.js";
+import { createTokensCommand } from "./commands/tokens.js";
+import { createUsersCommand } from "./commands/users.js";
+import { createWhoamiCommand } from "./commands/whoami.js";
+import { assertCliAccessToken } from "./lib/cli-token.js";
+import { setCommandToken } from "./lib/command-token.js";
+
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+
+export function buildProgram({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  env = process.env
+} = {}) {
+  const program = new Command();
+
+  program
+    .name("zeuslock")
+    .description("ZeusLock command line")
+    .version(packageJson.version)
+    .option("--token <zlu_token>", "personal CLI access token for one command invocation")
+    .configureOutput({
+      writeOut: (text) => stdout.write(text),
+      writeErr: (text) => stderr.write(text),
+      outputError: (text, write) => write(text)
+    });
+
+  program.hook("preAction", (thisCommand) => {
+    const token = String(thisCommand.opts().token || "").trim();
+    if (token) {
+      assertCliAccessToken(token, "--token");
+    }
+    setCommandToken(env, token);
+  });
+
+  program.addCommand(createAuthCommand({ stdin, stdout, stderr, env }));
+  program.addCommand(createScanCommand({ stdin, stdout, env }));
+  program.addCommand(createAnonymizeCommand({ stdout, env }));
+  program.addCommand(createHookCommand({ stdout, env }));
+  program.addCommand(createDeployCommand({ stdout, env }));
+  program.addCommand(createAgentsCommand({ stdin, stdout, env }));
+  program.addCommand(createExtensionsCommand({ stdout, env }));
+  program.addCommand(createIncidentsCommand({ stdout, env }));
+  program.addCommand(createUsersCommand({ stdin, stdout, env }));
+  program.addCommand(createKeysCommand({ stdin, stdout, env }));
+  program.addCommand(createTokensCommand({ stdin, stdout, env }));
+  program.addCommand(createRulesCommand({ stdout, env }));
+  program.addCommand(createSiemCommand({ stdout, env }));
+  program.addCommand(createShadowAiCommand({ stdout, env }));
+  program.addCommand(createMcpCommand({ stdout, env }));
+  program.addCommand(createWhoamiCommand({ stdout, stderr, env }));
+  program.addCommand(createStatusCommand({ stdout, env }));
+
+  return program;
+}
+
+export async function run(argv = process.argv) {
+  const program = buildProgram();
+  await program.parseAsync(argv);
+}

package/src/commands/agents.js

@@ -0,0 +1,211 @@
+import { Command } from "commander";
+
+import { requestAuthenticatedJson } from "../lib/api-client.js";
+import { promptText } from "../lib/prompt.js";
+import { dash, formatTable } from "../lib/table.js";
+import { parseApiTimestamp } from "../lib/time.js";
+import { compareVersions } from "../lib/version.js";
+
+const AGENT_ONLINE_WINDOW_MS = 5 * 60 * 1000;
+const STATUS_FILTERS = ["all", "online", "offline"];
+
+export function createAgentsCommand({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  env = process.env
+} = {}) {
+  const command = new Command("agents")
+    .description("Review and manage desktop agents");
+
+  command.addCommand(createAgentsListCommand({ stdout, env }));
+  command.addCommand(createAgentsRevokeCommand({ stdin, stdout, env }));
+
+  return command;
+}
+
+function createAgentsListCommand({ stdout = process.stdout, env = process.env } = {}) {
+  return new Command("list")
+    .description("List desktop agents")
+    .option("--status <status>", "status filter: all, online, or offline", "all")
+    .option("--search <text>", "search hostname or platform")
+    .option("--json", "print machine-readable output")
+    .action(async (options) => {
+      const status = parseStatus(options.status);
+      const agentsData = await requestAuthenticatedJson("/api/agents", { env });
+      const latestVersion = await fetchLatestAgentVersion({ env });
+      const agents = normalizeAgents(
+        Array.isArray(agentsData) ? agentsData : (agentsData.agents || []),
+        latestVersion
+      );
+
+      const filtered = agents.filter((agent) =>
+        matchesAgentFilters(agent, {
+          status,
+          search: options.search
+        })
+      );
+
+      const output = {
+        total: typeof agentsData?.total === "number" ? agentsData.total : agents.length,
+        online_count: typeof agentsData?.online_count === "number"
+          ? agentsData.online_count
+          : agents.filter((agent) => agent.is_online).length,
+        offline_count: typeof agentsData?.offline_count === "number"
+          ? agentsData.offline_count
+          : agents.filter((agent) => !agent.is_online).length,
+        latest_version: latestVersion || null,
+        filters: {
+          status,
+          search: options.search || null
+        },
+        agents: filtered
+      };
+
+      if (options.json) {
+        stdout.write(`${JSON.stringify(output)}\n`);
+        return;
+      }
+
+      stdout.write(`Agents: ${output.total} total, ${output.online_count} online, ${output.offline_count} offline\n`);
+      if (latestVersion) {
+        stdout.write(`Latest published version: ${latestVersion}\n`);
+      }
+      if (!filtered.length) {
+        stdout.write("No agents found.\n");
+        return;
+      }
+
+      stdout.write("\n");
+      stdout.write(`${formatTable(filtered, [
+        { header: "AGENT ID", value: (agent) => dash(agent.agent_id) },
+        { header: "HOSTNAME", value: (agent) => dash(agent.hostname) },
+        { header: "PLATFORM", value: (agent) => dash(agent.platform) },
+        { header: "VERSION", value: (agent) => dash(agent.version) },
+        { header: "UPDATE", value: (agent) => agent.update_available ? "yes" : "-" },
+        { header: "STATUS", value: (agent) => agent.status },
+        { header: "USER", value: (agent) => dash(agent.username) },
+        { header: "LAST HEARTBEAT", value: (agent) => dash(agent.last_seen) }
+      ])}\n`);
+    });
+}
+
+function createAgentsRevokeCommand({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  env = process.env
+} = {}) {
+  return new Command("revoke")
+    .description("Revoke a desktop agent")
+    .argument("<agent_id>", "agent ID from agents list")
+    .option("-y, --yes", "skip confirmation prompt")
+    .option("--json", "print machine-readable output")
+    .action(async (agentId, options) => {
+      if (!options.yes) {
+        const answer = await promptText({
+          message: `Revoke agent ${agentId}? Type "yes" to confirm: `,
+          stdin,
+          stdout,
+          optionName: "--yes"
+        });
+        if (answer.toLowerCase() !== "yes") {
+          stdout.write("Revocation cancelled.\n");
+          return;
+        }
+      }
+
+      const data = await requestAuthenticatedJson(`/api/agents/${encodeURIComponent(agentId)}`, {
+        env,
+        method: "DELETE"
+      });
+      const output = {
+        agent_id: agentId,
+        ...data
+      };
+
+      if (options.json) {
+        stdout.write(`${JSON.stringify(output)}\n`);
+        return;
+      }
+
+      stdout.write(`${output.message || "Agent revoked"}: ${agentId}\n`);
+    });
+}
+
+function parseStatus(value) {
+  const status = String(value || "all").trim().toLowerCase();
+  if (!STATUS_FILTERS.includes(status)) {
+    throw new Error(`Invalid --status. Allowed values: ${STATUS_FILTERS.join(", ")}.`);
+  }
+  return status;
+}
+
+async function fetchLatestAgentVersion({ env }) {
+  try {
+    const downloadsData = await requestAuthenticatedJson("/api/v1/agents/downloads", { env });
+    return downloadsData?.version || "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeAgents(agents, latestVersion = "") {
+  return agents.map((agent) => {
+    const online = computeOnline(agent);
+    const version = agent.version || "";
+    return {
+      agent_id: agent.agent_id || agent.id || "",
+      hostname: agent.hostname || "",
+      platform: agent.platform || "",
+      version,
+      username: agent.username || agent.user || agent.user_email || "",
+      last_seen: agent.last_seen || "",
+      first_seen: agent.first_seen || "",
+      is_online: online,
+      status: online ? "online" : "offline",
+      update_available: isOutdated(version, latestVersion),
+      alerts_today: numberOrZero(agent.alerts_today),
+      blocks_today: numberOrZero(agent.blocks_today),
+      anonymizations_today: numberOrZero(agent.anonymizations_today)
+    };
+  });
+}
+
+function matchesAgentFilters(agent, { status, search = "" }) {
+  if (status === "online" && !agent.is_online) {
+    return false;
+  }
+  if (status === "offline" && agent.is_online) {
+    return false;
+  }
+
+  const query = String(search || "").trim().toLowerCase();
+  if (query) {
+    return (
+      agent.hostname.toLowerCase().includes(query) ||
+      agent.platform.toLowerCase().includes(query)
+    );
+  }
+
+  return true;
+}
+
+function computeOnline(agent, now = new Date()) {
+  if (typeof agent?.is_online === "boolean") {
+    return agent.is_online;
+  }
+
+  const lastSeen = parseApiTimestamp(agent?.last_seen);
+  if (!lastSeen) {
+    return false;
+  }
+
+  return now.getTime() - lastSeen.getTime() < AGENT_ONLINE_WINDOW_MS;
+}
+
+function isOutdated(version, latestVersion) {
+  return Boolean(version && latestVersion && compareVersions(version, latestVersion) < 0);
+}
+
+function numberOrZero(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : 0;
+}

package/src/commands/anonymize.js

@@ -0,0 +1,83 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Command } from "commander";
+
+import { requestApiKeyJson } from "../lib/api-client.js";
+
+export function createAnonymizeCommand({
+  stdout = process.stdout,
+  env = process.env
+} = {}) {
+  return new Command("anonymize")
+    .description("Anonymize a text file before sending it to an LLM")
+    .argument("<file>", "text file to anonymize")
+    .option("--api-key <key>", "organization API key; defaults to saved key or ZEUSLOCK_API_KEY")
+    .option("--output <path>", "write anonymized text to a file instead of stdout")
+    .option("--include-sensitive-map", "include original-to-masked substitutions in JSON output")
+    .option("--json", "print machine-readable output")
+    .action(async (file, options) => {
+      const filePath = path.resolve(file);
+      const text = await readFile(filePath, "utf8");
+      const result = await requestApiKeyJson("/api/v1/anonymize", {
+        env,
+        apiKey: options.apiKey,
+        method: "POST",
+        body: { text }
+      });
+      const anonymizedText = String(result?.anonymized_text ?? result?.masked ?? "");
+      const anonymizationCount = Array.isArray(result?.anonymizations)
+        ? result.anonymizations.length
+        : 0;
+
+      if (options.output) {
+        await writeFile(path.resolve(options.output), anonymizedText, "utf8");
+      }
+
+      if (options.json) {
+        stdout.write(`${JSON.stringify(buildJsonOutput(result, {
+          file: filePath,
+          output: options.output ? path.resolve(options.output) : null,
+          includeSensitiveMap: Boolean(options.includeSensitiveMap),
+          anonymizedText,
+          anonymizationCount
+        }))}\n`);
+        return;
+      }
+
+      if (options.output) {
+        stdout.write(`Anonymized ${anonymizationCount} value(s) to ${path.resolve(options.output)}\n`);
+        return;
+      }
+
+      stdout.write(anonymizedText);
+      if (!anonymizedText.endsWith("\n")) {
+        stdout.write("\n");
+      }
+    });
+}
+
+function buildJsonOutput(result, {
+  file,
+  output,
+  includeSensitiveMap,
+  anonymizedText,
+  anonymizationCount
+}) {
+  const base = {
+    file,
+    output,
+    anonymized_text: anonymizedText,
+    anonymization_count: anonymizationCount
+  };
+
+  if (includeSensitiveMap) {
+    return {
+      ...base,
+      original: result?.original ?? "",
+      masked: result?.masked ?? anonymizedText,
+      anonymizations: Array.isArray(result?.anonymizations) ? result.anonymizations : []
+    };
+  }
+
+  return base;
+}