iobroker.javascript 9.2.4 → 9.3.1

package/build/main.js

@@ -316,6 +316,14 @@ 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 = [];
     globalScript = '';
     /** Generated declarations for global TypeScripts */
     globalDeclarations = '';
@@ -323,8 +331,11 @@ class JavaScript extends adapter_core_1.Adapter {
     // have access to, because it depends on the compilation order
     knownGlobalDeclarationsByScript = {};
     globalScriptLines = 0;
+    /** Running counter to build unique names for ad-hoc scripts started via the "execute" message */
+    executeCounter = 0;
     // compiler instance for typescript
     tsServer;
+    logCollectors = [];
     ignoreObjectChange = new Set();
     debugState = {
         scriptName: '',
@@ -761,6 +772,7 @@ class JavaScript extends adapter_core_1.Adapter {
                 clearInterval(this.setStateCountCheckInterval);
                 this.setStateCountCheckInterval = null;
             }
+            await this.unsubscribeAiCredentials();
             await this.stopAllScripts();
         }
         catch (err) {
@@ -810,6 +822,116 @@ 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 '';
+        }
+        try {
+            const cred = await adapter_core_1.Credentials.getCredentials(this, id);
+            return (cred?.values?.key || '').trim();
+        }
+        catch (e) {
+            this.log.warn(`Cannot read AI credential "${id}": ${e instanceof Error ? e.message : String(e)}`);
+            return '';
+        }
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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`);
+            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
@@ -999,23 +1121,28 @@ class JavaScript extends adapter_core_1.Adapter {
             }
             case 'chatCompletion': {
                 // Proxy chat completion requests to an OpenAI-compatible API endpoint.
-                // API keys are resolved server-side from encryptedNative config — they never
-                // leave the adapter (frontend only sends `provider`, not the key).
-                if (obj.callback) {
+                // API keys are resolved server-side from the encryptedNative config or the central
+                // credentials manager — they never leave the adapter (frontend only sends `provider`).
+                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();
-                    const { apiKey, baseUrl } = (0, aiProviderResolver_1.resolveProviderCredentials)(this.config, provider, obj.message?.baseUrl);
+                    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);
-                        break;
+                        return;
                     }
                     if (!chatModel || !messages) {
                         this.sendTo(obj.from, obj.command, { error: 'Model and messages are required' }, obj.callback);
-                        break;
+                        return;
                     }
                     let url;
                     const chatHeaders = {
@@ -1070,7 +1197,7 @@ class JavaScript extends adapter_core_1.Adapter {
                     const resolved = resolveRequestModule(url);
                     if (!resolved) {
                         this.sendTo(obj.from, obj.command, { error: `Invalid API URL: ${url}` }, obj.callback);
-                        break;
+                        return;
                     }
                     const { module: requestModule, isHttps } = resolved;
                     try {
@@ -1143,21 +1270,29 @@ class JavaScript extends adapter_core_1.Adapter {
                     catch (error) {
                         this.sendTo(obj.from, obj.command, { error: `Connection failed: ${error.toString()}` }, 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.
-                if (obj.callback) {
+                void (async () => {
+                    if (!obj.callback) {
+                        return;
+                    }
                     const provider = (obj.message?.provider || 'openai').trim();
-                    const { apiKey, baseUrl } = (0, aiProviderResolver_1.resolveTestCredentials)(this.config, provider, obj.message?.apiKey, obj.message?.baseUrl);
+                    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);
-                        break;
+                        return;
                     }
                     let url;
                     const testHeaders = {
@@ -1187,7 +1322,7 @@ class JavaScript extends adapter_core_1.Adapter {
                     const resolved = resolveRequestModule(url);
                     if (!resolved) {
                         this.sendTo(obj.from, obj.command, { error: `Invalid API URL: ${url}` }, obj.callback);
-                        break;
+                        return;
                     }
                     const { module: requestModule, isHttps } = resolved;
                     try {
@@ -1248,7 +1383,7 @@ class JavaScript extends adapter_core_1.Adapter {
                     catch (error) {
                         this.sendTo(obj.from, obj.command, { error: `Connection failed: ${error.toString()}` }, obj.callback);
                     }
-                }
+                })();
                 break;
             }
             case 'getAvailableAiProviders': {
@@ -1301,6 +1436,19 @@ class JavaScript extends adapter_core_1.Adapter {
                 }
                 break;
             }
+            case 'execute': {
+                if (obj.callback) {
+                    void 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,
+                        error: `Internal error: ${err}`,
+                        logs: [],
+                        output: '',
+                    }, obj.callback));
+                }
+                break;
+            }
         }
     }
     onLog(msg) {
@@ -1314,6 +1462,14 @@ class JavaScript extends adapter_core_1.Adapter {
                 }
             }
         }
+        // Special case if some script is executed now with "execute" command, and we see "script.js.__execute_X:" at the beginning
+        if (this.logCollectors.length) {
+            for (const logCollector of this.logCollectors) {
+                if (msg.message.includes(`${logCollector.name}:`)) {
+                    logCollector.collector(msg.severity, msg.message);
+                }
+            }
+        }
     }
     logError(scriptName, msg, e, offs) {
         const stack = e.stack ? e.stack.toString().split('\n') : e ? e.toString() : '';
@@ -1419,6 +1575,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();
         const doc = await this.getObjectViewAsync('script', 'javascript', {});
         if (doc?.rows?.length) {
             // sort global scripts if configured
@@ -2194,7 +2353,14 @@ class JavaScript extends adapter_core_1.Adapter {
             return false;
         }
     }
-    execute(script, name, engineType, verbose, debug) {
+    execute(script, name, engineType, verbose, debug, 
+    /**
+     * Optional sink for the "execute" message API. When provided, the script runs in an
+     * ephemeral diagnostic mode: every log line (the script's own `log()`/`console.*` output
+     * AND all verbose internal operations) is forwarded to this collector instead of the
+     * adapter log, and no `scriptProblem` state is written.
+     */
+    logCollector) {
         script.intervals = new Set();
         script.timeouts = new Set();
         script.schedules = [];
@@ -2206,12 +2372,14 @@ class JavaScript extends adapter_core_1.Adapter {
         script.subscribesFile = {};
         script.setStatePerMinuteCounter = 0;
         script.setStatePerMinuteProblemCounter = 0;
-        void this.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
-            val: false,
-            ack: true,
-            expire: 1000,
-        });
-        const sandbox = (0, sandbox_1.sandBox)(script, name, verbose, debug, this.context);
+        if (!logCollector) {
+            void this.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
+                val: false,
+                ack: true,
+                expire: 1000,
+            });
+        }
+        const sandbox = (0, sandbox_1.sandBox)(script, name, verbose, debug, this.context, logCollector);
         try {
             script.script.runInNewContext(sandbox, {
                 filename: name,
@@ -2220,13 +2388,131 @@ class JavaScript extends adapter_core_1.Adapter {
             });
         }
         catch (err) {
-            void this.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
-                val: true,
-                ack: true,
-                c: 'execute',
-            });
-            this.logError(name, 'Error by run:', err);
+            if (logCollector) {
+                const e = err;
+                const stack = (e?.stack ? e.stack.toString() : String(err))
+                    .split('\n')
+                    .map(line => this.fixLineNo(line))
+                    .join('\n');
+                logCollector('error', `Error by run: ${stack}`);
+            }
+            else {
+                void this.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
+                    val: true,
+                    ack: true,
+                    c: 'execute',
+                });
+                this.logError(name, 'Error by run:', err);
+            }
+        }
+    }
+    /**
+     * Run an ad-hoc script sent via the `execute` message and return everything it logged.
+     *
+     * The script is compiled (JavaScript or TypeScript), executed with the same sandbox API as a
+     * regular script (verbose by default, so internal operations like setState/subscribe are logged
+     * too), left running for `timeout` ms to collect asynchronous output, and afterwards stopped and
+     * fully cleaned up (timers, subscriptions, schedules). It is ephemeral: no script object or
+     * states are created.
+     *
+     * Expected `message`:
+     * - `source` / `code` (string, required) – the script source
+     * - `engineType` (string, optional) – `TypeScript/ts` to compile as TypeScript, otherwise JavaScript
+     * - `verbose` (boolean, optional, default `true`) – log internal sandbox operations
+     * - `logLevel` (silly|debug|info|warn|error, optional, default `silly`) – minimum severity to return
+     * - `timeout` (number ms, optional, default 5000, clamped to 0…60000) – collection window
+     * - `maxLogs` (number, optional, default 5000) – cap on returned log lines
+     */
+    async executeScript(message) {
+        const LEVELS = ['silly', 'debug', 'info', 'warn', 'error'];
+        const source = message?.source ?? message?.code;
+        const engineTypeStr = (message?.engineType || '').toString().toLowerCase();
+        const isTypeScript = engineTypeStr.startsWith('typescript') || engineTypeStr === 'ts';
+        const engineType = isTypeScript ? 'TypeScript/ts' : 'Javascript/js';
+        const empty = (error) => ({ ok: false, error, engineType, runtime: 0, truncated: false, logs: [], output: '' });
+        if (typeof source !== 'string' || !source.trim()) {
+            return empty('No source code provided');
+        }
+        if (this.context.debugMode) {
+            return empty('Cannot execute a script while a debug session is active');
+        }
+        let timeout = parseInt(message?.timeout, 10);
+        if (isNaN(timeout)) {
+            timeout = 5000;
+        }
+        timeout = Math.max(0, Math.min(timeout, 60000));
+        const verbose = message?.verbose !== false;
+        const minLevel = message?.logLevel
+            ? LEVELS.includes(message?.logLevel)
+                ? message.logLevel
+                : 'silly'
+            : 'silly';
+        let maxLogs = parseInt(message?.maxLogs, 10);
+        if (isNaN(maxLogs) || maxLogs <= 0) {
+            maxLogs = 5000;
+        }
+        const name = `${SCRIPT_CODE_MARKER}__execute_${++this.executeCounter}`;
+        // Compile the source the same way regular scripts are compiled
+        let createdScript;
+        if (isTypeScript) {
+            const transformedSource = (0, typescriptTools_1.transformScriptBeforeCompilation)(source, false);
+            const filename = (0, typescriptTools_1.scriptIdToTSFilename)(name);
+            let tsCompiled;
+            try {
+                tsCompiled = this.tsServer.compile(filename, transformedSource);
+            }
+            catch (err) {
+                return empty(`TypeScript compilation failed: ${err}`);
+            }
+            if (!tsCompiled.success) {
+                const errors = tsCompiled.diagnostics.map(diag => diag.annotatedSource).join('\n');
+                return empty(`TypeScript compilation failed:\n${errors}`);
+            }
+            createdScript = this.createVM(`${this.globalScript}\n${tsCompiled.result || ''}`, name, false);
+        }
+        else {
+            createdScript = this.createVM(`${this.globalScript}\n${source}`, name, true);
         }
+        if (!createdScript) {
+            return empty('Compilation failed');
+        }
+        const logs = [];
+        let truncated = false;
+        const collector = (severity, msg) => {
+            if (logs.length >= maxLogs) {
+                truncated = true;
+                return;
+            }
+            logs.push({ ts: Date.now(), severity, message: msg });
+        };
+        this.logCollectors.push({ name, collector });
+        this.updateLogSubscriptions();
+        this.scripts[name] = createdScript;
+        this.execute(createdScript, name, engineType, verbose, false, collector);
+        // Let asynchronous output (timeouts, awaited code, triggered subscriptions) accumulate
+        if (timeout) {
+            await new Promise(resolve => setTimeout(resolve, timeout));
+        }
+        // Stop and clean up the ephemeral script (timers, subscriptions, schedules, …)
+        await this.stopScript(name, true);
+        const pos = this.logCollectors.findIndex(it => it.name === name);
+        if (pos !== -1) {
+            this.logCollectors.splice(pos, 1);
+        }
+        this.updateLogSubscriptions();
+        const minIdx = LEVELS.indexOf(minLevel);
+        const filtered = logs.filter(entry => {
+            const idx = LEVELS.indexOf(entry.severity);
+            return idx < 0 || idx >= minIdx;
+        });
+        return {
+            ok: true,
+            engineType,
+            runtime: timeout,
+            truncated,
+            logs: filtered,
+            output: filtered.map(entry => `[${entry.severity}] ${entry.message}`).join('\n'),
+        };
     }
     /**
      * Finds the index of `id` in a sorted array using binary search – O(log n).
@@ -2302,35 +2588,44 @@ class JavaScript extends adapter_core_1.Adapter {
     }
     // Analyze if logs are still required or not
     updateLogSubscriptions() {
-        let found = false;
-        // go through all scripts and check if some script still requires logs
-        Object.keys(this.logSubscriptions).forEach(scriptName => {
-            if (!this.logSubscriptions?.[scriptName] || !this.logSubscriptions[scriptName].length) {
-                delete this.logSubscriptions[scriptName];
-            }
-            else {
-                found = true;
-            }
-        });
+        let found = '';
+        if (this.logCollectors.length) {
+            found = this.logCollectors[0].name;
+        }
+        else {
+            // go through all scripts and check if some script still requires logs
+            Object.keys(this.logSubscriptions).forEach(scriptName => {
+                if (!this.logSubscriptions?.[scriptName] || !this.logSubscriptions[scriptName].length) {
+                    delete this.logSubscriptions[scriptName];
+                }
+                else {
+                    found = scriptName;
+                }
+            });
+        }
         if (this.requireLog) {
             if (found && !this.logSubscribed) {
                 this.logSubscribed = true;
                 void this.requireLog(this.logSubscribed);
-                this.log.info(`Subscribed to log messages (found logSubscriptions)`);
+                this.log.info(`Subscribed to log messages (at least because of ${found})`);
             }
             else if (!found && this.logSubscribed) {
                 this.logSubscribed = false;
                 void this.requireLog(this.logSubscribed);
-                this.log.info(`Unsubscribed from log messages (not found logSubscriptions)`);
+                this.log.info(`Unsubscribed from log messages (not found any subscribers)`);
             }
         }
     }
-    async stopScript(name) {
+    async stopScript(name, silent) {
         if (!this.scripts[name]) {
             return false;
         }
-        this.log.info(`${name}: Stopping script`);
-        await this.setState(`scriptEnabled.${name.substring(SCRIPT_CODE_MARKER.length)}`, false, true);
+        // `silent` is used for ephemeral scripts started via the "execute" message – they have no
+        // `scriptEnabled` state and should not appear in the adapter log.
+        if (!silent) {
+            this.log.info(`${name}: Stopping script`);
+            await this.setState(`scriptEnabled.${name.substring(SCRIPT_CODE_MARKER.length)}`, false, true);
+        }
         if (this.messageBusHandlers[name]) {
             delete this.messageBusHandlers[name];
         }