@agenticmail/enterprise 0.5.298 → 0.5.299

package/dist/cli-verify-BTSN7SQ2.js

@@ -0,0 +1,149 @@
+import {
+  DomainLock
+} from "./chunk-UPU23ZRG.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;
+}
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+function detectDbType(url) {
+  const u = url.toLowerCase().trim();
+  if (u.startsWith("postgres") || u.startsWith("pg:")) return "postgres";
+  if (u.startsWith("mysql")) return "mysql";
+  if (u.startsWith("mongodb")) return "mongodb";
+  if (u.startsWith("libsql") || u.includes(".turso.io")) return "turso";
+  if (u.endsWith(".db") || u.endsWith(".sqlite") || u.endsWith(".sqlite3") || u.startsWith("file:")) return "sqlite";
+  return "postgres";
+}
+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 db = null;
+  let dbConnected = false;
+  const envDbUrl = process.env.DATABASE_URL;
+  if (envDbUrl) {
+    const dbType = detectDbType(envDbUrl);
+    const spinner = ora(`Connecting to database (${dbType})...`).start();
+    try {
+      const { createAdapter } = await import("./factory-4JY52C3T.js");
+      db = await createAdapter({ type: dbType, connectionString: envDbUrl });
+      await db.migrate();
+      const settings = await db.getSettings();
+      if (!domain && settings?.domain) domain = settings.domain;
+      if (settings?.domainDnsChallenge) dnsChallenge = settings.domainDnsChallenge;
+      dbConnected = true;
+      spinner.succeed(`Connected to ${dbType} database` + (domain ? ` (domain: ${domain})` : ""));
+    } catch (err) {
+      spinner.warn(`Could not connect via DATABASE_URL: ${err.message}`);
+      db = null;
+    }
+  }
+  if (!dbConnected) {
+    const dbPath = getFlag(args, "--db");
+    const dbType = getFlag(args, "--db-type") || "sqlite";
+    if (dbPath) {
+      const spinner = ora(`Connecting to ${dbType} database...`).start();
+      try {
+        const { createAdapter } = await import("./factory-4JY52C3T.js");
+        db = await createAdapter({ type: dbType, connectionString: dbPath });
+        await db.migrate();
+        const settings = await db.getSettings();
+        if (!domain && settings?.domain) domain = settings.domain;
+        if (settings?.domainDnsChallenge) dnsChallenge = settings.domainDnsChallenge;
+        dbConnected = true;
+        spinner.succeed(`Connected to ${dbType} database`);
+      } catch {
+        spinner.warn("Could not read local database");
+      }
+    }
+  }
+  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.yourcompany.com)"),
+      validate: (v) => v.includes(".") || "Enter a valid domain",
+      filter: (v) => v.trim().toLowerCase()
+    }]);
+    domain = answer.domain;
+  }
+  const lock = new DomainLock();
+  const maxAttempts = hasFlag(args, "--poll") ? 5 : 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const spinner = ora(
+      maxAttempts > 1 ? `Checking DNS verification (attempt ${attempt}/${maxAttempts})...` : "Checking DNS verification..."
+    ).start();
+    try {
+      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()
+            });
+            console.log(chalk.dim("  Database updated with verified status."));
+          } catch {
+          }
+        }
+        console.log("");
+        console.log(chalk.green.bold(`  \u2713 ${domain} is verified and protected.`));
+        console.log(chalk.dim("  Your deployment domain is locked. No other instance can claim it."));
+        console.log(chalk.dim("  The system now operates 100% offline \u2014 no outbound calls are made."));
+        console.log("");
+        if (db) await db.disconnect();
+        return;
+      }
+    } catch (err) {
+      spinner.warn(`Check failed: ${err.message}`);
+    }
+    if (attempt < maxAttempts) {
+      const waitSpinner = ora(`DNS record not found yet. Retrying in 10 seconds...`).start();
+      await new Promise((r) => setTimeout(r, 1e4));
+      waitSpinner.stop();
+    }
+  }
+  console.log("");
+  console.log(chalk.yellow("  DNS record not detected yet."));
+  console.log("");
+  console.log(chalk.bold("  Make sure this TXT record exists at your DNS provider:"));
+  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 dashboard or setup output)")}`);
+  }
+  console.log("");
+  console.log(chalk.dim("  DNS propagation can take up to 48 hours."));
+  console.log(chalk.dim("  Run with --poll to retry automatically:"));
+  console.log(chalk.dim(`    npx @agenticmail/enterprise verify-domain --domain ${domain} --poll`));
+  console.log("");
+  if (db) await db.disconnect();
+}
+export {
+  runVerifyDomain
+};

package/dist/cli.js

