twinclaw 1.0.0

package/dist/config/env-validator.js

@@ -0,0 +1,223 @@
+/**
+ * Unified runtime configuration validator.
+ *
+ * Produces structured, redaction-safe diagnostics for:
+ *   - Missing required config keys.
+ *   - Active features whose conditional keys are absent.
+ *   - Format/type violations on plain env vars.
+ *   - A machine-readable summary suitable for API responses and operator tooling.
+ *
+ * No secret values are ever included in the output.
+ */
+import { CONFIG_SCHEMA } from './env-schema.js';
+import { getSecretVaultService } from '../services/secret-vault.js';
+import { getConfigValue } from './config-loader.js';
+// ── Internal helpers ─────────────────────────────────────────────────────────
+/**
+ * Resolve a config key's value without leaking it.
+ * Returns true when a non-empty value exists (vault → env), false otherwise.
+ */
+function hasValue(spec) {
+    if (spec.type === 'secret') {
+        return getSecretVaultService().readSecret(spec.key) !== null;
+    }
+    const raw = getConfigValue(spec.key);
+    return typeof raw === 'string' && raw.trim().length > 0;
+}
+/**
+ * Validate additional format constraints for known env vars.
+ * Returns an issue string if invalid, null if ok.
+ */
+function formatError(spec) {
+    if (spec.type !== 'env') {
+        return null;
+    }
+    const raw = getConfigValue(spec.key);
+    if (!raw) {
+        return null; // missing handled separately
+    }
+    switch (spec.key) {
+        case 'TELEGRAM_USER_ID': {
+            const parsed = Number(raw.trim());
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                return `TELEGRAM_USER_ID must be a positive integer, got '${raw.trim()}'.`;
+            }
+            break;
+        }
+        case 'MEMORY_EMBEDDING_DIM': {
+            const parsed = Number(raw.trim());
+            if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+                return `MEMORY_EMBEDDING_DIM must be a positive integer, got '${raw.trim()}'.`;
+            }
+            break;
+        }
+        case 'API_PORT': {
+            const parsed = Number(raw.trim());
+            if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+                return `API_PORT must be an integer in range 1–65535, got '${raw.trim()}'.`;
+            }
+            break;
+        }
+        case 'EMBEDDING_PROVIDER': {
+            const v = raw.trim().toLowerCase();
+            if (v !== 'openai' && v !== 'ollama') {
+                return `EMBEDDING_PROVIDER must be 'openai' or 'ollama', got '${raw.trim()}'.`;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return null;
+}
+/**
+ * Detect which feature gates are currently active based on present keys.
+ *
+ * A feature gate is considered "active" if its paired conditional key is present.
+ */
+function detectActiveFeatures() {
+    const active = new Set();
+    for (const spec of CONFIG_SCHEMA) {
+        if (spec.class !== 'conditional' || !spec.condition) {
+            continue;
+        }
+        if (hasValue(spec)) {
+            active.add(spec.condition);
+        }
+    }
+    return active;
+}
+/**
+ * Resolve the model feature gates that are active.
+ *
+ * The model subsystem is considered "active" when at least one model API key is present.
+ * Individual model conditions only generate issues when no model key is available at all.
+ */
+function hasAnyModelKey() {
+    const modelKeys = ['MODAL_API_KEY', 'OPENROUTER_API_KEY', 'GEMINI_API_KEY'];
+    return modelKeys.some((key) => getSecretVaultService().readSecret(key) !== null);
+}
+// ── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Validate the runtime configuration against the schema.
+ *
+ * @param now - Injectable clock (ISO-8601 source). Defaults to `new Date()`.
+ */
+export function validateRuntimeConfig(now = () => new Date()) {
+    const issues = [];
+    const presentKeys = [];
+    const activeFeatures = detectActiveFeatures();
+    const anyModelKey = hasAnyModelKey();
+    for (const spec of CONFIG_SCHEMA) {
+        const present = hasValue(spec);
+        if (present) {
+            presentKeys.push(spec.key);
+        }
+        // ── Format validation (even for present keys) ───────────────────────────
+        const formatErr = formatError(spec);
+        if (formatErr) {
+            issues.push({
+                key: spec.key,
+                class: 'format_error',
+                message: formatErr,
+                remediation: spec.remediation,
+            });
+            continue;
+        }
+        if (present) {
+            continue; // value is present and valid
+        }
+        // ── Missing key handling ────────────────────────────────────────────────
+        switch (spec.class) {
+            case 'required':
+                issues.push({
+                    key: spec.key,
+                    class: 'missing_required',
+                    message: `Required config key '${spec.key}' is missing. ${spec.description}`,
+                    remediation: spec.remediation,
+                });
+                break;
+            case 'conditional': {
+                // Model keys: only flag as an issue when no model key is configured at all.
+                if (spec.condition === 'model:primary' ||
+                    spec.condition === 'model:fallback_1' ||
+                    spec.condition === 'model:fallback_2') {
+                    if (!anyModelKey) {
+                        // Only emit this issue once (for the first model key that is checked).
+                        // Deduplicate by checking if a model issue was already emitted.
+                        const alreadyReported = issues.some((i) => i.key === 'MODAL_API_KEY' ||
+                            i.key === 'OPENROUTER_API_KEY' ||
+                            i.key === 'GEMINI_API_KEY');
+                        if (!alreadyReported) {
+                            issues.push({
+                                key: spec.key,
+                                class: 'missing_conditional',
+                                message: `No model API key is configured (MODAL_API_KEY, OPENROUTER_API_KEY, GEMINI_API_KEY). ` +
+                                    `At least one is required for AI functionality.`,
+                                remediation: spec.remediation,
+                            });
+                        }
+                    }
+                    break;
+                }
+                // Telegram: both parts must be set together.
+                if (spec.condition === 'messaging:telegram' &&
+                    activeFeatures.has('messaging:telegram')) {
+                    issues.push({
+                        key: spec.key,
+                        class: 'missing_conditional',
+                        message: `Telegram integration is partially configured — '${spec.key}' is missing. ${spec.description}`,
+                        remediation: spec.remediation,
+                    });
+                    break;
+                }
+                // Voice: flag if any messaging platform is active but GROQ_API_KEY is absent.
+                if (spec.condition === 'messaging:voice') {
+                    const messagingActive = activeFeatures.has('messaging:telegram') ||
+                        activeFeatures.has('messaging:whatsapp');
+                    if (messagingActive) {
+                        issues.push({
+                            key: spec.key,
+                            class: 'missing_conditional',
+                            message: `GROQ_API_KEY is required for voice messaging but is not configured. ` +
+                                `Messaging dispatcher will start in text-only mode.`,
+                            remediation: spec.remediation,
+                        });
+                    }
+                    break;
+                }
+                // All other conditional keys: only flag when both parts of a pair are partially set.
+                // Otherwise, silently skip (feature is simply not enabled).
+                break;
+            }
+            case 'optional':
+                // Optional keys are never surfaced as issues when absent.
+                break;
+        }
+    }
+    const fatalIssues = issues.filter((i) => i.class === 'missing_required');
+    return {
+        ok: fatalIssues.length === 0 && !issues.some((i) => i.class === 'format_error'),
+        presentKeys: presentKeys.sort(),
+        issues,
+        activeFeatures: [...activeFeatures].sort(),
+        fatalIssues,
+        validatedAt: now().toISOString(),
+    };
+}
+/**
+ * Run the runtime config validation and throw when fatal issues exist.
+ *
+ * Safe to call during startup. Never exposes secret values in the thrown error.
+ *
+ * @returns The full `ConfigValidationResult` when validation passes.
+ * @throws Error with actionable, redaction-safe message when fatal issues are found.
+ */
+export function assertRuntimeConfig(now = () => new Date()) {
+    const result = validateRuntimeConfig(now);
+    if (result.fatalIssues.length > 0) {
+        const reasons = result.fatalIssues.map((i) => i.message).join(' | ');
+        throw new Error(`Runtime config validation failed: ${reasons}`);
+    }
+    return result;
+}

package/dist/config/identity-bootstrap.js

@@ -0,0 +1,115 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getIdentityDir, getWorkspaceSubdir } from './workspace.js';
+const DEFAULT_SOUL_TEMPLATE = `# TwinBot Core Directives
+
+## Operational Tone
+- Be direct, concise, and practical
+- Prioritize solving problems over being agreeable
+- Ask clarifying questions when instructions are ambiguous
+
+## Behavioral Boundaries
+- Never execute commands that could cause irreversible harm to the system
+- Always confirm before executing destructive operations
+- Maintain user privacy and never log sensitive information
+
+## Core Principles
+- Zero-cost infrastructure: Prefer local solutions over paid services
+- Local-first: Use local databases and file storage before external services
+- Proactive: Anticipate user needs and offer suggestions
+- Transparent: Be clear about limitations and uncertainties
+
+## Communication Style
+- Use natural, conversational language
+- Provide context for important decisions
+- Admit when you don't know something
+`;
+const DEFAULT_IDENTITY_TEMPLATE = `# TwinBot Identity
+
+## Basic Info
+- **Name:** TwinBot
+- **Role:** Local AI Assistant
+- **Version:** 1.0.0
+
+## Persona
+TwinBot is a local-first AI assistant that runs on your machine. It has access to your filesystem, can execute commands, and help with various tasks.
+
+## Capabilities
+- File system operations
+- Command execution
+- Web browsing via Playwright
+- Messaging via WhatsApp and Telegram
+- Long-term memory via semantic search
+
+## Limitations
+- Depends on local resources (CPU, memory, disk)
+- Requires API keys for cloud AI models
+- Cannot access the internet without configured channels
+`;
+const DEFAULT_MEMORY_TEMPLATE = `# TwinBot Memory
+
+This file stores long-term facts, preferences, and important information that should persist across sessions.
+
+## User Preferences
+- (Add user preferences here)
+
+## Important Facts
+- (Add important facts about the user or context here)
+
+## Learned Information
+- (Information learned from conversations that should be remembered)
+`;
+export function ensureIdentityFiles() {
+    const identityDir = getIdentityDir();
+    const memoryDir = getWorkspaceSubdir('memory');
+    if (!fs.existsSync(identityDir)) {
+        fs.mkdirSync(identityDir, { recursive: true });
+    }
+    if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    const soulPath = path.join(identityDir, 'soul.md');
+    if (!fs.existsSync(soulPath)) {
+        fs.writeFileSync(soulPath, DEFAULT_SOUL_TEMPLATE, { encoding: 'utf-8' });
+    }
+    const identityPath = path.join(identityDir, 'identity.md');
+    if (!fs.existsSync(identityPath)) {
+        fs.writeFileSync(identityPath, DEFAULT_IDENTITY_TEMPLATE, { encoding: 'utf-8' });
+    }
+    const memoryPath = path.join(memoryDir, 'memory.md');
+    if (!fs.existsSync(memoryPath)) {
+        fs.writeFileSync(memoryPath, DEFAULT_MEMORY_TEMPLATE, { encoding: 'utf-8' });
+    }
+}
+export function getIdentityFilesStatus() {
+    const identityDir = getIdentityDir();
+    const memoryDir = getWorkspaceSubdir('memory');
+    return {
+        soul: fs.existsSync(path.join(identityDir, 'soul.md')),
+        identity: fs.existsSync(path.join(identityDir, 'identity.md')),
+        memory: fs.existsSync(path.join(memoryDir, 'memory.md')),
+    };
+}
+export const IDENTITY_FILE_CHECKS = [
+    {
+        kind: 'filesystem',
+        name: 'identity-soul',
+        description: 'Identity soul.md constitution file',
+        severity: 'critical',
+        remediation: 'Run `node src/index.ts onboard` to initialize identity files.',
+    },
+    {
+        kind: 'filesystem',
+        name: 'identity-identity',
+        description: 'Identity persona file',
+        severity: 'critical',
+        remediation: 'Run `node src/index.ts onboard` to initialize identity files.',
+    },
+    {
+        kind: 'filesystem',
+        name: 'identity-memory',
+        description: 'Long-term memory file',
+        severity: 'warning',
+        remediation: 'Run `node src/index.ts onboard` to initialize memory file.',
+    },
+];

