@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/services/local-ai-core/src/runtime/deployment-diagnostics.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDeploymentDiagnostics = runDeploymentDiagnostics;
+const node_fs_1 = require("node:fs");
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+const sandbox_config_js_1 = require("../sandbox/sandbox-config.js");
+async function runDeploymentDiagnostics(input) {
+    const env = input.env || process.env;
+    const checkedAt = new Date().toISOString();
+    const config = input.config || {};
+    const profile = (0, index_js_1.getDesktopDeploymentProfile)(String(config.deployment_profile || env.AGENTDOCK_DEPLOYMENT_PROFILE || '').trim());
+    const provider = Array.isArray(config.sandbox_providers)
+        ? config.sandbox_providers.find((item) => item.id === profile.defaultSandboxProviderId) || config.sandbox_providers[0]
+        : undefined;
+    const sandboxProvider = provider || (0, index_js_1.defaultSandboxProviderForProfile)(profile.id);
+    const opensandboxUrl = normalizeUrl(sandboxProvider.server_url || env.AGENTDOCK_OPENSANDBOX_SERVER_URL || (0, sandbox_config_js_1.defaultOpenSandboxServerUrl)(env));
+    const checks = [
+        {
+            id: 'deployment.profile',
+            label: 'Deployment profile',
+            status: 'pass',
+            summary: `${profile.label} uses OpenSandbox at ${opensandboxUrl || 'not configured'}.`,
+        },
+        {
+            id: 'core.bind-host',
+            label: 'Core bind host',
+            status: profile.id === 'docker-compose' && env.AI_WORKSTATION_HOST !== '0.0.0.0' ? 'warn' : 'pass',
+            summary: `AI_WORKSTATION_HOST=${env.AI_WORKSTATION_HOST || '127.0.0.1'}.`,
+        },
+        dockerSocketCheck(profile.id),
+        workspacePathCheck(config, profile.id),
+        allowlistCheck(config, env),
+        sandboxImageCheck(config),
+        await opensandboxHealthCheck(opensandboxUrl, sandboxProvider.api_key_env, env),
+    ];
+    return {
+        status: summarizeStatus(checks),
+        checkedAt,
+        checks,
+    };
+}
+function dockerSocketCheck(profileId) {
+    if (profileId === 'docker-compose') {
+        return {
+            id: 'docker.socket',
+            label: 'Docker socket',
+            status: 'pass',
+            summary: 'Docker Compose delegates Docker access to OpenSandbox.',
+        };
+    }
+    const socketPath = '/var/run/docker.sock';
+    const ok = (0, node_fs_1.existsSync)(socketPath);
+    return {
+        id: 'docker.socket',
+        label: 'Docker socket',
+        status: ok ? 'pass' : 'warn',
+        summary: ok ? `${socketPath} is available.` : `${socketPath} is not visible to Core.`,
+    };
+}
+function workspacePathCheck(config, profileId) {
+    const projects = Array.isArray(config.projects) ? config.projects : [];
+    const missing = projects
+        .map((project) => ({
+        name: project.name,
+        workDir: String(project.agent?.options?.work_dir || '').trim(),
+        sandboxEnabled: Boolean(project.agent?.options?.sandbox?.enabled),
+    }))
+        .filter((project) => !(profileId === 'docker-compose' && project.sandboxEnabled))
+        .filter((project) => project.workDir && !(0, node_fs_1.existsSync)(project.workDir));
+    if (missing.length > 0) {
+        return {
+            id: 'workspace.paths',
+            label: 'Workspace paths',
+            status: 'warn',
+            summary: `${missing.length} configured workspace path(s) are not visible to Core.`,
+        };
+    }
+    if (profileId === 'docker-compose' && projects.some((project) => project.agent?.options?.sandbox?.enabled)) {
+        return {
+            id: 'workspace.paths',
+            label: 'Workspace paths',
+            status: 'pass',
+            summary: 'Sandbox workspace host paths are delegated to OpenSandbox.',
+        };
+    }
+    return {
+        id: 'workspace.paths',
+        label: 'Workspace paths',
+        status: 'pass',
+        summary: projects.length > 0 ? `${projects.length} workspace path(s) checked.` : 'No projects configured.',
+    };
+}
+function allowlistCheck(config, env) {
+    const allowlist = String(env.OPEN_SANDBOX_HOST_MOUNT_ALLOWLIST || '')
+        .split(',')
+        .map((item) => item.trim().replace(/\/+$/, ''))
+        .filter(Boolean);
+    if (allowlist.length === 0) {
+        return {
+            id: 'opensandbox.allowlist',
+            label: 'OpenSandbox mount allowlist',
+            status: 'warn',
+            summary: 'OPEN_SANDBOX_HOST_MOUNT_ALLOWLIST is not set.',
+        };
+    }
+    const projects = Array.isArray(config.projects) ? config.projects : [];
+    const denied = projects.filter((project) => {
+        const workDir = String(project.agent?.options?.work_dir || '').trim().replace(/\/+$/, '');
+        return workDir && !allowlist.some((root) => workDir === root || workDir.startsWith(`${root}/`));
+    });
+    return {
+        id: 'opensandbox.allowlist',
+        label: 'OpenSandbox mount allowlist',
+        status: denied.length > 0 ? 'warn' : 'pass',
+        summary: denied.length > 0
+            ? `${denied.length} project workspace path(s) are outside the allowlist.`
+            : `Allowlist covers configured workspace paths: ${allowlist.join(', ')}.`,
+    };
+}
+function sandboxImageCheck(config) {
+    const images = Array.isArray(config.sandbox_runtime_images) ? config.sandbox_runtime_images : [];
+    const missing = images.filter((image) => !String(image.image || '').trim());
+    return {
+        id: 'sandbox.images',
+        label: 'Sandbox images',
+        status: missing.length > 0 ? 'fail' : 'pass',
+        summary: images.length > 0 ? `${images.length} sandbox image registration(s) configured.` : 'No sandbox image registrations configured.',
+    };
+}
+async function opensandboxHealthCheck(serverUrl, apiKeyEnv, env) {
+    if (!serverUrl) {
+        return {
+            id: 'opensandbox.health',
+            label: 'OpenSandbox health',
+            status: 'fail',
+            summary: 'OpenSandbox server URL is empty.',
+        };
+    }
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 3000);
+        const apiKey = apiKeyEnv ? env[apiKeyEnv] : undefined;
+        const response = await fetch(`${serverUrl}/health`, {
+            signal: controller.signal,
+            headers: apiKey ? { authorization: `Bearer ${apiKey}` } : undefined,
+        });
+        clearTimeout(timer);
+        return {
+            id: 'opensandbox.health',
+            label: 'OpenSandbox health',
+            status: response.ok ? 'pass' : 'fail',
+            summary: `GET ${serverUrl}/health returned HTTP ${response.status}.`,
+        };
+    }
+    catch (error) {
+        return {
+            id: 'opensandbox.health',
+            label: 'OpenSandbox health',
+            status: 'fail',
+            summary: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function normalizeUrl(value) {
+    return String(value || '').trim().replace(/\/+$/, '');
+}
+function summarizeStatus(checks) {
+    if (checks.some((check) => check.status === 'fail')) {
+        return 'fail';
+    }
+    if (checks.some((check) => check.status === 'warn')) {
+        return 'warn';
+    }
+    return 'pass';
+}

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreController = void 0;
 const node_events_1 = require("node:events");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../shared/desktop.js");
 const bootstrap_js_1 = require("../kernel/bootstrap.js");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 const runtime_detection_service_js_1 = require("./runtime-detection-service.js");
+const provider_config_migration_js_1 = require("./provider-config-migration.js");
+const deployment_diagnostics_js_1 = require("./deployment-diagnostics.js");
 class LocalCoreController extends node_events_1.EventEmitter {
     userDataPath;
     state;
@@ -13,9 +19,11 @@ class LocalCoreController extends node_events_1.EventEmitter {
     channelRuntimes;
     scheduledJobs;
     automationMonitors;
+    store;
     kernel;
     runtime;
     runtimeDetection;
+    errorReporter;
     busUnsubscribers = [];
     pendingLogs = [];
     handlingLog = false;
@@ -28,6 +36,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
             log: (message) => this.handleLog(message),
         });
         this.state = this.runtime.state;
+        this.store = this.runtime.store;
         this.kernel = this.runtime.kernel;
         this.knowledgeProvider = this.runtime.knowledgeProvider;
         this.workspaceRouter = this.runtime.workspaceRouter;
@@ -43,6 +52,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
             runMonitorNow: async () => { throw new Error('Automation monitor service is not available.'); },
             listRuns: () => [],
         };
+        this.errorReporter = new local_core_errors_js_1.LocalCoreErrorReporter((message) => this.handleLog(message));
         this.runtimeDetection = new runtime_detection_service_js_1.RuntimeDetectionService({
             userDataPath,
             readConfig: async () => (await this.readConfigFile()).parsed,
@@ -64,12 +74,20 @@ class LocalCoreController extends node_events_1.EventEmitter {
             this.emit('automation-monitor-run', run);
         }), this.kernel.context.bus.on('runtime.state.changed', () => {
             void this.emitRuntime();
+        }), this.kernel.context.bus.on('localcore.error', (event) => {
+            const errorInfo = this.errorReporter.report(String(event.scope || 'local-ai-core'), event.errorInfo || event.error || 'Unknown error', event.context || {});
+            const runtimeId = String(event.context?.runtimeId || event.context?.agentType || '').trim();
+            if (runtimeId) {
+                this.runtimeDetection.recordLaunchError(runtimeId, errorInfo);
+            }
         }));
     }
     async init() {
         await this.runtime.start();
         await this.emitRuntime();
-        void this.runtimeDetection.refreshOnStartup();
+        setTimeout(() => {
+            void this.runtimeDetection.refreshOnStartup();
+        }, 5000);
     }
     async close() {
         for (const unsubscribe of this.busUnsubscribers) {
@@ -125,7 +143,7 @@ class LocalCoreController extends node_events_1.EventEmitter {
         return this.state.getLogEntries(level, limit);
     }
     async readConfigFile() {
-        return this.state.readConfigFile();
+        return this.readAndMigrateConfigFile();
     }
     async saveRawConfigFile(raw) {
         const next = await this.state.saveRawConfigFile(raw);
@@ -134,17 +152,228 @@ class LocalCoreController extends node_events_1.EventEmitter {
         return next;
     }
     async saveStructuredConfigFile(config) {
-        const next = await this.state.saveStructuredConfigFile(config);
+        const migrated = (0, provider_config_migration_js_1.migrateLegacyProjectProvidersToStore)(config, this.store);
+        const next = await this.state.saveStructuredConfigFile(migrated.config);
         await this.refreshChannelBindings();
         await this.emitRuntime();
         return next;
     }
+    async listModelProviders() {
+        return { providers: this.store.listModelProviders() };
+    }
+    async createModelProvider(input) {
+        return this.store.upsertModelProvider(input);
+    }
+    async updateModelProvider(providerId, input) {
+        const existing = this.store.getModelProvider(providerId);
+        if (!existing) {
+            throw new Error(`Provider not found: ${providerId}`);
+        }
+        return this.store.upsertModelProvider({ ...input, id: providerId });
+    }
+    async deleteModelProvider(providerId) {
+        const config = await this.readAndMigrateConfigFile();
+        const referencingProjects = (config.parsed?.projects || [])
+            .filter((project) => project.agent?.options?.provider_id === providerId)
+            .map((project) => project.name);
+        if (referencingProjects.length > 0) {
+            throw new Error(`Provider "${providerId}" is still used by projects: ${referencingProjects.join(', ')}`);
+        }
+        return this.store.deleteModelProvider(providerId);
+    }
     async saveSettings(input) {
         const settings = await this.state.saveSettings(input);
         await this.refreshChannelBindings();
         await this.emitRuntime();
         return settings;
     }
+    async ensureExternalProject(input) {
+        const userId = normalizeExternalId(input.user_id, 'user_id');
+        const externalProjectId = normalizeExternalId(input.external_project_id, 'external_project_id');
+        const agentType = normalizeExternalSegment(input.agent_type || 'pi', 'pi');
+        const existing = this.store.getExternalProject(userId, externalProjectId);
+        const provider = this.resolveExternalProvider(input.provider_id || existing?.providerId);
+        const workspaceId = externalWorkspaceId(userId, externalProjectId);
+        const workspacePath = this.externalProjectBasePath(userId, externalProjectId);
+        const displayName = String(input.display_name || externalProjectId).trim() || externalProjectId;
+        (0, node_fs_1.mkdirSync)(workspacePath, { recursive: true, mode: 0o700 });
+        const now = new Date().toISOString();
+        const project = this.store.upsertExternalProject({
+            userId,
+            externalProjectId,
+            workspaceId,
+            workspacePath,
+            displayName,
+            agentType,
+            providerId: provider.id,
+            metadata: input.metadata || existing?.metadata || {},
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+        });
+        await this.ensureExternalWorkspaceConfig(project, input.model);
+        this.store.upsertWorkspaceRegistryEntry({
+            workspaceId: project.workspaceId,
+            displayName: project.displayName,
+            path: project.workspacePath,
+            deviceId: 'external',
+            defaultRuntimeId: project.agentType,
+            health: { status: 'healthy', summary: 'External workspace is available.', issues: [], checkedAt: now },
+            metadata: {
+                external: true,
+                userId: project.userId,
+                externalProjectId: project.externalProjectId,
+            },
+        });
+        return project;
+    }
+    async createExternalRun(input) {
+        if (!String(input.prompt || '').trim()) {
+            throw new Error('prompt is required.');
+        }
+        const project = await this.ensureExternalProject(input);
+        const thread = await this.ensureExternalThread(project, input);
+        const sent = await this.workspaceRouter.sendThreadMessage(thread.threadId, input.prompt, {
+            permissionMode: input.permission_mode,
+            runtimeEnv: input.runtime_env,
+        });
+        const task = this.store.getAgentTaskByRunId(sent.runId);
+        return {
+            project,
+            thread,
+            workspace_id: project.workspaceId,
+            thread_id: thread.threadId,
+            run_id: sent.runId,
+            task_id: task?.taskId,
+            events_url: `/api/local/v1/external/runs/${encodeURIComponent(sent.runId)}/events`,
+        };
+    }
+    async getExternalRunSnapshot(runId) {
+        const task = this.store.getAgentTaskByRunId(runId);
+        const run = this.store.getRun(runId);
+        const threadId = task?.threadId || run?.thread_id || '';
+        const thread = threadId
+            ? await this.workspaceRouter.getThread(threadId).catch(() => undefined)
+            : undefined;
+        return {
+            runId,
+            task,
+            thread,
+        };
+    }
+    async readAndMigrateConfigFile() {
+        const current = await this.state.readConfigFile();
+        if (!current.parsed) {
+            return current;
+        }
+        const migrated = (0, provider_config_migration_js_1.migrateLegacyProjectProvidersToStore)(current.parsed, this.store);
+        if (!migrated.changed) {
+            return current;
+        }
+        const saved = await this.state.saveStructuredConfigFile(migrated.config);
+        return {
+            ...saved,
+            warnings: [
+                ...(current.warnings || []),
+                ...(saved.warnings || []),
+                ...migrated.warnings,
+            ],
+        };
+    }
+    resolveExternalProvider(providerId) {
+        const requested = String(providerId || '').trim();
+        if (requested) {
+            const provider = this.store.getModelProvider(requested);
+            if (!provider) {
+                throw new Error(`Provider not found: ${requested}`);
+            }
+            return provider;
+        }
+        const provider = this.store.listModelProviders()[0];
+        if (!provider) {
+            throw new Error('No model provider is configured. Create a provider before starting an external run.');
+        }
+        return provider;
+    }
+    async ensureExternalWorkspaceConfig(project, model) {
+        const current = await this.readAndMigrateConfigFile();
+        const config = {
+            ...(current.parsed || {}),
+            projects: Array.isArray(current.parsed?.projects) ? [...current.parsed.projects] : [],
+        };
+        const existingIndex = config.projects.findIndex((item) => item?.name === project.workspaceId);
+        const existing = existingIndex >= 0 ? config.projects[existingIndex] : undefined;
+        const defaultRuntimeImageId = Array.isArray(config.sandbox_runtime_images)
+            ? config.sandbox_runtime_images.find((image) => image?.agent_type === project.agentType)?.id
+            : undefined;
+        const options = {
+            ...(existing?.agent?.options || {}),
+            work_dir: project.workspacePath,
+            user_id: project.userId,
+            provider_id: project.providerId,
+            ...(model ? { model } : {}),
+            sandbox: {
+                ...(existing?.agent?.options?.sandbox || {}),
+                enabled: true,
+                ...(defaultRuntimeImageId ? { runtime_image_id: defaultRuntimeImageId } : {}),
+                state_scope: 'project',
+                sandbox_lifecycle: 'per_thread',
+            },
+        };
+        const nextProject = {
+            name: project.workspaceId,
+            agent: {
+                ...(existing?.agent || {}),
+                type: project.agentType,
+                options,
+            },
+            platforms: Array.isArray(existing?.platforms) ? existing.platforms : [],
+            admin_from: existing?.admin_from,
+            disabled_commands: existing?.disabled_commands,
+        };
+        if (existingIndex >= 0) {
+            config.projects[existingIndex] = nextProject;
+        }
+        else {
+            config.projects.push(nextProject);
+        }
+        await this.saveStructuredConfigFile(config);
+    }
+    async ensureExternalThread(project, input) {
+        const externalThreadId = normalizeExternalId(input.external_thread_id || `thread-${(0, node_crypto_1.randomUUID)()}`, 'external_thread_id');
+        const existing = this.store.getExternalThread(project.userId, project.externalProjectId, externalThreadId);
+        if (existing) {
+            const thread = await this.workspaceRouter.getThread(existing.threadId).catch(() => undefined);
+            if (thread) {
+                return existing;
+            }
+        }
+        const workspacePath = this.externalThreadWorkspacePath(project.userId, project.externalProjectId, externalThreadId);
+        (0, node_fs_1.mkdirSync)(workspacePath, { recursive: true, mode: 0o700 });
+        const title = String(input.title || externalThreadId).trim() || externalThreadId;
+        const thread = await this.workspaceRouter.createThread(project.workspaceId, title);
+        const now = new Date().toISOString();
+        return this.store.upsertExternalThread({
+            userId: project.userId,
+            externalProjectId: project.externalProjectId,
+            externalThreadId,
+            workspaceId: project.workspaceId,
+            threadId: thread.id,
+            workspacePath,
+            metadata: input.metadata || {},
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+    externalProjectBasePath(userId, externalProjectId) {
+        return (0, node_path_1.join)(this.externalWorkspaceRoot(), 'users', normalizeExternalSegment(userId, 'user'), 'projects', normalizeExternalSegment(externalProjectId, 'project'));
+    }
+    externalThreadWorkspacePath(userId, externalProjectId, externalThreadId) {
+        return (0, node_path_1.join)(this.externalProjectBasePath(userId, externalProjectId), 'threads', normalizeExternalSegment(externalThreadId, 'thread'), 'workspace');
+    }
+    externalWorkspaceRoot() {
+        return String(process.env.AGENTDOCK_EXTERNAL_WORKSPACE_ROOT || '').trim()
+            || (0, node_path_1.join)(this.userDataPath, 'external-workspaces');
+    }
     async listWorkspaces() {
         return this.workspaceRouter.listWorkspaces();
     }
@@ -342,6 +571,77 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async getPluginDiagnostics() {
         return this.kernel.diagnostics.snapshot();
     }
+    async listDiagnosticErrors() {
+        return this.errorReporter.list();
+    }
+    async runDiagnosticsDoctor() {
+        const checkedAt = new Date().toISOString();
+        const configFile = await this.readConfigFile();
+        const runtimeChecks = await this.refreshInstalledAgentRuntimes().catch((error) => {
+            const errorInfo = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error, 'internal_error');
+            return [{
+                    agentType: 'runtime',
+                    runtimeId: 'runtime',
+                    displayName: 'Runtime Detection',
+                    status: 'error',
+                    installed: false,
+                    detectedAt: checkedAt,
+                    summary: errorInfo.userMessage,
+                    issues: [{ code: errorInfo.code, severity: errorInfo.severity, message: errorInfo.message, help: errorInfo.suggestedAction }],
+                    recommendedActions: errorInfo.suggestedAction ? [{ label: 'Fix runtime detection', description: errorInfo.suggestedAction }] : [],
+                    source: 'path',
+                    error: errorInfo.message,
+                    readiness: 'failed',
+                    lastLaunchError: errorInfo,
+                }];
+        });
+        const channelStatuses = await this.listChannelGatewayStatuses().catch(() => []);
+        const checks = [
+            configFile.error
+                ? {
+                    id: 'config',
+                    label: 'Configuration',
+                    status: 'fail',
+                    summary: configFile.error,
+                    errorInfo: new local_core_errors_js_1.LocalCoreError('config_invalid', configFile.error).info,
+                }
+                : {
+                    id: 'config',
+                    label: 'Configuration',
+                    status: configFile.exists ? 'pass' : 'warn',
+                    summary: configFile.exists ? 'Configuration file is readable.' : 'Configuration file has not been created yet.',
+                },
+            {
+                id: 'runtime-detection',
+                label: 'Runtime Detection',
+                status: runtimeChecks.some((runtime) => runtime.status === 'error') ? 'fail' : 'pass',
+                summary: `${runtimeChecks.length} runtime(s) checked.`,
+            },
+            {
+                id: 'channels',
+                label: 'Channel Gateways',
+                status: channelStatuses.some((status) => status.status === 'error') ? 'warn' : 'pass',
+                summary: `${channelStatuses.length} channel gateway status record(s) checked.`,
+                errorInfo: channelStatuses.find((status) => status.lastErrorInfo)?.lastErrorInfo,
+            },
+            {
+                id: 'logs',
+                label: 'Logs',
+                status: 'pass',
+                summary: 'Local AI Core log reader is available.',
+            },
+        ];
+        const status = checks.some((check) => check.status === 'fail')
+            ? 'fail'
+            : checks.some((check) => check.status === 'warn')
+                ? 'warn'
+                : 'pass';
+        return { status, checkedAt, checks };
+    }
+    async runDeploymentDiagnostics() {
+        const configFile = await this.readConfigFile();
+        return (0, deployment_diagnostics_js_1.runDeploymentDiagnostics)({ config: configFile.parsed });
+    }
     async probeWorkspaceStreaming(workspaceId) {
         return this.workspaceRouter.probeWorkspaceStreaming(workspaceId);
     }
@@ -529,3 +829,30 @@ class LocalCoreController extends node_events_1.EventEmitter {
     }
 }
 exports.LocalCoreController = LocalCoreController;
+function normalizeExternalId(value, label) {
+    const normalized = String(value || '').trim();
+    if (!normalized) {
+        throw new Error(`${label} is required.`);
+    }
+    return normalized;
+}
+function normalizeExternalSegment(value, fallback) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        || fallback;
+}
+function externalWorkspaceId(userId, externalProjectId) {
+    const base = [
+        'external',
+        normalizeExternalSegment(userId, 'user'),
+        normalizeExternalSegment(externalProjectId, 'project'),
+    ].join('-');
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update(`${userId}\0${externalProjectId}`)
+        .digest('hex')
+        .slice(0, 8);
+    return `${base}-${digest}`;
+}

package/dist-electron/services/local-ai-core/src/runtime/local-core-runtime-state.js

@@ -38,6 +38,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const TOML = __importStar(require("@iarna/toml"));
 const rotating_logger_js_1 = require("../kernel/rotating-logger.js");
+const config_migration_js_1 = require("./config-migration.js");
 const DEFAULT_CONFIG = `# Managed by Local AI Core
 # Add [[projects]] entries from the workspace page before starting a conversation.
 `;
@@ -140,7 +141,14 @@ class FileBackedLocalCoreRuntimeState {
         const raw = (0, node_fs_1.readFileSync)(path, 'utf8');
         try {
             const parsed = TOML.parse(raw);
-            return { path, exists: true, raw, parsed };
+            const migrated = (0, config_migration_js_1.migrateDesktopConnectConfig)(parsed);
+            return {
+                path,
+                exists: true,
+                raw,
+                parsed: migrated.config,
+                warnings: migrated.warnings.length > 0 ? migrated.warnings : undefined,
+            };
         }
         catch (error) {
             return {
@@ -158,8 +166,9 @@ class FileBackedLocalCoreRuntimeState {
         return this.readConfigFile();
     }
     async saveStructuredConfigFile(config) {
+        const migrated = (0, config_migration_js_1.migrateDesktopConnectConfig)(config);
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.settings.configPath), { recursive: true });
-        (0, node_fs_1.writeFileSync)(this.settings.configPath, TOML.stringify(config), 'utf8');
+        (0, node_fs_1.writeFileSync)(this.settings.configPath, TOML.stringify(migrated.config), 'utf8');
         return this.readConfigFile();
     }
     loadSettings() {

package/dist-electron/services/local-ai-core/src/runtime/provider-config-migration.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateLegacyProjectProvidersToStore = migrateLegacyProjectProvidersToStore;
+const config_migration_js_1 = require("./config-migration.js");
+function migrateLegacyProjectProvidersToStore(input, store) {
+    const config = cloneConfig(input);
+    const warnings = [];
+    let changed = false;
+    for (const project of Array.isArray(config.projects) ? config.projects : []) {
+        const legacyProviders = Array.isArray(project.agent?.providers) ? project.agent.providers : [];
+        if (legacyProviders.length === 0) {
+            continue;
+        }
+        project.agent ||= { type: 'pi', options: {}, providers: [] };
+        project.agent.options ||= {};
+        const migratedProviderIds = [];
+        for (const provider of legacyProviders) {
+            const migrated = store.upsertModelProvider((0, config_migration_js_1.normalizeDesktopProviderForStorage)(provider));
+            migratedProviderIds.push(migrated.id);
+        }
+        if (!project.agent.options.provider_id && migratedProviderIds[0]) {
+            project.agent.options.provider_id = migratedProviderIds[0];
+        }
+        delete project.agent.providers;
+        warnings.push(`Project "${project.name}" migrated embedded providers to shared providers.`);
+        changed = true;
+    }
+    return { config, changed, warnings };
+}
+function cloneConfig(input) {
+    return JSON.parse(JSON.stringify(input || {}));
+}