@optimuslabs/harness-map-staging 1.5.26 → 1.5.28

package/dist/approved_tenant_gate.js

@@ -218,6 +218,33 @@ export function codexTenantViolation(approved, signedIn) {
         (v.allowed ? `Approved: ${v.allowed}. ` : '') +
         'Run `codex logout`, then sign in to an approved workspace.');
 }
+/**
+ * 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;
+}
 /**
  * The org Claude Desktop is signed into now, for its Code tab's prompts, or null when unknown.
  *

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, codexTenantViolation, codexTenants, emailAllowlistViolation, cursorTeamViolation, readClaudeDesktopSignedInTenant, readClaudeSignedInTenant, readCodexSignedIn, readCursorSignedInTeams, } from './approved_tenant_gate.js';
+import { agentApprovalViolation, approvedTenantViolation, codexLoginViolation, emailAllowlistViolation, cursorLoginViolation, readClaudeDesktopSignedInTenant, readClaudeSignedInTenant, readCodexSignedIn, readCursorSignedInTeams, } 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) {
@@ -265,23 +265,18 @@ function loginEmail(agent) {
 }
 /** Why this agent's signed-in tenant is not approved, or null when it is (or cannot be read). */
 function tenantViolation(agent) {
-    const approved = readRemediationInstructionsFile().approved_tenants;
+    const { approved_tenants: approved, team_email_domains: teamDomains } = readRemediationInstructionsFile();
     if (agent === 'claude')
         return approvedTenantViolation('claude', approved, readClaudeSignedInTenant());
     if (agent === 'claude_desktop') {
         return approvedTenantViolation('claude_desktop', approved, readClaudeDesktopSignedInTenant());
     }
-    // A personal account (Cursor on no team, Codex on a personal plan) has no tenant to approve: only
-    // the email allowlist decides it.
-    if (agent === 'codex') {
-        const signedIn = readCodexSignedIn();
-        const tenants = signedIn ? codexTenants(signedIn) : null;
-        return tenants?.some((t) => !t.startsWith('@')) ? codexTenantViolation(approved, signedIn) : null;
-    }
-    if (agent === 'cursor') {
-        const signedIn = readCursorSignedInTeams();
-        return signedIn?.team_ids.length ? cursorTeamViolation(approved, signedIn) : null;
-    }
+    // 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);
+    if (agent === 'cursor')
+        return cursorLoginViolation(approved, readCursorSignedInTeams(), teamDomains);
     return null;
 }
 /** The block for a login: which check refused it and why, or null when every check passes. */

package/dist/log_config_files/collection/claude_desktop_orgs_collector.js

