@minionry/minion 0.7.36

package/dist/server/services/websocket/debug-log.js

@@ -0,0 +1,38 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const DEBUG = process.env.MINIONRY_BROWSER_DEBUG === '1';
+function formatDetail(detail) {
+    if (detail === undefined)
+        return '';
+    if (typeof detail === 'string')
+        return ` ${detail}`;
+    if (detail instanceof Error)
+        return ` ${detail.message}`;
+    try {
+        return ` ${JSON.stringify(detail)}`;
+    }
+    catch {
+        return ` ${String(detail)}`;
+    }
+}
+export function debugLog(component) {
+    const prefix = `[B:${component}]`;
+    const fn = ((event, detail) => {
+        if (!DEBUG)
+            return;
+        console.log(`${prefix} ${event}${formatDetail(detail)}`);
+    });
+    fn.warn = (event, detail) => {
+        if (!DEBUG)
+            return;
+        console.warn(`${prefix} ${event}${formatDetail(detail)}`);
+    };
+    fn.info = (event, detail) => {
+        console.log(`${prefix} ${event}${formatDetail(detail)}`);
+    };
+    fn.error = (event, detail) => {
+        console.error(`${prefix} ${event}${formatDetail(detail)}`);
+    };
+    return fn;
+}
+export const debugEnabled = DEBUG;

package/dist/server/services/websocket/dispatch-util.js

@@ -0,0 +1,10 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export function dispatchByType(map, domain, type, onUnknown) {
+    const handler = map[type];
+    if (handler)
+        return handler();
+    console.warn(`[${domain}] Ignoring unknown message type: ${type}`);
+    onUnknown(type);
+    return undefined;
+}

package/dist/server/services/websocket/engine-auth-handlers.js

