@optimuslabs/harness-map-staging 1.5.28 → 1.5.30

package/dist/approved_tenant_gate.js

@@ -62,6 +62,7 @@ export function readClaudeSignedInTenant(env = process.env) {
             tenant_name: text('organizationName'),
             email: text('emailAddress'),
             account_uuid: text('accountUuid'),
+            plan: text('organizationType').toLowerCase().replace(/^claude_/, ''),
         };
     }
     catch {
@@ -69,14 +70,74 @@ export function readClaudeSignedInTenant(env = process.env) {
         return null;
     }
 }
-/** How to get out of a blocked tenant: Claude Desktop switches organization, Claude Code logs in. */
-function fix(agent, which) {
-    return agent === 'claude_desktop'
-        ? `Switch Claude Desktop to ${which} organization, or sign in to one.`
-        : `Run /login to sign in to ${which} organization.`;
+/**
+ * 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
+ * to <what>." and the same last sentence.
+ */
+const TENANT_WORDS = {
+    claude: { name: 'Claude Code', kind: 'organization', prep: 'under' },
+    claude_desktop: { name: 'Claude Desktop', kind: 'organization', prep: 'under' },
+    cursor: { name: 'Cursor', kind: 'team', prep: 'on' },
+    codex: { name: 'Codex', kind: 'workspace', prep: 'in' },
+};
+/** 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();
+}
+function emailDomain(email) {
+    const address = (email ?? '').trim().toLowerCase();
+    const at = address.lastIndexOf('@');
+    return at >= 0 && at < address.length - 1 ? address.slice(at + 1) : '';
 }
-function label(name, id) {
-    return name ? `${name} (${id})` : id;
+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) {
+    if (approved.length === 1)
+        return approved[0];
+    return approved.length > 1 ? 'one of them' : `your company's ${kind}`;
+}
+function switchStep(agent, approved) {
+    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)}.`;
+    if (agent === 'cursor') {
+        if (approved.length === 1)
+            return `Sign out of Cursor and sign in with your ${approved[0]} team account.`;
+        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)}.`;
+}
+/** The block message for `agent` signed in to `signedIn` (already worded) with these approved. */
+export function tenantBlockMessage(agent, approved, signedIn) {
+    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)}`;
+}
+const CLAUDE_PERSONAL_PLANS = new Set(['free', 'pro', 'max']);
+/** "a personal Max account (gmail.com)" or "the Beta Corp organization". */
+function claudeSignedInText(signedIn) {
+    const plan = (signedIn.plan ?? '').trim().toLowerCase();
+    const domain = emailDomain(signedIn.email);
+    const at = domain ? ` (${domain})` : '';
+    // A personal claude.ai org is named after its owner: "ada@gmail.com's Organization".
+    if (CLAUDE_PERSONAL_PLANS.has(plan) || /'s organization$/i.test(signedIn.tenant_name)) {
+        const planWord = CLAUDE_PERSONAL_PLANS.has(plan) ? `${capitalised(plan)} ` : '';
+        return `a personal ${planWord}account${at}`;
+    }
+    if (signedIn.tenant_name)
+        return `the ${signedIn.tenant_name} organization`;
+    return `an organization your company has not approved${at}`;
 }
 function tenantIds(tenants) {
     return (tenants ?? []).filter((t) => t && typeof t.tenant_id === 'string' && t.tenant_id.trim());
@@ -96,21 +157,11 @@ export function approvedTenantViolation(agent, approved, signedIn) {
     const unapprovedTenants = tenantIds(policy?.unapproved_tenants);
     const signedInId = signedIn.tenant_id.trim();
     const isIn = (list) => list.some((t) => t.tenant_id.trim() === signedInId);
-    let reason;
-    if (isIn(unapprovedTenants)) {
-        reason = 'which your organization has marked unapproved';
-    }
-    else if ((policy?.enforced || approvedTenants.length > 0) && !isIn(approvedTenants)) {
-        reason = 'which your organization has not approved';
-    }
-    else {
+    const blocked = isIn(unapprovedTenants) ||
+        ((policy?.enforced || approvedTenants.length > 0) && !isIn(approvedTenants));
+    if (!blocked)
         return null;
-    }
-    const allowed = approvedTenants.map((t) => label(t.tenant_name, t.tenant_id)).join(', ');
-    return (`this session is signed into ${label(signedIn.tenant_name, signedIn.tenant_id)}, ${reason}. ` +
-        (allowed
-            ? `Approved: ${allowed}. ${fix(agent, 'an approved')}`
-            : fix(agent, 'a different')));
+    return tenantBlockMessage(agent, approvedTenants.map(nameOf), claudeSignedInText(signedIn));
 }
 /**
  * The tenants a Cursor login is in: its teams, or, on no team, `@` and its email domain. Mirrors the
@@ -142,49 +193,72 @@ export function readCursorSignedInTeams(home = homedir()) {
  * 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.
  */
-function listedTenantViolation(policy, tenants, noun) {
+function listedTenantViolation(policy, tenants) {
     const approvedList = tenantIds(policy?.tenants);
     if (tenants.some((id) => isListed(approvedList, id)))
         return null;
-    const what = refusedTenantsText(tenants, noun, approvedList.length > 0 || Boolean(policy?.enforced), tenantIds(policy?.unapproved_tenants));
-    if (what === null)
+    const enforced = approvedList.length > 0 || Boolean(policy?.enforced);
+    if (!isRefused(tenants, enforced, tenantIds(policy?.unapproved_tenants)))
         return null;
-    return { what, allowed: approvedList.map((t) => label(t.tenant_name, t.tenant_id)).join(', ') };
+    return { approved: approvedList.map(nameOf) };
 }
 function isListed(list, id) {
     return list.some((t) => t.tenant_id.trim() === id);
 }
-function describeTenant(id, noun) {
-    return id.startsWith('@') ? `a personal account with an ${id} email` : `${noun} ${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;
 }
