iobroker.javascript 10.3.0 → 10.4.1

package/build/main.js

@@ -4,7 +4,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2014-2024 bluefox <dogafox@gmail.com>,
+ * Copyright (c) 2014-2026 bluefox <dogafox@gmail.com>,
  *
  * Copyright (c) 2014      hobbyquaker
  */
@@ -80,8 +80,9 @@ const words_1 = require("./lib/words");
 const sandbox_1 = require("./lib/sandbox");
 const nodeModulesManagement_1 = require("./lib/nodeModulesManagement");
 const secrets_1 = require("./lib/secrets");
-const aiProviderResolver_1 = require("./lib/aiProviderResolver");
-const anthropicAdapter_1 = require("./lib/anthropicAdapter");
+const ai_core_1 = require("@iobroker/ai-core");
+const ai_1 = require("./lib/ai");
+const scriptHistory_1 = require("./lib/scriptHistory");
 const eventObj_1 = require("./lib/eventObj");
 const scheduler_1 = require("./lib/scheduler");
 const typescriptSettings_1 = require("./lib/typescriptSettings");
@@ -251,33 +252,6 @@ const jsDeclarationServer = new lazyTsServer_1.LazyTsServer(typescriptSettings_1
  * Stores the IDs of script objects whose change should be ignored because
  * the compiled source was just updated
  */
-const HTTP_STATUS_TEXTS = {
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Not Found',
-    429: 'Too Many Requests / Rate Limit',
-    500: 'Internal Server Error',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-};
-function httpStatusText(code) {
-    return HTTP_STATUS_TEXTS[code] ?? `Error ${code}`;
-}
-/**
- * Resolves the correct http/https module based on the URL string.
- * Returns null if the URL is invalid.
- */
-function resolveRequestModule(url) {
-    try {
-        const { protocol } = new URL(url);
-        const isHttps = protocol === 'https:';
-        return { module: isHttps ? https : http, isHttps };
-    }
-    catch {
-        return null;
-    }
-}
 class JavaScript extends adapter_core_1.Adapter {
     context;
     errorLogFunction = {
@@ -340,14 +314,11 @@ class JavaScript extends adapter_core_1.Adapter {
     mirror;
     stopCounters = {};
     setStateCountCheckInterval = null;
-    /**
-     * Decrypted AI API keys cached from the central credential store (manager mode),
-     * keyed by credential ID (e.g. `system.credentials.anthropic`). Kept fresh by the
-     * subscriptions set up in `subscribeAiCredentials`.
-     */
-    aiCredentialCache = new Map();
-    /** Unsubscribe callbacks for the AI credential subscriptions (manager mode). */
-    aiCredentialUnsubscribers = [];
+    /** Providers, keys and the push of long answers for the AI of the script editor */
+    ai = new ai_core_1.AiBackend(this, {
+        getSettings: () => (0, ai_1.jsAiSettings)(this.config),
+        aliases: ai_1.JS_AI_ALIASES,
+    });
     /**
      * Decrypted credentials of the central ioBroker credential store (`system.credentials.*`),
      * exposed to the scripts as the global `SECRETS` object. Kept up to date by `onObjectChange`.
@@ -391,6 +362,16 @@ class JavaScript extends adapter_core_1.Adapter {
             ...options,
             name: 'javascript', // adapter name
             useFormatDate: true,
+            /*
+             * The script editor subscribes here so that a finished AI answer can be *pushed* to it.
+             * An AI request regularly runs longer than 30 s, and `@iobroker/ws` answers every socket
+             * callback with the string "timeout" after exactly that (socket.io.js: `Date.now() + 30_000`,
+             * not configurable). The answer then arrived in a dead callback and the chat stayed empty
+             * with nothing in any log. So the editor gets an immediate acknowledgement and the result
+             * later as an instance message.
+             */
+            uiClientSubscribe: (info) => this.ai.onUiClientSubscribe(info) ?? { accepted: false, error: 'Unknown subscription type' },
+            uiClientUnsubscribe: (info) => this.ai.onUiClientUnsubscribe(info),
             /**
              * If the JS-Controller catches an unhandled error, this will be called,
              * so we have a chance to handle it ourselves.
@@ -472,6 +453,13 @@ class JavaScript extends adapter_core_1.Adapter {
                 }
             }
         }
+        if (debugMode) {
+            // This process was started by the inspector (see `debugStart`) with `--debug`, so the whole log goes
+            // through the pipes of that process. If it is gone, writing to them fails with EPIPE, and an unhandled
+            // EPIPE would end the debugged process with an uncaught exception (#2382)
+            process.stdout.on('error', () => { });
+            process.stderr.on('error', () => { });
+        }
         this.context = {
             mods: this.mods,
             objects: this.objects,
@@ -523,6 +511,220 @@ class JavaScript extends adapter_core_1.Adapter {
         };
         this.tsServer = new lazyTsServer_1.LazyTsServer(typescriptSettings_1.tsCompilerOptions, this.tsLog, TS_MEMORY_RELEASE_DELAY_MS);
     }
+    /**
+     * Make sure the instance has a file area, which is where the script history lives.
+     *
+     * The adapter's own namespace needs a `meta` object before anything can be written under it.
+     * Deliberately not `javascript.admin`: that is the UI's file area and every
+     * `iobroker upload javascript` wipes it.
+     */
+    async ensureHistoryStorage() {
+        try {
+            await this.setForeignObjectNotExistsAsync(this.namespace, {
+                type: 'meta',
+                common: {
+                    name: 'javascript files',
+                    type: 'meta.user',
+                },
+                native: {},
+            });
+        }
+        catch (e) {
+            this.log.warn(`Cannot create the file storage of the instance: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * Keep the saved source of a script, so it can be looked at and brought back later.
+     *
+     * Hooked into the object change and not into the editor on purpose: this way a change from the
+     * mirror directory, from the object browser, from another script or from the AI is kept just
+     * the same as one typed into the editor.
+     *
+     * @param id id of the script
+     * @param obj the script as it is now
+     * @param formerObj the script as it was before this change, if it existed
+     */
+    async storeScriptVersion(id, obj, formerObj) {
+        const keep = (0, scriptHistory_1.resolveHistoryVersions)(this.config.historyVersions);
+        if (!keep) {
+            return;
+        }
+        // Only the instance that runs the script writes its history, otherwise two instances
+        // store every version twice
+        if (obj.common?.engine !== `system.adapter.${this.namespace}`) {
+            return;
+        }
+        const source = obj.common.source;
+        if (!(0, scriptHistory_1.isWorthStoring)(formerObj?.common?.source, source)) {
+            return;
+        }
+        try {
+            const ts = typeof obj.ts === 'number' && obj.ts ? obj.ts : Date.now();
+            const entry = {
+                ts,
+                ...(obj.from ? { from: obj.from } : {}),
+                ...(obj.user ? { user: obj.user } : {}),
+                // The source of a protected script is encrypted in the object and is kept that
+                // way - the history must not be the place where it lies around in plain text
+                ...(0, scriptHistory_1.describeSource)(source, !!obj.native?.protected),
+            };
+            await this.writeFileAsync(this.namespace, (0, scriptHistory_1.versionPath)(id, ts), source);
+            const raw = await this.readFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id)).catch(() => null);
+            const current = (0, scriptHistory_1.parseIndex)((0, scriptHistory_1.fileToString)(raw));
+            const { index, obsolete } = (0, scriptHistory_1.addVersion)(current, entry, keep);
+            await this.writeFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id), JSON.stringify(index));
+            for (const old of obsolete) {
+                await this.delFileAsync(this.namespace, (0, scriptHistory_1.versionPath)(id, old)).catch(() => {
+                    /* a version that is already gone is one we do not have to delete */
+                });
+            }
+            this.log.debug(`Script history: stored version ${ts} of ${id} (${index.length} kept)`);
+        }
+        catch (e) {
+            // A history is a convenience; it must never get in the way of saving a script
+            this.log.warn(`Cannot store the version of ${id}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * The stored versions of a script, newest first, without their sources.
+     *
+     * @param id id of the script
+     */
+    async readScriptVersions(id) {
+        try {
+            const raw = await this.readFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id));
+            return (0, scriptHistory_1.parseIndex)((0, scriptHistory_1.fileToString)(raw));
+        }
+        catch {
+            // No history yet - not an error, just nothing to show
+            return [];
+        }
+    }
+    /** What every stored history occupies, biggest first - read from the indexes, never from the sources */
+    async collectHistoryUsage() {
+        const rows = [];
+        let folders = [];
+        try {
+            folders = await this.readDirAsync(this.namespace, scriptHistory_1.HISTORY_ROOT);
+        }
+        catch {
+            // Nothing stored yet
+        }
+        for (const folder of folders) {
+            const id = (0, scriptHistory_1.decodeFolderName)(folder.file);
+            const index = await this.readScriptVersions(id);
+            if (!index.length) {
+                continue;
+            }
+            const { versions, bytes } = (0, scriptHistory_1.sumIndex)(index);
+            rows.push({ id, exists: !!this.objects[id], versions, bytes });
+        }
+        rows.sort((a, b) => b.bytes - a.bytes);
+        return {
+            rows,
+            total: {
+                scripts: rows.length,
+                versions: rows.reduce((sum, r) => sum + r.versions, 0),
+                bytes: rows.reduce((sum, r) => sum + r.bytes, 0),
+            },
+        };
+    }
+    /**
+     * Remove stored versions.
+     *
+     * @param options what to remove
+     * @param options.id the script whose versions are meant
+     * @param options.ts one single version of that script; without it the whole history goes
+     * @param options.orphans every history whose script no longer exists
+     * @param options.all every stored version there is - the scripts themselves stay untouched
+     */
+    async deleteHistory(options) {
+        let deleted = 0;
+        let bytes = 0;
+        /**
+         * Delete versions of one script and write the remaining index back.
+         *
+         * @param id the script
+         * @param keep the versions that stay; an empty list removes the index as well
+         * @param drop the versions to remove
+         */
+        const apply = async (id, keep, drop) => {
+            for (const version of drop) {
+                bytes += version.size || 0;
+                deleted++;
+                await this.delFileAsync(this.namespace, (0, scriptHistory_1.versionPath)(id, version.ts)).catch(() => {
+                    /* a version that is already gone is one we do not have to delete */
+                });
+            }
+            if (keep.length) {
+                await this.writeFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id), JSON.stringify(keep));
+            }
+            else {
+                await this.delFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id)).catch(() => {
+                    /* already gone */
+                });
+            }
+        };
+        if (options.orphans || options.all) {
+            const { rows } = await this.collectHistoryUsage();
+            // `all` takes everything, `orphans` only what has no script behind it anymore
+            for (const row of options.all ? rows : rows.filter(r => !r.exists)) {
+                await apply(row.id, [], await this.readScriptVersions(row.id));
+            }
+        }
+        else if (options.id) {
+            const index = await this.readScriptVersions(options.id);
+            if (options.ts) {
+                await apply(options.id, index.filter(v => v.ts !== options.ts), index.filter(v => v.ts === options.ts));
+            }
+            else {
+                await apply(options.id, [], index);
+            }
+        }
+        this.log.debug(`Script history: removed ${deleted} versions (${(0, scriptHistory_1.formatBytes)(bytes)})`);
+        return { deleted, bytes };
+    }
+    /**
+     * Cut every history down to the configured number of versions.
+     *
+     * Without this a smaller limit would only take effect script by script, on the next save of
+     * each - and setting it to zero would never free anything at all.
+     */
+    async trimAllHistories() {
+        const keep = (0, scriptHistory_1.resolveHistoryVersions)(this.config.historyVersions);
+        let folders = [];
+        try {
+            folders = await this.readDirAsync(this.namespace, scriptHistory_1.HISTORY_ROOT);
+        }
+        catch {
+            return;
+        }
+        for (const folder of folders) {
+            const id = (0, scriptHistory_1.decodeFolderName)(folder.file);
+            const index = await this.readScriptVersions(id);
+            if (!index.length) {
+                continue;
+            }
+            const { index: kept, obsolete } = (0, scriptHistory_1.trimIndex)(index, keep);
+            if (!obsolete.length) {
+                continue;
+            }
+            for (const ts of obsolete) {
+                await this.delFileAsync(this.namespace, (0, scriptHistory_1.versionPath)(id, ts)).catch(() => {
+                    /* already gone */
+                });
+            }
+            if (kept.length) {
+                await this.writeFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id), JSON.stringify(kept));
+            }
+            else {
+                await this.delFileAsync(this.namespace, (0, scriptHistory_1.indexPath)(id)).catch(() => {
+                    /* already gone */
+                });
+            }
+            this.log.debug(`Script history: trimmed ${id} to ${kept.length} versions`);
+        }
+    }
     async onObjectChange(id, obj) {
         // Check if we should ignore this change (once!) because we just updated the compiled sources
         if (this.ignoreObjectChange.has(id)) {
@@ -612,6 +814,10 @@ class JavaScript extends adapter_core_1.Adapter {
                 }
             }
         }
