madarx 2.15.1 → 2.16.0

package/lib/connection-seeds.js

@@ -7,8 +7,72 @@
 //
 // Setup kinds:
 //   - api_key       — collect one or more passwords, verify with provider
+//   - oauth2        — "Sign in with…" authorization-code flow (tokens in vault)
 //   - qr_pair       — WhatsApp pairing through the Baileys bridge daemon
 //   - binary_detect — local binary / directory probe (Hermes)
+//
+// OAuth2 connections never embed a secret: the operator's app client id/secret
+// are collected once as `api_key`-style fields and referenced from the vault by
+// name (`*_ref`); the minted access/refresh tokens land in `*_ACCESS_TOKEN` /
+// `*_REFRESH_TOKEN`. A declarative `health_check` block gives them a generic
+// "Test connection" through verifyViaHealthCheck — no per-service route code.
+
+/**
+ * Build an OAuth2 business-connection seed from a compact descriptor. Keeps the
+ * (verbose, security-sensitive) manifest shape consistent across every provider.
+ */
+function oauthConnectionSeed({
+  slug, title, description, category = 'integration', provider, scopes,
+  prefix, extraCredentials = [], unlocks, healthEndpoint, risk, tags,
+}) {
+  const accessRef = `${prefix}_ACCESS_TOKEN`;
+  return {
+    slug,
+    title,
+    description,
+    category,
+    author: 'madarx',
+    source_kind: 'builtin',
+    source_url: null,
+    version: null,
+    risk_summary: risk,
+    tags,
+    manifest: {
+      service_key: slug,
+      setup_kind: 'oauth2',
+      benefit: `Sign in with ${title} to unlock ${unlocks.length} tool${unlocks.length === 1 ? '' : 's'}. No code, no .env editing.`,
+      // Operator app credentials, supplied once. Referenced by the oauth block via *_ref.
+      credentials: [
+        { name: `${prefix}_CLIENT_ID`, label: `${title} client ID`, type: 'text', required: true, help_text: `Create an app on the ${title} developer console and paste its client ID.` },
+        { name: `${prefix}_CLIENT_SECRET`, label: `${title} client secret`, type: 'password', required: true, help_text: 'Stored encrypted in the local vault — never echoed back.' },
+        ...extraCredentials,
+      ],
+      oauth: {
+        provider,
+        scopes,
+        pkce: provider === 'google' || provider === 'tiktok',
+        redirect_path: `/api/connections/${slug}/oauth/callback`,
+        client_id_ref: `${prefix}_CLIENT_ID`,
+        client_secret_ref: `${prefix}_CLIENT_SECRET`,
+        access_token_ref: accessRef,
+        refresh_token_ref: `${prefix}_REFRESH_TOKEN`,
+      },
+      health_check: {
+        endpoint: healthEndpoint,
+        method: 'GET',
+        expect_status: 200,
+        auth: { in: 'header', name: 'Authorization', prefix: 'Bearer ', credential: accessRef },
+      },
+      verify_endpoint: `/api/connections/${slug}/verify`,
+      verify_supported: true,
+      deep_link: null,
+      supports_scopes: ['global', 'project', 'agent'],
+      unlocks_tool_slugs: unlocks,
+      engines: [],
+      logo_glyph: slug,
+    },
+  };
+}
 
 const CONNECTION_SEEDS = [
   {
@@ -397,6 +461,68 @@ const CONNECTION_SEEDS = [
       logo_glyph: 'hermes',
     },
   },
+
+  // ── Business OAuth2 connections (P0/P1 foundation) ──────────────────────────
+  // These collect the operator's provider-app credentials once, then use the
+  // local-first authorization-code flow to mint tokens into the vault. The tools
+  // they unlock are authored as connectors (Tool-Smith) or shipped later; the
+  // connection + grant machinery is ready for them today. All ad/spend writes
+  // they unlock remain irreversible_external → always approval-gated.
+  oauthConnectionSeed({
+    slug: 'meta-ads',
+    title: 'Meta Ads',
+    description: 'Build and report on Facebook + Instagram ad campaigns. Campaign/budget writes are always approval-gated.',
+    category: 'marketing',
+    provider: 'meta',
+    prefix: 'META',
+    scopes: ['ads_management', 'ads_read', 'business_management'],
+    unlocks: ['meta_ads.insights_read', 'meta_ads.campaign_create', 'meta_ads.adset_create', 'meta_ads.budget_set'],
+    healthEndpoint: 'https://graph.facebook.com/v19.0/me',
+    risk: 'Campaign create, budget set, and audience create are irreversible and always require approval.',
+    tags: ['marketing', 'ads', 'meta', 'oauth'],
+  }),
+  oauthConnectionSeed({
+    slug: 'google-ads',
+    title: 'Google Ads',
+    description: 'Manage Google Ads campaigns and pull GAQL reports. Requires a developer token in addition to OAuth sign-in.',
+    category: 'marketing',
+    provider: 'google',
+    prefix: 'GOOGLE_ADS',
+    scopes: ['https://www.googleapis.com/auth/adwords'],
+    extraCredentials: [
+      { name: 'GOOGLE_ADS_DEVELOPER_TOKEN', label: 'Developer token', type: 'password', required: true, help_text: 'Google Ads API access requires a developer token alongside OAuth.' },
+    ],
+    unlocks: ['google_ads.report', 'google_ads.campaign_create', 'google_ads.budget_set'],
+    healthEndpoint: 'https://googleads.googleapis.com/v17/customers:listAccessibleCustomers',
+    risk: 'Campaign create and budget set are irreversible and always require approval.',
+    tags: ['marketing', 'ads', 'google', 'oauth'],
+  }),
+  oauthConnectionSeed({
+    slug: 'ga4',
+    title: 'Google Analytics 4',
+    description: 'Read GA4 metrics for marketing reports. Read-only — no external writes.',
+    category: 'analytics',
+    provider: 'google',
+    prefix: 'GA4',
+    scopes: ['https://www.googleapis.com/auth/analytics.readonly'],
+    unlocks: ['ga4.run_report', 'ga4.realtime_report'],
+    healthEndpoint: 'https://analyticsdata.googleapis.com/v1beta/properties',
+    risk: 'Read-only analytics access.',
+    tags: ['analytics', 'ga4', 'google', 'oauth'],
+  }),
+  oauthConnectionSeed({
+    slug: 'hubspot-crm',
+    title: 'HubSpot CRM',
+    description: 'Read and (with approval) write contacts, deals, and activity in HubSpot.',
+    category: 'sales',
+    provider: 'hubspot',
+    prefix: 'HUBSPOT',
+    scopes: ['crm.objects.contacts.read', 'crm.objects.deals.read', 'crm.objects.contacts.write'],
+    unlocks: ['hubspot.contacts_read', 'hubspot.deals_read', 'hubspot.contact_upsert'],
+    healthEndpoint: 'https://api.hubapi.com/crm/v3/objects/contacts',
+    risk: 'CRM writes (contact/deal upsert) require approval.',
+    tags: ['sales', 'crm', 'hubspot', 'oauth'],
+  }),
 ];
 
 function upsertConnection(db, seed) {

package/lib/connections/health-check-verify.js

@@ -0,0 +1,114 @@
+// lib/connections/health-check-verify.js — generic "Test connection" verifier.
+//
+// The curated VERIFIERS map in app/api/connections/[service]/verify/route.js
+// covers the 9 seeded services with bespoke logic. This is the FALLBACK: any
+// connection manifest that declares a `health_check` block gets a working "Test
+// connection" with no edits to the route — closing the verify_supported:false gap
+// for Tool-Smith-authored connectors and the new OAuth connections.
+//
+// SECURITY: the resolved credential is injected into the outbound request and is
+// NEVER returned, logged, or echoed. The result carries only non-secret display
+// metadata (account_label, last_4 fingerprint). Error reasons are generic codes,
+// never the credential value.
+//
+// health_check shape (declared in the connection manifest):
+//   {
+//     endpoint: 'https://api.example.com/me',   // required, https
+//     method: 'GET',                             // optional, default GET
+//     expect_status: 200,                        // optional, default: any 2xx
+//     auth: {                                    // optional credential injection
+//       in: 'header',                            //   'header' | 'query'
+//       name: 'Authorization',                   //   header/param name
+//       prefix: 'Bearer ',                       //   value prefix
+//       credential: 'META_ACCESS_TOKEN'          //   key into the credentials map
+//     }
+//   }
+
+import { wrapFetch } from '../egress.js';
+
+function isHttpsUrl(value) {
+  if (typeof value !== 'string') return false;
+  try {
+    return new URL(value).protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function last4(value) {
+  const s = String(value || '');
+  return s.length >= 4 ? s.slice(-4) : null;
+}
+
+/**
+ * Run a manifest-declared health check.
+ *
+ * @param {object} healthCheck      manifest.health_check
+ * @param {object} credentials      { NAME: value } resolved for this attempt
+ * @param {object} [opts]           { fetchFn, serviceKey, agentId }
+ * @returns {Promise<{ ok, reason?, account_label?, last_4?, summary? }>}
+ */
+export async function verifyViaHealthCheck(healthCheck, credentials = {}, opts = {}) {
+  if (!healthCheck || typeof healthCheck !== 'object') {
+    return { ok: false, reason: 'unsupported' };
+  }
+  if (!isHttpsUrl(healthCheck.endpoint)) {
+    return { ok: false, reason: 'unsupported' };
+  }
+
+  const method = /^(GET|POST|PUT|PATCH|DELETE|HEAD)$/.test(String(healthCheck.method || ''))
+    ? String(healthCheck.method)
+    : 'GET';
+
+  let url;
+  try {
+    url = new URL(healthCheck.endpoint);
+  } catch {
+    return { ok: false, reason: 'unsupported' };
+  }
+
+  const headers = { Accept: 'application/json' };
+  let injectedCredentialValue = null;
+
+  const auth = healthCheck.auth;
+  if (auth && typeof auth === 'object' && auth.credential) {
+    const value = credentials[auth.credential];
+    if (typeof value !== 'string' || !value.trim()) {
+      // The credential the health check needs wasn't provided — treat as missing.
+      return { ok: false, reason: 'missing_field', field: auth.credential };
+    }
+    injectedCredentialValue = value.trim();
+    const composed = `${auth.prefix || ''}${injectedCredentialValue}`;
+    if (auth.in === 'query') {
+      url.searchParams.set(auth.name || 'access_token', composed);
+    } else {
+      headers[auth.name || 'Authorization'] = composed;
+    }
+  }
+
+  const fetchFn = opts.fetchFn || wrapFetch(`connection.verify.health.${opts.serviceKey || 'generic'}`, opts.agentId || null, fetch);
+
+  let res;
+  try {
+    res = await fetchFn(url.toString(), { method, headers });
+  } catch {
+    // Never surface the underlying error string — it could contain the URL with
+    // an injected query credential.
+    return { ok: false, reason: 'network' };
+  }
+
+  const expect = Number.isInteger(healthCheck.expect_status) ? healthCheck.expect_status : null;
+  const passed = expect != null ? res.status === expect : (res.status >= 200 && res.status < 300);
+
+  if (!passed) {
+    if (res.status === 401 || res.status === 403) return { ok: false, reason: 'unauthorized' };
+    return { ok: false, reason: 'invalid_key' };
+  }
+
+  return {
+    ok: true,
+    account_label: opts.accountLabel || (opts.serviceKey ? String(opts.serviceKey) : 'Connected'),
+    last_4: injectedCredentialValue ? last4(injectedCredentialValue) : null,
+    summary: { health_check: true, status: res.status },
+  };
+}

package/lib/connections/manifest-validator.js

@@ -0,0 +1,161 @@
+// lib/connections/manifest-validator.js — pure validator for connection manifests.
+//
+// A connection manifest is INERT DATA describing how the setup assistant collects
+// credentials for a service. This validator enforces the security envelope for the
+// new `setup_kind:'oauth2'` shape and the generic `health_check` block, so a
+// malformed/malicious manifest cannot embed a raw secret or point a health check
+// at a private host.
+//
+// Load-bearing properties (mirrors connector-validator.js):
+//   • OAuth client id/secret + tokens are referenced by *_ref ONLY (vault names),
+//     never inline. Any key carrying a raw secret value is rejected.
+//   • authorize_url / token_url / health_check.endpoint must be https.
+//   • No private/loopback hosts in health_check.endpoint.
+//
+// Pure ESM — no DB/fs/network imports. Returns { ok, errors, warnings }.
+
+const SECRET_REF_REGEX = /^[A-Z][A-Z0-9_]{1,63}$/;
+const VALID_SETUP_KINDS = new Set(['api_key', 'oauth2', 'qr_pair', 'binary_detect']);
+
+// Exact key names that must never hold a raw secret value in the oauth block.
+const RAW_SECRET_KEYS = new Set([
+  'client_id', 'client_secret', 'access_token', 'refresh_token', 'token', 'secret', 'password', 'api_key',
+]);
+
+const OAUTH_REF_FIELDS = ['client_id_ref', 'client_secret_ref', 'access_token_ref', 'refresh_token_ref'];
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function isHttpsUrl(value) {
+  if (typeof value !== 'string') return false;
+  try {
+    return new URL(value).protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function isPrivateOrLocalHost(host) {
+  if (!host) return false;
+  const h = String(host).toLowerCase().replace(/^\[|\]$/g, '');
+  if (h === 'localhost' || h === '::1' || h === '0.0.0.0') return true;
+  if (h.endsWith('.localhost') || h.endsWith('.local')) return true;
+  const ipv4 = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!ipv4) return false;
+  const [a, b] = [Number(ipv4[1]), Number(ipv4[2])];
+  if (a === 10 || a === 127 || a === 0) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  return false;
+}
+
+function validateOauthBlock(oauth, errors) {
+  if (!isPlainObject(oauth)) {
+    errors.push('oauth: required (plain object) for setup_kind oauth2');
+    return;
+  }
+
+  // SECURITY: reject any raw-secret key (must use *_ref instead).
+  for (const key of Object.keys(oauth)) {
+    if (RAW_SECRET_KEYS.has(key.toLowerCase())) {
+      errors.push(`oauth: raw secrets are not allowed; reference by *_ref only (found '${key}')`);
+    }
+  }
+
+  if (!oauth.provider || typeof oauth.provider !== 'string') {
+    errors.push('oauth.provider: required (string)');
+  }
+
+  // authorize_url / token_url may be omitted IF the provider is catalogued; the
+  // validator can't see the registry, so when present they must be https.
+  if (oauth.authorize_url != null && !isHttpsUrl(oauth.authorize_url)) {
+    errors.push('oauth.authorize_url: must be https');
+  }
+  if (oauth.token_url != null && !isHttpsUrl(oauth.token_url)) {
+    errors.push('oauth.token_url: must be https');
+  }
+
+  if (oauth.scopes != null && !Array.isArray(oauth.scopes)) {
+    errors.push('oauth.scopes: must be an array of strings');
+  }
+
+  // client_id_ref is required so the operator's app credentials resolve from the
+  // vault; access_token_ref is required so the minted token has a home.
+  if (!oauth.client_id_ref || typeof oauth.client_id_ref !== 'string') {
+    errors.push('oauth.client_id_ref: required (vault ref, e.g. META_CLIENT_ID)');
+  }
+  if (!oauth.access_token_ref || typeof oauth.access_token_ref !== 'string') {
+    errors.push('oauth.access_token_ref: required (vault ref, e.g. META_ACCESS_TOKEN)');
+  }
+
+  for (const field of OAUTH_REF_FIELDS) {
+    const val = oauth[field];
+    if (val == null) continue;
+    if (typeof val !== 'string' || !SECRET_REF_REGEX.test(val)) {
+      errors.push(`oauth.${field}: must match ${SECRET_REF_REGEX} (uppercase vault ref)`);
+    }
+  }
+}
+
+function validateHealthCheck(hc, errors) {
+  if (!isPlainObject(hc)) {
+    errors.push('health_check: must be a plain object');
+    return;
+  }
+  if (!hc.endpoint || !isHttpsUrl(hc.endpoint)) {
+    errors.push('health_check.endpoint: required (https URL)');
+  } else {
+    let host;
+    try { host = new URL(hc.endpoint).hostname; } catch { host = null; }
+    if (host && isPrivateOrLocalHost(host)) {
+      errors.push(`health_check.endpoint: private/local hosts are not allowed ('${host}')`);
+    }
+  }
+  if (hc.method != null && !/^(GET|POST|PUT|PATCH|DELETE|HEAD)$/.test(String(hc.method))) {
+    errors.push('health_check.method: must be a valid HTTP method (uppercase)');
+  }
+  if (hc.expect_status != null && !Number.isInteger(hc.expect_status)) {
+    errors.push('health_check.expect_status: must be an integer status code');
+  }
+}
+
+/**
+ * Validate a connection manifest. Strict for the oauth2 + health_check additions;
+ * permissive (warnings only) for the legacy api_key/qr_pair/binary_detect kinds so
+ * existing seeds keep validating.
+ *
+ * @param {object} manifest
+ * @returns {{ ok: boolean, errors: string[], warnings: string[] }}
+ */
+export function validateConnectionManifest(manifest) {
+  const errors = [];
+  const warnings = [];
+
+  if (!isPlainObject(manifest)) {
+    return { ok: false, errors: ['manifest: must be a plain object'], warnings };
+  }
+
+  const setupKind = manifest.setup_kind || 'api_key';
+  if (!VALID_SETUP_KINDS.has(setupKind)) {
+    errors.push(`setup_kind: must be one of ${[...VALID_SETUP_KINDS].join(', ')}`);
+  }
+
+  if (setupKind === 'oauth2') {
+    validateOauthBlock(manifest.oauth, errors);
+  }
+
+  if (manifest.health_check != null) {
+    validateHealthCheck(manifest.health_check, errors);
+  }
+
+  if (manifest.unlocks_tool_slugs != null && !Array.isArray(manifest.unlocks_tool_slugs)) {
+    errors.push('unlocks_tool_slugs: must be an array of tool slug strings');
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+export { VALID_SETUP_KINDS };

package/lib/marketplace-modules.js

@@ -27,6 +27,45 @@
 import { getDb, nowIso } from './db.js';
 import { appendComplianceAudit } from './compliance-audit.js';
 import { seedMinesAgents, removeMinesAgents } from './mines/seeds.js';
+import { installAgentTemplate, uninstallAgent } from './agent-templates.js';
+
+// Generic module provisioning: provision each agent TEMPLATE the module declares
+// (manifest.agents are template slugs). Idempotent — installAgentTemplate returns
+// the existing install without re-creating. Returns the count provisioned.
+function provisionTemplateAgents(item) {
+  const slugs = Array.isArray(item?.module?.agents) ? item.module.agents : [];
+  let count = 0;
+  for (const slug of slugs) {
+    try {
+      installAgentTemplate(slug, 'personal');
+      count += 1;
+    } catch {
+      // A missing template slug must not abort the whole install.
+    }
+  }
+  return count;
+}
+
+// Remove the agents this module provisioned, resolving each template slug back to
+// its installed agent_id via the installation table. Returns the count removed.
+function deprovisionTemplateAgents(db, item) {
+  const slugs = Array.isArray(item?.module?.agents) ? item.module.agents : [];
+  let count = 0;
+  for (const slug of slugs) {
+    try {
+      const row = db.prepare(
+        "SELECT agent_id FROM agent_template_installations WHERE template_slug = ? AND project_id = 'personal'"
+      ).get(slug);
+      if (row?.agent_id) {
+        uninstallAgent(row.agent_id);
+        count += 1;
+      }
+    } catch {
+      // best-effort teardown
+    }
+  }
+  return count;
+}
 
 const AUDIT_ORG_ID = 'personal-org';
 const AUDIT_USER_ID = 'system';
@@ -91,6 +130,9 @@ export function installModule(item, getItem) {
   const moduleId = item?.module?.module_id || item?.slug;
   if (moduleId === 'mines') {
     seedMinesAgents();
+  } else {
+    // Generic module: provision the agent templates it declares.
+    provisionTemplateAgents(item);
   }
 
   writeInstallRow(db, item.id, true, now);
@@ -146,6 +188,9 @@ export function uninstallModule(item, getItem) {
     if (moduleId === 'mines') {
       removedProjects = deleteMinesProjects(db);
       removedAgents = removeMinesAgents();
+    } else {
+      // Generic module: tear down the agent templates it provisioned.
+      removedAgents = deprovisionTemplateAgents(db, item);
     }
     writeInstallRow(db, item.id, false, now);
     db.exec('COMMIT');

package/lib/marketplace-seeds.js

@@ -233,6 +233,62 @@ const BUSINESS_SKILL_SEEDS = [
   },
 ];
 
+// Business Agent Suite skill packs (P4). Department-grouped skills that lean on
+// the planned/connected business tools. NOT default-on (no manifest.default) so
+// they don't crowd the fresh-install showcase — they install with the module.
+const BUSINESS_SUITE_SKILL_SEEDS = [
+  { slug: 'paid-campaign-build', title: 'Paid Campaign Build', category: 'marketing',
+    description: 'Structure a paid campaign — objective, audiences, ad sets, creative spec, and budget — ready for approval-gated launch.',
+    tools: ['create_artifact', 'web_search'], risk_summary: 'Plans campaigns; every publish/budget set stays approval-gated.',
+    tags: ['marketing', 'ads', 'campaign'], invocation: '/paid-campaign',
+    trigger_examples: ['build a Meta campaign', 'plan a paid launch', 'structure ad sets'] },
+  { slug: 'ads-reporting', title: 'Ads Reporting', category: 'marketing',
+    description: 'Pull spend, CPA, ROAS, and reach from connected ad accounts into one weekly performance report.',
+    tools: ['create_artifact', 'file_write'], risk_summary: 'Read-only reporting; no external writes.',
+    tags: ['marketing', 'ads', 'reporting'], invocation: '/ads-report',
+    trigger_examples: ['weekly ads report', 'how did campaigns perform', 'ROAS summary'] },
+  { slug: 'content-calendar', title: 'Content Calendar', category: 'content',
+    description: 'Plan a multi-channel content calendar with post drafts, captions, and a scheduled queue.',
+    tools: ['create_artifact', 'file_write'], risk_summary: 'Drafts and schedules; every publish stays approval-gated.',
+    tags: ['content', 'social', 'calendar'], invocation: '/content-calendar',
+    trigger_examples: ['plan this month of content', 'build a content calendar', 'draft social posts'] },
+  { slug: 'lead-research', title: 'Lead Research', category: 'sales',
+    description: 'Build a qualified target list, enrich it, and prep a personalized outreach sequence.',
+    tools: ['web_search', 'web_fetch', 'create_artifact'], risk_summary: 'Research + drafts; sequence enrollment and bulk sends are approval-gated.',
+    tags: ['sales', 'outreach', 'leads'], invocation: '/lead-research',
+    trigger_examples: ['build a target list', 'find leads for X', 'prep an outreach sequence'] },
+  { slug: 'ticket-reply', title: 'Ticket Reply', category: 'support',
+    description: 'Triage support tickets, draft replies in brand voice, and flag escalations.',
+    tools: ['gmail_messages_list', 'file_write'], risk_summary: 'Drafts replies; outbound sends/status changes are approval-gated.',
+    tags: ['support', 'helpdesk', 'tickets'], invocation: '/ticket-reply',
+    trigger_examples: ['triage support tickets', 'draft ticket replies', 'escalate this ticket'] },
+  { slug: 'runway-model', title: 'Runway Model', category: 'finance',
+    description: 'Turn revenue/expense data into a runway model and P&L summary with scenario sensitivity.',
+    tools: ['file_read', 'create_artifact'], risk_summary: 'Advisory analysis; any money movement is approval-gated.',
+    tags: ['finance', 'runway', 'modeling'], invocation: '/runway',
+    trigger_examples: ['model our runway', 'P&L summary', 'how many months of cash'] },
+];
+
+function buildSuiteSkillSeed(s) {
+  return {
+    slug: s.slug,
+    title: s.title,
+    description: s.description,
+    category: s.category,
+    author: 'madarx',
+    source_kind: 'builtin',
+    source_url: null,
+    version: null,
+    risk_summary: s.risk_summary,
+    tags: s.tags,
+    manifest: {
+      invocation: s.invocation,
+      uses_tools: s.tools,
+      trigger_examples: s.trigger_examples,
+    },
+  };
+}
+
 function buildBusinessSkillSeed(s) {
   return {
     slug: s.slug,
@@ -382,9 +438,54 @@ const MINES_MODULE_SEED = {
   },
 };
 
+// ── Business Agent Suite module (P4) ─────────────────────────────────────────
+// A "whole company in a box": one click provisions the cross-department agent
+// roster, installs the department skill packs, enables the safe built-in tools,
+// and points the operator at the connections to authenticate. External-write
+// capabilities (ads, sends, CRM, deploys) stay disabled until the matching
+// connection is set up and granted — nothing dangerous installs hot.
+//
+// manifest.agents are AGENT TEMPLATE SLUGS — installModule provisions each via
+// installAgentTemplate (generic provisioning path in lib/marketplace-modules.js).
+// manifest.connections lists the connection slugs the suite expects (seeded as
+// kind:'connection' items the operator connects on demand).
+const BUSINESS_SUITE_MODULE_SEED = {
+  slug: 'business-suite',
+  title: 'Business Agent Suite',
+  description: 'A whole company in a box: a cross-department roster of business agents, department skill packs, and the connections they need. Marketing, ads, content, sales, support, ops, finance, legal, product, web, analyst, and a Chief of Staff to run the cadence.',
+  category: 'business',
+  author: 'madarx',
+  source_kind: 'builtin',
+  source_url: null,
+  version: '0.1.0',
+  risk_summary: 'Agents install with safe built-in tools only. Ad spend, sends, CRM writes, and deploys stay approval-gated and require connecting + granting the matching service first.',
+  tags: ['business', 'company', 'marketing', 'sales', 'ops', 'starter'],
+  manifest: {
+    module_id: 'business-suite',
+    agents: [
+      'chief-of-staff', 'marketing-lead', 'ads-media-buyer', 'content-social',
+      'sales-bd', 'customer-support', 'ops-manager', 'finance-ops',
+      'legal-compliance', 'product-pm', 'web-ecommerce', 'competitor-scout',
+    ],
+    tools: [
+      'web_search', 'web_fetch', 'file_read', 'file_write', 'create_artifact',
+      'email_send', 'gmail_messages_list', 'calendar_events_list',
+      'create_workflow_definition',
+    ],
+    skill_packs: [
+      'market-research', 'report-builder', 'paid-campaign-build', 'ads-reporting',
+      'content-calendar', 'lead-research', 'ticket-reply', 'runway-model',
+    ],
+    connections: ['resend', 'meta-ads', 'google-ads', 'ga4', 'hubspot-crm'],
+    workflow_templates: [],
+    nav: [],
+  },
+};
+
 export function seedMarketplaceItems(db) {
   try {
     for (const s of BUSINESS_SKILL_SEEDS) upsertItem(db, 'skill', buildBusinessSkillSeed(s));
+    for (const s of BUSINESS_SUITE_SKILL_SEEDS) upsertItem(db, 'skill', buildSuiteSkillSeed(s));
     for (const seed of SKILL_SEEDS) upsertItem(db, 'skill', seed);
     for (const seed of BUNDLE_SEEDS) upsertItem(db, 'bundle', seed);
     for (const curated of OPEN_DESIGN_CURATED_SKILLS) {
@@ -394,6 +495,8 @@ export function seedMarketplaceItems(db) {
     seedConnections(db);
     // Mines module entry (kind:'module').
     upsertItem(db, 'module', MINES_MODULE_SEED);
+    // Business Agent Suite module entry (kind:'module').
+    upsertItem(db, 'module', BUSINESS_SUITE_MODULE_SEED);
   } catch (err) {
     console.warn('[marketplace-seeds] seed failed:', err?.message || err);
   }
@@ -440,6 +543,8 @@ export function defaultSkillsMarkdown() {
   return lines.join('\n').trimEnd() + '\n';
 }
 
+export const BUSINESS_SUITE_SKILL_SLUGS = BUSINESS_SUITE_SKILL_SEEDS.map(s => s.slug);
+export { BUSINESS_SUITE_MODULE_SEED };
 export const PHASE1_SKILL_SLUGS = SKILL_SEEDS.map(s => s.slug);
 export const PHASE1_BUNDLE_SLUGS = BUNDLE_SEEDS.map(s => s.slug);
 export const OPEN_DESIGN_SKILL_SLUGS = OPEN_DESIGN_CURATED_SKILLS.map(s => `open-design-${s.slug}`);

package/lib/marketplace.js

@@ -195,6 +195,7 @@ function shapeNonToolItem(row, installRow) {
       agents: Array.isArray(manifest.agents) ? manifest.agents : [],
       tools: Array.isArray(manifest.tools) ? manifest.tools : [],
       skill_packs: Array.isArray(manifest.skill_packs) ? manifest.skill_packs : [],
+      connections: Array.isArray(manifest.connections) ? manifest.connections : [],
       workflow_templates: Array.isArray(manifest.workflow_templates)
         ? manifest.workflow_templates
         : [],