@agenticmail/enterprise 0.3.2 → 0.4.0

package/dist/cli-submit-skill-RSBLF5XN.js

@@ -0,0 +1,162 @@
+import {
+  validateSkillManifest
+} from "./chunk-TY7NVD4U.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/engine/cli-submit-skill.ts
+var UPSTREAM_REPO = "agenticmail/enterprise";
+async function runSubmitSkill(args) {
+  const chalk = (await import("chalk")).default;
+  const ora = (await import("ora")).default;
+  const { execSync } = await import("child_process");
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const target = args.filter((a) => !a.startsWith("--"))[0];
+  if (!target) {
+    console.log(`${chalk.bold("Usage:")} agenticmail-enterprise submit-skill <path-to-skill-dir>`);
+    process.exit(1);
+    return;
+  }
+  const skillDir = path.resolve(target);
+  console.log("");
+  console.log(chalk.bold("\u{1F680} Submit Community Skill"));
+  console.log("");
+  const spinner = ora("Checking prerequisites...").start();
+  try {
+    execSync("gh --version", { stdio: "pipe" });
+  } catch {
+    spinner.fail("GitHub CLI (gh) is not installed");
+    console.log("");
+    console.log(chalk.dim("  Install it from: https://cli.github.com/"));
+    console.log(chalk.dim("  Then run: gh auth login"));
+    process.exit(1);
+    return;
+  }
+  try {
+    execSync("gh auth status", { stdio: "pipe" });
+  } catch {
+    spinner.fail("Not authenticated with GitHub CLI");
+    console.log(chalk.dim("  Run: gh auth login"));
+    process.exit(1);
+    return;
+  }
+  spinner.succeed("GitHub CLI authenticated");
+  const validateSpinner = ora("Validating skill manifest...").start();
+  const manifestPath = path.join(skillDir, "agenticmail-skill.json");
+  let manifest;
+  try {
+    const raw = await fs.readFile(manifestPath, "utf-8");
+    manifest = JSON.parse(raw);
+  } catch (err) {
+    validateSpinner.fail(`Cannot read manifest: ${err.message}`);
+    process.exit(1);
+    return;
+  }
+  const validation = validateSkillManifest(manifest);
+  if (!validation.valid) {
+    validateSpinner.fail("Manifest validation failed");
+    for (const err of validation.errors) {
+      console.log(chalk.red("  \u2502 " + err));
+    }
+    console.log(chalk.dim("\n  Fix the errors above and try again."));
+    process.exit(1);
+    return;
+  }
+  validateSpinner.succeed(`Manifest valid: ${manifest.name} v${manifest.version}`);
+  const skillId = manifest.id;
+  const branchName = `community/add-${skillId}`;
+  const forkSpinner = ora("Forking repository...").start();
+  try {
+    execSync(`gh repo fork ${UPSTREAM_REPO} --clone=false 2>&1 || true`, { stdio: "pipe" });
+    forkSpinner.succeed("Repository forked (or already exists)");
+  } catch {
+    forkSpinner.succeed("Fork exists");
+  }
+  let forkUrl;
+  try {
+    const ghUser = execSync("gh api user --jq .login", { encoding: "utf-8" }).trim();
+    forkUrl = `https://github.com/${ghUser}/enterprise.git`;
+  } catch {
+    forkSpinner.fail("Cannot determine GitHub username");
+    process.exit(1);
+    return;
+  }
+  const tmpDir = path.join(process.env.TMPDIR || "/tmp", `agenticmail-submit-${Date.now()}`);
+  const pushSpinner = ora("Cloning fork...").start();
+  try {
+    execSync(`git clone --depth 1 ${forkUrl} "${tmpDir}"`, { stdio: "pipe" });
+    pushSpinner.text = "Creating branch...";
+    const run = (cmd) => execSync(cmd, { cwd: tmpDir, stdio: "pipe", encoding: "utf-8" });
+    run(`git remote add upstream https://github.com/${UPSTREAM_REPO}.git`);
+    run("git fetch upstream main --depth 1");
+    run(`git checkout -b ${branchName} upstream/main`);
+    pushSpinner.text = "Copying skill files...";
+    const destDir = path.join(tmpDir, "community-skills", skillId);
+    await fs.mkdir(destDir, { recursive: true });
+    const files = await fs.readdir(skillDir);
+    for (const file of files) {
+      await fs.copyFile(path.join(skillDir, file), path.join(destDir, file));
+    }
+    pushSpinner.text = "Committing...";
+    run(`git add community-skills/${skillId}/`);
+    run(`git commit -m "Add community skill: ${manifest.name}"`);
+    pushSpinner.text = "Pushing to fork...";
+    run(`git push origin ${branchName} --force`);
+    pushSpinner.succeed("Pushed to fork");
+  } catch (err) {
+    pushSpinner.fail(`Git operation failed: ${err.message}`);
+    process.exit(1);
+    return;
+  }
+  const prSpinner = ora("Opening pull request...").start();
+  const toolsList = (manifest.tools || []).map(
+    (t) => `- \`${t.id}\` \u2014 ${t.name}: ${t.description}`
+  ).join("\n");
+  const prBody = `## Community Skill Submission
+
+**Skill ID:** \`${manifest.id}\`
+**Application:** ${manifest.name}
+**Category:** ${manifest.category}
+**Risk Level:** ${manifest.risk}
+**Author:** @${manifest.author}
+**License:** ${manifest.license}
+
+### Description
+
+${manifest.description}
+
+### Tools Provided
+
+${toolsList}
+
+### Validation
+
+- [x] Manifest passes \`agenticmail-enterprise validate\`
+- [x] All required fields present
+- [x] No duplicate tool IDs
+${manifest.tags ? `
+**Tags:** ${manifest.tags.join(", ")}` : ""}`;
+  try {
+    const prUrl = execSync(
+      `gh pr create --repo ${UPSTREAM_REPO} --head ${branchName} --title "Add community skill: ${manifest.name}" --body "${prBody.replace(/"/g, '\\"')}"`,
+      { cwd: tmpDir, encoding: "utf-8", stdio: "pipe" }
+    ).trim();
+    prSpinner.succeed("Pull request opened!");
+    console.log(chalk.green(`
+  ${prUrl}
+`));
+  } catch (err) {
+    if (err.stderr?.includes("already exists")) {
+      prSpinner.warn("A PR for this skill already exists");
+    } else {
+      prSpinner.fail(`Could not open PR: ${err.message}`);
+    }
+  }
+  try {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+export {
+  runSubmitSkill
+};

package/dist/cli-validate-WJBUOEGW.js

@@ -0,0 +1,148 @@
+import {
+  ALL_TOOLS,
+  init_tool_catalog
+} from "./chunk-X6UVWFHW.js";
+import {
+  collectCommunityToolIds,
+  validateSkillManifest
+} from "./chunk-TY7NVD4U.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/engine/cli-validate.ts
+init_tool_catalog();
+async function runValidate(args) {
+  const chalk = (await import("chalk")).default;
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const jsonMode = args.includes("--json");
+  const allMode = args.includes("--all");
+  const pathArgs = args.filter((a) => !a.startsWith("--"));
+  const builtinIds = new Set(ALL_TOOLS.map((t) => t.id));
+  const communityDir = path.resolve(process.cwd(), "community-skills");
+  const reports = [];
+  if (allMode) {
+    let entries;
+    try {
+      entries = await fs.readdir(communityDir, { withFileTypes: true });
+    } catch {
+      if (jsonMode) {
+        console.log(JSON.stringify({ error: "community-skills/ directory not found" }));
+      } else {
+        console.error(chalk.red("Error: community-skills/ directory not found"));
+      }
+      process.exit(1);
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+      const skillDir = path.join(communityDir, entry.name);
+      const report = await validatePath(skillDir, builtinIds, communityDir);
+      reports.push(report);
+    }
+  } else {
+    const target = pathArgs[0];
+    if (!target) {
+      if (jsonMode) {
+        console.log(JSON.stringify({ error: "No path specified. Usage: agenticmail-enterprise validate <path> [--all] [--json]" }));
+      } else {
+        console.log(`${chalk.bold("Usage:")} agenticmail-enterprise validate <path>`);
+        console.log("");
+        console.log("  <path>    Path to a skill directory or agenticmail-skill.json file");
+        console.log("  --all     Validate all skills in community-skills/");
+        console.log("  --json    Machine-readable JSON output");
+      }
+      process.exit(1);
+      return;
+    }
+    const report = await validatePath(path.resolve(target), builtinIds, communityDir);
+    reports.push(report);
+  }
+  if (jsonMode) {
+    console.log(JSON.stringify({ results: reports, totalErrors: reports.reduce((s, r) => s + r.errors.length, 0) }, null, 2));
+  } else {
+    console.log("");
+    for (const report of reports) {
+      if (report.valid) {
+        console.log(chalk.green("  \u2714") + " " + chalk.bold(report.skillId) + chalk.dim(` (${report.path})`));
+      } else {
+        console.log(chalk.red("  \u2718") + " " + chalk.bold(report.skillId) + chalk.dim(` (${report.path})`));
+        for (const err of report.errors) {
+          console.log(chalk.red("    \u2502 ") + err);
+        }
+      }
+      for (const warn of report.warnings) {
+        console.log(chalk.yellow("    \u26A0 ") + warn);
+      }
+    }
+    console.log("");
+    const passed = reports.filter((r) => r.valid).length;
+    const failed = reports.filter((r) => !r.valid).length;
+    if (failed > 0) {
+      console.log(chalk.red(`  ${failed} failed`) + chalk.dim(`, ${passed} passed, ${reports.length} total`));
+    } else {
+      console.log(chalk.green(`  ${passed} passed`) + chalk.dim(`, ${reports.length} total`));
+    }
+    console.log("");
+  }
+  if (reports.some((r) => !r.valid)) {
+    process.exit(1);
+  }
+}
+async function validatePath(targetPath, builtinIds, communityDir) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  let manifestPath;
+  try {
+    const stat = await fs.stat(targetPath);
+    if (stat.isDirectory()) {
+      manifestPath = path.join(targetPath, "agenticmail-skill.json");
+    } else {
+      manifestPath = targetPath;
+    }
+  } catch {
+    return {
+      path: targetPath,
+      skillId: path.basename(targetPath),
+      valid: false,
+      errors: [`Path not found: ${targetPath}`],
+      warnings: []
+    };
+  }
+  let raw;
+  try {
+    raw = await fs.readFile(manifestPath, "utf-8");
+  } catch {
+    return {
+      path: manifestPath,
+      skillId: path.basename(path.dirname(manifestPath)),
+      valid: false,
+      errors: [`Cannot read: ${manifestPath}`],
+      warnings: []
+    };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (err) {
+    return {
+      path: manifestPath,
+      skillId: path.basename(path.dirname(manifestPath)),
+      valid: false,
+      errors: [`Invalid JSON: ${err.message}`],
+      warnings: []
+    };
+  }
+  const communityIds = await collectCommunityToolIds(communityDir, manifest.id);
+  const allExistingIds = /* @__PURE__ */ new Set([...builtinIds, ...communityIds]);
+  const result = validateSkillManifest(manifest, { existingToolIds: allExistingIds });
+  return {
+    path: manifestPath,
+    skillId: manifest.id || path.basename(path.dirname(manifestPath)),
+    valid: result.valid,
+    errors: result.errors,
+    warnings: result.warnings
+  };
+}
+export {
+  runValidate
+};

package/dist/cli-verify-V3GPFMWU.js

@@ -0,0 +1,98 @@
+import {
+  DomainLock
+} from "./chunk-HSF6OJ5Z.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/domain-lock/cli-verify.ts
+function getFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  return void 0;
+}
+async function runVerifyDomain(args) {
+  const { default: chalk } = await import("chalk");
+  const { default: ora } = await import("ora");
+  console.log("");
+  console.log(chalk.bold("  AgenticMail Enterprise \u2014 Domain Verification"));
+  console.log("");
+  let domain = getFlag(args, "--domain");
+  let dnsChallenge;
+  let dbConnected = false;
+  let db = null;
+  if (!domain) {
+    const dbPath = getFlag(args, "--db");
+    const dbType = getFlag(args, "--db-type") || "sqlite";
+    if (dbPath) {
+      try {
+        const { createAdapter } = await import("./factory-FVJH5RRY.js");
+        db = await createAdapter({ type: dbType, connectionString: dbPath });
+        await db.migrate();
+        const settings = await db.getSettings();
+        domain = settings?.domain;
+        dnsChallenge = settings?.domainDnsChallenge;
+        dbConnected = true;
+      } catch {
+      }
+    }
+  }
+  if (!domain) {
+    const { default: inquirer } = await import("inquirer");
+    const answer = await inquirer.prompt([{
+      type: "input",
+      name: "domain",
+      message: "Domain to verify:",
+      suffix: chalk.dim("  (e.g. agents.agenticmail.io)"),
+      validate: (v) => v.includes(".") || "Enter a valid domain"
+    }]);
+    domain = answer.domain;
+  }
+  const spinner = ora("Checking DNS verification...").start();
+  const lock = new DomainLock();
+  const result = await lock.checkVerification(domain);
+  if (!result.success) {
+    spinner.fail("Verification check failed");
+    console.log("");
+    console.error(chalk.red(`  ${result.error}`));
+    console.log("");
+    if (db) await db.disconnect();
+    process.exit(1);
+  }
+  if (result.verified) {
+    spinner.succeed("Domain verified!");
+    if (dbConnected && db) {
+      try {
+        await db.updateSettings({
+          domainStatus: "verified",
+          domainVerifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    console.log("");
+    console.log(chalk.green.bold(`  ${domain} is verified and protected.`));
+    console.log(chalk.dim("  Your deployment domain is locked. No other instance can claim it."));
+    console.log("");
+  } else {
+    spinner.info("DNS record not found yet");
+    console.log("");
+    console.log(chalk.yellow("  The DNS TXT record has not been detected."));
+    console.log("");
+    console.log(chalk.bold("  Make sure this record exists:"));
+    console.log("");
+    console.log(`  ${chalk.bold("Host:")}   ${chalk.cyan(`_agenticmail-verify.${domain}`)}`);
+    console.log(`  ${chalk.bold("Type:")}   ${chalk.cyan("TXT")}`);
+    if (dnsChallenge) {
+      console.log(`  ${chalk.bold("Value:")}  ${chalk.cyan(dnsChallenge)}`);
+    } else {
+      console.log(`  ${chalk.bold("Value:")}  ${chalk.dim("(check your setup records or dashboard)")}`);
+    }
+    console.log("");
+    console.log(chalk.dim("  DNS changes can take up to 48 hours to propagate."));
+    console.log(chalk.dim("  Run this command again after adding the record."));
+    console.log("");
+  }
+  if (db) await db.disconnect();
+}
+export {
+  runVerifyDomain
+};