@kai-chat/desktop 0.0.1

package/LICENSE

@@ -0,0 +1,167 @@
+KAI-CHAT PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 Eutima AG, Switzerland. All rights reserved.
+
+"Eutima AG" means Eutima AG, Switzerland.
+
+"Software" means the KAI-Chat software package and all files included in
+the package, whether in source, compiled, bundled, or other machine-readable
+form.
+
+"KAI-Chat Account" means a valid user account issued or authorized by
+Eutima AG for use with a KAI-Chat server operated or authorized by Eutima AG.
+
+1. GRANT OF LICENSE
+
+Subject to the terms of this License, Eutima AG grants you a limited,
+non-exclusive, non-transferable, non-sublicensable license to use the
+Software solely as permitted by this License.
+
+You may use the Software:
+
+(a) if you hold a valid KAI-Chat Account, solely for running the Software
+unmodified to connect to and interact with a KAI-Chat server operated or
+authorized by Eutima AG; or
+
+(b) if Eutima AG has separately authorized your use in writing, subject to
+the terms of that authorization.
+
+No other rights or licenses are granted.
+
+2. RESTRICTIONS
+
+Except where expressly permitted by this License or by mandatory applicable
+law, you may not:
+
+(a) modify, adapt, patch, translate, fork, or create derivative works of the
+Software;
+
+(b) reverse engineer, decompile, disassemble, deobfuscate, or otherwise
+attempt to derive source code, algorithms, protocols, or data formats from
+the Software;
+
+(c) sell, rent, lease, sublicense, distribute, publish, transfer, or otherwise
+make the Software available to any third party;
+
+(d) remove, alter, or obscure copyright notices, license notices, or other
+proprietary notices contained in the Software;
+
+(e) use the Software to develop, operate, or provide a product or service that
+substantially replicates KAI-Chat or is intended to compete with
+KAI-Chat; or
+
+(f) use the Software in a manner that circumvents authentication, access
+controls, licensing mechanisms, usage restrictions, or other technical
+protections implemented by Eutima AG.
+
+Permission granted for one specific modification, use case, person, or
+organization does not constitute permission for any other modification, use
+case, person, or organization unless expressly agreed by Eutima AG in writing.
+
+3. NO REDISTRIBUTION
+
+The Software may be obtained from npm or other distribution channels expressly
+authorized by Eutima AG.
+
+Obtaining the Software from a public distribution channel does not grant any
+right to redistribute, mirror, republish, sublicense, or otherwise make the
+Software available outside those authorized channels.
+
+4. OWNERSHIP
+
+The Software is licensed, not sold.
+
+Eutima AG and its licensors retain all right, title, and interest in and to
+the Software, including all intellectual property rights.
+
+Except for the limited license expressly granted under this License, no rights
+are granted, whether express, implied, by estoppel, or otherwise.
+
+5. TRADEMARKS
+
+This License does not grant any rights to use the trademarks, trade names,
+logos, service marks, or other branding of Eutima AG or KAI-Chat.
+
+You may not use the name "KAI-Chat", the name "Eutima", or associated logos or
+branding to imply endorsement, sponsorship, affiliation, or authorization
+without prior written permission from Eutima AG.
+
+6. THIRD-PARTY SOFTWARE
+
+The Software may include or depend upon third-party software components that
+are distributed under their own license terms.
+
+Those components remain subject to their respective licenses. Nothing in this
+License is intended to restrict rights granted to you under applicable
+third-party licenses.
+
+7. NO WARRANTY
+
+THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
+NON-INFRINGEMENT, TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW.
+
+8. LIMITATION OF LIABILITY
+
+TO THE MAXIMUM EXTENT PERMITTED BY SWISS LAW, EUTIMA AG SHALL NOT BE LIABLE
+FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES,
+OR FOR ANY LOSS OF PROFITS, REVENUE, DATA, BUSINESS, OR GOODWILL ARISING OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THIS LICENSE.
+
+Nothing in this License excludes or limits liability to the extent that such
+exclusion or limitation is prohibited by mandatory applicable law, including
+liability arising from intentional misconduct or gross negligence where such
+liability cannot lawfully be excluded.
+
+9. TERMINATION
+
+This License terminates automatically if you materially breach its terms.
+
+Upon termination, you must immediately cease using the Software and delete all
+copies of the Software in your possession or control, except where retention
+is required by mandatory applicable law.
+
+Termination does not affect any rights or remedies that Eutima AG may have
+arising from a breach of this License.
+
+10. CHANGES TO THIS LICENSE
+
+Eutima AG may publish updated versions of this License for future versions or
+releases of the Software.
+
+Unless expressly stated otherwise, the license applicable to a particular
+version of the Software is the license included with that version.
+
+11. GOVERNING LAW AND JURISDICTION
+
+This License is governed by Swiss substantive law, excluding its conflict of
+laws rules.
+
+The exclusive place of jurisdiction for disputes arising from or in connection
+with this License shall be the competent courts at the registered seat of
+Eutima AG, Switzerland, subject to mandatory statutory jurisdiction.
+
+12. SEVERABILITY
+
+If any provision of this License is held to be invalid or unenforceable, the
+remaining provisions shall remain in full force and effect.
+
+13. ENTIRE AGREEMENT
+
+This License constitutes the entire agreement between you and Eutima AG
+concerning the licensing of the Software, except for any separate written
+agreement between you and Eutima AG that expressly applies to the Software.
+
+Any separate written authorization or agreement with Eutima AG takes
+precedence over this License to the extent of any conflict.
+
+PERMISSION REQUESTS
+
+Requests for additional permissions, including permission to modify,
+redistribute, integrate, or otherwise use the Software outside the scope of
+this License, should be directed to:
+
+Eutima AG
+Switzerland
+info@eutima.ch