package/dist/config/json-config.js

@@ -0,0 +1,344 @@
+import * as fs from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+import { getConfigPath as getWorkspaceConfigPath, hasLegacyConfig, migrateLegacyConfig, ensureWorkspaceDir, } from './workspace.js';
+export const DEFAULT_CONFIG = {
+    runtime: {
+        apiSecret: '',
+        apiPort: 3100,
+        secretVaultRequired: [],
+    },
+    models: {
+        modalApiKey: '',
+        openRouterApiKey: '',
+        geminiApiKey: '',
+    },
+    messaging: {
+        telegram: {
+            enabled: false,
+            botToken: '',
+            userId: null,
+        },
+        whatsapp: {
+            enabled: false,
+            phoneNumber: '',
+        },
+        voice: {
+            groqApiKey: '',
+        },
+        inbound: {
+            enabled: true,
+            debounceMs: 1500,
+        },
+        streaming: {
+            blockStreamingDefault: true,
+            blockStreamingBreak: 'paragraph',
+            blockStreamingMinChars: 50,
+            blockStreamingMaxChars: 800,
+            blockStreamingCoalesce: true,
+            humanDelayMs: 800,
+        },
+    },
+    storage: {
+        embeddingDim: 1536,
+    },
+    integration: {
+        embeddingProvider: '',
+        embeddingApiKey: '',
+        openaiApiKey: '',
+        embeddingApiUrl: 'https://api.openai.com/v1/embeddings',
+        embeddingModel: 'text-embedding-3-small',
+        ollamaBaseUrl: 'http://localhost:11434',
+        ollamaEmbeddingModel: 'mxbai-embed-large',
+    },
+    tools: {
+        allow: [],
+        deny: [],
+    },
+};
+export function getConfigPath(overridePath) {
+    if (overridePath)
+        return path.resolve(overridePath);
+    const envPath = process.env.TWINBOT_CONFIG_PATH || process.env.TWINCLAW_CONFIG_PATH;
+    if (envPath) {
+        return path.resolve(envPath);
+    }
+    ensureWorkspaceDir();
+    return getWorkspaceConfigPath();
+}
+export async function ensureConfigDir(configPath) {
+    const dir = path.dirname(configPath);
+    if (!existsSync(dir)) {
+        await fs.mkdir(dir, { recursive: true });
+    }
+}
+export async function readConfig(overridePath) {
+    const targetPath = getConfigPath(overridePath);
+    try {
+        const rawData = await fs.readFile(targetPath, 'utf-8');
+        const parsed = JSON.parse(rawData);
+        return mergeWithDefaults(parsed);
+    }
+    catch (error) {
+        const fsError = error;
+        if (fsError.code === 'ENOENT')
+            return mergeWithDefaults({});
+        throw new Error(`Failed to parse config file at ${targetPath}: ${fsError.message}`);
+    }
+}
+export async function writeConfig(config, overridePath) {
+    const targetPath = getConfigPath(overridePath);
+    await ensureConfigDir(targetPath);
+    const tempPath = `${targetPath}.${Date.now()}.tmp`;
+    try {
+        const serialized = JSON.stringify(config, null, 2);
+        await fs.writeFile(tempPath, serialized, { encoding: 'utf-8', mode: 0o600 });
+        await fs.rename(tempPath, targetPath);
+    }
+    catch (error) {
+        const fsError = error;
+        try {
+            if (existsSync(tempPath))
+                await fs.unlink(tempPath);
+        }
+        catch (_) { }
+        throw new Error(`Failed to save config to ${targetPath}: ${fsError.message}`);
+    }
+}
+function mergeWithDefaults(loaded) {
+    const loadedRecord = (typeof loaded === 'object' && loaded !== null
+        ? loaded
+        : {});
+    const config = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+    if (!loadedRecord)
+        return config;
+    const runtime = loadedRecord.runtime;
+    const models = loadedRecord.models;
+    const messaging = loadedRecord.messaging;
+    const storage = loadedRecord.storage;
+    const integration = loadedRecord.integration;
+    const tools = loadedRecord.tools;
+    if (runtime)
+        config.runtime = { ...config.runtime, ...runtime };
+    if (models)
+        config.models = { ...config.models, ...models };
+    if (messaging) {
+        const telegram = messaging.telegram;
+        const whatsapp = messaging.whatsapp;
+        const voice = messaging.voice;
+        const inbound = messaging.inbound;
+        const streaming = messaging.streaming;
+        if (telegram)
+            config.messaging.telegram = { ...config.messaging.telegram, ...telegram };
+        if (whatsapp)
+            config.messaging.whatsapp = { ...config.messaging.whatsapp, ...whatsapp };
+        if (voice)
+            config.messaging.voice = { ...config.messaging.voice, ...voice };
+        if (inbound)
+            config.messaging.inbound = { ...config.messaging.inbound, ...inbound };
+        if (streaming)
+            config.messaging.streaming = { ...config.messaging.streaming, ...streaming };
+    }
+    if (storage)
+        config.storage = { ...config.storage, ...storage };
+    if (integration)
+        config.integration = { ...config.integration, ...integration };
+    if (tools) {
+        config.tools = {
+            allow: Array.isArray(tools.allow)
+                ? tools.allow.filter((value) => typeof value === 'string')
+                : config.tools.allow,
+            deny: Array.isArray(tools.deny)
+                ? tools.deny.filter((value) => typeof value === 'string')
+                : config.tools.deny,
+        };
+    }
+    return config;
+}
+// ── Legacy Flat KV Adapter ──────────────────────────────────────────────────
+let cachedConfig = null;
+const legacyWarningEmitted = new Set();
+export function clearConfigCacheForTests() {
+    cachedConfig = null;
+    legacyWarningEmitted.clear();
+}
+export function reloadConfigSync() {
+    const configPath = getConfigPath();
+    try {
+        if (existsSync(configPath)) {
+            const content = readFileSync(configPath, 'utf8');
+            cachedConfig = mergeWithDefaults(JSON.parse(content));
+            return;
+        }
+    }
+    catch (error) {
+        console.error(`[TwinBot Config] Failed to parse JSON config at ${configPath}:`, error);
+    }
+    cachedConfig = mergeWithDefaults({});
+}
+/**
+ * Gets a configured value either from `twinbot.json` (mapped) or `process.env`.
+ */
+export function getConfigValue(key, sensitive = false) {
+    if (cachedConfig === null) {
+        reloadConfigSync();
+    }
+    const config = cachedConfig;
+    let jsonValue = undefined;
+    switch (key) {
+        case 'API_SECRET':
+            jsonValue = config.runtime.apiSecret;
+            break;
+        case 'API_PORT':
+            jsonValue = config.runtime.apiPort;
+            break;
+        case 'SECRET_VAULT_REQUIRED':
+            jsonValue = config.runtime.secretVaultRequired?.join(',');
+            break;
+        case 'LOCAL_STATE_SNAPSHOT_CRON':
+            jsonValue = config.runtime.localStateSnapshotCron;
+            break;
+        case 'INCIDENT_POLL_CRON':
+            jsonValue = config.runtime.incidentPollCron;
+            break;
+        case 'HEARTBEAT_CRON':
+            jsonValue = config.runtime.heartbeatCron;
+            break;
+        case 'HEARTBEAT_MESSAGE':
+            jsonValue = config.runtime.heartbeatMessage;
+            break;
+        case 'MODAL_API_KEY':
+            jsonValue = config.models.modalApiKey;
+            break;
+        case 'OPENROUTER_API_KEY':
+            jsonValue = config.models.openRouterApiKey;
+            break;
+        case 'GEMINI_API_KEY':
+            jsonValue = config.models.geminiApiKey;
+            break;
+        case 'TELEGRAM_BOT_TOKEN':
+            jsonValue = config.messaging.telegram.botToken;
+            break;
+        case 'TELEGRAM_USER_ID':
+            jsonValue = config.messaging.telegram.userId;
+            break;
+        case 'WHATSAPP_PHONE_NUMBER':
+            jsonValue = config.messaging.whatsapp.phoneNumber;
+            break;
+        case 'GROQ_API_KEY':
+            jsonValue = config.messaging.voice.groqApiKey;
+            break;
+        case 'MEMORY_EMBEDDING_DIM':
+            jsonValue = config.storage.embeddingDim;
+            break;
+        case 'EMBEDDING_PROVIDER':
+            jsonValue = config.integration.embeddingProvider;
+            break;
+        case 'EMBEDDING_API_KEY':
+            jsonValue = config.integration.embeddingApiKey;
+            break;
+        case 'OPENAI_API_KEY':
+            jsonValue = config.integration.openaiApiKey;
+            break;
+        case 'EMBEDDING_API_URL':
+            jsonValue = config.integration.embeddingApiUrl;
+            break;
+        case 'EMBEDDING_MODEL':
+            jsonValue = config.integration.embeddingModel;
+            break;
+        case 'OLLAMA_BASE_URL':
+            jsonValue = config.integration.ollamaBaseUrl;
+            break;
+        case 'OLLAMA_EMBEDDING_MODEL':
+            jsonValue = config.integration.ollamaEmbeddingModel;
+            break;
+        case 'TOOLS_ALLOW':
+            jsonValue = config.tools.allow?.join(',');
+            break;
+        case 'TOOLS_DENY':
+            jsonValue = config.tools.deny?.join(',');
+            break;
+        case 'INBOUND_DEBOUNCE_ENABLED':
+            jsonValue = config.messaging.inbound.enabled;
+            break;
+        case 'INBOUND_DEBOUNCE_MS':
+            jsonValue = config.messaging.inbound.debounceMs;
+            break;
+        case 'BLOCK_STREAMING_DEFAULT':
+            jsonValue = config.messaging.streaming.blockStreamingDefault;
+            break;
+        case 'BLOCK_STREAMING_BREAK':
+            jsonValue = config.messaging.streaming.blockStreamingBreak;
+            break;
+        case 'BLOCK_STREAMING_MIN_CHARS':
+            jsonValue = config.messaging.streaming.blockStreamingMinChars;
+            break;
+        case 'BLOCK_STREAMING_MAX_CHARS':
+            jsonValue = config.messaging.streaming.blockStreamingMaxChars;
+            break;
+        case 'BLOCK_STREAMING_COALESCE':
+            jsonValue = config.messaging.streaming.blockStreamingCoalesce;
+            break;
+        case 'HUMAN_DELAY_MS':
+            jsonValue = config.messaging.streaming.humanDelayMs;
+            break;
+    }
+    // 1. Process explicit environment variables that act as overrides
+    if (isAllowedOverride(key) && process.env[key] !== undefined && String(process.env[key]).trim() !== '') {
+        return String(process.env[key]);
+    }
+    // 2. Return the parsed config value (which merges twinbot.json with defaults)
+    if (jsonValue !== undefined && jsonValue !== null && String(jsonValue).trim() !== '') {
+        return String(jsonValue);
+    }
+    // 3. Fallback to process.env for legacy non-overrides, emitting a deprecation warning
+    const envValue = process.env[key];
+    if (envValue !== undefined && envValue !== null && String(envValue).trim() !== '') {
+        if (!sensitive && !legacyWarningEmitted.has(key)) {
+            console.warn(`[TwinBot Config Migration] Deprecation Warning: Loaded configuration key '${key}' from process.env (or .env). Please re-run 'twinbot onboard' or generate a twinbot.json file.`);
+            legacyWarningEmitted.add(key);
+        }
+        return String(envValue);
+    }
+    return undefined;
+}
+function isAllowedOverride(key) {
+    return [
+        'TWINBOT_CONFIG_PATH',
+        'TWINBOT_PROFILE',
+        'TWINCLAW_CONFIG_PATH',
+        'TWINCLAW_PROFILE',
+        'RUNTIME_BUDGET_DEFAULT_PROFILE',
+        'RUNTIME_BUDGET_PREFER_LOCAL_MODEL',
+        'RUNTIME_BUDGET_LOCAL_MODEL_ID',
+        'API_PORT',
+        'LOCAL_STATE_SNAPSHOT_CRON',
+        'INCIDENT_POLL_CRON',
+        'TOOLS_ALLOW',
+        'TOOLS_DENY',
+        'NODE_ENV',
+        'SECRET_VAULT_MASTER_KEY',
+        'API_SECRET',
+        'MODEL_ROUTING_FALLBACK_MODE'
+    ].includes(key);
+}
+let migrationPerformed = false;
+export function checkAndMigrateWorkspace() {
+    if (migrationPerformed) {
+        return { migrated: false, sourcePath: null, targetPath: null };
+    }
+    migrationPerformed = true;
+    if (hasLegacyConfig()) {
+        console.log('[TwinBot] Detected legacy ~/.twinbot configuration. Migrating to workspace structure...');
+        const result = migrateLegacyConfig();
+        if (result.migrated) {
+            console.log(`[TwinBot] Successfully migrated config to ${result.targetPath}`);
+        }
+        else if (result.error) {
+            console.error(`[TwinBot] Migration failed: ${result.error}`);
+        }
+        return result;
+    }
+    return { migrated: false, sourcePath: null, targetPath: null };
+}
+export { hasLegacyConfig, migrateLegacyConfig };