@minionry/minion 0.7.36

package/dist/server/services/apps/space-apps.js

@@ -0,0 +1,248 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { readFileSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { withFileLock, writeFileAtomic } from '../../utils/file-store.js';
+import { isValidAppId } from '../sdk/sandbox.js';
+import { SPACE_LAYOUT, spacePath } from '../space-layout.js';
+export const SPACE_APPS_FILENAME = SPACE_LAYOUT.appsRoster;
+const SPACE_APPS_VERSION = 1;
+const MAX_NAME_LENGTH = 120;
+const MAX_URL_LENGTH = 2048;
+const MAX_SLUG_LENGTH = 64;
+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const ENTRY_KINDS = new Set(['hosted', 'local', 'sideloaded']);
+const META_FIELDS = ['name', 'iconUrl', 'kind', 'entry', 'slug'];
+export const MAX_SPACE_APPS = 128;
+export class SpaceRosterFullError extends Error {
+    constructor(limit) {
+        super(`This Space's app roster is full (${limit} apps)`);
+        this.name = 'SpaceRosterFullError';
+    }
+}
+const HIDDEN_BUILTINS_KEY = 'hiddenBuiltins';
+export const MAX_HIDDEN_BUILTINS = 32;
+export class SpaceAppConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SpaceAppConfigError';
+    }
+}
+function isHttpUrl(value) {
+    if (value.length > MAX_URL_LENGTH)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function isDisallowedNameChar(code) {
+    return (code < 0x20 ||
+        (code >= 0x7f && code <= 0x9f) ||
+        code === 0x200e ||
+        code === 0x200f ||
+        (code >= 0x202a && code <= 0x202e) ||
+        (code >= 0x2066 && code <= 0x2069));
+}
+function cleanName(raw) {
+    let kept = '';
+    for (const char of raw.replace(/\s+/g, ' ')) {
+        if (!isDisallowedNameChar(char.codePointAt(0) ?? 0))
+            kept += char;
+    }
+    const name = kept.replace(/\s+/g, ' ').trim();
+    return name !== '' && name.length <= MAX_NAME_LENGTH ? name : null;
+}
+export function sanitizeSpaceEntryMeta(input) {
+    const raw = input;
+    const meta = {};
+    const name = typeof raw.name === 'string' ? cleanName(raw.name) : null;
+    if (name !== null)
+        meta.name = name;
+    if (typeof raw.iconUrl === 'string' && isHttpUrl(raw.iconUrl))
+        meta.iconUrl = raw.iconUrl;
+    if (typeof raw.kind === 'string' && ENTRY_KINDS.has(raw.kind))
+        meta.kind = raw.kind;
+    if (typeof raw.entry === 'string' && isHttpUrl(raw.entry))
+        meta.entry = raw.entry;
+    if (typeof raw.slug === 'string' && raw.slug.length <= MAX_SLUG_LENGTH && SLUG_PATTERN.test(raw.slug)) {
+        meta.slug = raw.slug;
+    }
+    return meta;
+}
+export function getSpaceAppsFile(workingDir) {
+    return spacePath(realpathSync(resolve(workingDir)), 'appsRoster');
+}
+function spaceAppsLockPath(workingDir) {
+    return `${getSpaceAppsFile(workingDir)}.lock`;
+}
+function normalizeEntry(raw, nowIso) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const entry = raw;
+    if (typeof entry.appId !== 'string' || !isValidAppId(entry.appId))
+        return null;
+    const addedAt = typeof entry.addedAt === 'string' && entry.addedAt !== '' ? entry.addedAt : nowIso;
+    const unknownFields = { ...entry };
+    for (const field of META_FIELDS)
+        delete unknownFields[field];
+    return { ...unknownFields, ...sanitizeSpaceEntryMeta(entry), appId: entry.appId, addedAt };
+}
+function mergeEntryMeta(existing, meta) {
+    const merged = { ...existing };
+    let changed = false;
+    if (meta.name !== undefined && meta.name !== existing.name) {
+        merged.name = meta.name;
+        changed = true;
+    }
+    if (meta.iconUrl !== undefined && meta.iconUrl !== existing.iconUrl) {
+        merged.iconUrl = meta.iconUrl;
+        changed = true;
+    }
+    if (meta.kind !== undefined && meta.kind !== existing.kind) {
+        merged.kind = meta.kind;
+        changed = true;
+    }
+    if (meta.entry !== undefined && meta.entry !== existing.entry) {
+        merged.entry = meta.entry;
+        changed = true;
+    }
+    if (meta.slug !== undefined && meta.slug !== existing.slug) {
+        merged.slug = meta.slug;
+        changed = true;
+    }
+    return changed ? merged : existing;
+}
+function normalizeHiddenBuiltins(value) {
+    if (!Array.isArray(value))
+        return null;
+    const ids = [];
+    for (const id of value) {
+        if (ids.length >= MAX_HIDDEN_BUILTINS)
+            break;
+        if (typeof id === 'string' && isValidAppId(id) && !ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
+const EMPTY_DOCUMENT = () => ({ raw: {}, apps: [], hiddenBuiltins: null });
+function loadSpaceAppsDocument(workingDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(getSpaceAppsFile(workingDir), 'utf8'));
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            console.warn(`[apps] this Space's app roster is unreadable — treating it as empty: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return EMPTY_DOCUMENT();
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return EMPTY_DOCUMENT();
+    const raw = parsed;
+    const nowIso = new Date().toISOString();
+    const seen = new Set();
+    const apps = [];
+    for (const candidate of Array.isArray(raw.apps) ? raw.apps : []) {
+        const entry = normalizeEntry(candidate, nowIso);
+        if (!entry || seen.has(entry.appId))
+            continue;
+        seen.add(entry.appId);
+        apps.push(entry);
+    }
+    return { raw, apps, hiddenBuiltins: normalizeHiddenBuiltins(raw[HIDDEN_BUILTINS_KEY]) };
+}
+function writeSpaceAppsDocument(workingDir, document) {
+    const rest = { ...document.raw };
+    delete rest[HIDDEN_BUILTINS_KEY];
+    const out = {
+        ...rest,
+        version: SPACE_APPS_VERSION,
+        apps: document.apps,
+        ...(document.hiddenBuiltins !== null ? { [HIDDEN_BUILTINS_KEY]: document.hiddenBuiltins } : {}),
+    };
+    writeFileAtomic(getSpaceAppsFile(workingDir), `${JSON.stringify(out, null, 2)}\n`, { mode: 0o600 });
+}
+function configOf(document) {
+    return { apps: document.apps, hiddenBuiltins: document.hiddenBuiltins };
+}
+export function readSpaceApps(workingDir) {
+    return loadSpaceAppsDocument(workingDir).apps;
+}
+export function readSpaceAppConfig(workingDir) {
+    return configOf(loadSpaceAppsDocument(workingDir));
+}
+export function addSpaceApp(workingDir, appId, meta = {}) {
+    if (!isValidAppId(appId)) {
+        throw new Error(`Invalid appId '${appId}' — expected the D5 grammar (lowercase [a-z0-9-])`);
+    }
+    const clean = sanitizeSpaceEntryMeta(meta);
+    return withFileLock(spaceAppsLockPath(workingDir), () => {
+        const document = loadSpaceAppsDocument(workingDir);
+        const { apps } = document;
+        const index = apps.findIndex((entry) => entry.appId === appId);
+        if (index !== -1) {
+            const merged = mergeEntryMeta(apps[index], clean);
+            if (merged === apps[index])
+                return { changed: false, ...configOf(document) };
+            const next = { ...document, apps: apps.map((entry, position) => (position === index ? merged : entry)) };
+            writeSpaceAppsDocument(workingDir, next);
+            return { changed: true, ...configOf(next) };
+        }
+        if (apps.length >= MAX_SPACE_APPS)
+            throw new SpaceRosterFullError(MAX_SPACE_APPS);
+        const next = { ...document, apps: [...apps, { appId, addedAt: new Date().toISOString(), ...clean }] };
+        writeSpaceAppsDocument(workingDir, next);
+        return { changed: true, ...configOf(next) };
+    });
+}
+export function removeSpaceApp(workingDir, appId) {
+    let lockPath;
+    try {
+        lockPath = spaceAppsLockPath(workingDir);
+    }
+    catch {
+        return { changed: false, apps: [], hiddenBuiltins: null };
+    }
+    return withFileLock(lockPath, () => {
+        const document = loadSpaceAppsDocument(workingDir);
+        const apps = document.apps.filter((entry) => entry.appId !== appId);
+        if (apps.length === document.apps.length)
+            return { changed: false, ...configOf(document) };
+        const next = { ...document, apps };
+        writeSpaceAppsDocument(workingDir, next);
+        return { changed: true, ...configOf(next) };
+    });
+}
+export function setSpaceBuiltinHidden(workingDir, appId, hidden, base = []) {
+    if (!isValidAppId(appId)) {
+        throw new SpaceAppConfigError(`Invalid built-in app id '${appId}' — expected the D5 grammar (lowercase [a-z0-9-])`);
+    }
+    const inherited = normalizeHiddenBuiltins(base) ?? [];
+    return withFileLock(spaceAppsLockPath(workingDir), () => {
+        const document = loadSpaceAppsDocument(workingDir);
+        const current = document.hiddenBuiltins ?? inherited;
+        if (current.includes(appId) === hidden)
+            return { changed: false, ...configOf(document) };
+        if (hidden && current.length >= MAX_HIDDEN_BUILTINS) {
+            throw new SpaceAppConfigError(`This Space already removes ${MAX_HIDDEN_BUILTINS} built-in apps`);
+        }
+        const next = { ...document, hiddenBuiltins: hidden ? [...current, appId] : current.filter((id) => id !== appId) };
+        writeSpaceAppsDocument(workingDir, next);
+        return { changed: true, ...configOf(next) };
+    });
+}
+export function initSpaceHiddenBuiltins(workingDir, hiddenBuiltins) {
+    const ids = normalizeHiddenBuiltins(hiddenBuiltins) ?? [];
+    return withFileLock(spaceAppsLockPath(workingDir), () => {
+        const document = loadSpaceAppsDocument(workingDir);
+        if (document.hiddenBuiltins !== null)
+            return { changed: false, ...configOf(document) };
+        const next = { ...document, hiddenBuiltins: ids };
+        writeSpaceAppsDocument(workingDir, next);
+        return { changed: true, ...configOf(next) };
+    });
+}

package/dist/server/services/auth.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { ensureMachineDir, machineFile } from '../../bin/machine-layout.js';
+function sessionTokenPath() {
+    return machineFile('sessionToken');
+}
+export class AuthService {
+    localToken;
+    constructor() {
+        this.localToken = this.loadOrCreateToken();
+    }
+    loadOrCreateToken() {
+        const existing = AuthService.readLocalToken();
+        if (existing) {
+            return existing;
+        }
+        const token = randomBytes(32).toString('hex');
+        this.writeToken(token);
+        return token;
+    }
+    writeToken(token) {
+        ensureMachineDir('credentials');
+        writeFileSync(sessionTokenPath(), token, { mode: 0o600 });
+    }
+    validateLocalToken(token) {
+        if (token.length !== this.localToken.length)
+            return false;
+        return timingSafeEqual(Buffer.from(token), Buffer.from(this.localToken));
+    }
+    getLocalToken() {
+        return this.localToken;
+    }
+    static readLocalToken() {
+        try {
+            const path = sessionTokenPath();
+            if (existsSync(path)) {
+                const token = readFileSync(path, 'utf-8').trim();
+                if (token.length > 0) {
+                    return token;
+                }
+            }
+        }
+        catch { }
+        return null;
+    }
+}

package/dist/server/services/browser/chrome-sandbox.js

@@ -0,0 +1,245 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn as nodeSpawn } from 'node:child_process';
+import { chmodSync, chownSync, existsSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { platform as osPlatform } from 'node:os';
+import { delimiter, dirname, join } from 'node:path';
+export const ROOT_UID = 0;
+export const REQUIRED_MODE = 0o4755;
+const DEFAULT_SUDO_TIMEOUT_MS = 5_000;
+const TAIL_CAP = 2_000;
+export function resolveChromeSandboxPath(electronBinary) {
+    return join(dirname(electronBinary), 'chrome-sandbox');
+}
+export function isSandboxConfigured(uid, mode) {
+    return uid === ROOT_UID && (mode & 0o7777) === REQUIRED_MODE;
+}
+export function buildFixSteps(sandboxPath) {
+    return [`sudo chown root:root '${sandboxPath}'`, `sudo chmod 4755 '${sandboxPath}'`];
+}
+export function buildFixCommand(sandboxPath) {
+    return buildFixSteps(sandboxPath).join(' && ');
+}
+export function inspectChromeSandbox(sandboxPath, stat = statSync) {
+    try {
+        const s = stat(sandboxPath);
+        return {
+            path: sandboxPath,
+            exists: true,
+            uid: s.uid,
+            mode: s.mode,
+            ok: isSandboxConfigured(s.uid, s.mode),
+        };
+    }
+    catch {
+        return { path: sandboxPath, exists: false, uid: null, mode: null, ok: false };
+    }
+}
+const defaultSpawn = (cmd, args, opts) => new Promise((resolveExit) => {
+    let settled = false;
+    const finish = (r) => {
+        if (settled)
+            return;
+        settled = true;
+        resolveExit(r);
+    };
+    const inherit = opts.inheritStdio === true;
+    let tail = '';
+    let child;
+    try {
+        child = nodeSpawn(cmd, args, {
+            stdio: inherit ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+    }
+    catch (err) {
+        finish({ ok: false, code: null, tail: `spawn error: ${err.message}` });
+        return;
+    }
+    let timer = null;
+    if (!inherit && opts.timeoutMs && opts.timeoutMs > 0) {
+        timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+            }
+            finish({ ok: false, code: null, tail: `${tail}\n(timed out after ${opts.timeoutMs}ms)`.slice(-TAIL_CAP) });
+        }, opts.timeoutMs);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+    }
+    if (!inherit) {
+        const append = (chunk) => {
+            tail = (tail + chunk.toString('utf8')).slice(-TAIL_CAP);
+        };
+        child.stdout?.on('data', append);
+        child.stderr?.on('data', append);
+    }
+    child.on('error', (err) => {
+        if (timer)
+            clearTimeout(timer);
+        finish({ ok: false, code: null, tail: `${tail}\nspawn error: ${err.message}`.slice(-TAIL_CAP) });
+    });
+    child.on('exit', (code) => {
+        if (timer)
+            clearTimeout(timer);
+        finish({ ok: code === 0, code, tail });
+    });
+});
+export class DirectElevator {
+    deps;
+    id = 'direct';
+    constructor(deps) {
+        this.deps = deps;
+    }
+    isAvailable() {
+        try {
+            return this.deps.geteuid() === ROOT_UID;
+        }
+        catch {
+            return false;
+        }
+    }
+    async elevate(sandboxPath) {
+        try {
+            this.deps.chown(sandboxPath, ROOT_UID, ROOT_UID);
+            this.deps.chmod(sandboxPath, REQUIRED_MODE);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+}
+export class SudoElevator {
+    deps;
+    id = 'sudo';
+    constructor(deps) {
+        this.deps = deps;
+    }
+    isAvailable() {
+        try {
+            return this.deps.lookupPath('sudo');
+        }
+        catch {
+            return false;
+        }
+    }
+    async elevate(sandboxPath, ctx) {
+        const chain = `chown root:root '${sandboxPath}' && chmod 4755 '${sandboxPath}'`;
+        const args = ctx.interactive ? ['sh', '-c', chain] : ['-n', 'sh', '-c', chain];
+        try {
+            const r = await this.deps.spawn('sudo', args, {
+                timeoutMs: ctx.interactive ? 0 : this.deps.timeoutMs,
+                inheritStdio: ctx.interactive,
+            });
+            return { ok: r.ok, error: r.ok ? undefined : r.tail.trim() || `sudo exited ${r.code ?? 'null'}` };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+}
+function defaultResolveElectronBinary() {
+    try {
+        const require_ = createRequire(import.meta.url);
+        const resolved = require_('electron');
+        return typeof resolved === 'string' ? resolved : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultStat(path) {
+    const s = statSync(path);
+    return { uid: s.uid, mode: s.mode };
+}
+export function defaultGeteuid() {
+    return typeof process.geteuid === 'function' ? process.geteuid() : -1;
+}
+function defaultLookupPath(cmd) {
+    const pathEnv = process.env.PATH ?? '';
+    for (const dir of pathEnv.split(delimiter)) {
+        if (dir && existsSync(join(dir, cmd)))
+            return true;
+    }
+    return false;
+}
+export class ChromeSandboxConfigurator {
+    resolveElectronBinary;
+    stat;
+    platform;
+    log;
+    elevators;
+    constructor(deps = {}) {
+        this.resolveElectronBinary = deps.resolveElectronBinary ?? defaultResolveElectronBinary;
+        this.stat = deps.stat ?? defaultStat;
+        this.platform = deps.platform ?? osPlatform();
+        this.log = deps.log ?? (() => { });
+        this.elevators = deps.elevators ?? [
+            new DirectElevator({
+                geteuid: deps.geteuid ?? defaultGeteuid,
+                chown: deps.chown ?? chownSync,
+                chmod: deps.chmod ?? chmodSync,
+            }),
+            new SudoElevator({
+                spawn: deps.spawn ?? defaultSpawn,
+                lookupPath: deps.lookupPath ?? defaultLookupPath,
+                timeoutMs: deps.timeoutMs ?? DEFAULT_SUDO_TIMEOUT_MS,
+            }),
+        ];
+    }
+    async ensure(opts = {}) {
+        try {
+            return await this.ensureInner(opts);
+        }
+        catch (err) {
+            return { ok: false, changed: false, state: 'cannot-fix', path: null, error: err.message };
+        }
+    }
+    async ensureInner({ interactive = false }) {
+        if (this.platform === 'win32') {
+            return { ok: true, changed: false, state: 'skipped-platform', path: null };
+        }
+        const binary = this.resolveElectronBinary();
+        if (!binary) {
+            return { ok: true, changed: false, state: 'absent', path: null };
+        }
+        const sandboxPath = resolveChromeSandboxPath(binary);
+        const before = inspectChromeSandbox(sandboxPath, this.stat);
+        if (!before.exists) {
+            return { ok: true, changed: false, state: 'absent', path: sandboxPath };
+        }
+        if (before.ok) {
+            return { ok: true, changed: false, state: 'already-ok', path: sandboxPath };
+        }
+        return this.repair(sandboxPath, interactive);
+    }
+    async repair(sandboxPath, interactive) {
+        for (const elevator of this.elevators) {
+            if (!elevator.isAvailable())
+                continue;
+            this.log(`chrome-sandbox: attempting fix via ${elevator.id}…`);
+            const outcome = await elevator.elevate(sandboxPath, { interactive });
+            if (inspectChromeSandbox(sandboxPath, this.stat).ok) {
+                return { ok: true, changed: true, state: 'fixed', path: sandboxPath, strategyUsed: elevator.id };
+            }
+            if (!outcome.ok) {
+                this.log(`chrome-sandbox: ${elevator.id} could not elevate (${outcome.error ?? 'unknown'}).`);
+            }
+        }
+        return {
+            ok: false,
+            changed: false,
+            state: 'cannot-fix',
+            path: sandboxPath,
+            manualCommand: buildFixCommand(sandboxPath),
+        };
+    }
+}
+export function ensureChromeSandbox(opts = {}) {
+    const { interactive, ...deps } = opts;
+    return new ChromeSandboxConfigurator(deps).ensure({ interactive });
+}

package/dist/server/services/browser/chromium-launch-spec.js

@@ -0,0 +1,51 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync } from 'node:fs';
+const CORE_DUMP_SHELL = '/bin/sh';
+export function chromiumLaunchFlags(input) {
+    const { platform, env, xvfbDisplayNumber, sandboxEnabled } = input;
+    const flags = [];
+    if (env.MINIONRY_WEBRTC_IPV6 !== '1') {
+        flags.push('--force-fieldtrials=WebRTC-IPv6Default/Disabled/');
+    }
+    if (platform !== 'linux')
+        return flags;
+    if (!sandboxEnabled)
+        flags.push('--no-sandbox');
+    if (env.MINIONRY_GPU !== '1')
+        flags.push('--disable-gpu');
+    if (xvfbDisplayNumber !== null)
+        flags.push('--ozone-platform=x11');
+    flags.push('--disable-renderer-backgrounding');
+    flags.push('--disable-backgrounding-occluded-windows');
+    flags.push('--disable-background-timer-throttling');
+    if (env.MINIONRY_DBUS !== '1') {
+        flags.push('--password-store=basic');
+        flags.push('--use-mock-keychain');
+        flags.push('--disable-features=MediaRouter,DialMediaRouteProvider,GlobalShortcutsPortal,GlobalMediaControls,HardwareMediaKeyHandling,BatteryStatus');
+    }
+    return flags;
+}
+export function childEnvOverrides(input) {
+    const overrides = {};
+    if (input.xvfbDisplayNumber !== null) {
+        overrides.DISPLAY = `:${input.xvfbDisplayNumber}`;
+        overrides.WAYLAND_DISPLAY = '';
+    }
+    if (input.platform === 'linux' && !input.env.DBUS_SESSION_BUS_ADDRESS) {
+        overrides.DBUS_SESSION_BUS_ADDRESS = 'disabled:';
+    }
+    overrides.ELECTRON_DISABLE_SECURITY_WARNINGS = 'true';
+    if (input.sdkStubPath)
+        overrides.MINIONRY_SDK_STUB_PATH = input.sdkStubPath;
+    Object.assign(overrides, input.audioSinkOverrides);
+    return overrides;
+}
+export function withoutCoreDumps(platform, binary, args, shellExists = existsSync) {
+    if (platform !== 'linux' || !shellExists(CORE_DUMP_SHELL))
+        return { command: binary, args };
+    return {
+        command: CORE_DUMP_SHELL,
+        args: ['-c', 'ulimit -c 0 2>/dev/null; exec "$0" "$@"', binary, ...args],
+    };
+}