package/bin/kai-desktop.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawn } = require('child_process');
+// Resolves to the path of the Electron binary that npm installed next to this package.
+const electronPath = require('electron');
+const { buildLaunch } = require('./launch.js');
+
+const launch = buildLaunch(electronPath, process.argv.slice(2), process.env);
+const child = spawn(launch.command, launch.args, { stdio: 'inherit', env: launch.env });
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.on(signal, () => child.kill(signal));
+}
+child.on('error', (err) => {
+  console.error(`Could not start KAI: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code, signal) => {
+  process.exit(signal ? 1 : (code ?? 0));
+});

package/bin/launch.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const path = require('path');
+
+/** The folder of this package: the Electron main process (`main` in package.json) lives under it. */
+const packageRoot = path.resolve(__dirname, '..');
+
+/**
+ * What to run for `kai-desktop`: the Electron binary pointed at this package. NODE_ENV is forced
+ * to production because electron/main.ts otherwise loads the Vite dev server (localhost:5173)
+ * instead of the bundled renderer.
+ */
+function buildLaunch(electronPath, args, env) {
+  return {
+    command: electronPath,
+    args: [packageRoot, ...args],
+    env: { ...env, NODE_ENV: 'production' },
+  };
+}
+
+module.exports = { buildLaunch, packageRoot };

package/dist/electron/browser-window.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browser = void 0;
+const electron_1 = require("electron");
+const browser_js_1 = require("./capabilities/browser.js");
+const image_js_1 = require("./image.js");
+const settings_js_1 = require("./settings.js");
+// The Electron side of the agent browser: a visible window, and the policy that keeps it where the
+// person would expect. Only glue: what an agent may ask (`BrowserController`) and where the window
+// may go (`checkUrl`) are decided, and tested, in `capabilities/browser.ts`. This file is checked by
+// using it (see the manual steps in the change that added it).
+const LOAD_TIMEOUT_MS = 30_000;
+const SETTLE_MS = 5_000;
+// What a page may fetch besides pages: pictures and the like can be inline data, everything else
+// goes through the same address policy as the page itself.
+const INLINE = new Set(['data:', 'blob:']);
+function protect(ses, resolve) {
+    ses.webRequest.onBeforeRequest(async (details, callback) => {
+        try {
+            const kind = new URL(details.url).protocol;
+            if (INLINE.has(kind) && details.resourceType !== 'mainFrame' && details.resourceType !== 'subFrame')
+                return callback({});
+            await (0, browser_js_1.checkUrl)(details.url, resolve);
+            callback({});
+        }
+        catch {
+            callback({ cancel: true });
+        }
+    });
+    // Nothing on a page may ask for the camera, the microphone, the location, notifications, ...
+    ses.setPermissionRequestHandler((_contents, _permission, callback) => callback(false));
+    ses.setPermissionCheckHandler(() => false);
+    ses.on('will-download', event => event.preventDefault());
+}
+function protectContents(contents) {
+    contents.setWindowOpenHandler(() => ({ action: 'deny' }));
+    contents.on('will-prevent-unload', event => event.preventDefault());
+    // Dialogs would block the whole app until someone answers them.
+    contents.on('dom-ready', () => {
+        void contents
+            .executeJavaScript('window.alert = () => {}; window.confirm = () => false; window.prompt = () => null;')
+            .catch(() => undefined);
+    });
+}
+async function openWindow(resolve) {
+    // A partition without the "persist:" prefix lives in memory: no cookie, login or storage is
+    // shared with anything else, and all of it is gone when the window is.
+    const partition = `kai-browser-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const ses = electron_1.session.fromPartition(partition);
+    protect(ses, resolve);
+    const win = new electron_1.BrowserWindow({
+        width: 1100,
+        height: 800,
+        title: 'KAI browser',
+        webPreferences: {
+            partition,
+            sandbox: true,
+            contextIsolation: true,
+            nodeIntegration: false,
+            webSecurity: true,
+            backgroundThrottling: false,
+            spellcheck: false,
+        },
+    });
+    const contents = win.webContents;
+    protectContents(contents);
+    const closed = [];
+    win.on('closed', () => {
+        for (const callback of closed)
+            callback();
+        void ses.clearStorageData().catch(() => undefined);
+    });
+    const wait = (ms) => new Promise(done => setTimeout(done, ms));
+    return {
+        async load(url) {
+            let timer;
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    contents.stop();
+                    reject(new Error('The page took too long to load.'));
+                }, LOAD_TIMEOUT_MS);
+            });
+            try {
+                // An address that loads a download or is replaced by another navigation rejects with ERR_ABORTED.
+                await Promise.race([contents.loadURL(url).catch(err => (String(err?.message ?? err).includes('ERR_ABORTED') ? undefined : Promise.reject(err))), timeout]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        },
+        url: () => contents.getURL(),
+        evaluate: (script) => contents.executeJavaScript(script, true),
+        async click(x, y) {
+            contents.sendInputEvent({ type: 'mouseMove', x, y });
+            contents.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount: 1 });
+            contents.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount: 1 });
+        },
+        insertText: text => contents.insertText(text),
+        async pressEnter() {
+            // Key events only reach a page that has the focus (mouse events do not need it).
+            contents.focus();
+            // The `char` event is what submits a form, and it needs the character itself, not the key's name.
+            contents.sendInputEvent({ type: 'keyDown', keyCode: 'Enter' });
+            contents.sendInputEvent({ type: 'char', keyCode: '\r' });
+            contents.sendInputEvent({ type: 'keyUp', keyCode: 'Enter' });
+        },
+        async settle() {
+            const started = Date.now();
+            await wait(300);
+            while (contents.isLoading() && Date.now() - started < SETTLE_MS)
+                await wait(100);
+            await wait(200);
+        },
+        async capture() {
+            return (await contents.capturePage()).toPNG();
+        },
+        close: () => {
+            if (!win.isDestroyed())
+                win.close();
+        },
+        onClosed: callback => void closed.push(callback),
+    };
+}
+const resolve = (0, browser_js_1.cachedResolver)(browser_js_1.systemResolver);
+/** The one browser of this app. */
+exports.browser = new browser_js_1.BrowserController({
+    enabled: settings_js_1.getBrowserEnabled,
+    open: () => openWindow(resolve),
+    resolve,
+    toImage: image_js_1.toImageResult,
+});
+//# sourceMappingURL=browser-window.js.map