@supen-ai/cli 0.1.6

package/daemon/dist/core/config.js

@@ -0,0 +1,663 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { readEnvFile, readModelsConfig } from './env.js';
+import { logger } from './logger.js';
+// Read config values from ~/.supen/config.yaml.
+// Secrets are NOT read here — they stay on disk and are loaded only
+// where needed (container-computer.ts) to avoid leaking to child processes.
+const envConfig = readEnvFile([
+    'TIMEZONE',
+    'ASSISTANT_NAME',
+    'ASSISTANT_HAS_OWN_NUMBER',
+    'SUPEN_CODING_CLI',
+    'SUPEN_CODEX_TRANSPORT',
+    'SKILLS_DIRS',
+    'SKILLS_ADMIN_ONLY',
+    'SKILLS_ALLOW_LEVEL3',
+    'SKILLS_AUTO_ENABLE',
+    'MIND_ADMIN_USERS',
+    'MIND_LOCK_MODE',
+    'HTTP_PORT',
+    'HTTP_ENABLED',
+    'HTTP_API_KEY',
+    'CONTROL_PLANE_URL',
+    'CONTROL_PLANE_ENROLLMENT_MODE',
+    'ACP_ENABLED',
+    'ACP_RELAY_URL',
+    'SECURITY_TRUSTED_REMOTE_HOSTS',
+    'SECURITY_ALLOW_INSECURE_REMOTE_ENDPOINTS',
+    'CODEX_TRUSTED_DATA_HOSTS',
+    'WORKSPACE_ALLOWED_ROOTS',
+    'CHILD_ENV_ALLOWLIST',
+    'CONCURRENCY_LIMIT',
+    'AGENT_CONCURRENCY_LIMIT',
+    'SESSION_CONCURRENCY_LIMIT',
+    'TASK_DEFAULT_TIMEOUT_MS',
+    'TASK_DEFAULT_STEP_TIMEOUT_MS',
+    'TASK_DEFAULT_RETRY_COUNT',
+    'TASK_DEFAULT_RETRY_BACKOFF_MS',
+    'SUPEN_DAEMON_NAME',
+    'SUPEN_PRODUCT_NAME',
+    'SUPEN_AUTH_TOKEN',
+    'WORKSPACE_ROOT',
+    'ALLOWED_ORIGINS',
+    'SPACE_DIR',
+    'SPACES_DIR',
+    'LIBREOFFICE_BINARY',
+    'TIWATER_CONVERT_BINARY',
+    'ONLYOFFICE_DOCUMENT_SERVER_URL',
+    'ONLYOFFICE_JWT_SECRET',
+    'ONLYOFFICE_SOURCE_BASE_URL',
+], { ensureExists: false });
+export const ASSISTANT_NAME = process.env.ASSISTANT_NAME || envConfig.ASSISTANT_NAME || 'Shaw';
+export const ASSISTANT_HAS_OWN_NUMBER = (process.env.ASSISTANT_HAS_OWN_NUMBER ||
+    envConfig.ASSISTANT_HAS_OWN_NUMBER) === 'true';
+/** Workspace skill CLI: gemini, codex, claude, etc. Used only when agent needs to run code. */
+export const SUPEN_CODING_CLI = process.env.SUPEN_CODING_CLI || envConfig.SUPEN_CODING_CLI || 'codex';
+// Comma-separated sender IDs that can perform privileged mind operations.
+// Example: MIND_ADMIN_USERS="ou_xxx,dc:user:12345"
+export const MIND_ADMIN_USERS = (process.env.MIND_ADMIN_USERS ||
+    envConfig.MIND_ADMIN_USERS ||
+    '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+// strict: locked mind rejects all natural persona edits
+// admin_override: locked mind allows natural persona edits from admin users
+export const MIND_LOCK_MODE = process.env.MIND_LOCK_MODE || envConfig.MIND_LOCK_MODE || 'admin_override';
+export const POLL_INTERVAL = 2000;
+export const SCHEDULER_POLL_INTERVAL = 60000;
+// Absolute paths for Supen data management
+const HOME_DIR = process.env.HOME || os.homedir();
+export let SUPEN_HOME = process.env.SUPEN_HOME || path.join(HOME_DIR, '.supen');
+function parseBoolean(value, fallback) {
+    if (value == null || value === '')
+        return fallback;
+    return value === 'true' || value === '1' || value === 'yes';
+}
+function findMonorepoRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (current !== path.parse(current).root) {
+        if (fs.existsSync(path.join(current, 'pnpm-workspace.yaml'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return null;
+}
+// Resolve current file's directory dynamically (compatible with ESM or CJS compiled output)
+const currentFileDir = typeof __dirname !== 'undefined'
+    ? __dirname
+    : new URL('.', import.meta.url).pathname;
+const monorepoRoot = findMonorepoRoot(currentFileDir);
+export function expandHomePath(inputPath) {
+    if (inputPath === '~')
+        return HOME_DIR;
+    if (inputPath.startsWith('~/')) {
+        return path.join(HOME_DIR, inputPath.slice(2));
+    }
+    if (inputPath.startsWith('@/') && monorepoRoot) {
+        return path.join(monorepoRoot, inputPath.slice(2));
+    }
+    return path.resolve(inputPath);
+}
+export function resolveSpacesDir(homeDir) {
+    const explicitSpaceDir = process.env.SPACE_DIR ||
+        envConfig.SPACE_DIR ||
+        process.env.SPACES_DIR ||
+        envConfig.SPACES_DIR;
+    return explicitSpaceDir ? expandHomePath(explicitSpaceDir) : homeDir;
+}
+function parsePathList(value, fallback) {
+    const rawItems = value
+        ? value
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : fallback;
+    return Array.from(new Set(rawItems.map((item) => expandHomePath(item))));
+}
+function parseStringList(value, fallback) {
+    const rawItems = value
+        ? value
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean)
+        : fallback;
+    return Array.from(new Set(rawItems));
+}
+export let MOUNT_ALLOWLIST_PATH = path.join(SUPEN_HOME, 'mount-allowlist.json');
+// Single Computer root for this SUPEN_HOME volume.
+export let SPACES_DIR = resolveSpacesDir(SUPEN_HOME);
+export let AGENTS_DIR = path.join(SUPEN_HOME, 'agents');
+export let DATA_DIR = path.join(SUPEN_HOME, 'data');
+export let SKILLS_HOME = path.join(SUPEN_HOME, 'skills');
+export let SKILLS_STATE_DIR = path.join(SKILLS_HOME, '.state');
+export let SKILLS_STATE_PATH = path.join(SKILLS_STATE_DIR, 'lock.json');
+export let SKILLS_AUDIT_LOG_PATH = path.join(SKILLS_STATE_DIR, 'audit.log');
+export function configureSupenDaemon(options) {
+    if (options.dataDir) {
+        SUPEN_HOME = options.dataDir;
+        MOUNT_ALLOWLIST_PATH = path.join(SUPEN_HOME, 'mount-allowlist.json');
+        SPACES_DIR = resolveSpacesDir(SUPEN_HOME);
+        AGENTS_DIR = path.join(SUPEN_HOME, 'agents');
+        DATA_DIR = path.join(SUPEN_HOME, 'data');
+        SKILLS_HOME = path.join(SUPEN_HOME, 'skills');
+        SKILLS_STATE_DIR = path.join(SKILLS_HOME, '.state');
+        SKILLS_STATE_PATH = path.join(SKILLS_STATE_DIR, 'lock.json');
+        SKILLS_AUDIT_LOG_PATH = path.join(SKILLS_STATE_DIR, 'audit.log');
+        SKILLS_CONFIG.directories = resolveSkillsDirectories();
+        SKILLS_CONFIG.statePath = SKILLS_STATE_PATH;
+        SKILLS_CONFIG.auditLogPath = SKILLS_AUDIT_LOG_PATH;
+    }
+}
+export function initializeDataDirs() {
+    if (!fs.existsSync(SUPEN_HOME))
+        fs.mkdirSync(SUPEN_HOME, { recursive: true });
+    if (!fs.existsSync(SPACES_DIR))
+        fs.mkdirSync(SPACES_DIR, { recursive: true });
+    if (!fs.existsSync(AGENTS_DIR))
+        fs.mkdirSync(AGENTS_DIR, { recursive: true });
+}
+export const SECURITY_TRUSTED_REMOTE_HOSTS = parseStringList(process.env.SECURITY_TRUSTED_REMOTE_HOSTS ||
+    envConfig.SECURITY_TRUSTED_REMOTE_HOSTS, []);
+export const SECURITY_ALLOW_INSECURE_REMOTE_ENDPOINTS = parseBoolean(process.env.SECURITY_ALLOW_INSECURE_REMOTE_ENDPOINTS ||
+    envConfig.SECURITY_ALLOW_INSECURE_REMOTE_ENDPOINTS, false);
+export const CODEX_TRUSTED_DATA_HOSTS = parseStringList(process.env.CODEX_TRUSTED_DATA_HOSTS || envConfig.CODEX_TRUSTED_DATA_HOSTS, ['gateway.supen.ai']);
+export const WORKSPACE_ALLOWED_ROOTS = parsePathList(process.env.WORKSPACE_ALLOWED_ROOTS || envConfig.WORKSPACE_ALLOWED_ROOTS, [HOME_DIR]);
+function activeSpaceId() {
+    return (process.env.SUPEN_SPACE_ID || 'local').trim() || 'local';
+}
+export function defaultSpaceRoot(_spaceId) {
+    // Single-Computer runtime: API ids never select sibling filesystem roots
+    // inside this local volume.
+    return path.resolve(SPACES_DIR);
+}
+function readSpaceConfigFile(spaceId) {
+    return readSpaceConfig(spaceId).config;
+}
+function readSpaceConfig(spaceId) {
+    const root = defaultSpaceRoot(spaceId);
+    const candidates = [
+        { configPath: path.join(root, 'space.yaml'), baseRoot: root },
+        { configPath: path.join(root, 'space', 'config.yaml'), baseRoot: path.join(root, 'space') },
+    ];
+    for (const candidate of candidates) {
+        const { configPath, baseRoot } = candidate;
+        try {
+            if (!fs.existsSync(configPath))
+                continue;
+            const parsed = yaml.load(fs.readFileSync(configPath, 'utf-8'));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                return { config: {}, baseRoot, configPath };
+            }
+            return { config: parsed, baseRoot, configPath };
+        }
+        catch (err) {
+            logger.warn({ err, spaceId, configPath }, 'Failed to read space config; using defaults');
+            return { config: {}, baseRoot, configPath };
+        }
+    }
+    return { config: {}, baseRoot: root, configPath: null };
+}
+function configuredRootValue(config, key) {
+    const section = config[key];
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    const root = section.root;
+    return typeof root === 'string' && root.trim() ? root.trim() : null;
+}
+function configuredRootSectionValue(section) {
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    const root = section.root;
+    return typeof root === 'string' && root.trim() ? root.trim() : null;
+}
+function configuredNestedRootValue(config, sectionKey, childKey) {
+    const section = config[sectionKey];
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    return configuredRootSectionValue(section[childKey]);
+}
+function configuredStringValue(section, key) {
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    const value = section[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function isWithinAllowedWorkspaceRoot(candidate) {
+    const resolvedPath = path.resolve(candidate);
+    return WORKSPACE_ALLOWED_ROOTS.some((root) => {
+        const resolvedRoot = path.resolve(root);
+        return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+    });
+}
+export function resolveSpaceConfiguredRoot(spaceId, key, defaultSegment) {
+    const loaded = readSpaceConfig(spaceId);
+    const fallback = path.join(defaultSpaceRoot(spaceId), defaultSegment);
+    const configured = configuredRootValue(loaded.config, key);
+    return resolveSpaceConfigRoot(spaceId, String(key), configured, fallback, loaded.baseRoot);
+}
+export function resolveSpaceFilesRoot(spaceId, key, defaultSegment) {
+    const loaded = readSpaceConfig(spaceId);
+    const fallback = path.join(defaultSpaceRoot(spaceId), defaultSegment);
+    const configured = configuredNestedRootValue(loaded.config, 'files', key);
+    return resolveSpaceConfigRoot(spaceId, `files.${key}`, configured, fallback, loaded.baseRoot);
+}
+export function resolveSpaceTasksRoot(spaceId) {
+    const loaded = readSpaceConfig(spaceId);
+    const fallback = path.join(defaultSpaceRoot(spaceId), 'tasks');
+    const configured = configuredNestedRootValue(loaded.config, 'files', 'tasks');
+    if (!configured)
+        return fallback;
+    return resolveSpaceConfigRoot(spaceId, 'files.tasks', configured, fallback, loaded.baseRoot);
+}
+function resolveSpaceConfigRoot(spaceId, key, configured, fallback, baseRoot = defaultSpaceRoot(spaceId)) {
+    if (!configured)
+        return fallback;
+    if (configured.startsWith('~/') || configured === '~' || configured.startsWith('@/') || path.isAbsolute(configured)) {
+        const requested = expandHomePath(configured);
+        if (isWithinAllowedWorkspaceRoot(requested))
+            return requested;
+        logger.warn({ spaceId, key, requested, allowedRoots: WORKSPACE_ALLOWED_ROOTS }, 'Configured space root is outside WORKSPACE_ALLOWED_ROOTS; using default');
+        return fallback;
+    }
+    const requested = path.resolve(baseRoot, configured);
+    if (requested === baseRoot || requested.startsWith(`${baseRoot}${path.sep}`)) {
+        return requested;
+    }
+    logger.warn({ spaceId, key, requested, baseRoot }, 'Configured relative space root escapes space root; using default');
+    return fallback;
+}
+function assertSafeKnowledgeId(input) {
+    const normalized = input.trim();
+    if (!normalized ||
+        normalized === '.' ||
+        normalized === '..' ||
+        normalized.includes('/') ||
+        normalized.includes('\\') ||
+        normalized.includes('\0')) {
+        return null;
+    }
+    return normalized;
+}
+export function resolveSpaceKnowledgeRoots(spaceId) {
+    const safeSpaceId = 'local';
+    const loaded = readSpaceConfig(spaceId);
+    const config = loaded.config;
+    const knowledgeConfig = config.knowledge;
+    const configuredRoots = knowledgeConfig && typeof knowledgeConfig === 'object' && !Array.isArray(knowledgeConfig)
+        ? knowledgeConfig.roots
+        : null;
+    const parsedRoots = [];
+    if (Array.isArray(configuredRoots)) {
+        for (const rootEntry of configuredRoots) {
+            if (!rootEntry || typeof rootEntry !== 'object' || Array.isArray(rootEntry))
+                continue;
+            const rawId = configuredStringValue(rootEntry, 'id');
+            const id = rawId ? assertSafeKnowledgeId(rawId) : null;
+            const configured = configuredRootSectionValue(rootEntry);
+            if (!id || !configured) {
+                logger.warn({ spaceId: safeSpaceId, rootEntry }, 'Skipping invalid space knowledge root');
+                continue;
+            }
+            const name = configuredStringValue(rootEntry, 'name') || id;
+            const mode = configuredStringValue(rootEntry, 'mode') || undefined;
+            const fallback = path.join(defaultSpaceRoot(safeSpaceId), 'knowledge', id);
+            parsedRoots.push({
+                id,
+                name,
+                mode,
+                root: resolveSpaceConfigRoot(safeSpaceId, `knowledge.${id}`, configured, fallback, loaded.baseRoot),
+            });
+        }
+    }
+    if (parsedRoots.length === 0) {
+        return [{
+                id: 'default',
+                name: 'Knowledge',
+                mode: 'default',
+                root: path.join(defaultSpaceRoot(safeSpaceId), 'knowledge'),
+                isDefault: true,
+            }];
+    }
+    const requestedDefault = knowledgeConfig && typeof knowledgeConfig === 'object' && !Array.isArray(knowledgeConfig)
+        ? configuredStringValue(knowledgeConfig, 'default')
+        : null;
+    const safeDefault = requestedDefault ? assertSafeKnowledgeId(requestedDefault) : null;
+    const defaultId = safeDefault && parsedRoots.some((root) => root.id === safeDefault)
+        ? safeDefault
+        : parsedRoots[0].id;
+    return parsedRoots.map((root) => ({
+        ...root,
+        isDefault: root.id === defaultId,
+    }));
+}
+export function resolveSpaceKnowledgeRoot(spaceId, knowledgeId) {
+    const roots = resolveSpaceKnowledgeRoots(spaceId);
+    const requested = knowledgeId ? assertSafeKnowledgeId(knowledgeId) : null;
+    return ((requested ? roots.find((root) => root.id === requested) : null) ||
+        roots.find((root) => root.isDefault) ||
+        roots[0]);
+}
+export function resolveSpaceDriveRoot(spaceId) {
+    return resolveSpaceKnowledgeRoot(spaceId).root;
+}
+export function resolveSpaceSkillMountRoots(spaceId = activeSpaceId()) {
+    return Array.from(new Set(resolveSpaceKnowledgeRoots(spaceId).flatMap((root) => [
+        path.join(root.root, 'skills'),
+        path.join(root.root, 'plugins'),
+        root.root,
+    ])));
+}
+export function resolveSpacePluginMountRoots(spaceId = activeSpaceId()) {
+    return Array.from(new Set(resolveSpaceKnowledgeRoots(spaceId).map((root) => path.join(root.root, 'plugins'))));
+}
+export const CHILD_ENV_ALLOWLIST = parseStringList(process.env.CHILD_ENV_ALLOWLIST || envConfig.CHILD_ENV_ALLOWLIST, []);
+export const AGENT_MIND_FILES = [
+    'SOUL.md',
+    'IDENTITY.md',
+    'USER.md',
+    'MEMORY.md',
+];
+function defaultSkillDirectories() {
+    const defaults = [
+        '~/.supen/skills',
+        '@/skills',
+        './skills',
+        ...resolveSpaceSkillMountRoots(),
+    ];
+    return defaults;
+}
+function resolveSkillsDirectories() {
+    return parsePathList(process.env.SKILLS_DIRS || envConfig.SKILLS_DIRS, defaultSkillDirectories());
+}
+export const SKILLS_CONFIG = {
+    directories: resolveSkillsDirectories(),
+    adminOnly: parseBoolean(process.env.SKILLS_ADMIN_ONLY || envConfig.SKILLS_ADMIN_ONLY, true),
+    allowLevel3: parseBoolean(process.env.SKILLS_ALLOW_LEVEL3 || envConfig.SKILLS_ALLOW_LEVEL3, true),
+    autoEnableOnInstall: parseBoolean(process.env.SKILLS_AUTO_ENABLE || envConfig.SKILLS_AUTO_ENABLE, false),
+    defaultEnabled: process.env.SKILLS_DEFAULT_ENABLED || envConfig.SKILLS_DEFAULT_ENABLED
+        ? (process.env.SKILLS_DEFAULT_ENABLED ||
+            envConfig.SKILLS_DEFAULT_ENABLED)
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [],
+    statePath: SKILLS_STATE_PATH,
+    auditLogPath: SKILLS_AUDIT_LOG_PATH,
+};
+export const CONTAINER_IMAGE = process.env.CONTAINER_IMAGE || 'supen-agent:latest';
+export const CONTAINER_TIMEOUT = parseInt(process.env.CONTAINER_TIMEOUT || '1800000', 10);
+export const CONTAINER_MAX_OUTPUT_SIZE = parseInt(process.env.CONTAINER_MAX_OUTPUT_SIZE || '10485760', 10); // 10MB default
+export const IPC_POLL_INTERVAL = 1000;
+export const IDLE_TIMEOUT = parseInt(process.env.IDLE_TIMEOUT || '1800000', 10); // 30min default — how long to keep container alive after last result
+export const MAX_CONCURRENT_CONTAINERS = Math.max(1, parseInt(process.env.MAX_CONCURRENT_CONTAINERS || '5', 10) || 5);
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export const TRIGGER_PATTERN = new RegExp(`^@${escapeRegex(ASSISTANT_NAME)}\\b`, 'i');
+// Timezone for scheduled tasks (cron expressions, etc.)
+// Uses config.yaml timezone by default, then falls back to host timezone.
+export const TIMEZONE = process.env.TZ || envConfig.TIMEZONE || Intl.DateTimeFormat().resolvedOptions().timeZone;
+// HTTP SSE channel
+export const HTTP_PORT = parseInt(process.env.PORT || process.env.HTTP_PORT || envConfig.HTTP_PORT || '2756', 10);
+export const HTTP_ENABLED = (process.env.HTTP_ENABLED ?? envConfig.HTTP_ENABLED ?? 'true') !== 'false';
+export const HTTP_API_KEY = process.env.HTTP_API_KEY || envConfig.HTTP_API_KEY || '';
+export const SUPEN_AUTH_TOKEN = process.env.SUPEN_AUTH_TOKEN || envConfig.SUPEN_AUTH_TOKEN || '';
+export const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || envConfig.WORKSPACE_ROOT || '';
+export const ALLOWED_ORIGINS = process.env.ALLOWED_ORIGINS || envConfig.ALLOWED_ORIGINS || '';
+// LLM configuration is now fully provider-driven via config.yaml `providers` array.
+// No more raw env-var exports for api keys / base urls / model names.
+/**
+ * Model registry — loaded once at startup from config.yaml `providers` list.
+ * Each entry is a (provider, model) pair with a composite ID "provider_id:model_name".
+ */
+/** Provider-keyed fallback pricing per 1M tokens in USD. */
+const MODEL_PRICING = {
+    _global: {
+        'glm-4': { input: 0.1, output: 0.1 },
+        'glm-4v': { input: 0.1, output: 0.1 },
+        'glm-4-air': { input: 0.01, output: 0.01 },
+        'glm-4-flash': { input: 0.0, output: 0.0 },
+        'claude-3-5-sonnet': { input: 3.0, output: 15.0 },
+        'claude-3-5-haiku': { input: 0.25, output: 1.25 },
+        'claude-3-opus': { input: 15.0, output: 75.0 },
+        'claude-sonnet-4': { input: 3.0, output: 15.0 },
+        'claude-opus-4': { input: 15.0, output: 75.0 },
+        'gemini-1.5-pro': { input: 1.25, output: 5.0 },
+        'gemini-1.5-flash': { input: 0.075, output: 0.3 },
+    },
+    babelark: {
+        'qwen3.6': { input: 0.29, output: 1.74 },
+        'qwen3.5': { input: 0.12, output: 0.7 },
+        'gpt-5.4': { input: 2.5, output: 15.0 },
+        'claude-sonnet-4.6': { input: 3.0, output: 15.0 },
+    },
+};
+/**
+ * Get pricing for a model entry.
+ * Priority: 1) explicit config.yaml pricing, 2) provider-specific built-in, 3) global fallback.
+ */
+export function getModelPricing(entry) {
+    // 1. Explicit pricing from config.yaml
+    if (entry.pricing && (entry.pricing.input_usd_per_1m > 0 || entry.pricing.output_usd_per_1m > 0)) {
+        return { input: entry.pricing.input_usd_per_1m, output: entry.pricing.output_usd_per_1m };
+    }
+    // 2. Provider-specific built-in pricing (fuzzy match)
+    const providerMap = MODEL_PRICING[entry.provider_id];
+    if (providerMap) {
+        for (const [key, pricing] of Object.entries(providerMap)) {
+            if (entry.model.toLowerCase().startsWith(key)) {
+                return pricing;
+            }
+        }
+    }
+    // 3. Global fallback (fuzzy match)
+    const globalMap = MODEL_PRICING._global;
+    for (const [key, pricing] of Object.entries(globalMap)) {
+        if (entry.model.toLowerCase().startsWith(key)) {
+            return pricing;
+        }
+    }
+    return { input: 0, output: 0 };
+}
+function enrichModelsWithPricing(entries) {
+    // Enrich with pricing
+    for (const entry of entries) {
+        if (!entry.pricing) {
+            const p = getModelPricing(entry);
+            if (p.input > 0 || p.output > 0) {
+                entry.pricing = { input_usd_per_1m: p.input, output_usd_per_1m: p.output };
+            }
+        }
+    }
+    return entries;
+}
+/** Runtime model registry. Reloadable without daemon restart. */
+export let MODELS_REGISTRY = [];
+/** Runtime default model entry (marked default:true, or first in list). */
+export let DEFAULT_MODEL = undefined;
+/**
+ * Reload model providers/models from config.yaml into the runtime registry.
+ * Returns a small summary for API/CLI callers.
+ */
+export function reloadModelsRegistry(options = {}) {
+    MODELS_REGISTRY = enrichModelsWithPricing(readModelsConfig(options));
+    DEFAULT_MODEL = MODELS_REGISTRY.find((m) => m.default) ?? MODELS_REGISTRY[0];
+    return {
+        total_models: MODELS_REGISTRY.length,
+        default_model: DEFAULT_MODEL?.id ?? null,
+    };
+}
+// Initial load must be side-effect free so importing start.ts does not create
+// config.yaml before the daemon actually starts.
+reloadModelsRegistry({ ensureExists: false });
+// Daemon identity — derived from hostname or manual override via SUPEN_DAEMON_NAME
+const rawHostname = os.hostname() || 'supen-local';
+export const DAEMON_HOSTNAME = process.env.SUPEN_DAEMON_NAME || envConfig.SUPEN_DAEMON_NAME || rawHostname;
+/** Product branding name (e.g. "Supen", "Ticos"). Defaults to "Supen". */
+export const SUPEN_PRODUCT_NAME = process.env.SUPEN_PRODUCT_NAME || envConfig.SUPEN_PRODUCT_NAME || 'Supen';
+function resolveLibreOfficeBinary() {
+    const configured = process.env.LIBREOFFICE_BINARY || envConfig.LIBREOFFICE_BINARY;
+    if (configured)
+        return configured;
+    if (process.platform === 'darwin') {
+        const macAppBundleBinary = '/Applications/LibreOffice.app/Contents/MacOS/soffice';
+        if (fs.existsSync(macAppBundleBinary))
+            return macAppBundleBinary;
+    }
+    return 'libreoffice';
+}
+export const LIBREOFFICE_BINARY = resolveLibreOfficeBinary();
+export const TIWATER_CONVERT_BINARY = process.env.TIWATER_CONVERT_BINARY || envConfig.TIWATER_CONVERT_BINARY || 'tiwater-convert';
+export const ONLYOFFICE_DOCUMENT_SERVER_URL = process.env.ONLYOFFICE_DOCUMENT_SERVER_URL ||
+    envConfig.ONLYOFFICE_DOCUMENT_SERVER_URL ||
+    'http://139.224.22.149:7177';
+export const ONLYOFFICE_JWT_SECRET = process.env.ONLYOFFICE_JWT_SECRET ||
+    envConfig.ONLYOFFICE_JWT_SECRET ||
+    'change-this-long-random-secret';
+export const ONLYOFFICE_SOURCE_BASE_URL = process.env.ONLYOFFICE_SOURCE_BASE_URL || envConfig.ONLYOFFICE_SOURCE_BASE_URL || '';
+// ACP (Agent Communication Protocol) configuration
+export const ACP_ENABLED = (process.env.ACP_ENABLED ?? envConfig.ACP_ENABLED ?? 'false') === 'true';
+export const ACP_RELAY_URL = process.env.ACP_RELAY_URL || envConfig.ACP_RELAY_URL || '';
+// Concurrency limits
+export const CONCURRENCY_LIMIT = Math.max(1, parseInt(process.env.CONCURRENCY_LIMIT || envConfig.CONCURRENCY_LIMIT || '5', 10) || 5);
+export const AGENT_CONCURRENCY_LIMIT = Math.max(1, parseInt(process.env.AGENT_CONCURRENCY_LIMIT ||
+    envConfig.AGENT_CONCURRENCY_LIMIT ||
+    '3', 10) || 3);
+export const SESSION_CONCURRENCY_LIMIT = Math.max(1, parseInt(process.env.SESSION_CONCURRENCY_LIMIT ||
+    envConfig.SESSION_CONCURRENCY_LIMIT ||
+    '1', 10) || 1);
+// Task executor defaults
+export const TASK_DEFAULT_TIMEOUT_MS = parseInt(process.env.TASK_DEFAULT_TIMEOUT_MS ||
+    envConfig.TASK_DEFAULT_TIMEOUT_MS ||
+    '0', 10);
+export const TASK_DEFAULT_STEP_TIMEOUT_MS = parseInt(process.env.TASK_DEFAULT_STEP_TIMEOUT_MS ||
+    envConfig.TASK_DEFAULT_STEP_TIMEOUT_MS ||
+    '0', 10);
+export const TASK_DEFAULT_RETRY_COUNT = parseInt(process.env.TASK_DEFAULT_RETRY_COUNT ||
+    envConfig.TASK_DEFAULT_RETRY_COUNT ||
+    '0', 10);
+export const TASK_DEFAULT_RETRY_BACKOFF_MS = parseInt(process.env.TASK_DEFAULT_RETRY_BACKOFF_MS ||
+    envConfig.TASK_DEFAULT_RETRY_BACKOFF_MS ||
+    '5000', 10);
+// --- Convention-based agent paths ---
+export function agentPaths(agentId) {
+    const normalizedAgentId = (agentId || '').trim();
+    if (!normalizedAgentId ||
+        normalizedAgentId === '.' ||
+        normalizedAgentId === '..' ||
+        normalizedAgentId.includes('/') ||
+        normalizedAgentId.includes('\\') ||
+        normalizedAgentId.includes('\0')) {
+        throw new Error(`Invalid agent_id: ${JSON.stringify(agentId)}`);
+    }
+    function resolveWorkspaceOverride(base, defaultWorkspace) {
+        const configPath = path.join(base, 'agent-config.json');
+        let workspace = defaultWorkspace;
+        if (!fs.existsSync(configPath)) {
+            return workspace;
+        }
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (config.workspace) {
+                const requested = expandHomePath(config.workspace);
+                const inAllowedRoot = WORKSPACE_ALLOWED_ROOTS.some((root) => {
+                    const resolvedRoot = path.resolve(root);
+                    const resolvedPath = path.resolve(requested);
+                    return (resolvedPath === resolvedRoot ||
+                        resolvedPath.startsWith(`${resolvedRoot}${path.sep}`));
+                });
+                if (inAllowedRoot) {
+                    workspace = requested;
+                }
+                else {
+                    console.warn(`[security] Workspace "${requested}" is outside WORKSPACE_ALLOWED_ROOTS; falling back to default for agent "${normalizedAgentId}".`);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return workspace;
+    }
+    const base = path.resolve(AGENTS_DIR, normalizedAgentId);
+    if (base !== AGENTS_DIR && !base.startsWith(`${AGENTS_DIR}${path.sep}`)) {
+        throw new Error(`Invalid agent_id path escape attempt: ${normalizedAgentId}`);
+    }
+    const configPath = path.join(base, 'agent-config.json');
+    const recordPath = path.join(base, 'agent.json');
+    let assignedSpaceId = (process.env.SUPEN_SPACE_ID || '').trim();
+    if (fs.existsSync(recordPath)) {
+        try {
+            const record = JSON.parse(fs.readFileSync(recordPath, 'utf-8'));
+            const recordSpaceId = typeof record?.space_id === 'string' ? record.space_id.trim() : '';
+            if (recordSpaceId)
+                assignedSpaceId = recordSpaceId;
+        }
+        catch {
+            /* ignore malformed agent metadata */
+        }
+    }
+    const defaultWorkspace = resolveSpaceDriveRoot(assignedSpaceId || 'local');
+    const workspace = resolveWorkspaceOverride(base, defaultWorkspace);
+    return {
+        base,
+        config: configPath,
+        workspace,
+        logs: path.join(base, 'logs'),
+        brain: base,
+    };
+}
+/**
+ * Get the ordered list of models for a specific agent.
+ *
+ * 1. Checks `agent-config.json` for `model`: "provider_id:model_name" (composite key)
+ * 2. If present, puts that model first, followed by the rest of the registry for fallback.
+ * 3. If absent or invalid, returns the full registry (which puts the default model first).
+ */
+export function getAgentModelConfig(agentId, silent = false) {
+    let selectedModelId;
+    try {
+        const configPath = path.join(AGENTS_DIR, agentId, 'agent-config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (typeof config.model === 'string' && config.model) {
+                selectedModelId = config.model;
+            }
+        }
+    }
+    catch (e) {
+        if (!silent) {
+            logger.warn({ err: e.message, agentId }, 'Failed to parse agent-config.json for model selection');
+        }
+    }
+    // If no model explicitly selected, return default-first ordering for fallback behavior.
+    if (!selectedModelId || MODELS_REGISTRY.length === 0) {
+        if (MODELS_REGISTRY.length <= 1)
+            return MODELS_REGISTRY;
+        const defaultIdx = MODELS_REGISTRY.findIndex((m) => m.default);
+        if (defaultIdx <= 0)
+            return MODELS_REGISTRY;
+        const ordered = [...MODELS_REGISTRY];
+        const [selectedDefault] = ordered.splice(defaultIdx, 1);
+        return [selectedDefault, ...ordered];
+    }
+    // Find by composite key (e.g. "babelark:qwen3.6-plus")
+    let selectedIdx = MODELS_REGISTRY.findIndex(m => m.id === selectedModelId);
+    // If the agent requested a model that isn't in the registry, fall back to default
+    if (selectedIdx === -1) {
+        if (!silent) {
+            logger.warn({ agentId, requestedModel: selectedModelId }, 'Agent requested model ID not found in config.yaml providers block. Falling back to default.');
+        }
+        return MODELS_REGISTRY;
+    }
+    // Build the list: Selected model FIRST, then the rest in their original order for fallback
+    const list = [...MODELS_REGISTRY];
+    const [selected] = list.splice(selectedIdx, 1);
+    return [selected, ...list];
+}
+//# sourceMappingURL=config.js.map