@@ -1,6 +1,7 @@
 import { closeSync, existsSync, fstatSync, openSync, readdirSync, readFileSync, readSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { readClaudeLoginPlan } from './claude_login_plan.js';
 /**
  * Every org Claude Desktop's signed-in account has used, so both tenants are recorded when one
  * login belongs to a team org and a personal org and switches between them in Desktop.
@@ -20,7 +21,8 @@ import { homedir } from 'node:os';
  * Reads `lastKnownAccountUuid` from config.json and nothing else from it -- the same file holds
  * Desktop's encrypted token caches, which are never touched or uploaded. The email, and the active
  * org's name and plan, come from ~/.claude.json only when it is the same account (and, for the name
- * and plan, the same org): Desktop's own files name neither. macOS only.
+ * and plan, the same org): Desktop's own files name neither. The plan prefers Claude Code's stored
+ * login over that cached profile (see claude_login_plan.ts). macOS only.
  */
 const FILE_TYPE = 'claude_desktop_orgs';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -124,7 +126,7 @@ function claudeJsonDetails(home, account, orgUuids) {
     const name = text(oauth.organizationName);
     if (name)
         details.orgNames[org] = name;
-    const plan = claudeCodePlan(claudeJson, oauth);
+    const plan = readClaudeLoginPlan(home) || claudeCodePlan(claudeJson, oauth);
     if (plan)
         details.orgPlans[org] = plan;
     return details;

package/dist/log_config_files/collection/claude_login_plan.js

@@ -0,0 +1,72 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+/**
+ * The plan of the login Claude Code is actually using, from its stored OAuth credentials.
+ *
+ * `~/.claude.json`'s `oauthAccount` is a cached profile and can disagree with the login: a Team
+ * login has been seen there as `organizationType: "claude_pro"` on the person's personal org, while
+ * `/status` (which reads the credentials) said "Claude Team account". The credentials'
+ * `claudeAiOauth.subscriptionType` is what Claude Code bills and runs prompts against, so it wins.
+ *
+ * Credentials live in `~/.claude/.credentials.json` on Linux and Windows, and in the macOS login
+ * keychain as "Claude Code-credentials". Only `subscriptionType` is read out; the tokens beside it
+ * are never kept, logged or uploaded. The keychain is only read for the real home directory: it
+ * belongs to the signed-in macOS user, not to any other home a scan is pointed at.
+ */
+const KEYCHAIN_SERVICE = 'Claude Code-credentials';
+const PLAN = /^[a-z0-9_-]{1,64}$/i;
+function planFrom(credentials) {
+    try {
+        const plan = JSON.parse(credentials)?.claudeAiOauth
+            ?.subscriptionType;
+        return typeof plan === 'string' && PLAN.test(plan.trim()) ? plan.trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
+function readCredentialsFile(home) {
+    try {
+        return readFileSync(join(home, '.claude', '.credentials.json'), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function readKeychainCredentials(home) {
+    if (process.platform !== 'darwin' || home !== homedir())
+        return '';
+    try {
+        return execFileSync('security', ['find-generic-password', '-s', KEYCHAIN_SERVICE, '-w'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 3000,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const isObject = (value) => typeof value === 'object' && value !== null;
+/** Claude Code's login plan (e.g. "team", "pro"), or '' when no stored login names one. */
+export function readClaudeLoginPlan(home = homedir()) {
+    return planFrom(readCredentialsFile(home)) || planFrom(readKeychainCredentials(home));
+}
+/**
+ * Sets the login plan as the top-level `subscriptionType` of each uploaded `~/.claude.json` with a
+ * claude.ai login, the field the backend reads first for Claude's plan. Files are returned as given
+ * when there is no such upload or no plan.
+ */
+export function withClaudeLoginPlan(files, home = homedir()) {
+    const claudeJsons = files.filter((f) => basename(f.file_path) === '.claude.json' && isObject(f.raw_content?.oauthAccount));
+    if (claudeJsons.length === 0)
+        return files;
+    const plan = readClaudeLoginPlan(home);
+    if (!plan)
+        return files;
+    for (const file of claudeJsons)
+        file.raw_content.subscriptionType = plan;
+    return files;
+}

package/dist/log_config_files/runtime/main_runner.js

@@ -26,6 +26,7 @@ import { canonicalCursorUserStateVscdbPath } from './remediation_config_path.js'
 import { ensureWorkspaceRepoEnv, resolveProjectRoot } from './workspace_repo.js';
 import { scanActiveWorktrees, activeWorktreeRootSet, filterConfigFilesToActiveWorktrees, } from './worktree_scanner.js';
 import { createSignature, canonicalizePayload } from '../sender/signing.js';
+import { withClaudeLoginPlan } from '../collection/claude_login_plan.js';
 const PROJECT_ROOT = resolveProjectRoot();
 const configFileKey = (c) => `${c.file_type}\t${c.file_path}`;
 /** Appends the entries not in the batch yet (by file type and path), recording each as seen. */
@@ -70,7 +71,7 @@ async function fetchPatterns(endpointBase) {
 function scanPatterns(patternsResponse) {
     persistVscdbComposerContractFromPatternsResponse(patternsResponse);
     hookRunLog(`scanning config files`);
-    return collectConfigFilesFromPatterns(patternsResponse.patterns, PROJECT_ROOT, hookRunLog, {
+    const files = collectConfigFilesFromPatterns(patternsResponse.patterns, PROJECT_ROOT, hookRunLog, {
         vscdbEntrySpecs: patternsResponse.vscdb_entry_specs,
         vscdb_read_queries: patternsResponse.vscdb_read_queries,
         vscdb_merge_from_composer_state: patternsResponse.vscdb_merge_from_composer_state,
@@ -80,6 +81,7 @@ function scanPatterns(patternsResponse) {
         absolute_path_prefixes: patternsResponse.absolute_path_prefixes,
         mcp_tool_glob_spec: patternsResponse.mcp_tool_glob_spec ?? null,
     });
+    return withClaudeLoginPlan(files, HOME_DIR);
 }
 /** MCP tool caches: the global cache, Cursor's per-project caches and its workspace vscdb files. */
 function addMcpToolCaches(patternsResponse, configFiles, seen) {

package/dist/log_config_files/runtime/management_storage.js

@@ -133,20 +133,29 @@ export function writeRemediationInstructionsFile(file) {
 }
 function writeInstructionsFile(file, remediationsWrittenAt) {
     // Most callers write `{ remediations }` only; keep the approval lists they didn't pass.
-    const onDisk = readRemediationInstructionsFile();
-    const approved_tenants = 'approved_tenants' in file ? file.approved_tenants : onDisk.approved_tenants;
-    const unapproved_email_domains = 'unapproved_email_domains' in file ? file.unapproved_email_domains : onDisk.unapproved_email_domains;
-    const allowed_email_domains = 'allowed_email_domains' in file ? file.allowed_email_domains : onDisk.allowed_email_domains;
-    const approved_agents = 'approved_agents' in file ? file.approved_agents : onDisk.approved_agents;
     atomicWriteJson(getRemediationInstructionsPath(), {
         ...file,
-        ...(approved_tenants === undefined ? {} : { approved_tenants }),
-        ...(unapproved_email_domains === undefined ? {} : { unapproved_email_domains }),
-        ...(allowed_email_domains === undefined ? {} : { allowed_email_domains }),
-        ...(approved_agents === undefined ? {} : { approved_agents }),
+        ...keptApprovalLists(file, readRemediationInstructionsFile()),
         remediations_written_at: remediationsWrittenAt,
     });
 }
+const APPROVAL_LISTS = [
+    'approved_tenants',
+    'unapproved_email_domains',
+    'allowed_email_domains',
+    'approved_agents',
+    'team_email_domains',
+];
+/** Each approval list from `file` when it names one, else the one on disk; absent ones left out. */
+function keptApprovalLists(file, onDisk) {
+    const kept = {};
+    for (const key of APPROVAL_LISTS) {
+        const value = key in file ? file[key] : onDisk[key];
+        if (value !== undefined)
+            kept[key] = value;
+    }
+    return kept;
+}
 /** When the remediations on disk were written: recorded, or for an older file its mtime. */
 function remediationsWrittenAtOf(onDisk) {
     if (onDisk.remediations_written_at)
@@ -167,6 +176,10 @@ export function writeUnapprovedEmailDomains(unapproved_email_domains) {
 export function writeApprovedAgents(approved_agents) {
     writeApprovalList({ approved_agents });
 }
+/** Replace only the team email domains, keeping everything else on disk. */
+export function writeTeamEmailDomains(team_email_domains) {
+    writeApprovalList({ team_email_domains });
+}
 /** Replace only the email allowlist, keeping everything else on disk. */
 export function writeAllowedEmailDomains(allowed_email_domains) {
     writeApprovalList({ allowed_email_domains });

package/dist/log_config_files/runtime/remediation_sync.js

@@ -4,7 +4,7 @@ import { homedir } from 'node:os';
 import { executeBody } from '../../endpoint_client/http_transport.js';
 import { parseJsonWithJsoncFallback, parseTomlText, stringifyToml } from '../readers/file_readers.js';
 import { complianceRunnerDiag, hookRunLog, logRemediationApplyFailure } from './hook_logger.js';
-import { atomicWriteJson, getDeferredVscdbApplyPath, getFileCollectionVscdbContractPath, getRemediationInstructionsPath, readRemediationInstructionsFile, writeApprovedTenants, writeUnapprovedEmailDomains, writeAllowedEmailDomains, writeApprovedAgents, writeRemediationInstructionsFile, } from './management_storage.js';
+import { atomicWriteJson, getDeferredVscdbApplyPath, getFileCollectionVscdbContractPath, getRemediationInstructionsPath, readRemediationInstructionsFile, writeApprovedTenants, writeUnapprovedEmailDomains, writeAllowedEmailDomains, writeTeamEmailDomains, writeApprovedAgents, writeRemediationInstructionsFile, } from './management_storage.js';
 import { readStoredAuthKey } from '../auth/auth_key_store.js';
 import { ensureAuthentication } from '../auth/auth_flow.js';
 import { createSignature } from '../sender/signing.js';
@@ -1653,6 +1653,9 @@ function storeApprovals(syncResult) {
     const allowedDomains = syncResult.allowed_email_domains;
     if (Array.isArray(allowedDomains))
         writeAllowedEmailDomains(lowercaseStrings(allowedDomains));
+    const teamDomains = syncResult.team_email_domains;
+    if (Array.isArray(teamDomains))
+        writeTeamEmailDomains(lowercaseStrings(teamDomains));
 }
 async function reconcileInstructions(endpointBase, machineUuid, want) {
     try {

package/package.json

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