ai-maestro 1.0.0

package/src/codex-home-inspect.mjs

@@ -0,0 +1,252 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { pathExists } from './files.mjs';
+
+export function isSensitivePath(filePath) {
+  return /(auth|token|secret|credential|session|cookie|login|key|cache|history|state|account)/i.test(filePath);
+}
+
+export function isPolicyLikePath(filePath) {
+  return /(trust|trusted|approval|permission|policy|sandbox|rule|instruction|config|profile|project)/i.test(filePath);
+}
+
+const inventoryNeedles = /(trust|trusted|approval|approvals|policy|policies|permission|permissions|sandbox|workspace|workspaces|project|projects|rules|config|settings|state|metadata)/i;
+const excludedNeedles = /(auth|token|credential|secret|session|cookie|cache|key|login|account)/i;
+
+export function classifyInventoryPath(relPath, entry = {}) {
+  const normalized = relPath.replace(/\\/g, '/');
+  const size = entry.size || 0;
+
+  if (/(^|\/)(attachments|vendor_imports|\.tmp|tmp|sessions|rollouts?)(\/|$)/i.test(normalized)) {
+    return { classification: 'cache', safeCopyCandidate: false, reason: 'attachments/vendor/tmp/session trees are not copied by probe' };
+  }
+  if (/(auth|token|credential|secret|key|login|account)/i.test(normalized)) {
+    return { classification: 'auth-sensitive', safeCopyCandidate: false, reason: 'path looks like auth/token/credential material' };
+  }
+  if (/(session|cookie)/i.test(normalized)) {
+    return { classification: 'session-sensitive', safeCopyCandidate: false, reason: 'path looks like session or cookie state' };
+  }
+  if (/(^|\/)(cache|\.tmp|tmp|history)(\/|$)|history|\.log$/i.test(normalized)) {
+    return { classification: 'cache', safeCopyCandidate: false, reason: 'cache/tmp/history/log content is not copied by probe' };
+  }
+  if (/^\.sandbox-bin\//i.test(normalized) || normalized === '.sandbox/setup_marker.json') {
+    return { classification: 'sandbox-runtime', safeCopyCandidate: false, reason: 'sandbox runtime already handled by codex-home-repair' };
+  }
+  if (/(^|\/)\.sandbox-secrets(\/|$)/i.test(normalized)) {
+    return { classification: 'auth-sensitive', safeCopyCandidate: false, reason: '.sandbox-secrets is sensitive' };
+  }
+  if (/(^|\/)\.sandbox(\/|$)/i.test(normalized) && !excludedNeedles.test(normalized)) {
+    return { classification: 'policy', safeCopyCandidate: entry.type === 'file' && size > 0 && size <= 1024 * 1024, reason: 'sandbox policy-like file and not excluded by sensitive patterns' };
+  }
+  if (/rules?/i.test(normalized) && !excludedNeedles.test(normalized)) {
+    return { classification: 'rule', safeCopyCandidate: entry.type === 'file' && size > 0 && size <= 512 * 1024, reason: 'rules file and not excluded by sensitive patterns' };
+  }
+  if (/config|settings/i.test(normalized) && !excludedNeedles.test(normalized)) {
+    return { classification: 'config', safeCopyCandidate: entry.type === 'file' && size > 0 && size <= 512 * 1024, reason: 'config/settings file and not excluded by sensitive patterns' };
+  }
+  if (/trust|trusted/i.test(normalized) && !excludedNeedles.test(normalized)) {
+    return { classification: 'trust', safeCopyCandidate: entry.type === 'file' && size > 0 && size <= 512 * 1024, reason: 'trust-like file and not excluded by sensitive patterns' };
+  }
+  if (/approval|policy|permission|workspace|project/i.test(normalized) && !excludedNeedles.test(normalized)) {
+    return { classification: 'policy', safeCopyCandidate: entry.type === 'file' && size > 0 && size <= 512 * 1024, reason: 'policy/workspace/project file and not excluded by sensitive patterns' };
+  }
+  if (/state|metadata/i.test(normalized)) {
+    return { classification: 'unknown-sensitive', safeCopyCandidate: false, reason: 'state/metadata can contain opaque local state; report only' };
+  }
+  if (inventoryNeedles.test(normalized) && excludedNeedles.test(normalized)) {
+    return { classification: 'unknown-sensitive', safeCopyCandidate: false, reason: 'matches policy keywords but also sensitive exclusions' };
+  }
+  return { classification: 'unknown-sensitive', safeCopyCandidate: false, reason: 'not classified as safely copyable' };
+}
+
+export async function sha256File(filePath) {
+  const buffer = await fs.readFile(filePath);
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+export function looksTextFile(relPath) {
+  return ['.toml', '.json', '.jsonl', '.md', '.txt', '.yaml', '.yml'].includes(path.extname(relPath).toLowerCase());
+}
+
+const sensitiveContentPattern = /(api_key|apikey|token|secret|authorization|bearer|session|cookie|credential|password|sk-|OPENAI_API_KEY|ANTHROPIC_API_KEY|NINEROUTER_API_KEY)/i;
+
+export async function inspectSensitiveContent(filePath, relPath) {
+  if (!looksTextFile(relPath)) {
+    return { ok: true };
+  }
+  try {
+    const text = await fs.readFile(filePath, 'utf-8');
+    if (sensitiveContentPattern.test(text)) {
+      return { ok: false, reason: 'blocked-copy-sensitive-content' };
+    }
+  } catch (error) {
+    return { ok: false, reason: 'blocked-copy-read-error' };
+  }
+  return { ok: true };
+}
+
+export function redactSuspiciousValues(text) {
+  return text
+    .replace(/(["']?[^"'\s]*(token|secret|key|credential|password|auth|cookie)[^"'\s]*["']?\s*[:=]\s*)["'][^"']+["']/gi, '$1"<redacted>"')
+    .replace(/(Bearer\s+)[A-Za-z0-9._-]+/gi, '$1<redacted>')
+    .slice(0, 12000);
+}
+
+export async function readSafeStructure(root, relPath, classification) {
+  if (!looksTextFile(relPath) || /(sensitive|cache)/.test(classification)) {
+    return null;
+  }
+  const fullPath = path.join(root, relPath);
+  try {
+    const text = await fs.readFile(fullPath, 'utf-8');
+    if (relPath.toLowerCase().endsWith('.toml')) {
+      return parseTomlShape(text);
+    }
+    if (relPath.toLowerCase().endsWith('.json')) {
+      const parsed = JSON.parse(text);
+      return { jsonKeys: Array.isArray(parsed) ? ['<array>'] : Object.keys(parsed).slice(0, 80), preview: redactSuspiciousValues(text).slice(0, 1000) };
+    }
+    return { preview: redactSuspiciousValues(text).split(/\r?\n/).slice(0, 80).join('\n') };
+  } catch (error) {
+    return { error: error.message };
+  }
+}
+
+export async function listHomeFiles(root) {
+  const rows = [];
+  async function walk(dir) {
+    let entries = [];
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const rel = path.relative(root, fullPath).replace(/\\/g, '/');
+      if (entry.isDirectory()) {
+        rows.push({ path: rel, type: 'dir', sensitive: isSensitivePath(rel), policyLike: isPolicyLikePath(rel) });
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const stat = await fs.stat(fullPath);
+        rows.push({ path: rel, type: 'file', size: stat.size, sensitive: isSensitivePath(rel), policyLike: isPolicyLikePath(rel) });
+      }
+    }
+  }
+  await walk(root);
+  return rows.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+export function parseTomlShape(content) {
+  const sections = [];
+  const keys = {};
+  let current = 'root';
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*/, '').trim();
+    if (!line) {
+      continue;
+    }
+    const section = line.match(/^\[([^\]]+)\]$/);
+    if (section) {
+      current = section[1];
+      sections.push(current);
+      continue;
+    }
+    const keyMatch = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.*)$/);
+    if (keyMatch) {
+      const key = keyMatch[1];
+      const rawValue = keyMatch[2].trim();
+      const fullKey = current === 'root' ? key : current + '.' + key;
+      keys[fullKey] = /(token|secret|key|credential|password|auth|cookie)/i.test(fullKey)
+        ? '<redacted>'
+        : rawValue.replace(/"(?:[^"\\]|\\.)*"/g, value => value.length > 160 ? '"<long-string>"' : value);
+    }
+  }
+  return { sections, keys };
+}
+
+export async function inspectHome(root) {
+  const exists = await pathExists(root);
+  const files = exists ? await listHomeFiles(root) : [];
+  const toml = {};
+  for (const file of files.filter(item => item.type === 'file' && item.path.toLowerCase().endsWith('.toml'))) {
+    const fullPath = path.join(root, file.path);
+    if (file.sensitive) {
+      toml[file.path] = { sensitive: true, keys: {}, sections: [] };
+      continue;
+    }
+    try {
+      toml[file.path] = parseTomlShape(await fs.readFile(fullPath, 'utf-8'));
+    } catch (error) {
+      toml[file.path] = { error: error.message, keys: {}, sections: [] };
+    }
+  }
+  return {
+    root,
+    exists,
+    files,
+    toml,
+    policyLikeFiles: files.filter(file => file.policyLike),
+    sensitiveFiles: files.filter(file => file.sensitive).map(file => ({ path: file.path, type: file.type, size: file.size || null }))
+  };
+}
+
+export function summarizeHomeIssues(home) {
+  const config = home.toml['config.toml'] || { keys: {}, sections: [] };
+  const profile = home.toml['9router.config.toml'] || { keys: {}, sections: [] };
+  const combinedKeys = { ...config.keys, ...profile.keys };
+  return {
+    hasConfigToml: !!home.toml['config.toml'],
+    has9routerConfigToml: !!home.toml['9router.config.toml'],
+    profileModelProvider: profile.keys.model_provider || null,
+    configModelProvider: config.keys.model_provider || null,
+    sandboxMode: combinedKeys.sandbox_mode || null,
+    approvalPolicy: combinedKeys.approval_policy || null,
+    defaultPermissions: combinedKeys.default_permissions || null,
+    hasSandboxWorkspaceWriteSection: Object.keys(combinedKeys).some(key => key.startsWith('sandbox_workspace_write.')) || (profile.sections || []).includes('sandbox_workspace_write') || (config.sections || []).includes('sandbox_workspace_write'),
+    hasProvider9routerInProfileFile: (profile.sections || []).includes('model_providers.9router'),
+    hasProvider9routerInConfigToml: (config.sections || []).includes('model_providers.9router'),
+    hasProfiles9router: (config.sections || []).includes('profiles.9router') || (profile.sections || []).includes('profiles.9router'),
+    mixesDefaultPermissionsAndSandboxMode: !!combinedKeys.default_permissions && !!combinedKeys.sandbox_mode
+  };
+}
+
+export function timestampForPath() {
+  const now = new Date();
+  const pad = value => String(value).padStart(2, '0');
+  return String(now.getFullYear()) + pad(now.getMonth() + 1) + pad(now.getDate()) + '-' + pad(now.getHours()) + pad(now.getMinutes()) + pad(now.getSeconds());
+}
+
+export async function copyDirectorySafe(source, target) {
+  await fs.mkdir(target, { recursive: true });
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const targetPath = path.join(target, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectorySafe(sourcePath, targetPath);
+    } else if (entry.isFile()) {
+      await fs.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+export async function removePathSafe(targetPath) {
+  try {
+    await fs.rm(targetPath, { recursive: true, force: true });
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}
+
+export async function restoreDirectoryFromBackup(backupPath, targetPath) {
+  await removePathSafe(targetPath);
+  await copyDirectorySafe(backupPath, targetPath);
+}
+
+export function safeProbeName(relPath) {
+  return relPath.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 80) || 'candidate';
+}

package/src/codex-home.mjs

@@ -0,0 +1,258 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { CONFIG } from './config.mjs';
+
+export const DEFAULT_CODEX_PROFILE_CONFIG = `model = "ricardo-codex-agentico"
+model_provider = "9router"
+model_reasoning_effort = "low"
+approval_policy = "never"
+sandbox_mode = "workspace-write"
+
+[model_providers.9router]
+name = "9Router Local"
+base_url = "http://localhost:20128/v1"
+env_key = "NINEROUTER_API_KEY"
+wire_api = "responses"
+`;
+
+// Hotfix A.2: minimal, isolated config for the Maestro Codex home.
+// Contains ONLY what a Maestro worker needs (9Router provider, agentic
+// model, approval never, low reasoning, trusted workspace). It must never
+// carry Desktop plugins, marketplaces, MCP servers, notify hooks, desktop
+// settings, CUA runtimes, `[windows] sandbox = "elevated"`, or any
+// reference to the normal Codex home — those are exactly what broke the
+// isolated sandbox with `apply deny-read ACLs`.
+export function buildMinimalIsolatedCodexConfig(projectRoot = process.cwd(), extraTrustedProjects = []) {
+  const normalizeKey = value => String(value).replace(/\//g, '\\').replace(/\\+$/, '').toLowerCase();
+  const keys = [];
+  for (const candidate of [projectRoot, ...extraTrustedProjects]) {
+    const key = normalizeKey(candidate);
+    if (key && !keys.includes(key)) {
+      keys.push(key);
+    }
+  }
+  const projectSections = keys
+    .map(key => `[projects.'${key}']\ntrust_level = "trusted"`)
+    .join('\n\n');
+  // `[windows] sandbox = "unelevated"` is the non-admin Windows sandbox
+  // (restricted token). Verified with `codex sandbox` probes on this
+  // machine (Codex CLI 0.144.3): it grants real workspace-write inside the
+  // project and still denies writes outside the workspace. The Desktop's
+  // `sandbox = "elevated"` must never be copied here: its ACL helper is
+  // bound to the normal CODEX_HOME and fails with
+  // `helper_unknown_error: apply deny-read ACLs` in the isolated home;
+  // omitting the section entirely silently downgrades workers to read-only.
+  return `model = "ricardo-codex-agentico"
+model_provider = "9router"
+model_reasoning_effort = "low"
+approval_policy = "never"
+
+[model_providers.9router]
+name = "9Router Local"
+base_url = "http://localhost:20128/v1"
+env_key = "NINEROUTER_API_KEY"
+wire_api = "responses"
+
+[windows]
+sandbox = "unelevated"
+
+${projectSections}
+`;
+}
+
+// Matches the normal Codex home path in TOML content whether it is written
+// with single, double (escaped TOML) or forward slashes, without matching
+// the isolated home itself (e.g. `C:\Users\PC\.codex-maestro`).
+function buildNormalHomePattern(normalCodexHome) {
+  const segments = String(normalCodexHome)
+    .split(/[\\/]+/)
+    .filter(Boolean)
+    .map(segment => segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  return new RegExp(segments.join('[\\\\/]+') + '(?![-\\w])', 'i');
+}
+
+// Static analysis of an isolated-home config.toml: flags every kind of
+// Desktop/normal-home contamination this hotfix removes. `contaminated`
+// means the file must be backed up and rewritten with the minimal config.
+export function analyzeIsolatedCodexConfig(content, { normalCodexHome = CONFIG.normalCodexHome } = {}) {
+  const text = String(content || '');
+  const flags = {
+    referencesNormalCodexHome: buildNormalHomePattern(normalCodexHome).test(text),
+    desktopPluginsEnabled: /^\s*\[plugins\./m.test(text),
+    marketplacesConfigured: /^\s*\[marketplaces\./m.test(text),
+    mcpServersConfigured: /^\s*\[mcp_servers\./m.test(text),
+    notifyConfigured: /^\s*notify\s*=/m.test(text),
+    desktopSectionPresent: /^\s*\[desktop\]/m.test(text),
+    windowsSandboxSectionPresent: /^\s*\[windows\]/m.test(text),
+    windowsSandboxElevated: /^\s*\[windows\]/m.test(text) && /sandbox\s*=\s*"elevated"/.test(text),
+    desktopRuntimeReferenced: /codex-runtimes|AppData[\\/]+Local[\\/]+OpenAI[\\/]+Codex/i.test(text),
+    usesDefaultPermissions: /default_permissions\s*=/.test(text)
+  };
+  // `[windows] sandbox = "unelevated"` is part of the sanctioned minimal
+  // config (see buildMinimalIsolatedCodexConfig), so only the "elevated"
+  // value counts as contamination, not the section itself.
+  flags.contaminated = flags.referencesNormalCodexHome
+    || flags.desktopPluginsEnabled
+    || flags.marketplacesConfigured
+    || flags.mcpServersConfigured
+    || flags.notifyConfigured
+    || flags.desktopSectionPresent
+    || flags.windowsSandboxElevated
+    || flags.desktopRuntimeReferenced;
+  return flags;
+}
+
+// Preserve `[projects.'...'] trust_level = "trusted"` entries when a
+// contaminated config is rewritten: trust entries are benign and losing
+// them would break other projects that use the isolated home.
+export function extractTrustedProjects(content) {
+  const keys = [];
+  const pattern = /\[projects\.'([^']+)'\]\s*\r?\n\s*trust_level\s*=\s*"trusted"/g;
+  let match;
+  while ((match = pattern.exec(String(content || ''))) !== null) {
+    keys.push(match[1]);
+  }
+  return keys;
+}
+
+export const LEGACY_CODEX_CONFIG = `model = "ricardo-codex-agentico"
+model_provider = "9router"
+model_reasoning_effort = "low"
+
+[model_providers.9router]
+name = "9Router Local"
+base_url = "http://localhost:20128/v1"
+env_key = "NINEROUTER_API_KEY"
+wire_api = "responses"
+
+[profiles.9router]
+model = "ricardo-codex-agentico"
+model_provider = "9router"
+model_reasoning_effort = "low"
+`;
+
+export function getCodexHome() {
+  return CONFIG.codexHome;
+}
+
+export function getNormalCodexHome() {
+  return CONFIG.normalCodexHome;
+}
+
+export function getCodexEnv(extraEnv = {}) {
+  return {
+    ...process.env,
+    ...extraEnv,
+    CODEX_HOME: getCodexHome()
+  };
+}
+
+// Kept only so the doctor can report the legacy file honestly. The
+// workspace-permissions strategy was removed in Hotfix A.2: its profile
+// layer was never actually loaded by any default run ("default_permissions
+// used: false" in maestro doctor), and Codex CLI 0.144.x refuses to combine
+// `default_permissions` with the `sandbox_mode` mechanism this project
+// standardizes on. The old file stays on disk (backed up), but nothing
+// writes or loads it.
+export function getLegacyWorkspacePermissionsConfigPath() {
+  return path.join(getCodexHome(), 'workspace-permissions.config.toml');
+}
+
+export async function ensureCodexHome(options = {}) {
+  const codexHome = getCodexHome();
+  const projectRoot = options.projectRoot || process.cwd();
+  await fs.mkdir(codexHome, { recursive: true });
+
+  const configPath = path.join(codexHome, 'config.toml');
+  const profilePath = path.join(codexHome, '9router.config.toml');
+  let created = false;
+  let backedUp = false;
+  let sanitized = false;
+  let backupPath = null;
+  try {
+    await fs.access(configPath);
+  } catch (error) {
+    await fs.writeFile(configPath, buildMinimalIsolatedCodexConfig(projectRoot));
+    created = true;
+  }
+
+  let content = await fs.readFile(configPath, 'utf-8');
+  let analysis = analyzeIsolatedCodexConfig(content);
+  if (analysis.contaminated) {
+    // The isolated config was overwritten with a Codex Desktop copy at some
+    // point (plugins, node_repl MCP pointing at the normal home, notify to
+    // the CUA runtime, `[windows] sandbox = "elevated"`). That mix is the
+    // confirmed root cause of `windows sandbox: helper_unknown_error:
+    // apply deny-read ACLs`. Back it up (never delete) and rewrite the
+    // minimal isolated config, preserving trusted project entries.
+    backupPath = configPath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(configPath, backupPath);
+    backedUp = true;
+    content = buildMinimalIsolatedCodexConfig(projectRoot, extractTrustedProjects(content));
+    await fs.writeFile(configPath, content);
+    sanitized = true;
+    analysis = analyzeIsolatedCodexConfig(content);
+  }
+  if (/\[profiles\.9router\]/.test(content)) {
+    const legacyBackupPath = configPath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(configPath, legacyBackupPath);
+    backedUp = true;
+    content = content.replace(/\n?\[profiles\.9router\][\s\S]*$/m, '').trim() + '\n';
+    await fs.writeFile(configPath, content);
+  }
+  if (!/approval_policy\s*=\s*"never"/.test(content)) {
+    const approvalBackupPath = configPath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(configPath, approvalBackupPath);
+    backedUp = true;
+    content = content.replace(/(model_reasoning_effort\s*=\s*"low"\s*)/, '$1approval_policy = "never"\n');
+    await fs.writeFile(configPath, content);
+  }
+  if (!/^\s*\[windows\]/m.test(content)) {
+    // Without a `[windows]` section Codex silently downgrades workers to
+    // read-only on Windows (no sandbox backend available). Heal existing
+    // minimal configs by adding the sanctioned non-admin sandbox.
+    const windowsBackupPath = configPath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(configPath, windowsBackupPath);
+    backedUp = true;
+    content = content.trim() + '\n\n[windows]\nsandbox = "unelevated"\n';
+    await fs.writeFile(configPath, content);
+    analysis = analyzeIsolatedCodexConfig(content);
+  }
+
+  try {
+    await fs.access(profilePath);
+  } catch (error) {
+    await fs.writeFile(profilePath, DEFAULT_CODEX_PROFILE_CONFIG);
+    created = true;
+  }
+
+  let profileContent = await fs.readFile(profilePath, 'utf-8');
+  if (!/approval_policy\s*=\s*"never"/.test(profileContent)) {
+    const backupPath = profilePath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(profilePath, backupPath);
+    backedUp = true;
+    profileContent = profileContent.replace(/(model_reasoning_effort\s*=\s*"low"\s*)/, '$1approval_policy = "never"\n');
+    await fs.writeFile(profilePath, profileContent);
+  }
+  if (!/sandbox_mode\s*=\s*"workspace-write"/.test(profileContent)) {
+    const backupPath = profilePath + '.bak-' + new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copyFile(profilePath, backupPath);
+    backedUp = true;
+    profileContent = profileContent.trim() + '\nsandbox_mode = "workspace-write"\n';
+    await fs.writeFile(profilePath, profileContent);
+  }
+  const checks = validateCodexConfig(content, profileContent);
+  return { codexHome, configPath, profilePath, created, backedUp, sanitized, backupPath, checks, analysis, content, profileContent };
+}
+
+export function validateCodexConfig(content, profileContent = '') {
+  const combined = content + '\n' + profileContent;
+  return {
+    hasProfile9router: /model_provider\s*=\s*"9router"/.test(profileContent),
+    hasProvider9router: /\[model_providers\.9router\]/.test(content),
+    hasResponsesWireApi: /wire_api\s*=\s*"responses"/.test(content),
+    usesDefaultPermissions: /default_permissions\s*=/.test(combined),
+    usesSandboxMode: /sandbox_mode\s*=/.test(combined),
+    mixesDefaultPermissionsAndSandboxMode: /default_permissions\s*=/.test(combined) && /sandbox_mode\s*=/.test(combined)
+  };
+}