@hasna/microservices 0.0.4 → 0.0.5

package/microservices/microservice-contracts/src/mcp/index.ts

@@ -13,16 +13,33 @@ import {
   listExpiring,
   renewContract,
   getContractStats,
+  submitForReview,
+  approveContract,
+  getContractHistory,
+  recordSignature,
+  listSignatures,
+  compareContracts,
+  exportContract,
 } from "../db/contracts.js";
 import {
   createClause,
   listClauses,
   deleteClause,
+  addClauseFromTemplate,
+  saveClauseTemplate,
+  listClauseTemplates,
 } from "../db/contracts.js";
 import {
   createReminder,
   listReminders,
   deleteReminder,
+  setMultiReminders,
+} from "../db/contracts.js";
+import {
+  createObligation,
+  listObligations,
+  completeObligation,
+  listOverdueObligations,
 } from "../db/contracts.js";
 
 const server = new McpServer({
@@ -40,7 +57,7 @@ server.registerTool(
     inputSchema: {
       title: z.string(),
       type: z.enum(["nda", "service", "employment", "license", "other"]).optional(),
-      status: z.enum(["draft", "pending_signature", "active", "expired", "terminated"]).optional(),
+      status: z.enum(["draft", "pending_review", "pending_signature", "active", "expired", "terminated"]).optional(),
       counterparty: z.string().optional(),
       counterparty_email: z.string().optional(),
       start_date: z.string().optional(),
@@ -82,7 +99,7 @@ server.registerTool(
     inputSchema: {
       search: z.string().optional(),
       type: z.enum(["nda", "service", "employment", "license", "other"]).optional(),
-      status: z.enum(["draft", "pending_signature", "active", "expired", "terminated"]).optional(),
+      status: z.enum(["draft", "pending_review", "pending_signature", "active", "expired", "terminated"]).optional(),
       counterparty: z.string().optional(),
       limit: z.number().optional(),
     },
@@ -109,7 +126,7 @@ server.registerTool(
       id: z.string(),
       title: z.string().optional(),
       type: z.enum(["nda", "service", "employment", "license", "other"]).optional(),
-      status: z.enum(["draft", "pending_signature", "active", "expired", "terminated"]).optional(),
+      status: z.enum(["draft", "pending_review", "pending_signature", "active", "expired", "terminated"]).optional(),
       counterparty: z.string().optional(),
       counterparty_email: z.string().optional(),
       start_date: z.string().optional(),
@@ -209,6 +226,148 @@ server.registerTool(
   }
 );
 
+// --- Approval workflow ---
+
+server.registerTool(
+  "submit_for_review",
+  {
+    title: "Submit for Review",
+    description: "Submit a draft contract for review (draft -> pending_review).",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    try {
+      const contract = submitForReview(id);
+      if (!contract) {
+        return { content: [{ type: "text", text: `Contract '${id}' not found.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(contract, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
+server.registerTool(
+  "approve_contract",
+  {
+    title: "Approve Contract",
+    description: "Approve a contract, advancing it through the approval workflow (pending_review -> pending_signature -> active).",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    try {
+      const contract = approveContract(id);
+      if (!contract) {
+        return { content: [{ type: "text", text: `Contract '${id}' not found.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(contract, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
+// --- Version history ---
+
+server.registerTool(
+  "contract_history",
+  {
+    title: "Contract History",
+    description: "Get version history for a contract, showing previous states before each update.",
+    inputSchema: { contract_id: z.string() },
+  },
+  async ({ contract_id }) => {
+    const history = getContractHistory(contract_id);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ history, count: history.length }, null, 2) },
+      ],
+    };
+  }
+);
+
+// --- Signature logging ---
+
+server.registerTool(
+  "record_signature",
+  {
+    title: "Record Signature",
+    description: "Record a signature on a contract.",
+    inputSchema: {
+      contract_id: z.string(),
+      signer_name: z.string(),
+      signer_email: z.string().optional(),
+      method: z.enum(["digital", "wet", "docusign"]).optional(),
+    },
+  },
+  async (params) => {
+    const sig = recordSignature(params);
+    return { content: [{ type: "text", text: JSON.stringify(sig, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_signatures",
+  {
+    title: "List Signatures",
+    description: "List all signatures for a contract.",
+    inputSchema: { contract_id: z.string() },
+  },
+  async ({ contract_id }) => {
+    const sigs = listSignatures(contract_id);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ signatures: sigs, count: sigs.length }, null, 2) },
+      ],
+    };
+  }
+);
+
+// --- Contract comparison ---
+
+server.registerTool(
+  "compare_contracts",
+  {
+    title: "Compare Contracts",
+    description: "Compare two contracts, showing field and clause differences.",
+    inputSchema: {
+      id1: z.string(),
+      id2: z.string(),
+    },
+  },
+  async ({ id1, id2 }) => {
+    try {
+      const diff = compareContracts(id1, id2);
+      return { content: [{ type: "text", text: JSON.stringify(diff, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
+// --- Markdown export ---
+
+server.registerTool(
+  "export_contract",
+  {
+    title: "Export Contract",
+    description: "Export a contract as formatted markdown or JSON.",
+    inputSchema: {
+      id: z.string(),
+      format: z.enum(["md", "json"]).optional(),
+    },
+  },
+  async ({ id, format }) => {
+    try {
+      const output = exportContract(id, format || "md");
+      return { content: [{ type: "text", text: output }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
 // --- Clauses ---
 
 server.registerTool(
@@ -259,6 +418,132 @@ server.registerTool(
   }
 );
 
+// --- Clause templates ---
+
+server.registerTool(
+  "save_clause_template",
+  {
+    title: "Save Clause Template",
+    description: "Save a clause as a reusable template in the clause library.",
+    inputSchema: {
+      name: z.string(),
+      text: z.string(),
+      type: z.enum(["standard", "custom", "negotiated"]).optional(),
+    },
+  },
+  async (params) => {
+    const template = saveClauseTemplate(params);
+    return { content: [{ type: "text", text: JSON.stringify(template, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_clause_templates",
+  {
+    title: "List Clause Templates",
+    description: "List all clause templates in the clause library.",
+    inputSchema: {},
+  },
+  async () => {
+    const templates = listClauseTemplates();
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ templates, count: templates.length }, null, 2) },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "add_clause_from_template",
+  {
+    title: "Add Clause from Template",
+    description: "Add a clause to a contract using a clause template by name.",
+    inputSchema: {
+      contract_id: z.string(),
+      template_name: z.string(),
+    },
+  },
+  async ({ contract_id, template_name }) => {
+    try {
+      const clause = addClauseFromTemplate(contract_id, template_name);
+      return { content: [{ type: "text", text: JSON.stringify(clause, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
+// --- Obligations ---
+
+server.registerTool(
+  "add_obligation",
+  {
+    title: "Add Obligation",
+    description: "Add an obligation to a clause for tracking.",
+    inputSchema: {
+      clause_id: z.string(),
+      description: z.string(),
+      due_date: z.string().optional(),
+      assigned_to: z.string().optional(),
+    },
+  },
+  async (params) => {
+    const obligation = createObligation(params);
+    return { content: [{ type: "text", text: JSON.stringify(obligation, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_obligations",
+  {
+    title: "List Obligations",
+    description: "List all obligations for a clause.",
+    inputSchema: { clause_id: z.string() },
+  },
+  async ({ clause_id }) => {
+    const obligations = listObligations(clause_id);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ obligations, count: obligations.length }, null, 2) },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "complete_obligation",
+  {
+    title: "Complete Obligation",
+    description: "Mark an obligation as completed.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    const obligation = completeObligation(id);
+    if (!obligation) {
+      return { content: [{ type: "text", text: `Obligation '${id}' not found.` }], isError: true };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(obligation, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "list_overdue_obligations",
+  {
+    title: "List Overdue Obligations",
+    description: "List all overdue obligations across all contracts.",
+    inputSchema: {},
+  },
+  async () => {
+    const obligations = listOverdueObligations();
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ obligations, count: obligations.length }, null, 2) },
+      ],
+    };
+  }
+);
+
 // --- Reminders ---
 
 server.registerTool(
@@ -295,6 +580,30 @@ server.registerTool(
   }
 );
 
+server.registerTool(
+  "set_multi_reminders",
+  {
+    title: "Set Multi-Stage Reminders",
+    description: "Set multiple reminders at once based on days before contract end date.",
+    inputSchema: {
+      contract_id: z.string(),
+      days_before: z.array(z.number()),
+    },
+  },
+  async ({ contract_id, days_before }) => {
+    try {
+      const reminders = setMultiReminders(contract_id, days_before);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ reminders, count: reminders.length }, null, 2) },
+        ],
+      };
+    } catch (err) {
+      return { content: [{ type: "text", text: (err as Error).message }], isError: true };
+    }
+  }
+);
+
 // --- Start ---
 async function main() {
   const transport = new StdioServerTransport();

package/microservices/microservice-domains/src/cli/index.ts

@@ -19,7 +19,18 @@ import {
   createAlert,
   listAlerts,
   deleteAlert,
+  whoisLookup,
+  checkDnsPropagation,
+  checkSsl,
+  exportZoneFile,
+  importZoneFile,
+  discoverSubdomains,
+  validateDns,
+  exportPortfolio,
+  checkAllDomains,
+  getDomainByName,
 } from "../db/domains.js";
+import { readFileSync, writeFileSync } from "node:fs";
 
 const program = new Command();
 
@@ -269,6 +280,109 @@ program
     }
   });
 
+// --- WHOIS Lookup ---
+
+program
+  .command("whois")
+  .description("Run WHOIS lookup for a domain and update DB record")
+  .argument("<name>", "Domain name (e.g. example.com)")
+  .option("--json", "Output as JSON", false)
+  .action((name, opts) => {
+    try {
+      const result = whoisLookup(name);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`WHOIS for ${result.domain}:`);
+        console.log(`  Registrar: ${result.registrar || "unknown"}`);
+        console.log(`  Expires: ${result.expires_at || "unknown"}`);
+        if (result.nameservers.length > 0) {
+          console.log(`  Nameservers: ${result.nameservers.join(", ")}`);
+        }
+      }
+    } catch (error: unknown) {
+      console.error(`WHOIS lookup failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+
+// --- SSL Check ---
+
+program
+  .command("ssl-check")
+  .description("Check SSL certificate for a domain and update DB record")
+  .argument("<name>", "Domain name (e.g. example.com)")
+  .option("--json", "Output as JSON", false)
+  .action((name, opts) => {
+    const result = checkSsl(name);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (result.error) {
+        console.error(`SSL check failed: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(`SSL Certificate for ${result.domain}:`);
+      console.log(`  Issuer: ${result.issuer || "unknown"}`);
+      console.log(`  Expires: ${result.expires_at || "unknown"}`);
+      if (result.subject) console.log(`  Subject: ${result.subject}`);
+    }
+  });
+
+// --- Portfolio Export ---
+
+program
+  .command("export")
+  .description("Export all domains as CSV or JSON")
+  .option("--format <format>", "Export format (csv or json)", "json")
+  .option("--output <file>", "Write to file instead of stdout")
+  .action((opts) => {
+    const format = opts.format === "csv" ? "csv" : "json";
+    const output = exportPortfolio(format as "csv" | "json");
+    if (opts.output) {
+      writeFileSync(opts.output, output, "utf-8");
+      console.log(`Exported to ${opts.output}`);
+    } else {
+      console.log(output);
+    }
+  });
+
+// --- Bulk Domain Check ---
+
+program
+  .command("check-all")
+  .description("Run WHOIS + SSL + DNS validation on all domains")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const results = checkAllDomains();
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      if (results.length === 0) {
+        console.log("No domains to check.");
+        return;
+      }
+      for (const r of results) {
+        console.log(`\n${r.domain}:`);
+        if (r.whois) {
+          console.log(`  WHOIS: registrar=${r.whois.registrar || "?"}, expires=${r.whois.expires_at || "?"}`);
+          if (r.whois.error) console.log(`    Error: ${r.whois.error}`);
+        }
+        if (r.ssl) {
+          console.log(`  SSL: issuer=${r.ssl.issuer || "?"}, expires=${r.ssl.expires_at || "?"}`);
+          if (r.ssl.error) console.log(`    Error: ${r.ssl.error}`);
+        }
+        if (r.dns_validation) {
+          console.log(`  DNS: valid=${r.dns_validation.valid}, issues=${r.dns_validation.issue_count}`);
+          for (const e of r.dns_validation.errors) {
+            console.log(`    ${e}`);
+          }
+        }
+      }
+      console.log(`\nChecked ${results.length} domain(s)`);
+    }
+  });
+
 // --- DNS Records ---
 
 const dnsCmd = program
@@ -370,6 +484,145 @@ dnsCmd
     }
   });
 
+// --- DNS Propagation Check ---
+
+dnsCmd
+  .command("check-propagation")
+  .description("Check DNS propagation across multiple servers")
+  .argument("<domain>", "Domain name to check")
+  .option("--record <type>", "Record type (A/AAAA/CNAME/MX/TXT/NS)", "A")
+  .option("--json", "Output as JSON", false)
+  .action((domain, opts) => {
+    const result = checkDnsPropagation(domain, opts.record);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`DNS Propagation for ${result.domain} (${result.record_type}):`);
+      console.log(`  Consistent: ${result.consistent ? "yes" : "NO"}`);
+      for (const s of result.servers) {
+        const values = s.values.length > 0 ? s.values.join(", ") : "(empty)";
+        const status = s.status === "error" ? ` [ERROR: ${s.error}]` : "";
+        console.log(`  ${s.name} (${s.server}): ${values}${status}`);
+      }
+    }
+  });
+
+// --- Zone File Export ---
+
+dnsCmd
+  .command("export")
+  .description("Export DNS records as BIND zone file")
+  .argument("<domain-id>", "Domain ID")
+  .option("--format <format>", "Export format (zone)", "zone")
+  .option("--output <file>", "Write to file instead of stdout")
+  .action((domainId, opts) => {
+    const zone = exportZoneFile(domainId);
+    if (!zone) {
+      console.error(`Domain '${domainId}' not found.`);
+      process.exit(1);
+    }
+    if (opts.output) {
+      writeFileSync(opts.output, zone, "utf-8");
+      console.log(`Exported zone file to ${opts.output}`);
+    } else {
+      console.log(zone);
+    }
+  });
+
+// --- Zone File Import ---
+
+dnsCmd
+  .command("import")
+  .description("Import DNS records from a BIND zone file")
+  .argument("<domain-id>", "Domain ID")
+  .requiredOption("--file <path>", "Path to zone file")
+  .option("--json", "Output as JSON", false)
+  .action((domainId, opts) => {
+    let content: string;
+    try {
+      content = readFileSync(opts.file, "utf-8");
+    } catch {
+      console.error(`Could not read file: ${opts.file}`);
+      process.exit(1);
+    }
+
+    const result = importZoneFile(domainId, content);
+    if (!result) {
+      console.error(`Domain '${domainId}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Imported ${result.imported} record(s), skipped ${result.skipped}`);
+      if (result.errors.length > 0) {
+        console.log("Errors:");
+        for (const e of result.errors) {
+          console.log(`  - ${e}`);
+        }
+      }
+    }
+  });
+
+// --- Subdomain Discovery ---
+
+dnsCmd
+  .command("discover-subdomains")
+  .description("Discover subdomains via certificate transparency logs (crt.sh)")
+  .argument("<domain>", "Domain name")
+  .option("--json", "Output as JSON", false)
+  .action(async (domain, opts) => {
+    const result = await discoverSubdomains(domain);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (result.error) {
+        console.error(`Discovery failed: ${result.error}`);
+        process.exit(1);
+      }
+      if (result.subdomains.length === 0) {
+        console.log(`No subdomains found for ${domain}.`);
+        return;
+      }
+      console.log(`Subdomains for ${domain} (source: ${result.source}):`);
+      for (const s of result.subdomains) {
+        console.log(`  ${s}`);
+      }
+      console.log(`\n${result.subdomains.length} subdomain(s) found`);
+    }
+  });
+
+// --- DNS Validation ---
+
+dnsCmd
+  .command("validate")
+  .description("Validate DNS records for common issues")
+  .argument("<domain-id>", "Domain ID")
+  .option("--json", "Output as JSON", false)
+  .action((domainId, opts) => {
+    const result = validateDns(domainId);
+    if (!result) {
+      console.error(`Domain '${domainId}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`DNS Validation for ${result.domain_name}:`);
+      console.log(`  Valid: ${result.valid ? "yes" : "NO"}`);
+      if (result.issues.length === 0) {
+        console.log("  No issues found.");
+      } else {
+        for (const issue of result.issues) {
+          const prefix = issue.type === "error" ? "ERROR" : "WARN";
+          console.log(`  [${prefix}] ${issue.message}`);
+        }
+      }
+    }
+  });
+
 // --- Alerts ---
 
 const alertCmd = program