@optimuslabs/harness-map-staging 1.5.35 → 1.5.36

package/dist/approved_tenant_gate.js

@@ -87,7 +87,7 @@ export function readClaudeSignedInTenant(env = process.env) {
 /**
  * Block messages, one shape for every agent (Optimus Labs' prompt-block wording):
  * "This device only allows <agent> <under/on/in> the <approved> <kind>. You're signed in to
- * <what>. <how to switch>." With nothing approved yet: "This device doesn't allow <agent> signed in
+ * <what>. <how to switch>." With nothing approved yet: "This device doesn't allow <agent> to be signed in
  * to <what>." and the same last sentence.
  */
 const TENANT_WORDS = {
@@ -96,6 +96,8 @@ const TENANT_WORDS = {
     cursor: { name: 'Cursor', kind: 'team', prep: 'on' },
     codex: { name: 'Codex', kind: 'workspace', prep: 'in' },
 };
+/** How a block that names the organization's own rule begins; such a block needs no title above it. */
+export const ORGANIZATION_LEAD = 'Your organization';
 /** A tenant's name as the admin approved it, or its id when it has none. */
 function nameOf(t) {
     return (t.tenant_name || '').trim() || t.tenant_id.trim();
@@ -108,35 +110,54 @@ function emailDomain(email) {
 function capitalised(word) {
     return word ? word[0].toUpperCase() + word.slice(1) : word;
 }
-/** What to pick to get back in: the one approved tenant, one of several, or the company's own. */
-function choice(approved, kind) {
+/**
+ * What to pick to get back in: the one approved tenant, one of several, or the company's own,
+ * named after `company` when it is known ("your Optimus Labs organization").
+ */
+function choice(approved, kind, company) {
     if (approved.length === 1)
         return approved[0];
-    return approved.length > 1 ? 'one of them' : `your company's ${kind}`;
+    return approved.length > 1 ? 'one of them' : `your ${company || "company's"} ${kind}`;
 }
-function switchStep(agent, approved) {
+function switchStep(agent, approved, company) {
     const kind = TENANT_WORDS[agent].kind;
     if (agent === 'claude_desktop')
-        return `Switch Claude Desktop to ${choice(approved, kind)}.`;
-    if (agent === 'codex')
-        return `Run codex logout, then codex login and choose ${choice(approved, kind)}.`;
+        return `Switch Claude Desktop to ${choice(approved, kind, company)}.`;
+    if (agent === 'codex') {
+        return `Run codex logout, then codex login and choose ${choice(approved, kind, company)}.`;
+    }
     if (agent === 'cursor') {
-        if (approved.length === 1)
-            return `Sign out of Cursor and sign in with your ${approved[0]} team account.`;
+        // Reached only without one account to name (see cursorTeamViolation).
         return approved.length > 1
             ? 'Sign out of Cursor and sign in with an account on one of those teams.'
             : "Sign out of Cursor and sign in with your company's team account.";
     }
-    return `Run /login and choose ${choice(approved, kind)}.`;
+    return `Run /login and choose ${choice(approved, kind, company)}.`;
 }
-/** The block message for `agent` signed in to `signedIn` (already worded) with these approved. */
-export function tenantBlockMessage(agent, approved, signedIn) {
+/**
+ * The block message for `agent` signed in to `signedIn` (already worded) with these approved.
+ * `company` names the company when the agent has nothing approved of its own; '' says "company's".
+ */
+export function tenantBlockMessage(agent, approved, signedIn, company = '') {
     const w = TENANT_WORDS[agent];
     const lead = approved.length
         ? `This device only allows ${w.name} ${w.prep} the ${approved.join(' or ')} ${w.kind}. ` +
             `You're signed in to ${signedIn}.`
-        : `This device doesn't allow ${w.name} signed in to ${signedIn}.`;
-    return `${lead} ${switchStep(agent, approved)}`;
+        : `This device doesn't allow ${w.name} to be signed in to ${signedIn}.`;
+    return `${lead} ${switchStep(agent, approved, company)}`;
+}
+/**
+ * The company's name for "your <company> team account": the one name its approved tenants go by,
+ * across every agent (a Cursor login on no approved team is pointed at the company's Claude
+ * organization's name). '' when there is none, or several. Personal accounts (`@<domain>`) and a
+ * person's own org ("ada@gmail.com's Organization") are not the company's.
+ */
+export function companyName(approved) {
+    const names = new Set(Object.values(approved ?? {})
+        .flatMap((policy) => tenantIds(policy?.tenants))
+        .filter((t) => !t.tenant_id.trim().startsWith('@') && !/'s organization$/i.test(nameOf(t)))
+        .map(nameOf));
+    return names.size === 1 ? [...names][0] : '';
 }
 const CLAUDE_PERSONAL_PLANS = new Set(['free', 'pro', 'max']);
 /** "a personal Max account (gmail.com)" or "the Beta Corp organization". */
@@ -159,23 +180,18 @@ function tenantIds(tenants) {
 /**
  * The block message when `signedIn` may not be used for `agent`, else null.
  *
- * Mirrors the backend's `tenant_approval`: a tenant the organization marked unapproved is always
- * blocked; a shadow tenant (never decided) only once the agent has at least one approved tenant.
- * Ids compare exactly, as the backend does -- vendor ids are not ours to case-fold.
+ * Only a tenant the organization blocked (marked unapproved) is refused. One never decided is
+ * awaiting review and gets through, as an approved one does. Ids compare exactly, as the backend
+ * does -- vendor ids are not ours to case-fold.
  */
 export function approvedTenantViolation(agent, approved, signedIn) {
     if (!signedIn)
         return null;
     const policy = approved?.[agent];
-    const approvedTenants = tenantIds(policy?.tenants);
-    const unapprovedTenants = tenantIds(policy?.unapproved_tenants);
     const signedInId = signedIn.tenant_id.trim();
-    const isIn = (list) => list.some((t) => t.tenant_id.trim() === signedInId);
-    const blocked = isIn(unapprovedTenants) ||
-        ((policy?.enforced || approvedTenants.length > 0) && !isIn(approvedTenants));
-    if (!blocked)
+    if (!tenantIds(policy?.unapproved_tenants).some((t) => t.tenant_id.trim() === signedInId))
         return null;
-    return tenantBlockMessage(agent, approvedTenants.map(nameOf), claudeSignedInText(signedIn));
+    return tenantBlockMessage(agent, tenantIds(policy?.tenants).map(nameOf), claudeSignedInText(signedIn), companyName(approved));
 }
 /**
  * The tenants a Cursor login is in: its teams, or, on no team, `@` and its email domain. Mirrors the
@@ -203,42 +219,30 @@ export function readCursorSignedInTeams(home = homedir()) {
 /**
  * Why a login in these tenants may not be used, or null when it may. Shared by every agent whose
  * login is a list of tenants (Cursor's teams) or one tenant that may be a personal account's
- * `@<domain>` (Codex), and mirrors the backend's `team_tenant_approval`: any approved tenant admits
- * the login; failing that, one marked unapproved is always blocked, and any other -- an unknown
- * tenant, or a personal account -- only once at least one tenant is approved for this agent.
+ * `@<domain>` (Codex). Blocked only when every tenant the login is in was blocked (marked
+ * unapproved): Cursor admits a login when any of its teams is allowed, and a tenant awaiting review
+ * is allowed, as an approved one is.
  */
 function listedTenantViolation(policy, tenants) {
-    const approvedList = tenantIds(policy?.tenants);
-    if (tenants.some((id) => isListed(approvedList, id)))
+    const unapprovedList = tenantIds(policy?.unapproved_tenants);
+    if (!tenants.length || !tenants.every((id) => isListed(unapprovedList, id)))
         return null;
-    const enforced = approvedList.length > 0 || Boolean(policy?.enforced);
-    if (!isRefused(tenants, enforced, tenantIds(policy?.unapproved_tenants)))
-        return null;
-    return { approved: approvedList.map(nameOf) };
+    return { approved: tenantIds(policy?.tenants).map(nameOf) };
 }
 function isListed(list, id) {
     return list.some((t) => t.tenant_id.trim() === id);
 }
-/** Whether a login in these tenants is refused: one marked unapproved always; any other only once
- * the agent is enforced (an older backend that sends no flag, with nothing approved, lets it pass). */
-function isRefused(tenants, enforced, unapprovedList) {
-    if (tenants.some((id) => isListed(unapprovedList, id)))
-        return true;
-    return enforced;
-}
 /** A tenant's name from the organization's lists, or '' when it has none there. */
 function knownName(policy, id) {
     const all = [...tenantIds(policy?.tenants), ...tenantIds(policy?.unapproved_tenants)];
     const hit = all.find((t) => t.tenant_id.trim() === id);
     return (hit?.tenant_name || '').trim();
 }
-/** "a personal account on no team (gmail.com)", "the Beta team" or "team 9876". */
+/** "a personal account", "the Beta team" or "team 9876". */
 function cursorSignedInText(signedIn, policy) {
     const tenants = cursorTenants(signedIn);
-    if (!tenants.length || tenants[0].startsWith('@')) {
-        const domain = emailDomain(signedIn.email) || (tenants[0] ?? '').slice(1);
-        return `a personal account on no team${domain ? ` (${domain})` : ''}`;
-    }
+    if (!tenants.length || tenants[0].startsWith('@'))
+        return 'a personal account';
     return tenants
         .map((id) => (knownName(policy, id) ? `the ${knownName(policy, id)} team` : `team ${id}`))
         .join(' and ');
@@ -255,13 +259,22 @@ function codexSignedInText(signedIn, tenants, policy) {
     return name ? `the ${name} workspace` : `workspace ${tenant}`;
 }
 /** The block message when Cursor's login may not be used, else null. */
-export function cursorTeamViolation(approved, signedIn) {
+export function cursorTeamViolation(approved, signedIn, teamDomains = []) {
     if (!signedIn)
         return null;
     const v = listedTenantViolation(approved?.cursor, cursorTenants(signedIn));
     if (!v)
         return null;
-    return tenantBlockMessage('cursor', v.approved, cursorSignedInText(signedIn, approved?.cursor));
+    const signedInText = cursorSignedInText(signedIn, approved?.cursor);
+    // The one account to point at: the approved team, else the company's name. Several approved
+    // teams, or no name known, keep the generic message.
+    const account = v.approved.length === 1 ? v.approved[0] : v.approved.length ? '' : companyName(approved);
+    if (!account)
+        return tenantBlockMessage('cursor', v.approved, signedInText);
+    const domains = teamDomains.length ? ` (${teamDomains.join(', ')})` : '';
+    return (`${ORGANIZATION_LEAD} does not allow Cursor to be signed in to ${signedInText}. ` +
+        `The approved organization's team account for Cursor is ${account}${domains}. ` +
+        'Please sign out and sign in with the approved account to use Cursor.');
 }
 /**
  * Codex plans that are personal, mirroring the backend's `CodexPlans.PERSONAL`. On one of these
@@ -307,34 +320,7 @@ export function codexTenantViolation(approved, signedIn) {
     const v = listedTenantViolation(approved?.codex, tenants);
     if (!v)
         return null;
-    return tenantBlockMessage('codex', v.approved, codexSignedInText(signedIn, tenants, approved?.codex));
-}
-/**
- * Whether a personal account's `@<domain>` tenant is on a team domain: an allowlisted domain that
- * someone on an approved team or enterprise tenant signs in with (any vendor's). A subdomain counts.
- */
-export function onTeamDomain(tenant, teamDomains) {
-    if (!tenant.startsWith('@') || !teamDomains?.length)
-        return false;
-    const domain = tenant.slice(1);
-    return teamDomains.some((d) => domain === d || domain.endsWith(`.${d}`));
-}
-/**
- * The block message for Cursor's login, else null. A login on a team is checked against the
- * approved teams. A personal account is only checked once its email is on a team domain; then it
- * is blocked unless an admin approved that personal tenant (`@<domain>`).
- */
-export function cursorLoginViolation(approved, signedIn, teamDomains) {
-    if (!signedIn)
-        return null;
-    const checked = signedIn.team_ids.length > 0 || cursorTenants(signedIn).some((t) => onTeamDomain(t, teamDomains));
-    return checked ? cursorTeamViolation(approved, signedIn) : null;
-}
-/** The block message for Codex's login, else null; a personal plan is checked as Cursor's is. */
-export function codexLoginViolation(approved, signedIn, teamDomains) {
-    const tenants = signedIn ? codexTenants(signedIn) : null;
-    const checked = tenants?.some((t) => !t.startsWith('@') || onTeamDomain(t, teamDomains));
-    return checked ? codexTenantViolation(approved, signedIn) : null;
+    return tenantBlockMessage('codex', v.approved, codexSignedInText(signedIn, tenants, approved?.codex), companyName(approved));
 }
 /**
  * The org Claude Desktop is signed into now, for its Code tab's prompts, or null when unknown.
@@ -378,26 +364,6 @@ export function unapprovedEmailDomainViolation(email, unapproved) {
     return (`This device doesn't allow accounts on ${hit}. You're signed in as ${address}. ` +
         'Sign in with your work account.');
 }
-/**
- * The block message when a login's email is not on the organization's email allowlist, else null.
- *
- * The allowlist is the organization's approved email domains; a domain covers its subdomains
- * (`mail.acme.com` under `acme.com`). Null, so the login is allowed, when no allowlist has been
- * synced to this machine yet or the login has no email we can read.
- */
-export function emailAllowlistViolation(email, allowed) {
-    if (!Array.isArray(allowed))
-        return null;
-    const address = (email ?? '').trim().toLowerCase();
-    const at = address.lastIndexOf('@');
-    if (at < 0 || at === address.length - 1)
-        return null;
-    const domain = address.slice(at + 1);
-    if (allowed.some((d) => domain === d || domain.endsWith(`.${d}`)))
-        return null;
-    return (`This device only allows accounts on your organization's email domains. You're signed in as ${address}. ` +
-        'Sign in with your work account.');
-}
 /** The id an agent is approved under on the Agents page: Desktop's Code tab runs Claude Code. */
 const APPROVAL_ID = { claude_desktop: 'claude' };
 const AGENT_NAME = {

package/dist/compliance_prompt_gate.js

@@ -24,7 +24,7 @@ import { tryResolveHardwareUuid } from './log_config_files/runtime/hardware_uuid
 import { cursorAutofixDefersInlineVerify, syncRemediations, } from './log_config_files/runtime/remediation_sync.js';
 import { loadEndpointBase } from './log_config_files/sender/endpoint_config.js';
 import { formatRemediationChangePreviewForApplied } from './remediation_change_preview.js';
-import { agentApprovalViolation, approvedTenantViolation, codexLoginViolation, emailAllowlistViolation, cursorLoginViolation, readClaudeDesktopSignedInTenant, readClaudeSignedInTenant, readCodexSignedIn, readCursorSignedInTeams, } from './approved_tenant_gate.js';
+import { agentApprovalViolation, approvedTenantViolation, codexTenantViolation, cursorTeamViolation, ORGANIZATION_LEAD, readClaudeDesktopSignedInTenant, readClaudeSignedInTenant, readCodexSignedIn, readCursorSignedInTeams, unapprovedEmailDomainViolation, } from './approved_tenant_gate.js';
 const MANIFEST_STALE_MS = 7 * 24 * 60 * 60 * 1000;
 /** After verified (or failed verify), push enforcement + session log immediately — do not wait for background runner. */
 async function flushRemediationOutcomeToServer(complianceLogPath) {
@@ -89,8 +89,12 @@ function printAllowWithAdvisory(ide, advisoryMessage) {
 }
 /** Every block reads as an Optimus Labs notice: a title line, then the message. */
 const BLOCK_TITLE = 'Optimus Labs\n\n';
+/** The block as shown: titled, unless it already says it is the organization's rule. */
+function titled(violationMessage) {
+    return violationMessage.startsWith(ORGANIZATION_LEAD) ? violationMessage : BLOCK_TITLE + violationMessage;
+}
 function blockPayload(ide, violationMessage) {
-    const text = BLOCK_TITLE + violationMessage;
+    const text = titled(violationMessage);
     if (ide === 'claude' || ide === 'copilot' || ide === 'opencode') {
         return JSON.stringify({ decision: 'block', reason: text, systemMessage: text });
     }
@@ -101,7 +105,7 @@ function blockPayload(ide, violationMessage) {
  * warning, so the Claude-shaped payload (which carries both) prints the same sentence twice.
  */
 function codexBlockPayload(violationMessage) {
-    return JSON.stringify({ decision: 'block', reason: BLOCK_TITLE + violationMessage });
+    return JSON.stringify({ decision: 'block', reason: titled(violationMessage) });
 }
 function getManifestStalenessMs() {
     try {
@@ -264,7 +268,7 @@ function loginEmail(agent) {
         return readCursorSignedInTeams()?.email ?? '';
     return null;
 }
-/** Why this agent's signed-in tenant is not approved, or null when it is (or cannot be read). */
+/** Why this agent's signed-in tenant is blocked, or null when it is not (or cannot be read). */
 function tenantViolation(agent) {
     const { approved_tenants: approved, team_email_domains: teamDomains } = readRemediationInstructionsFile();
     if (agent === 'claude')
@@ -272,12 +276,10 @@ function tenantViolation(agent) {
     if (agent === 'claude_desktop') {
         return approvedTenantViolation('claude_desktop', approved, readClaudeDesktopSignedInTenant());
     }
-    // A personal account (Cursor on no team, Codex on a personal plan) is left to the email allowlist
-    // until its domain is a team domain; then it needs its personal tenant approved.
     if (agent === 'codex')
-        return codexLoginViolation(approved, readCodexSignedIn(), teamDomains);
+        return codexTenantViolation(approved, readCodexSignedIn());
     if (agent === 'cursor')
-        return cursorLoginViolation(approved, readCursorSignedInTeams(), teamDomains);
+        return cursorTeamViolation(approved, readCursorSignedInTeams(), teamDomains);
     return null;
 }
 /** The block for a login: which check refused it and why, or null when every check passes. */
@@ -288,16 +290,16 @@ function loginBlock(agent, email) {
         return { event: 'prompt_gate_block_unapproved_agent', reason: agentMsg };
     if (email === null)
         return null;
-    const emailMsg = emailAllowlistViolation(email, synced.allowed_email_domains);
+    const emailMsg = unapprovedEmailDomainViolation(email, synced.unapproved_email_domains);
     if (emailMsg)
-        return { event: 'prompt_gate_block_email_not_allowlisted', reason: emailMsg };
+        return { event: 'prompt_gate_block_unapproved_email_domain', reason: emailMsg };
     const tenantMsg = tenantViolation(agent);
     return tenantMsg ? { event: 'prompt_gate_block_unapproved_tenant', reason: tenantMsg } : null;
 }
 /**
- * Block the prompt unless the agent is approved, the login's email is on the organization's email
- * allowlist and its tenant is approved (all as remediation sync stored them), printing the block
- * payload; true when it did. A login whose email or tenant cannot be read passes that check, and a
+ * Block the prompt when the agent is not approved, or the login's email domain or its tenant was
+ * blocked (all as remediation sync stored them), printing the block payload; true when it did. A
+ * domain or tenant awaiting review gets through. A login whose email or tenant cannot be read passes that check, and a
  * machine that has synced nothing yet is not blocked.
  */
 function blockedByLogin(agent, ide) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optimuslabs/harness-map-staging",
-  "version": "1.5.35",
+  "version": "1.5.36",
   "description": "CLI helpers for logging hardware UUIDs and posting startup payloads to Optimus Security.",
   "type": "module",
   "bin": {