+        // Keep the saved source before the branches below decide what else to do with it
+        if (obj?.type === 'script') {
+            await this.storeScriptVersion(id, obj, formerObj);
+        }
         // handle Script object updates
         if (!obj && formerObj?.type === 'script') {
             // Object Deleted just now
@@ -821,13 +1027,15 @@ class JavaScript extends adapter_core_1.Adapter {
     }
     async onUnload(callback) {
         try {
-            await this.debugStop();
+            // Do not wait for it: the inspector needs a moment to stop the debugged process, and it does that by
+            // itself as soon as the connection to this process is gone. The shutdown must not be delayed by it.
+            void this.debugStop();
             this.stopTimeSchedules();
             if (this.setStateCountCheckInterval) {
                 clearInterval(this.setStateCountCheckInterval);
                 this.setStateCountCheckInterval = null;
             }
-            await this.unsubscribeAiCredentials();
+            await this.ai.stop();
             this.secretsManager.destroy();
             if (this.editorCheckInterval) {
                 clearInterval(this.editorCheckInterval);
@@ -884,53 +1092,38 @@ class JavaScript extends adapter_core_1.Adapter {
         }
         await this.main();
     }
-    /** Read and decrypt a single AI credential's key from the central store; returns '' (and logs) on error. */
-    async readAiCredentialKey(id) {
-        if (!adapter_core_1.Credentials?.getCredentials) {
-            this.log.warn(`Cannot read AI credential "${id}": Credentials API is only with 7.2 js-controller available`);
-            return '';
+    /**
+     * Whether the user a message was sent on behalf of may have code executed here.
+     *
+     * `obj.user` arrives with js-controller 7.2.5 and newer: a socket server such as `admin` or `web`
+     * puts the authenticated user of the connection there, and a socket client cannot set it itself.
+     * Where it is missing - an older controller, a script, an adapter that names nobody - nothing is
+     * checked and everything stays as it was.
+     *
+     * The right asked for is the one `cmdExec` is checked against: running a script here is running
+     * code on this host, whatever the ACL of the single objects it then touches says.
+     *
+     * @param obj the incoming message
+     */
+    async mayExecuteFor(obj) {
+        // `user` is not in the older `@iobroker/types` this adapter builds against
+        const user = obj.user;
+        if (!user) {
+            return null;
         }
         try {
-            const cred = await adapter_core_1.Credentials.getCredentials(this, id);
-            return (cred?.values?.key || '').trim();
+            const permissions = await this.calculatePermissionsAsync(user, {
+                cmdExec: { type: 'other', operation: 'execute' },
+            });
+            if (permissions?.other?.execute) {
+                return null;
+            }
+            return `User "${user}" has no permission to execute scripts`;
         }
         catch (e) {
-            this.log.warn(`Cannot read AI credential "${id}": ${e instanceof Error ? e.message : String(e)}`);
-            return '';
+            return `Cannot check the permissions of "${user}": ${e instanceof Error ? e.message : String(e)}`;
         }
     }
-    /**
-     * Resolve the API key (and base URL) for an AI provider.
-     *
-     * In `manual` mode the key comes from the encryptedNative adapter config.
-     * In `manager` mode the config only stores the ID of a credential in the central
-     * ioBroker credential store (`system.credentials.*`); the actual key is taken from the
-     * `aiCredentialCache` (kept fresh by `subscribeAiCredentials`) or, for credentials we are
-     * not subscribed to (e.g. a not-yet-saved selection in the settings dialog), read directly.
-     *
-     * The settings-dialog Test button may pass form values that are not saved yet
-     * (`messageApiKey` / `messageCredentialId` / `credentialType`); those win over the stored config.
-     */
-    async resolveAiCredentials(provider, opts = {}) {
-        const mode = opts.credentialType || this.config.credentialType || 'manual';
-        if (mode === 'manager') {
-            // The base URL is not a secret and is resolved the same way in both modes.
-            const { baseUrl } = (0, aiProviderResolver_1.resolveProviderCredentials)(this.config, provider, opts.messageBaseUrl);
-            const id = (opts.messageCredentialId || (0, aiProviderResolver_1.getProviderCredentialId)(this.config, provider)).trim();
-            if (!id) {
-                return { apiKey: '', baseUrl };
-            }
-            // Prefer the cached value kept fresh by the credential subscription.
-            const cached = this.aiCredentialCache.get(id);
-            const apiKey = cached !== undefined ? cached : await this.readAiCredentialKey(id);
-            return { apiKey, baseUrl };
-        }
-        // Manual mode. The Test button sends the current form key (maybe empty) — let it win.
-        if (opts.messageApiKey !== undefined) {
-            return (0, aiProviderResolver_1.resolveTestCredentials)(this.config, provider, opts.messageApiKey, opts.messageBaseUrl);
-        }
-        return (0, aiProviderResolver_1.resolveProviderCredentials)(this.config, provider, opts.messageBaseUrl);
-    }
     /**
      * Warns about the one setup that the fix for #2369 stops working.
      *
@@ -945,81 +1138,19 @@ class JavaScript extends adapter_core_1.Adapter {
         if (!(this.config.gptBaseUrl || '').trim()) {
             return;
         }
-        const manager = this.config.credentialType === 'manager';
-        const custom = manager
-            ? (0, aiProviderResolver_1.getProviderCredentialId)(this.config, 'custom')
-            : (this.config.gptBaseUrlKey || '').trim();
-        const openai = manager ? (0, aiProviderResolver_1.getProviderCredentialId)(this.config, 'openai') : (this.config.gptKey || '').trim();
-        if (!custom && openai) {
+        const settings = (0, ai_1.jsAiSettings)(this.config);
+        const of = settings.credentialType === 'manager' ? settings.credentialIds : settings.keys;
+        if (!of.custom && of.openai) {
             this.log.warn(`A custom AI endpoint ("${this.config.gptBaseUrl}") is configured, but its own API key is empty. ` +
                 `Requests to it are no longer signed with the OpenAI key - move the key of that endpoint into ` +
                 `the "Custom API key" field of the adapter settings.`);
         }
     }
-    /**
-     * In `manager` mode, subscribe to all configured AI credentials so that edits made in the
-     * admin credential manager (Settings → Credentials) are picked up live, without restarting
-     * the adapter (the `system.credentials.*` objects are global, not part of the instance config).
-     * The decrypted keys are cached and kept fresh by the subscription handlers.
-     */
-    async subscribeAiCredentials() {
-        // Always start from a clean state (idempotent — also used to re-subscribe).
-        await this.unsubscribeAiCredentials();
-        if (this.config.credentialType !== 'manager') {
-            return;
-        }
-        if (!adapter_core_1.Credentials?.subscribeCredentials) {
-            this.log.warn(`Cannot subscribe AI credential: Credentials API is only with 7.2 js-controller available`);
+    onMessage(obj) {
+        // the AI commands, also under the names the editor used before `ai-core`
+        if (this.ai.handleMessage(obj)) {
             return;
         }
-        // Collect the distinct credential IDs configured across all AI providers.
-        const ids = new Set();
-        for (const provider of ['openai', 'anthropic', 'gemini', 'deepseek', 'custom']) {
-            const id = (0, aiProviderResolver_1.getProviderCredentialId)(this.config, provider);
-            if (id) {
-                ids.add(id);
-            }
-        }
-        for (const id of ids) {
-            try {
-                const unsubscribe = await adapter_core_1.Credentials.subscribeCredentials(this, id, (changedId, cred) => {
-                    if (cred) {
-                        this.aiCredentialCache.set(changedId, (cred.values?.key || '').trim());
-                        this.log.debug(`AI credential "${changedId}" updated`);
-                    }
-                    else {
-                        // The credential was deleted
-                        this.aiCredentialCache.delete(changedId);
-                        this.log.debug(`AI credential "${changedId}" was deleted`);
-                    }
-                });
-                this.aiCredentialUnsubscribers.push(unsubscribe);
-                // Prime the cache with the current value (the handler may only fire on later changes).
-                this.aiCredentialCache.set(id, await this.readAiCredentialKey(id));
-            }
-            catch (e) {
-                this.log.warn(`Cannot subscribe to AI credential "${id}": ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-        if (this.aiCredentialUnsubscribers.length) {
-            this.log.debug(`Subscribed to ${this.aiCredentialUnsubscribers.length} AI credential(s)`);
-        }
-    }
-    /** Tear down all AI credential subscriptions and clear the cache. */
-    async unsubscribeAiCredentials() {
-        const unsubscribers = this.aiCredentialUnsubscribers;
-        this.aiCredentialUnsubscribers = [];
-        this.aiCredentialCache.clear();
-        for (const unsubscribe of unsubscribers) {
-            try {
-                await unsubscribe();
-            }
-            catch (e) {
-                this.log.warn(`Cannot unsubscribe from AI credential: ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-    }
-    onMessage(obj) {
         switch (obj?.command) {
             // process messageTo commands
             case 'toScript':
@@ -1268,297 +1399,98 @@ class JavaScript extends adapter_core_1.Adapter {
                 this.context.rulesOpened = null;
                 break;
             }
-            case 'getIoBrokerDataDir': {
-                if (obj.callback) {
-                    this.sendTo(obj.from, obj.command, {
-                        dataDir: (0, adapter_core_1.getAbsoluteDefaultDataDir)(),
-                        sep: node_path_1.sep,
-                    }, obj.callback);
-                }
-                break;
-            }
-            case 'chatCompletion': {
-                // Proxy chat completion requests to an OpenAI-compatible API endpoint.
-                // API keys are resolved server-side from the encryptedNative config or the central
-                // credentials manager — they never leave the adapter (frontend only sends `provider`).
+            case 'getScriptVersions': {
+                // The stored versions of one script, without their sources - the list must stay
+                // cheap, a history of 30 Blockly versions is megabytes
                 void (async () => {
                     if (!obj.callback) {
                         return;
                     }
-                    const chatModel = (obj.message?.model || '').trim();
-                    const messages = obj.message?.messages;
-                    const tools = obj.message?.tools;
-                    const provider = (obj.message?.provider || 'openai').trim();
-                    // How long the caller is willing to wait - see `resolveRequestTimeout`
-                    const requestTimeout = (0, aiProviderResolver_1.resolveRequestTimeout)(obj.message?.timeout);
-                    const { apiKey, baseUrl } = await this.resolveAiCredentials(provider, {
-                        messageBaseUrl: obj.message?.baseUrl,
-                    });
-                    // Anthropic, Gemini, and DeepSeek always require an API key; OpenAI-compatible allows empty key with custom base URL
-                    if (!apiKey &&
-                        (provider === 'anthropic' || provider === 'gemini' || provider === 'deepseek' || !baseUrl)) {
-                        this.sendTo(obj.from, obj.command, { error: 'No API key provided' }, obj.callback);
+                    const scriptId = (obj.message?.id || '').toString();
+                    if (!scriptId) {
+                        this.sendTo(obj.from, obj.command, { error: 'No script ID provided' }, obj.callback);
                         return;
                     }
-                    if (!chatModel || !messages) {
-                        this.sendTo(obj.from, obj.command, { error: 'Model and messages are required' }, obj.callback);
+                    const versions = await this.readScriptVersions(scriptId);
+                    this.sendTo(obj.from, obj.command, { versions }, obj.callback);
+                })();
+                break;
+            }
+            case 'getScriptVersion': {
+                // The source of one stored version, fetched when it is actually looked at
+                void (async () => {
+                    if (!obj.callback) {
                         return;
                     }
-                    let url;
-                    const chatHeaders = {
-                        'Content-Type': 'application/json',
-                    };
-                    let bodyObj;
-                    if (provider === 'anthropic') {
-                        url = 'https://api.anthropic.com/v1/messages';
-                        chatHeaders['x-api-key'] = apiKey;
-                        chatHeaders['anthropic-version'] = '2023-06-01';
-                        // Translate OpenAI-format messages/tools into Anthropic's content-block format.
-                        const { system: systemText, messages: anthropicMessages } = (0, anthropicAdapter_1.translateMessagesToAnthropic)(messages);
-                        const anthropicTools = tools?.length ? (0, anthropicAdapter_1.translateToolsToAnthropic)(tools) : [];
-                        bodyObj = {
-                            model: chatModel,
-                            max_tokens: 8192,
-                            stream: false,
-                            ...(systemText ? { system: systemText } : {}),
-                            messages: anthropicMessages,
-                            ...(anthropicTools.length ? { tools: anthropicTools } : {}),
-                        };
-                    }
-                    else if (provider === 'gemini') {
-                        url = 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions';
-                        if (apiKey) {
-                            chatHeaders.Authorization = `Bearer ${apiKey}`;
-                        }
-                        bodyObj = { model: chatModel, messages, stream: false, ...(tools?.length ? { tools } : {}) };
-                    }
-                    else if (provider === 'deepseek') {
-                        url = 'https://api.deepseek.com/chat/completions';
-                        chatHeaders.Authorization = `Bearer ${apiKey}`;
-                        bodyObj = { model: chatModel, messages, stream: false, ...(tools?.length ? { tools } : {}) };
-                    }
-                    else {
-                        url = `${baseUrl || 'https://api.openai.com/v1'}/chat/completions`;
-                        if (apiKey) {
-                            chatHeaders.Authorization = `Bearer ${apiKey}`;
-                        }
-                        bodyObj = {
-                            model: chatModel,
-                            messages,
-                            stream: false,
-                            ...(tools?.length ? { tools } : {}),
-                            /*
-                             * `reasoning_effort` used to be pinned to `none` for every custom base URL,
-                             * to save context and time on a local model. Behind a proxy that fronts a
-                             * subscription, the same setting turns off the reasoning the model is being
-                             * used for, or is rejected outright. It is a setting now, and the default is
-                             * to leave the parameter out and let the endpoint decide.
-                             */
-                            ...(this.config.aiReasoningEffort
-                                ? { reasoning_effort: this.config.aiReasoningEffort }
-                                : {}),
-                        };
-                    }
-                    const body = JSON.stringify(bodyObj);
-                    const bodyBuffer = Buffer.from(body, 'utf8');
-                    chatHeaders['Content-Length'] = bodyBuffer.length;
-                    const resolved = resolveRequestModule(url);
-                    if (!resolved) {
-                        this.sendTo(obj.from, obj.command, { error: `Invalid API URL: ${url}` }, obj.callback);
+                    const scriptId = (obj.message?.id || '').toString();
+                    const ts = parseInt(obj.message?.ts, 10);
+                    if (!scriptId || isNaN(ts)) {
+                        this.sendTo(obj.from, obj.command, { error: 'No script ID or timestamp' }, obj.callback);
                         return;
                     }
-                    const { module: requestModule, isHttps } = resolved;
                     try {
-                        const req = requestModule.request(url, {
-                            method: 'POST',
-                            headers: chatHeaders,
-                            timeout: requestTimeout,
-                            ...(isHttps && this.config.allowSelfSignedCerts ? { rejectUnauthorized: false } : {}),
-                        }, res => {
-                            let data = '';
-                            res.on('data', (chunk) => {
-                                data += chunk.toString();
-                            });
-                            res.on('end', () => {
-                                if (res.statusCode === 200) {
-                                    try {
-                                        const parsed = JSON.parse(data);
-                                        let content;
-                                        let tool_calls;
-                                        if (provider === 'anthropic') {
-                                            const translated = (0, anthropicAdapter_1.translateAnthropicResponseToOpenAI)(parsed);
-                                            content = translated.content;
-                                            tool_calls = translated.tool_calls;
-                                        }
-                                        else {
-                                            const message = parsed.choices?.[0]?.message;
-                                            content = message?.content || '';
-                                            tool_calls = message?.tool_calls;
-                                        }
-                                        if (!content && !tool_calls?.length) {
-                                            this.sendTo(obj.from, obj.command, { error: 'Empty response from API' }, obj.callback);
-                                        }
-                                        else {
-                                            this.sendTo(obj.from, obj.command, {
-                                                success: true,
-                                                content,
-                                                ...(tool_calls ? { tool_calls } : {}),
-                                            }, obj.callback);
-                                        }
-                                    }
-                                    catch {
-                                        this.sendTo(obj.from, obj.command, { error: 'Invalid JSON response from API' }, obj.callback);
-                                    }
-                                }
-                                else {
-                                    let detail = '';
-                                    try {
-                                        const errParsed = JSON.parse(data);
-                                        detail = errParsed.error?.message || data.substring(0, 200);
-                                    }
-                                    catch {
-                                        detail = data.substring(0, 200);
-                                    }
-                                    this.sendTo(obj.from, obj.command, {
-                                        error: `${detail || httpStatusText(res.statusCode || 0)} (${res.statusCode})`,
-                                    }, obj.callback);
-                                }
-                            });
-                        });
-                        req.on('error', (err) => {
-                            this.sendTo(obj.from, obj.command, { error: `Connection failed: ${err.message}` }, obj.callback);
-                        });
-                        req.on('timeout', () => {
-                            req.destroy();
-                            this.sendTo(obj.from, obj.command, { error: `Connection timeout (${Math.round(requestTimeout / 1000)}s)` }, obj.callback);
-                        });
-                        req.write(bodyBuffer);
-                        req.end();
+                        const raw = await this.readFileAsync(this.namespace, (0, scriptHistory_1.versionPath)(scriptId, ts));
+                        const source = (0, scriptHistory_1.fileToString)(raw);
+                        this.sendTo(obj.from, obj.command, { source }, obj.callback);
                     }
-                    catch (error) {
-                        this.sendTo(obj.from, obj.command, { error: `Connection failed: ${error.toString()}` }, obj.callback);
+                    catch (e) {
+                        this.sendTo(obj.from, obj.command, { error: `Cannot read the version: ${e instanceof Error ? e.message : String(e)}` }, obj.callback);
                     }
                 })();
                 break;
             }
-            case 'testApiConnection': {
-                // Test connection to an OpenAI-compatible API endpoint.
-                // The settings-dialog Test button sends the current form value as `apiKey`
-                // (so users can test before saving); otherwise we fall back to the stored key.
+            case 'getHistoryUsage': {
+                // Read by the overview in the adapter settings (`textSendTo` with container html)
                 void (async () => {
                     if (!obj.callback) {
                         return;
                     }
-                    const provider = (obj.message?.provider || 'openai').trim();
-                    const { apiKey, baseUrl } = await this.resolveAiCredentials(provider, {
-                        messageApiKey: obj.message?.apiKey,
-                        messageBaseUrl: obj.message?.baseUrl,
-                        messageCredentialId: obj.message?.credentialId,
-                        credentialType: obj.message?.credentialType,
-                    });
-                    // Anthropic, Gemini, and DeepSeek always require an API key; OpenAI-compatible allows empty key with custom base URL
-                    if (!apiKey &&
-                        (provider === 'anthropic' || provider === 'gemini' || provider === 'deepseek' || !baseUrl)) {
-                        this.sendTo(obj.from, obj.command, { error: 'No API key provided' }, obj.callback);
-                        return;
-                    }
-                    let url;
-                    const testHeaders = {
-                        'Content-Type': 'application/json',
-                    };
-                    if (provider === 'anthropic') {
-                        url = 'https://api.anthropic.com/v1/models';
-                        testHeaders['x-api-key'] = apiKey;
-                        testHeaders['anthropic-version'] = '2023-06-01';
-                    }
-                    else if (provider === 'gemini') {
-                        url = 'https://generativelanguage.googleapis.com/v1beta/openai/models';
-                        if (apiKey) {
-                            testHeaders.Authorization = `Bearer ${apiKey}`;
-                        }
+                    try {
+                        this.sendTo(obj.from, obj.command, await this.collectHistoryUsage(), obj.callback);
                     }
-                    else if (provider === 'deepseek') {
-                        url = 'https://api.deepseek.com/models';
-                        testHeaders.Authorization = `Bearer ${apiKey}`;
+                    catch (e) {
+                        this.sendTo(obj.from, obj.command, { error: `Cannot read the history: ${e instanceof Error ? e.message : String(e)}` }, obj.callback);
                     }
-                    else {
-                        url = `${baseUrl || 'https://api.openai.com/v1'}/models`;
-                        if (apiKey) {
-                            testHeaders.Authorization = `Bearer ${apiKey}`;
-                        }
+                })();
+                break;
+            }
+            case 'deleteHistory': {
+                // One version, the history of one script, or every history without a script
+                void (async () => {
+                    if (!obj.callback) {
+                        return;
                     }
-                    const resolved = resolveRequestModule(url);
-                    if (!resolved) {
-                        this.sendTo(obj.from, obj.command, { error: `Invalid API URL: ${url}` }, obj.callback);
+                    const scriptId = (obj.message?.id || '').toString();
+                    const orphans = !!obj.message?.orphans;
+                    // Wiping every history is a deliberate request, never the default of a
+                    // message that forgot to say what it meant
+                    const all = !!obj.message?.all;
+                    if (!scriptId && !orphans && !all) {
+                        this.sendTo(obj.from, obj.command, { error: 'No script ID provided' }, obj.callback);
                         return;
                     }
-                    const { module: requestModule, isHttps } = resolved;
                     try {
-                        const req = requestModule.request(url, {
-                            method: 'GET',
-                            headers: testHeaders,
-                            timeout: 10000,
-                            ...(isHttps && this.config.allowSelfSignedCerts ? { rejectUnauthorized: false } : {}),
-                        }, res => {
-                            let data = '';
-                            res.on('data', (chunk) => {
-                                data += chunk.toString();
-                            });
-                            res.on('end', () => {
-                                if (res.statusCode === 200) {
-                                    try {
-                                        const parsed = JSON.parse(data);
-                                        const models = (parsed.data || [])
-                                            .map((m) => m.id.startsWith('models/') ? m.id.substring(7) : m.id)
-                                            .sort();
-                                        this.sendTo(obj.from, obj.command, { success: true, models, count: models.length }, obj.callback);
-                                    }
-                                    catch {
-                                        this.sendTo(obj.from, obj.command, { error: 'Invalid JSON response from API' }, obj.callback);
-                                    }
-                                }
-                                else if (res.statusCode === 401) {
-                                    this.sendTo(obj.from, obj.command, { error: 'Invalid API key (401)' }, obj.callback);
-                                }
-                                else if (res.statusCode === 403) {
-                                    this.sendTo(obj.from, obj.command, { error: 'Access denied (403)' }, obj.callback);
-                                }
-                                else {
-                                    // Include response body for debugging
-                                    let detail = '';
-                                    try {
-                                        const errParsed = JSON.parse(data);
-                                        detail = errParsed.error?.message || data.substring(0, 200);
-                                    }
-                                    catch {
-                                        detail = data.substring(0, 200);
-                                    }
-                                    this.sendTo(obj.from, obj.command, {
-                                        error: `${detail || httpStatusText(res.statusCode || 0)} (${res.statusCode})`,
-                                    }, obj.callback);
-                                }
-                            });
-                        });
-                        req.on('error', (err) => {
-                            this.sendTo(obj.from, obj.command, { error: `Connection failed: ${err.message}` }, obj.callback);
+                        const ts = parseInt(obj.message?.ts, 10);
+                        const result = await this.deleteHistory({
+                            ...(scriptId ? { id: scriptId } : {}),
+                            ...(isNaN(ts) ? {} : { ts }),
+                            ...(orphans ? { orphans: true } : {}),
+                            ...(all ? { all: true } : {}),
                         });
-                        req.on('timeout', () => {
-                            req.destroy();
-                            this.sendTo(obj.from, obj.command, { error: 'Connection timeout (10s)' }, obj.callback);
-                        });
-                        req.end();
+                        this.sendTo(obj.from, obj.command, result, obj.callback);
                     }
-                    catch (error) {
-                        this.sendTo(obj.from, obj.command, { error: `Connection failed: ${error.toString()}` }, obj.callback);
+                    catch (e) {
+                        this.sendTo(obj.from, obj.command, { error: `Cannot delete: ${e instanceof Error ? e.message : String(e)}` }, obj.callback);
                     }
                 })();
                 break;
             }
-            case 'getAvailableAiProviders': {
-                // Reports which AI providers have stored credentials (keys never leave the backend).
+            case 'getIoBrokerDataDir': {
                 if (obj.callback) {
-                    const providers = (0, aiProviderResolver_1.listAvailableProviders)(this.config);
-                    this.sendTo(obj.from, obj.command, { providers }, obj.callback);
+                    this.sendTo(obj.from, obj.command, {
+                        dataDir: (0, adapter_core_1.getAbsoluteDefaultDataDir)(),
+                        sep: node_path_1.sep,
+                    }, obj.callback);
                 }
                 break;
             }
@@ -1618,7 +1550,15 @@ class JavaScript extends adapter_core_1.Adapter {
             }
             case 'execute': {
                 if (obj.callback) {
-                    void this.executeScript(obj.message)
+                    /*
+                     * This runs code on this host with the whole ioBroker API behind it. Anybody who
+                     * may send a message here could ask for it, and the message never said on whose
+                     * behalf - so there was nothing to check it against. Where the controller names
+                     * the user (js-controller 7.2.5 and newer), that user needs the right a command on
+                     * the host needs; where it does not, nothing changes.
+                     */
+                    void this.mayExecuteFor(obj)
+                        .then(async (error) => error ? { ok: false, error, logs: [], output: '' } : await this.executeScript(obj.message))
                         .then(result => this.sendTo(obj.from, obj.command, result, obj.callback))
                         .catch(err => this.sendTo(obj.from, obj.command, {
                         ok: false,
@@ -1690,6 +1630,9 @@ class JavaScript extends adapter_core_1.Adapter {
         }
     }
     async main() {
+        await this.ensureHistoryStorage();
+        // Makes a changed limit take effect at once instead of script by script
+        await this.trimAllHistories();
         // Patch the font as it sometimes is wrong
         if (!this.context.debugMode) {
             if (await this.patchFont()) {
@@ -1770,9 +1713,9 @@ class JavaScript extends adapter_core_1.Adapter {
         // Store allowSelfSignedCerts on the context, so sandbox HTTP functions can use it
         // without setting the global process.env.NODE_TLS_REJECT_UNAUTHORIZED (which affects all adapters in compact mode)
         this.context.allowSelfSignedCerts = this.config.allowSelfSignedCerts;
-        // In `manager` credential mode, subscribe to the configured AI credentials so changes in the
-        // central credential store are picked up live (the keys are cached for the AI sendTo handlers).
-        await this.subscribeAiCredentials();
+        // In `manager` credential mode the configured AI credentials are subscribed, so a change in the
+        // central credential store counts without a restart
+        await this.ai.start();
         this.warnAboutMisplacedCustomAiKey();
         // Read the central credential store, so the scripts can use `SECRETS.<name>.<field>`.
         // Later changes are picked up in `onObjectChange`.
@@ -3553,10 +3496,12 @@ class JavaScript extends adapter_core_1.Adapter {
     async debugStop() {
         if (this.debugState.child) {
             this.debugSendToInspector({ cmd: 'end' });
+            // The inspector stops the debugged process first and ends itself only then, because that process writes
+            // its log through its pipes (#2382). Kill it only if it does not manage that in time.
             this.debugState.endTimeout = setTimeout(() => {
                 this.debugState.endTimeout = null;
-                this.debugState.child?.kill('SIGTERM');
-            }, 500);
+                this.debugState.child?.kill('SIGKILL');
+            }, 5_000);
             this.debugState.promiseOnEnd ||= Promise.resolve(0);
         }
         else {