thaddeus 1.0.26 → 1.0.28

package/src/utils/employeeDb.js

@@ -0,0 +1,326 @@
+/**
+ * employeeDb.ts — SQLite persistence layer for AI Employees.
+ *
+ * Ported from Oracle Business (oracle-agent/src/tools/ai-employees.js).
+ * Uses Bun's built-in bun:sqlite for zero-dependency SQLite access.
+ * Database is stored at ~/.thaddeus/employees.db.
+ *
+ * ALL queries use prepared statements to prevent SQL injection.
+ */
+import { Database } from 'bun:sqlite';
+import { mkdirSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// ---------------------------------------------------------------------------
+// Database singleton
+// ---------------------------------------------------------------------------
+let _db = null;
+function getDbPath() {
+    const dir = join(homedir(), '.thaddeus');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return join(dir, 'employees.db');
+}
+export function getDb() {
+    if (!_db) {
+        _db = new Database(getDbPath());
+        _db.exec('PRAGMA journal_mode = WAL;');
+        _db.exec('PRAGMA foreign_keys = ON;');
+        ensureSchema(_db);
+    }
+    return _db;
+}
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+function ensureSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS ai_employees (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      role TEXT DEFAULT '',
+      department TEXT DEFAULT '',
+      mission TEXT DEFAULT '',
+      system_prompt TEXT DEFAULT '',
+      default_model TEXT DEFAULT 'default',
+      workspace_name TEXT DEFAULT '' UNIQUE,
+      assigned_integrations TEXT DEFAULT '',
+      status TEXT DEFAULT 'idle' CHECK(status IN ('draft','idle','running','paused','archived','error')),
+      current_agent_id TEXT DEFAULT '',
+      last_agent_id TEXT DEFAULT '',
+      last_objective TEXT DEFAULT '',
+      last_status_detail TEXT DEFAULT '',
+      last_result_summary TEXT DEFAULT '',
+      launch_count INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now','localtime')),
+      updated_at TEXT DEFAULT (datetime('now','localtime')),
+      last_launched_at TEXT,
+      last_completed_at TEXT,
+      last_heartbeat_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_ai_employees_status ON ai_employees(status);
+    CREATE INDEX IF NOT EXISTS idx_ai_employees_role ON ai_employees(role);
+    CREATE INDEX IF NOT EXISTS idx_ai_employees_department ON ai_employees(department);
+  `);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function slugify(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64);
+}
+export function resolveWorkspaceName(params) {
+    return (slugify(params.workspace_name ||
+        params.name ||
+        `${params.role || 'ai-employee'}-${Date.now()}`) || `ai-employee-${Date.now()}`);
+}
+// ---------------------------------------------------------------------------
+// CRUD operations (all use prepared statements)
+// ---------------------------------------------------------------------------
+export function getEmployeeById(id) {
+    const db = getDb();
+    const stmt = db.prepare('SELECT * FROM ai_employees WHERE id = ? LIMIT 1');
+    return stmt.get(id) ?? null;
+}
+export function getEmployeeByExactName(name) {
+    const db = getDb();
+    const stmt = db.prepare(`SELECT * FROM ai_employees
+     WHERE LOWER(status) != 'archived'
+       AND LOWER(name) = LOWER(?)
+     ORDER BY id ASC
+     LIMIT 2`);
+    return stmt.all(name);
+}
+export function getEmployeeByFuzzyName(name) {
+    const db = getDb();
+    const stmt = db.prepare(`SELECT * FROM ai_employees
+     WHERE LOWER(status) != 'archived'
+       AND LOWER(name) LIKE LOWER(?)
+     ORDER BY id ASC
+     LIMIT 5`);
+    return stmt.all(`%${name}%`);
+}
+/**
+ * Resolve an employee by id, lookup_name, or name.
+ * Returns { row } on success, { error } on failure.
+ */
+export function resolveEmployeeRow(params) {
+    if (params.id !== undefined && params.id !== null) {
+        const row = getEmployeeById(params.id);
+        if (!row)
+            return { error: `AI employee #${params.id} not found.` };
+        return { row };
+    }
+    const lookupName = String(params.lookup_name || params.name || '').trim();
+    if (!lookupName) {
+        return { error: 'Error: id, lookup_name, or name is required.' };
+    }
+    const exactRows = getEmployeeByExactName(lookupName);
+    if (exactRows.length === 1)
+        return { row: exactRows[0] };
+    if (exactRows.length > 1) {
+        return {
+            error: `Multiple AI employees are named "${lookupName}". Use id instead.`,
+        };
+    }
+    const fuzzyRows = getEmployeeByFuzzyName(lookupName);
+    if (fuzzyRows.length === 1)
+        return { row: fuzzyRows[0] };
+    if (fuzzyRows.length > 1) {
+        return {
+            error: `Multiple AI employees match "${lookupName}": ${fuzzyRows.map(r => `#${r.id} ${r.name}`).join(', ')}. Use id instead.`,
+        };
+    }
+    return { error: `AI employee "${lookupName}" not found.` };
+}
+export function insertEmployee(params) {
+    const db = getDb();
+    const stmt = db.prepare(`INSERT INTO ai_employees
+       (name, workspace_name, role, department, mission, system_prompt,
+        default_model, assigned_integrations, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    stmt.run(params.name, params.workspace_name, params.role ?? '', params.department ?? '', params.mission ?? '', params.system_prompt ?? '', params.default_model ?? 'default', params.assigned_integrations ?? '', params.status ?? 'idle');
+    const last = db.prepare('SELECT * FROM ai_employees ORDER BY id DESC LIMIT 1');
+    return last.get();
+}
+/**
+ * Update employee fields. Only updates fields present in the `updates` record.
+ * Always sets updated_at to current time.
+ */
+export function updateEmployee(id, updates) {
+    const db = getDb();
+    const setClauses = [];
+    const values = [];
+    // Safelist of columns that can be updated — prevents SQL injection via object keys
+    const ALLOWED_COLUMNS = new Set([
+        'name', 'role', 'department', 'mission', 'system_prompt',
+        'default_model', 'workspace_name', 'assigned_integrations', 'status',
+        'current_agent_id', 'last_agent_id', 'last_objective',
+        'last_status_detail', 'last_result_summary', 'launch_count',
+        'last_launched_at', 'last_completed_at', 'last_heartbeat_at',
+    ]);
+    for (const [key, value] of Object.entries(updates)) {
+        if (value !== undefined && ALLOWED_COLUMNS.has(key)) {
+            // Sanitize workspace_name through slugify
+            const finalValue = key === 'workspace_name' ? slugify(String(value)) || '' : value;
+            setClauses.push(`${key} = ?`);
+            values.push(finalValue);
+        }
+    }
+    if (setClauses.length === 0)
+        return;
+    setClauses.push(`updated_at = datetime('now','localtime')`);
+    values.push(id);
+    const sql = `UPDATE ai_employees SET ${setClauses.join(', ')} WHERE id = ?`;
+    const stmt = db.prepare(sql);
+    stmt.run(...values);
+}
+export function deleteEmployeeById(id) {
+    const db = getDb();
+    const stmt = db.prepare('DELETE FROM ai_employees WHERE id = ?');
+    stmt.run(id);
+}
+export function listEmployees(filters) {
+    const db = getDb();
+    const conditions = [];
+    const values = [];
+    if (filters.status) {
+        conditions.push('status = ?');
+        values.push(filters.status);
+    }
+    if (filters.department) {
+        conditions.push('department = ?');
+        values.push(filters.department);
+    }
+    if (filters.role) {
+        conditions.push('role LIKE ?');
+        values.push(`%${filters.role}%`);
+    }
+    const where = conditions.length
+        ? `WHERE ${conditions.join(' AND ')}`
+        : '';
+    const stmt = db.prepare(`SELECT * FROM ai_employees ${where}
+     ORDER BY status = 'running' DESC, status = 'idle' DESC,
+              department ASC, name ASC`);
+    return stmt.all(...values);
+}
+export function getAllEmployees() {
+    const db = getDb();
+    const stmt = db.prepare('SELECT * FROM ai_employees ORDER BY id ASC');
+    return stmt.all();
+}
+export function getEmployeeStats() {
+    const db = getDb();
+    const statusRows = db
+        .prepare(`SELECT status, COUNT(*) as count FROM ai_employees
+       GROUP BY status ORDER BY count DESC`)
+        .all();
+    const deptRows = db
+        .prepare(`SELECT department, COUNT(*) as count FROM ai_employees
+       WHERE TRIM(COALESCE(department, '')) != ''
+       GROUP BY department ORDER BY count DESC LIMIT 10`)
+        .all();
+    const roleRows = db
+        .prepare(`SELECT role, COUNT(*) as count FROM ai_employees
+       WHERE TRIM(COALESCE(role, '')) != ''
+       GROUP BY role ORDER BY count DESC LIMIT 10`)
+        .all();
+    const total = db
+        .prepare(`SELECT COUNT(*) as count FROM ai_employees WHERE status != 'archived'`)
+        .get()?.count ?? 0;
+    const running = db
+        .prepare(`SELECT COUNT(*) as count FROM ai_employees WHERE status = 'running'`)
+        .get()?.count ?? 0;
+    const paused = db
+        .prepare(`SELECT COUNT(*) as count FROM ai_employees WHERE status = 'paused'`)
+        .get()?.count ?? 0;
+    const idle = db
+        .prepare(`SELECT COUNT(*) as count FROM ai_employees WHERE status = 'idle'`)
+        .get()?.count ?? 0;
+    const memoryReady = db
+        .prepare(`SELECT COUNT(*) as count FROM ai_employees
+         WHERE status != 'archived'
+           AND TRIM(COALESCE(workspace_name, '')) != ''`)
+        .get()?.count ?? 0;
+    return { total, running, idle, paused, memoryReady, statusRows, deptRows, roleRows };
+}
+/**
+ * Mark a running employee as launched (update agent tracking fields).
+ */
+export function markEmployeeLaunched(id, agentId, workspaceName, objective) {
+    const db = getDb();
+    const stmt = db.prepare(`UPDATE ai_employees SET
+       workspace_name = ?,
+       status = 'running',
+       current_agent_id = ?,
+       last_agent_id = ?,
+       last_objective = ?,
+       last_status_detail = 'Launching',
+       launch_count = COALESCE(launch_count, 0) + 1,
+       last_launched_at = datetime('now','localtime'),
+       last_heartbeat_at = datetime('now','localtime'),
+       updated_at = datetime('now','localtime')
+     WHERE id = ?`);
+    stmt.run(workspaceName, agentId, agentId, objective, id);
+}
+/**
+ * Mark an employee as having received a follow-up objective.
+ */
+export function markEmployeeFollowUp(id, objective, statusDetail) {
+    const db = getDb();
+    const stmt = db.prepare(`UPDATE ai_employees SET
+       status = 'running',
+       last_objective = ?,
+       last_status_detail = ?,
+       last_heartbeat_at = datetime('now','localtime'),
+       updated_at = datetime('now','localtime')
+     WHERE id = ?`);
+    stmt.run(objective, statusDetail, id);
+}
+/**
+ * Mark a running employee as paused.
+ */
+export function markEmployeePaused(id, detail) {
+    const db = getDb();
+    const stmt = db.prepare(`UPDATE ai_employees SET
+       status = 'paused',
+       current_agent_id = '',
+       last_status_detail = ?,
+       updated_at = datetime('now','localtime')
+     WHERE id = ?`);
+    stmt.run(detail, id);
+}
+/**
+ * Mark a running employee as completed or errored (terminal state).
+ */
+export function markEmployeeTerminal(id, terminalStatus, detail, summary) {
+    const db = getDb();
+    const stmt = db.prepare(`UPDATE ai_employees SET
+       status = ?,
+       current_agent_id = '',
+       last_status_detail = ?,
+       last_result_summary = ?,
+       last_completed_at = datetime('now','localtime'),
+       updated_at = datetime('now','localtime')
+     WHERE id = ?`);
+    stmt.run(terminalStatus, detail, summary, id);
+}
+/**
+ * Update heartbeat for a running employee.
+ */
+export function markEmployeeHeartbeat(id, detail) {
+    const db = getDb();
+    const stmt = db.prepare(`UPDATE ai_employees SET
+       status = 'running',
+       last_status_detail = ?,
+       last_heartbeat_at = datetime('now','localtime'),
+       updated_at = datetime('now','localtime')
+     WHERE id = ?`);
+    stmt.run(detail, id);
+}

package/src/utils/env.js

@@ -0,0 +1,358 @@
+import memoize from 'lodash-es/memoize.js';
+import { homedir } from 'os';
+import { join } from 'path';
+import { fileSuffixForOauthConfig } from '../constants/oauth.js';
+import { isRunningWithBun } from './bundledMode.js';
+import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js';
+import { findExecutable } from './findExecutable.js';
+import { getFsImplementation } from './fsOperations.js';
+import { which } from './which.js';
+// Config and data paths
+export const getGlobalClaudeFile = memoize(() => {
+    // Legacy fallback for backwards compatibility
+    if (getFsImplementation().existsSync(join(getClaudeConfigHomeDir(), '.config.json'))) {
+        return join(getClaudeConfigHomeDir(), '.config.json');
+    }
+    const filename = `.claude${fileSuffixForOauthConfig()}.json`;
+    return join(process.env.CLAUDE_CONFIG_DIR || homedir(), filename);
+});
+const hasInternetAccess = memoize(async () => {
+    try {
+        const { default: axiosClient } = await import('axios');
+        await axiosClient.head('http://1.1.1.1', {
+            signal: AbortSignal.timeout(1000),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+});
+async function isCommandAvailable(command) {
+    try {
+        // which does not execute the file.
+        return !!(await which(command));
+    }
+    catch {
+        return false;
+    }
+}
+const detectPackageManagers = memoize(async () => {
+    const packageManagers = [];
+    if (await isCommandAvailable('npm'))
+        packageManagers.push('npm');
+    if (await isCommandAvailable('yarn'))
+        packageManagers.push('yarn');
+    if (await isCommandAvailable('pnpm'))
+        packageManagers.push('pnpm');
+    return packageManagers;
+});
+const detectRuntimes = memoize(async () => {
+    const runtimes = [];
+    if (await isCommandAvailable('bun'))
+        runtimes.push('bun');
+    if (await isCommandAvailable('deno'))
+        runtimes.push('deno');
+    if (await isCommandAvailable('node'))
+        runtimes.push('node');
+    return runtimes;
+});
+/**
+ * Checks if we're running in a WSL environment
+ * @returns true if running in WSL, false otherwise
+ */
+const isWslEnvironment = memoize(() => {
+    try {
+        // Check for WSLInterop file which is a reliable indicator of WSL
+        return getFsImplementation().existsSync('/proc/sys/fs/binfmt_misc/WSLInterop');
+    }
+    catch (_error) {
+        // If there's an error checking, assume not WSL
+        return false;
+    }
+});
+/**
+ * Checks if the npm executable is located in the Windows filesystem within WSL
+ * @returns true if npm is from Windows (starts with /mnt/c/), false otherwise
+ */
+const isNpmFromWindowsPath = memoize(() => {
+    try {
+        // Only relevant in WSL environment
+        if (!isWslEnvironment()) {
+            return false;
+        }
+        // Find the actual npm executable path
+        const { cmd } = findExecutable('npm', []);
+        // If npm is in Windows path, it will start with /mnt/c/
+        return cmd.startsWith('/mnt/c/');
+    }
+    catch (_error) {
+        // If there's an error, assume it's not from Windows
+        return false;
+    }
+});
+/**
+ * Checks if we're running via Conductor
+ * @returns true if running via Conductor, false otherwise
+ */
+function isConductor() {
+    return process.env.__CFBundleIdentifier === 'com.conductor.app';
+}
+export const JETBRAINS_IDES = [
+    'pycharm',
+    'intellij',
+    'webstorm',
+    'phpstorm',
+    'rubymine',
+    'clion',
+    'goland',
+    'rider',
+    'datagrip',
+    'appcode',
+    'dataspell',
+    'aqua',
+    'gateway',
+    'fleet',
+    'jetbrains',
+    'androidstudio',
+];
+// Detect terminal type with fallbacks for all platforms
+function detectTerminal() {
+    if (process.env.CURSOR_TRACE_ID)
+        return 'cursor';
+    // Cursor and Windsurf under WSL have TERM_PROGRAM=vscode
+    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('cursor')) {
+        return 'cursor';
+    }
+    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('windsurf')) {
+        return 'windsurf';
+    }
+    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('antigravity')) {
+        return 'antigravity';
+    }
+    const bundleId = process.env.__CFBundleIdentifier?.toLowerCase();
+    if (bundleId?.includes('vscodium'))
+        return 'codium';
+    if (bundleId?.includes('windsurf'))
+        return 'windsurf';
+    if (bundleId?.includes('com.google.android.studio'))
+        return 'androidstudio';
+    // Check for JetBrains IDEs in bundle ID
+    if (bundleId) {
+        for (const ide of JETBRAINS_IDES) {
+            if (bundleId.includes(ide))
+                return ide;
+        }
+    }
+    if (process.env.VisualStudioVersion) {
+        // This is desktop Visual Studio, not VS Code
+        return 'visualstudio';
+    }
+    // Check for JetBrains terminal on Linux/Windows
+    if (process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm') {
+        // For macOS, bundle ID detection above already handles JetBrains IDEs
+        if (process.platform === 'darwin')
+            return 'pycharm';
+        // For finegrained detection on Linux/Windows use envDynamic.getTerminalWithJetBrainsDetection()
+        return 'pycharm';
+    }
+    // Check for specific terminals by TERM before TERM_PROGRAM
+    // This handles cases where TERM and TERM_PROGRAM might be inconsistent
+    if (process.env.TERM === 'xterm-ghostty') {
+        return 'ghostty';
+    }
+    if (process.env.TERM?.includes('kitty')) {
+        return 'kitty';
+    }
+    if (process.env.TERM_PROGRAM) {
+        return process.env.TERM_PROGRAM;
+    }
+    if (process.env.TMUX)
+        return 'tmux';
+    if (process.env.STY)
+        return 'screen';
+    // Check for terminal-specific environment variables (common on Linux)
+    if (process.env.KONSOLE_VERSION)
+        return 'konsole';
+    if (process.env.GNOME_TERMINAL_SERVICE)
+        return 'gnome-terminal';
+    if (process.env.XTERM_VERSION)
+        return 'xterm';
+    if (process.env.VTE_VERSION)
+        return 'vte-based';
+    if (process.env.TERMINATOR_UUID)
+        return 'terminator';
+    if (process.env.KITTY_WINDOW_ID) {
+        return 'kitty';
+    }
+    if (process.env.ALACRITTY_LOG)
+        return 'alacritty';
+    if (process.env.TILIX_ID)
+        return 'tilix';
+    // Windows-specific detection
+    if (process.env.WT_SESSION)
+        return 'windows-terminal';
+    if (process.env.SESSIONNAME && process.env.TERM === 'cygwin')
+        return 'cygwin';
+    if (process.env.MSYSTEM)
+        return process.env.MSYSTEM.toLowerCase(); // MINGW64, MSYS2, etc.
+    if (process.env.ConEmuANSI ||
+        process.env.ConEmuPID ||
+        process.env.ConEmuTask) {
+        return 'conemu';
+    }
+    // WSL detection
+    if (process.env.WSL_DISTRO_NAME)
+        return `wsl-${process.env.WSL_DISTRO_NAME}`;
+    // SSH session detection
+    if (isSSHSession()) {
+        return 'ssh-session';
+    }
+    // Fall back to TERM which is more universally available
+    // Special case for common terminal identifiers in TERM
+    if (process.env.TERM) {
+        const term = process.env.TERM;
+        if (term.includes('alacritty'))
+            return 'alacritty';
+        if (term.includes('rxvt'))
+            return 'rxvt';
+        if (term.includes('termite'))
+            return 'termite';
+        return process.env.TERM;
+    }
+    // Detect non-interactive environment
+    if (!process.stdout.isTTY)
+        return 'non-interactive';
+    return null;
+}
+/**
+ * Detects the deployment environment/platform based on environment variables
+ * @returns The deployment platform name, or 'unknown' if not detected
+ */
+export const detectDeploymentEnvironment = memoize(() => {
+    // Cloud development environments
+    if (isEnvTruthy(process.env.CODESPACES))
+        return 'codespaces';
+    if (process.env.GITPOD_WORKSPACE_ID)
+        return 'gitpod';
+    if (process.env.REPL_ID || process.env.REPL_SLUG)
+        return 'replit';
+    if (process.env.PROJECT_DOMAIN)
+        return 'glitch';
+    // Cloud platforms
+    if (isEnvTruthy(process.env.VERCEL))
+        return 'vercel';
+    if (process.env.RAILWAY_ENVIRONMENT_NAME ||
+        process.env.RAILWAY_SERVICE_NAME) {
+        return 'railway';
+    }
+    if (isEnvTruthy(process.env.RENDER))
+        return 'render';
+    if (isEnvTruthy(process.env.NETLIFY))
+        return 'netlify';
+    if (process.env.DYNO)
+        return 'heroku';
+    if (process.env.FLY_APP_NAME || process.env.FLY_MACHINE_ID)
+        return 'fly.io';
+    if (isEnvTruthy(process.env.CF_PAGES))
+        return 'cloudflare-pages';
+    if (process.env.DENO_DEPLOYMENT_ID)
+        return 'deno-deploy';
+    if (process.env.AWS_LAMBDA_FUNCTION_NAME)
+        return 'aws-lambda';
+    if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_FARGATE')
+        return 'aws-fargate';
+    if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_EC2')
+        return 'aws-ecs';
+    // Check for EC2 via hypervisor UUID
+    try {
+        const uuid = getFsImplementation()
+            .readFileSync('/sys/hypervisor/uuid', { encoding: 'utf8' })
+            .trim()
+            .toLowerCase();
+        if (uuid.startsWith('ec2'))
+            return 'aws-ec2';
+    }
+    catch {
+        // Ignore errors reading hypervisor UUID (ENOENT on non-EC2, etc.)
+    }
+    if (process.env.K_SERVICE)
+        return 'gcp-cloud-run';
+    if (process.env.GOOGLE_CLOUD_PROJECT)
+        return 'gcp';
+    if (process.env.WEBSITE_SITE_NAME || process.env.WEBSITE_SKU)
+        return 'azure-app-service';
+    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
+        return 'azure-functions';
+    if (process.env.APP_URL?.includes('ondigitalocean.app')) {
+        return 'digitalocean-app-platform';
+    }
+    if (process.env.SPACE_CREATOR_USER_ID)
+        return 'huggingface-spaces';
+    // CI/CD platforms
+    if (isEnvTruthy(process.env.GITHUB_ACTIONS))
+        return 'github-actions';
+    if (isEnvTruthy(process.env.GITLAB_CI))
+        return 'gitlab-ci';
+    if (process.env.CIRCLECI)
+        return 'circleci';
+    if (process.env.BUILDKITE)
+        return 'buildkite';
+    if (isEnvTruthy(process.env.CI))
+        return 'ci';
+    // Container orchestration
+    if (process.env.KUBERNETES_SERVICE_HOST)
+        return 'kubernetes';
+    try {
+        if (getFsImplementation().existsSync('/.dockerenv'))
+            return 'docker';
+    }
+    catch {
+        // Ignore errors checking for Docker
+    }
+    // Platform-specific fallback for undetected environments
+    if (env.platform === 'darwin')
+        return 'unknown-darwin';
+    if (env.platform === 'linux')
+        return 'unknown-linux';
+    if (env.platform === 'win32')
+        return 'unknown-win32';
+    return 'unknown';
+});
+// all of these should be immutable
+function isSSHSession() {
+    return !!(process.env.SSH_CONNECTION ||
+        process.env.SSH_CLIENT ||
+        process.env.SSH_TTY);
+}
+export const env = {
+    hasInternetAccess,
+    isCI: isEnvTruthy(process.env.CI),
+    platform: (['win32', 'darwin'].includes(process.platform)
+        ? process.platform
+        : 'linux'),
+    arch: process.arch,
+    nodeVersion: process.version,
+    terminal: detectTerminal(),
+    isSSH: isSSHSession,
+    getPackageManagers: detectPackageManagers,
+    getRuntimes: detectRuntimes,
+    isRunningWithBun: memoize(isRunningWithBun),
+    isWslEnvironment,
+    isNpmFromWindowsPath,
+    isConductor,
+    detectDeploymentEnvironment,
+};
+/**
+ * Returns the host platform for analytics reporting.
+ * If THADDEUS_HOST_PLATFORM is set to a valid platform value, that overrides
+ * the detected platform. This is useful for container/remote environments where
+ * process.platform reports the container OS but the actual host platform differs.
+ */
+export function getHostPlatformForAnalytics() {
+    const override = process.env.THADDEUS_HOST_PLATFORM;
+    if (override === 'win32' || override === 'darwin' || override === 'linux') {
+        return override;
+    }
+    return env.platform;
+}