-/** What the login is signed into and why that is refused, or null when it is not refused. */
-function refusedTenantsText(tenants, noun, enforced, unapprovedList) {
-    const marked = tenants.find((id) => isListed(unapprovedList, id));
-    if (marked)
-        return `${describeTenant(marked, noun)}, which your organization has marked unapproved`;
-    // Not enforced (an older backend that sends no flag) and nothing approved: shadow passes.
-    if (!enforced)
-        return null;
-    if (tenants.length === 0)
-        return `a personal account that is on no ${noun}, which your organization has not approved`;
-    return `${tenants.map((id) => describeTenant(id, noun)).join(', ')}, which your organization has not approved`;
+/** 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". */
+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})` : ''}`;
+    }
+    return tenants
+        .map((id) => (knownName(policy, id) ? `the ${knownName(policy, id)} team` : `team ${id}`))
+        .join(' and ');
+}
+/** "a personal ChatGPT Plus account (gmail.com)", "the Beta workspace" or "workspace ws-1". */
+function codexSignedInText(signedIn, tenants, policy) {
+    const tenant = tenants[0] ?? '';
+    if (!tenant || tenant.startsWith('@')) {
+        const plan = capitalised((signedIn.plan ?? '').trim().toLowerCase());
+        const domain = emailDomain(signedIn.email) || tenant.slice(1);
+        return `a personal ChatGPT ${plan ? `${plan} ` : ''}account${domain ? ` (${domain})` : ''}`;
+    }
+    const name = knownName(policy, tenant);
+    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) {
     if (!signedIn)
         return null;
-    const v = listedTenantViolation(approved?.cursor, cursorTenants(signedIn), 'team');
+    const v = listedTenantViolation(approved?.cursor, cursorTenants(signedIn));
     if (!v)
         return null;
-    return (`this Cursor session is signed into ${v.what}. ` +
-        (v.allowed ? `Approved: ${v.allowed}. ` : '') +
-        'Sign out of Cursor and sign in with an account on an approved team.');
+    return tenantBlockMessage('cursor', v.approved, cursorSignedInText(signedIn, approved?.cursor));
 }
 /**
  * Codex plans that are personal, mirroring the backend's `CodexPlans.PERSONAL`. On one of these
  * the ChatGPT account is the person's own, so the login is keyed by email domain instead.
  */
 const CODEX_PERSONAL_PLANS = new Set(['free', 'go', 'plus']);