@@ -14,10 +14,10 @@ switch (command) {
     import("./cli-submit-skill-LDFJGSKO.js").then((m) => m.runSubmitSkill(args.slice(1))).catch(fatal);
     break;
   case "recover":
-    import("./cli-recover-NXARYVSH.js").then((m) => m.runRecover(args.slice(1))).catch(fatal);
+    import("./cli-recover-MFF5AXLN.js").then((m) => m.runRecover(args.slice(1))).catch(fatal);
     break;
   case "verify-domain":
-    import("./cli-verify-RKB6KQN4.js").then((m) => m.runVerifyDomain(args.slice(1))).catch(fatal);
+    import("./cli-verify-BTSN7SQ2.js").then((m) => m.runVerifyDomain(args.slice(1))).catch(fatal);
     break;
   case "reset-password":
     import("./cli-reset-password-SO5Y6MW7.js").then((m) => m.runResetPassword(args.slice(1))).catch(fatal);
@@ -57,14 +57,14 @@ Skill Development:
     break;
   case "serve":
   case "start":
-    import("./cli-serve-RRKVF3QM.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
+    import("./cli-serve-BXI7TTNN.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
     break;
   case "agent":
-    import("./cli-agent-WSCDFYMU.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
+    import("./cli-agent-4DVE3NDA.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
     break;
   case "setup":
   default:
-    import("./setup-OL4GJ53G.js").then((m) => m.runSetupWizard()).catch(fatal);
+    import("./setup-KIAPXKEX.js").then((m) => m.runSetupWizard()).catch(fatal);
     break;
 }
 function fatal(err) {

package/dist/dashboard/app.js

@@ -27,6 +27,7 @@ import { VaultPage } from './pages/vault.js';
 import { OrgChartPage } from './pages/org-chart.js';
 import { TaskPipelinePage } from './pages/task-pipeline.js';
 import { DatabaseAccessPage } from './pages/database-access.js';
+import { OrganizationsPage } from './pages/organizations.js';
 
 // ─── Toast System ────────────────────────────────────────
 let toastId = 0;
@@ -211,6 +212,7 @@ function App() {
     { section: 'Overview', items: [{ id: 'dashboard', icon: I.dashboard, label: 'Dashboard' }] },
     { section: 'Management', items: [
       { id: 'agents', icon: I.agents, label: 'Agents' },
+      { id: 'organizations', icon: I.building, label: 'Organizations' },
       { id: 'skills', icon: I.skills, label: 'Skills' },
       { id: 'community-skills', icon: I.marketplace, label: 'Community Skills' },
       { id: 'skill-connections', icon: I.link, label: 'Integrations & MCP' },
@@ -262,6 +264,7 @@ function App() {
     'org-chart': OrgChartPage,
     'task-pipeline': TaskPipelinePage,
     'database-access': DatabaseAccessPage,
+    organizations: OrganizationsPage,
   };
 
   const navigateToAgent = (agentId) => { _setSelectedAgentId(agentId); history.pushState(null, '', '/dashboard/agents/' + agentId); };

package/dist/dashboard/components/icons.js

@@ -56,5 +56,6 @@ export const I = {
   chevronLeft: () => h('svg', S, h('polyline', { points: '15 18 9 12 15 6' })),
 chevronRight: () => h('svg', S, h('polyline', { points: '9 18 15 12 9 6' })),
 chevronDown: () => h('svg', S, h('polyline', { points: '6 9 12 15 18 9' })),
+  building: () => h('svg', S, h('path', { d: 'M3 21h18M3 10h18M3 7l9-4 9 4M4 10v11M20 10v11M8 14v.01M12 14v.01M16 14v.01M8 18v.01M12 18v.01M16 18v.01' })),
   edit: () => h('svg', S, h('path', { d: 'M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7' }), h('path', { d: 'M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z' })),
 };

package/dist/dashboard/pages/agent-detail/overview.js

@@ -363,6 +363,9 @@ export function OverviewSection(props) {
       )
     ),
 
+    // ─── Organization & Knowledge Access ──────────────────
+    h(OrgAndKnowledgeCards, { agentId: agentId, agent: agent, engineAgent: engineAgent, toast: toast }),
+
     // ─── Real-Time Status Card ────────────────────────────
     h('div', { className: 'card', style: { marginBottom: 20 } },
       h('div', { className: 'card-header', style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center' } },
@@ -649,6 +652,113 @@ function _timeAgo(ts) {
   return Math.floor(diff / 3600000) + 'h ago';
 }
 
+// ─── Organization & Knowledge Access Cards ────────────────
+function OrgAndKnowledgeCards(props) {
+  var agentId = props.agentId;
+  var toast = props.toast;
+
+  var _orgs = useState([]);
+  var orgs = _orgs[0]; var setOrgs = _orgs[1];
+  var _currentOrg = useState(null);
+  var currentOrg = _currentOrg[0]; var setCurrentOrg = _currentOrg[1];
+  var _kbs = useState([]);
+  var kbs = _kbs[0]; var setKbs = _kbs[1];
+  var _kaGrants = useState([]);
+  var kaGrants = _kaGrants[0]; var setKaGrants = _kaGrants[1];
+  var _acting = useState('');
+  var acting = _acting[0]; var setActing = _acting[1];
+  var _selOrg = useState('');
+  var selOrg = _selOrg[0]; var setSelOrg = _selOrg[1];
+
+  useEffect(function() {
+    // Load orgs list
+    apiCall('/organizations').then(function(d) { setOrgs(d.organizations || []); }).catch(function() {});
+    // Load agent's current org
+    apiCall('/agents/' + agentId).then(function(a) {
+      if (a && a.client_org_id) {
+        setSelOrg(a.client_org_id);
+        apiCall('/organizations/' + a.client_org_id).then(function(o) { setCurrentOrg(o); }).catch(function() {});
+      }
+    }).catch(function() {});
+    // Load knowledge access
+    apiCall('/agents/' + agentId + '/knowledge-access').then(function(d) { setKaGrants(d.grants || []); }).catch(function() {});
+    // Load knowledge bases
+    engineCall('/knowledge').then(function(d) { setKbs(d.knowledgeBases || d || []); }).catch(function() {});
+  }, [agentId]);
+
+  var assignOrg = function(orgId) {
+    if (!orgId) {
+      setActing('unassign');
+      apiCall('/agents/' + agentId + '/unassign-org', { method: 'POST' }).then(function() {
+        setCurrentOrg(null); setSelOrg(''); toast('Organization unassigned', 'success');
+      }).catch(function(e) { toast(e.message, 'error'); }).finally(function() { setActing(''); });
+      return;
+    }
+    setActing('assign');
+    apiCall('/agents/' + agentId + '/assign-org', { method: 'POST', body: JSON.stringify({ orgId: orgId }) }).then(function() {
+      setSelOrg(orgId);
+      var org = orgs.find(function(o) { return o.id === orgId; });
+      setCurrentOrg(org || null);
+      toast('Organization assigned', 'success');
+    }).catch(function(e) { toast(e.message, 'error'); }).finally(function() { setActing(''); });
+  };
+
+  return h(Fragment, null,
+    h('div', { style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16, marginBottom: 20 } },
+      // Organization card
+      h('div', { className: 'card' },
+        h('div', { className: 'card-header' }, 'Organization'),
+        h('div', { className: 'card-body' },
+          currentOrg
+            ? h('div', null,
+                h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 4 } }, currentOrg.name),
+                h('div', { style: { fontSize: 12, color: 'var(--text-muted)', fontFamily: 'var(--font-mono, monospace)', marginBottom: 8 } }, currentOrg.slug),
+                h('span', { className: 'badge badge-' + (currentOrg.is_active ? 'success' : 'warning') }, currentOrg.is_active ? 'Active' : 'Inactive')
+              )
+            : h('div', { style: { fontSize: 13, color: 'var(--text-muted)', marginBottom: 8 } }, 'Unassigned'),
+          h('div', { style: { marginTop: 10 } },
+            h('select', { className: 'input', value: selOrg, disabled: !!acting, onChange: function(e) { assignOrg(e.target.value); }, style: { width: '100%', fontSize: 12 } },
+              h('option', { value: '' }, '— No organization —'),
+              orgs.map(function(o) { return h('option', { key: o.id, value: o.id }, o.name); })
+            )
+          )
+        )
+      ),
+      // Knowledge Access card
+      h('div', { className: 'card' },
+        h('div', { className: 'card-header' }, 'Knowledge Access'),
+        h('div', { className: 'card-body' },
+          kbs.length === 0
+            ? h('div', { style: { fontSize: 13, color: 'var(--text-muted)' } }, 'No knowledge bases configured')
+            : h('div', { style: { display: 'flex', flexDirection: 'column', gap: 6 } },
+                kbs.map(function(kb) {
+                  var grant = kaGrants.find(function(g) { return g.knowledge_base_id === kb.id; });
+                  var accessType = grant ? grant.access_type : '';
+                  return h('div', { key: kb.id, style: { display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '4px 0', borderBottom: '1px solid var(--border)' } },
+                    h('span', { style: { fontSize: 13, fontWeight: 500 } }, kb.name || kb.id),
+                    h('select', { className: 'input', value: accessType, style: { width: 120, fontSize: 11, padding: '2px 6px' }, onChange: function(e) {
+                      var newVal = e.target.value;
+                      var newGrants = kaGrants.filter(function(g) { return g.knowledge_base_id !== kb.id; });
+                      if (newVal) newGrants.push({ knowledge_base_id: kb.id, access_type: newVal });
+                      var payload = newGrants.map(function(g) { return { knowledgeBaseId: g.knowledge_base_id, accessType: g.access_type }; });
+                      apiCall('/agents/' + agentId + '/knowledge-access', { method: 'PUT', body: JSON.stringify({ grants: payload }) })
+                        .then(function() { setKaGrants(newGrants); toast('Knowledge access updated', 'success'); })
+                        .catch(function(err) { toast(err.message, 'error'); });
+                    }},
+                      h('option', { value: '' }, 'No access'),
+                      h('option', { value: 'read' }, 'Read'),
+                      h('option', { value: 'contribute' }, 'Contribute'),
+                      h('option', { value: 'both' }, 'Both')
+                    )
+                  );
+                })
+              )
+        )
+      )
+    )
+  );
+}
+
 // Inject pulse animation CSS if not already present
 if (typeof document !== 'undefined' && !document.getElementById('_pulse_css')) {
   var style = document.createElement('style');