@@ -0,0 +1,323 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { getCodexConnectionStatus, runCodexDeviceLogin, } from '../../engines/codex/codex-auth.js';
+import { probeCredential } from '../../engines/credentials/credential-probe.js';
+import { APP_PROFILE_ID_PREFIX, ModelProfileStore, profileCredentialId, } from '../../engines/credentials/model-profiles.js';
+import { ANTHROPIC_PROVIDER_ID, CODEX_PROVIDER_ID, ProviderCredentialStore, } from '../../engines/credentials/provider-credentials.js';
+import { ENGINE_IDS, parseEngineId } from '../../engines/EngineEvent.js';
+import { collectHermesProviderCredentials, getHermesConnectionStatus, hermesPortalLogin, } from '../../engines/hermes/hermes-auth.js';
+import { resolveHermesCommand } from '../../engines/hermes/hermes-provision.js';
+const activeCodexLogins = new Map();
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function defaultProviderId(engine) {
+    if (engine === 'codex')
+        return CODEX_PROVIDER_ID;
+    if (engine === 'claude-code')
+        return ANTHROPIC_PROVIDER_ID;
+    return undefined;
+}
+function sendError(ctx, ws, engine, message) {
+    ctx.send(ws, {
+        type: 'engineAuthError',
+        ...(engine !== 'unknown' ? { engine } : {}),
+        data: { engine, message },
+    });
+}
+async function resolveHermesCmd(deps) {
+    const resolver = deps.hermesCommand ?? (() => resolveHermesCommand());
+    return resolver();
+}
+export const CREDENTIALED_ENGINES = ['codex', 'hermes'];
+export const STATUS_PROBE_TIMEOUT_MS = 10_000;
+function storedOnlyStatus(engine, store) {
+    if (engine === 'hermes') {
+        const { providers } = collectHermesProviderCredentials(store);
+        return {
+            engine,
+            connected: providers.length > 0,
+            providers,
+            path: providers.length > 0 ? 'provider' : 'none',
+            portalConnected: false,
+        };
+    }
+    const providerId = defaultProviderId(engine);
+    const connected = providerId ? store.getApiKey(providerId) !== undefined : false;
+    return {
+        engine,
+        connected,
+        providers: connected && providerId ? [providerId] : [],
+        ...(providerId ? { path: connected ? 'api-key' : 'none' } : {}),
+    };
+}
+const KEY_HINT_LENGTH = 4;
+function withKeyHints(status, store) {
+    const keyHints = {};
+    for (const providerId of status.providers) {
+        const key = store.getApiKey(providerId);
+        if (key && key.length > KEY_HINT_LENGTH)
+            keyHints[providerId] = key.slice(-KEY_HINT_LENGTH);
+    }
+    return Object.keys(keyHints).length > 0 ? { ...status, keyHints } : status;
+}
+async function computeStatus(engine, store, deps) {
+    return withKeyHints(await computeRawStatus(engine, store, deps), store);
+}
+async function computeRawStatus(engine, store, deps) {
+    let timer;
+    try {
+        return await Promise.race([
+            probeStatus(engine, store, deps),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(storedOnlyStatus(engine, store)), STATUS_PROBE_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function probeStatus(engine, store, deps) {
+    if (engine === 'hermes') {
+        let status;
+        try {
+            const command = () => resolveHermesCmd(deps);
+            const statusFn = deps.hermesStatus ??
+                ((cmd, s) => getHermesConnectionStatus(cmd, { store: s }));
+            status = await statusFn(command, store);
+        }
+        catch {
+            return storedOnlyStatus(engine, store);
+        }
+        return {
+            engine,
+            connected: status.connected,
+            providers: status.providers,
+            path: status.path,
+            portalConnected: status.portalConnected,
+        };
+    }
+    if (engine === 'codex') {
+        const statusFn = deps.codexStatus ?? ((s) => getCodexConnectionStatus(s));
+        const status = await statusFn(store);
+        const hasStoredKey = store.getApiKey(CODEX_PROVIDER_ID) !== undefined;
+        return {
+            engine,
+            connected: status.connected,
+            providers: hasStoredKey ? [CODEX_PROVIDER_ID] : [],
+            path: status.method,
+        };
+    }
+    return storedOnlyStatus(engine, store);
+}
+async function handleStatus(ctx, ws, engine, store, deps) {
+    const data = await computeStatus(engine, store, deps);
+    ctx.send(ws, { type: 'engineAuthStatusResult', engine, data });
+}
+async function broadcastStatus(ctx, engine, store, deps) {
+    const data = await computeStatus(engine, store, deps);
+    ctx.broadcastToAll({ type: 'engineAuthStatusResult', engine, data });
+}
+export async function broadcastEngineAuthStatuses(ctx, deps = {}) {
+    const store = deps.store ?? new ProviderCredentialStore();
+    await Promise.all(ENGINE_IDS.map((engine) => broadcastStatus(ctx, engine, store, deps)));
+}
+async function handleSetKey(ctx, ws, engine, msg, store, deps) {
+    const providedId = typeof msg.data?.providerId === 'string' ? msg.data.providerId.trim() : '';
+    const providerId = providedId || defaultProviderId(engine);
+    const key = typeof msg.data?.key === 'string' ? msg.data.key : '';
+    if (!providerId) {
+        sendError(ctx, ws, engine, 'A provider id is required to set a key for this engine');
+        return;
+    }
+    if (!key.trim()) {
+        sendError(ctx, ws, engine, 'API key is required');
+        return;
+    }
+    if (providerId.startsWith(profileCredentialId(APP_PROFILE_ID_PREFIX))) {
+        sendError(ctx, ws, engine, "An app-registered model's key can only be set by the app");
+        return;
+    }
+    try {
+        store.setApiKey(providerId, key);
+    }
+    catch (err) {
+        sendError(ctx, ws, engine, errorMessage(err));
+        return;
+    }
+    await broadcastStatus(ctx, engine, store, deps);
+}
+async function handleRemoveKey(ctx, ws, engine, msg, store, deps) {
+    const providedId = typeof msg.data?.providerId === 'string' ? msg.data.providerId.trim() : '';
+    const providerId = providedId || defaultProviderId(engine);
+    if (!providerId) {
+        sendError(ctx, ws, engine, 'A provider id is required to remove a key for this engine');
+        return;
+    }
+    try {
+        store.remove(providerId);
+    }
+    catch (err) {
+        sendError(ctx, ws, engine, errorMessage(err));
+        return;
+    }
+    await broadcastStatus(ctx, engine, store, deps);
+}
+async function handleLogin(ctx, ws, engine, msg, store, deps) {
+    if (engine === 'hermes') {
+        const command = await resolveHermesCmd(deps);
+        const loginFn = deps.hermesLogin ?? ((cmd, s) => hermesPortalLogin(cmd, { store: s }));
+        const result = await loginFn(command, store);
+        const progress = {
+            engine,
+            status: result.connected ? 'connected' : 'awaiting_user',
+            message: result.message,
+            command: result.command,
+        };
+        ctx.send(ws, { type: 'engineLoginProgress', engine, data: progress });
+        return;
+    }
+    if (engine === 'codex') {
+        await handleCodexLogin(ctx, ws, engine, msg, store, deps);
+        return;
+    }
+    const progress = {
+        engine,
+        status: 'pending',
+        message: 'Interactive login for this engine is not available yet. Add an API key in Settings to connect it for now.',
+    };
+    ctx.send(ws, { type: 'engineLoginProgress', engine, data: progress });
+}
+async function handleCodexLogin(ctx, ws, engine, msg, store, deps) {
+    if (msg.data?.cancel === true) {
+        activeCodexLogins.get(engine)?.abort();
+        return;
+    }
+    activeCodexLogins.get(engine)?.abort();
+    const controller = new AbortController();
+    activeCodexLogins.set(engine, controller);
+    const loginFn = deps.codexLogin ?? ((options) => runCodexDeviceLogin(options));
+    try {
+        const result = await loginFn({
+            signal: controller.signal,
+            onProgress: (update) => {
+                const progress = {
+                    engine,
+                    status: update.status,
+                    verificationUrl: update.verificationUrl,
+                    userCode: update.userCode,
+                    message: update.message,
+                };
+                ctx.send(ws, { type: 'engineLoginProgress', engine, data: progress });
+            },
+        });
+        const terminal = {
+            engine,
+            status: result.status,
+            verificationUrl: result.verificationUrl,
+            userCode: result.userCode,
+            message: result.message,
+        };
+        ctx.send(ws, { type: 'engineLoginProgress', engine, data: terminal });
+        if (result.connected) {
+            await broadcastStatus(ctx, engine, store, deps);
+        }
+    }
+    catch (err) {
+        sendError(ctx, ws, engine, errorMessage(err));
+    }
+    finally {
+        if (activeCodexLogins.get(engine) === controller) {
+            activeCodexLogins.delete(engine);
+        }
+    }
+}
+async function handleTestCredential(ctx, ws, engine, msg, store) {
+    const profileId = typeof msg.data?.profileId === 'string' ? msg.data.profileId.trim() : '';
+    const requestedProvider = typeof msg.data?.providerId === 'string' ? msg.data.providerId.trim() : '';
+    let credentialId;
+    let baseUrl;
+    let target = engine;
+    if (profileId) {
+        const profile = new ModelProfileStore().get(profileId);
+        if (!profile) {
+            ctx.send(ws, {
+                type: 'engineCredentialTestResult',
+                engine,
+                data: {
+                    engine,
+                    profileId,
+                    ok: false,
+                    failure: 'invalid_key',
+                    message: 'That custom model no longer exists on this machine.',
+                },
+            });
+            return;
+        }
+        target = profile.engine;
+        baseUrl = profile.baseUrl;
+        credentialId = profileCredentialId(profile.id);
+    }
+    else {
+        credentialId = requestedProvider || defaultProviderId(engine);
+    }
+    const reply = (data) => {
+        ctx.send(ws, { type: 'engineCredentialTestResult', engine: target, data });
+    };
+    const echo = profileId ? { profileId } : credentialId ? { providerId: credentialId } : {};
+    const key = credentialId ? store.getApiKey(credentialId) : undefined;
+    if (!key) {
+        reply({
+            engine: target,
+            ...echo,
+            ok: false,
+            failure: 'invalid_key',
+            message: 'No API key is stored for this provider yet.',
+        });
+        return;
+    }
+    const result = await probeCredential({ engine: target, baseUrl, apiKey: key });
+    reply(result.ok
+        ? { engine: target, ...echo, ok: true }
+        : {
+            engine: target,
+            ...echo,
+            ok: false,
+            failure: result.failure,
+            ...(result.status !== undefined ? { status: result.status } : {}),
+            message: result.message,
+        });
+}
+export async function handleEngineAuthMessage(ctx, ws, msg, deps = {}) {
+    const engine = parseEngineId(msg.data?.engine ?? msg.engine);
+    if (!engine) {
+        sendError(ctx, ws, 'unknown', 'Engine credential management is not available for this engine');
+        return;
+    }
+    const store = deps.store ?? new ProviderCredentialStore();
+    try {
+        switch (msg.type) {
+            case 'engineAuthStatus':
+                await handleStatus(ctx, ws, engine, store, deps);
+                return;
+            case 'setEngineApiKey':
+                await handleSetKey(ctx, ws, engine, msg, store, deps);
+                return;
+            case 'removeEngineApiKey':
+                await handleRemoveKey(ctx, ws, engine, msg, store, deps);
+                return;
+            case 'startEngineLogin':
+                await handleLogin(ctx, ws, engine, msg, store, deps);
+                return;
+            case 'testEngineCredential':
+                await handleTestCredential(ctx, ws, engine, msg, store);
+                return;
+        }
+    }
+    catch (err) {
+        sendError(ctx, ws, engine, errorMessage(err));
+    }
+}

package/dist/server/services/websocket/engine-credential-watcher.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { mkdirSync, watch } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { defaultAuthFilePath, ProviderCredentialStore, } from '../../engines/credentials/provider-credentials.js';
+import { broadcastEngineAuthStatuses } from './engine-auth-handlers.js';
+const DEBOUNCE_MS = 250;
+export class EngineCredentialWatcher {
+    ctx;
+    watcher = null;
+    debounceTimer = null;
+    lastProviderHash = '';
+    started = false;
+    authFilePath;
+    store;
+    deps;
+    constructor(ctx, options = {}) {
+        this.ctx = ctx;
+        this.authFilePath = options.authFilePath ?? defaultAuthFilePath();
+        this.store = new ProviderCredentialStore({ authFilePath: this.authFilePath });
+        this.deps = options.deps ?? {};
+    }
+    start() {
+        if (this.started)
+            return;
+        this.lastProviderHash = this.computeHash();
+        const dir = dirname(this.authFilePath);
+        const file = basename(this.authFilePath);
+        try {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            this.watcher = watch(dir, (_event, filename) => {
+                if (filename && basename(filename) !== file)
+                    return;
+                this.debounce();
+            });
+            this.watcher.on('error', () => {
+            });
+        }
+        catch {
+        }
+        this.started = true;
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.started = false;
+    }
+    debounce() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            void this.handleChange();
+        }, DEBOUNCE_MS);
+    }
+    async handleChange() {
+        try {
+            const hash = this.computeHash();
+            if (hash === this.lastProviderHash)
+                return;
+            this.lastProviderHash = hash;
+            await broadcastEngineAuthStatuses(this.ctx, { ...this.deps, store: this.store });
+        }
+        catch {
+        }
+    }
+    computeHash() {
+        try {
+            return this.store
+                .list()
+                .map((p) => p.id)
+                .join(',');
+        }
+        catch {
+            return '';
+        }
+    }
+}

package/dist/server/services/websocket/engine-profile-handlers.js

@@ -0,0 +1,92 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ModelProfileError, ModelProfileStore, profileCredentialId, profileModelValue, } from '../../engines/credentials/model-profiles.js';
+import { ProviderCredentialStore } from '../../engines/credentials/provider-credentials.js';
+import { parseEngineId } from '../../engines/EngineEvent.js';
+const KEY_HINT_LENGTH = 4;
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function sendError(ctx, ws, message) {
+    ctx.send(ws, {
+        type: 'engineAuthError',
+        data: { engine: 'unknown', message },
+    });
+}
+function summarize(profiles, credentials) {
+    return {
+        profiles: profiles.list().map((profile) => {
+            const key = credentials.getApiKey(profileCredentialId(profile.id));
+            return {
+                ...profile,
+                hasApiKey: key !== undefined,
+                ...(key && key.length > KEY_HINT_LENGTH ? { keyHint: key.slice(-KEY_HINT_LENGTH) } : {}),
+                modelValue: profileModelValue(profile),
+            };
+        }),
+    };
+}
+function broadcastProfiles(ctx, profiles, credentials) {
+    ctx.broadcastToAll({
+        type: 'engineModelProfilesResult',
+        data: summarize(profiles, credentials),
+    });
+}
+function handleSave(ctx, ws, msg, profiles, credentials) {
+    const raw = (msg.data?.profile ?? {});
+    const engine = parseEngineId(raw.engine);
+    if (!engine) {
+        sendError(ctx, ws, 'Choose which engine this model runs on.');
+        return;
+    }
+    if (raw.owner !== undefined) {
+        throw new ModelProfileError('RESERVED_ID', 'App-registered models can only be created by the app.');
+    }
+    const saved = profiles.save({
+        id: typeof raw.id === 'string' ? raw.id : undefined,
+        label: typeof raw.label === 'string' ? raw.label : '',
+        engine,
+        model: typeof raw.model === 'string' ? raw.model : '',
+        baseUrl: typeof raw.baseUrl === 'string' ? raw.baseUrl : undefined,
+        wireApi: raw.wireApi === 'responses' || raw.wireApi === 'chat' ? raw.wireApi : undefined,
+        expiresAt: raw.expiresAt,
+        contextLength: raw.contextLength,
+    });
+    const apiKey = typeof msg.data?.apiKey === 'string' ? msg.data.apiKey.trim() : '';
+    if (apiKey)
+        credentials.setApiKey(profileCredentialId(saved.id), apiKey);
+    broadcastProfiles(ctx, profiles, credentials);
+}
+function handleRemove(ctx, ws, msg, profiles, credentials) {
+    const profileId = typeof msg.data?.profileId === 'string' ? msg.data.profileId.trim() : '';
+    if (!profileId) {
+        sendError(ctx, ws, 'A profile id is required to remove a custom model.');
+        return;
+    }
+    credentials.remove(profileCredentialId(profileId));
+    profiles.remove(profileId);
+    broadcastProfiles(ctx, profiles, credentials);
+}
+export function handleModelProfileMessage(ctx, ws, msg, deps = {}) {
+    const profiles = deps.profiles ?? new ModelProfileStore();
+    const credentials = deps.credentials ?? new ProviderCredentialStore();
+    try {
+        switch (msg.type) {
+            case 'engineModelProfiles':
+                ctx.send(ws, {
+                    type: 'engineModelProfilesResult',
+                    data: summarize(profiles, credentials),
+                });
+                return;
+            case 'setEngineModelProfile':
+                handleSave(ctx, ws, msg, profiles, credentials);
+                return;
+            case 'removeEngineModelProfile':
+                handleRemove(ctx, ws, msg, profiles, credentials);
+                return;
+        }
+    }
+    catch (err) {
+        sendError(ctx, ws, errorMessage(err));
+    }
+}