+/**
+ * Codex work plans, mirroring the backend's `CodexPlans.WORK`: only these are a shared workspace.
+ * Any other plan with a ChatGPT login (Pro, or one not recognised) is a personal account too.
+ */
+const CODEX_WORK_PLANS = new Set(['business', 'hc', 'enterprise', 'edu', 'education']);
 /** Codex's login from ~/.codex/auth.json (claims only, never tokens), or null when there is none. */
 export function readCodexSignedIn(home = homedir()) {
     const identity = readCodexIdentity(home);
@@ -192,31 +266,34 @@ export function readCodexSignedIn(home = homedir()) {
 }
 /**
  * The tenant a Codex login is in, mirroring the backend's `codex_tenants`: its ChatGPT workspace
- * (`chatgpt_account_id`, the claim Codex's own `forced_chatgpt_workspace_id` checks), or
- * `@<email domain>` on a personal plan. Null when there is no ChatGPT login (an API key).
+ * (`chatgpt_account_id`, the claim Codex's own `forced_chatgpt_workspace_id` checks) on a work plan,
+ * else `@<email domain>`, a personal account. Null when there is no ChatGPT login (an API key).
  */
 export function codexTenants(signedIn) {
     const plan = (signedIn.plan ?? '').trim().toLowerCase();
-    if (CODEX_PERSONAL_PLANS.has(plan)) {
-        const email = (signedIn.email ?? '').trim();
-        const at = email.lastIndexOf('@');
-        return at >= 0 && at < email.length - 1 ? [`@${email.slice(at + 1).toLowerCase()}`] : [];
-    }
+    if (CODEX_PERSONAL_PLANS.has(plan))
+        return codexEmailDomainTenant(signedIn);
     const account = (signedIn.account_id ?? '').trim();
     // The collector falls back to the API organization ("org-...") with no ChatGPT account.
-    return account && !account.startsWith('org-') ? [account] : null;
+    if (!account || account.startsWith('org-'))
+        return null;
+    return CODEX_WORK_PLANS.has(plan) ? [account] : codexEmailDomainTenant(signedIn);
+}
+/** `@<email domain>` for a Codex login, or [] when it has no email: how a personal account is keyed. */
+function codexEmailDomainTenant(signedIn) {
+    const email = (signedIn.email ?? '').trim();
+    const at = email.lastIndexOf('@');
+    return at >= 0 && at < email.length - 1 ? [`@${email.slice(at + 1).toLowerCase()}`] : [];
 }
 /** The block message when Codex's login may not be used, else null. */
 export function codexTenantViolation(approved, signedIn) {
     const tenants = signedIn ? codexTenants(signedIn) : null;
     if (!tenants)
         return null;
-    const v = listedTenantViolation(approved?.codex, tenants, 'workspace');
+    const v = listedTenantViolation(approved?.codex, tenants);
     if (!v)
         return null;
-    return (`this Codex session is signed into ${v.what}. ` +
-        (v.allowed ? `Approved: ${v.allowed}. ` : '') +
-        'Run `codex logout`, then sign in to an approved workspace.');
+    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
@@ -266,6 +343,7 @@ export function readClaudeDesktopSignedInTenant(home = homedir(), env = process.
         tenant_name: same ? fromClaudeCode.tenant_name : '',
         email: same ? fromClaudeCode.email : '',
         account_uuid: account || (same ? fromClaudeCode.account_uuid : ''),
+        plan: same ? fromClaudeCode.plan : '',
     };
 }
 /**
@@ -283,8 +361,8 @@ export function unapprovedEmailDomainViolation(email, unapproved) {
     const hit = unapproved.find((d) => domain === d || domain.endsWith(`.${d}`));
     if (!hit)
         return null;
-    return (`this session is signed in as ${address}, on @${hit}, which your organization has unapproved. ` +
-        'Sign in with an account on an approved email domain.');
+    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.
@@ -303,8 +381,8 @@ export function emailAllowlistViolation(email, allowed) {
     const domain = address.slice(at + 1);
     if (allowed.some((d) => domain === d || domain.endsWith(`.${d}`)))
         return null;
-    return (`this session is signed in as ${address}, and @${domain} is not on your organization's email allowlist. ` +
-        'Sign in with an account on an allowed email domain.');
+    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' };

package/dist/compliance_prompt_gate.js

@@ -87,9 +87,10 @@ 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';
 function blockPayload(ide, violationMessage) {
-    const prefix = 'Prompt blocked by Optimus: ';
-    const text = prefix + violationMessage;
+    const text = BLOCK_TITLE + violationMessage;
     if (ide === 'claude' || ide === 'copilot' || ide === 'opencode') {
         return JSON.stringify({ decision: 'block', reason: text, systemMessage: text });
     }
@@ -100,7 +101,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: 'Prompt blocked by Optimus: ' + violationMessage });
+    return JSON.stringify({ decision: 'block', reason: BLOCK_TITLE + violationMessage });
 }
 function getManifestStalenessMs() {
     try {

package/dist/log_config_files/collection/claude_desktop_orgs_collector.js

@@ -126,11 +126,17 @@ function claudeJsonDetails(home, account, orgUuids) {
     const name = text(oauth.organizationName);
     if (name)
         details.orgNames[org] = name;
-    const plan = readClaudeLoginPlan(home) || claudeCodePlan(claudeJson, oauth);
+    // The org's own type first: the login token's plan describes whichever org the token is for now,
+    // which is not this one while ~/.claude.json still caches the org from before a move to a team.
+    const plan = claudeOrgPlan(oauth) || readClaudeLoginPlan(home) || claudeCodePlan(claudeJson, oauth);
     if (plan)
         details.orgPlans[org] = plan;
     return details;
 }
+/** The plan of the org `oauthAccount` names, fetched with it: its type, else its seat tier. */
+function claudeOrgPlan(oauth) {
+    return text(oauth.organizationType) || text(oauth.seatTier);
+}
 /** Raw, in the order the backend reads Claude Code's plan, so both normalise alike. */
 function claudeCodePlan(claudeJson, oauth) {
     return (text(claudeJson?.subscriptionType) ||

package/package.json

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