@minionry/minion 0.7.36

package/dist/server/services/snippets/watcher.js

@@ -0,0 +1,60 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { watch } from 'node:fs';
+const DEBOUNCE_MS = 250;
+export class SnippetWatcher {
+    registry;
+    sources;
+    onReload;
+    watchers = [];
+    debounceTimer = null;
+    started = false;
+    constructor(registry, sources, onReload) {
+        this.registry = registry;
+        this.sources = sources;
+        this.onReload = onReload;
+    }
+    start() {
+        if (this.started)
+            return;
+        for (const source of this.sources) {
+            try {
+                const w = watch(source.dir, { recursive: false }, (_event, filename) => {
+                    if (!filename?.toString().endsWith('.md'))
+                        return;
+                    this.debounce();
+                });
+                w.on('error', () => { });
+                this.watchers.push(w);
+            }
+            catch {   }
+        }
+        this.started = true;
+    }
+    stop() {
+        for (const w of this.watchers) {
+            try {
+                w.close();
+            }
+            catch {   }
+        }
+        this.watchers = [];
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.started = false;
+    }
+    debounce() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            try {
+                this.registry.reload();
+                this.onReload?.();
+            }
+            catch {   }
+        }, DEBOUNCE_MS);
+    }
+}

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

@@ -0,0 +1,80 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, renameSync, rmdirSync } from 'node:fs';
+import { join } from 'node:path';
+export const SPACE_DIRNAME = '.minionry';
+export const SPACE_LAYOUT = {
+    specs: 'specs',
+    snippets: 'snippets',
+    appsRoster: 'apps.json',
+    boardExport: 'board',
+    history: 'history',
+    exports: 'exports',
+    agents: 'agents',
+    quality: 'quality',
+    sessionRegistry: 'session-registry.json',
+    apps: 'apps',
+    logs: 'logs',
+    tmp: 'tmp',
+};
+export const LEGACY_SPECS_DIRNAME = 'pm';
+export function spaceRoot(workingDir) {
+    return join(workingDir, SPACE_DIRNAME);
+}
+export function spacePath(workingDir, entry, ...rest) {
+    return join(workingDir, SPACE_DIRNAME, SPACE_LAYOUT[entry], ...rest);
+}
+export function specsDir(workingDir) {
+    return spacePath(workingDir, 'specs');
+}
+const warnedStaleLegacy = new Set();
+const legacyFallback = new Set();
+function report(message, err) {
+    if (err === undefined)
+        console.warn(`[SpaceLayout] ${message}`);
+    else
+        console.warn(`[SpaceLayout] ${message}`, err);
+}
+function removeIfEmptyDir(dir) {
+    try {
+        rmdirSync(dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveSpecsDir(workingDir) {
+    const specs = specsDir(workingDir);
+    const legacy = join(spaceRoot(workingDir), LEGACY_SPECS_DIRNAME);
+    if (existsSync(specs)) {
+        if (!existsSync(legacy))
+            return specs;
+        if (!removeIfEmptyDir(specs)) {
+            if (!warnedStaleLegacy.has(workingDir)) {
+                warnedStaleLegacy.add(workingDir);
+                report(`${legacy} is a leftover from before the Specs rename and is ignored; ${specs} is the live directory`);
+            }
+            return specs;
+        }
+    }
+    if (!existsSync(legacy))
+        return null;
+    if (legacyFallback.has(workingDir))
+        return legacy;
+    try {
+        renameSync(legacy, specs);
+        report(`Migrated ${legacy} → ${specs}`);
+        return specs;
+    }
+    catch (err) {
+        if (existsSync(specs))
+            return specs;
+        legacyFallback.add(workingDir);
+        report(`Could not rename ${legacy} to ${specs}; this process continues with the legacy directory and will retry on its next start:`, err);
+        return legacy;
+    }
+}
+export function specsDirOrDefault(workingDir) {
+    return resolveSpecsDir(workingDir) ?? specsDir(workingDir);
+}

package/dist/server/services/system-prompts.js

@@ -0,0 +1,219 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { machinePath } from '../../bin/machine-layout.js';
+const PROFILE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const LANG_PATTERN = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})?$/i;
+export const MAX_SYSTEM_PROMPT_LENGTH = 100_000;
+export function systemPromptsDir(baseDir) {
+    return baseDir ?? machinePath('prompts');
+}
+function deriveLabel(content) {
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const heading = line.match(/^#{1,6}\s+(.+)$/);
+        return (heading ? heading[1] : line).trim().slice(0, 80);
+    }
+    return null;
+}
+function parsePromptFileName(name) {
+    if (!name.toLowerCase().endsWith('.md'))
+        return null;
+    const stem = name.slice(0, -3);
+    const dot = stem.indexOf('.');
+    if (dot === -1) {
+        return PROFILE_PATTERN.test(stem) ? { profile: stem } : null;
+    }
+    const profile = stem.slice(0, dot);
+    const lang = stem.slice(dot + 1);
+    if (!PROFILE_PATTERN.test(profile) || !LANG_PATTERN.test(lang))
+        return null;
+    return { profile, lang };
+}
+function readPromptDirEntries(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR')
+            return [];
+        throw err;
+    }
+}
+export function listSystemPromptProfiles(baseDir) {
+    const dir = systemPromptsDir(baseDir);
+    const entries = readPromptDirEntries(dir);
+    const groups = new Map();
+    for (const entry of entries) {
+        const parsed = parsePromptFileName(entry);
+        if (!parsed)
+            continue;
+        const group = groups.get(parsed.profile) ?? { languages: new Set(), hasBase: false };
+        if (parsed.lang)
+            group.languages.add(parsed.lang);
+        else
+            group.hasBase = true;
+        groups.set(parsed.profile, group);
+    }
+    const profiles = [];
+    for (const [profile, group] of groups) {
+        const fileName = `${profile}.md`;
+        const basePath = join(dir, fileName);
+        let label = profile;
+        if (group.hasBase) {
+            try {
+                label = deriveLabel(readFileSync(basePath, 'utf8')) ?? profile;
+            }
+            catch {
+            }
+        }
+        profiles.push({
+            profile,
+            label,
+            languages: [...group.languages].sort(),
+            fileName,
+            path: basePath,
+        });
+    }
+    return profiles.sort((a, b) => a.profile.localeCompare(b.profile));
+}
+export function resolveSystemPromptContent(profile, lang, baseDir) {
+    if (!PROFILE_PATTERN.test(profile))
+        return undefined;
+    const dir = systemPromptsDir(baseDir);
+    const candidates = [];
+    if (lang && LANG_PATTERN.test(lang))
+        candidates.push(join(dir, `${profile}.${lang}.md`));
+    candidates.push(join(dir, `${profile}.md`));
+    for (const candidate of candidates) {
+        try {
+            const content = readFileSync(candidate, 'utf8').trim();
+            if (content)
+                return content;
+        }
+        catch {
+        }
+    }
+    return undefined;
+}
+export function resolveSystemPromptLabel(profile, baseDir) {
+    if (!PROFILE_PATTERN.test(profile))
+        return profile;
+    try {
+        const content = readFileSync(join(systemPromptsDir(baseDir), `${profile}.md`), 'utf8');
+        return deriveLabel(content) ?? profile;
+    }
+    catch {
+        return profile;
+    }
+}
+export function createSystemPrompt(rawName, baseDir, content) {
+    let name = (rawName ?? '').trim();
+    if (name.toLowerCase().endsWith('.md'))
+        name = name.slice(0, -3).trim();
+    if (!name)
+        return { success: false, error: 'Enter a name for the prompt.' };
+    if (!PROFILE_PATTERN.test(name)) {
+        return { success: false, error: 'Use letters, digits, hyphens or underscores (no spaces).' };
+    }
+    const body = content?.trim()
+        ? content
+        : `# ${name}\n\nDescribe how the agent should behave when this prompt is selected.\n`;
+    if (body.length > MAX_SYSTEM_PROMPT_LENGTH) {
+        return { success: false, error: promptTooLongError() };
+    }
+    const dir = systemPromptsDir(baseDir);
+    const fileName = `${name}.md`;
+    const path = join(dir, fileName);
+    try {
+        mkdirSync(dir, { recursive: true });
+        if (existsSync(path)) {
+            return { success: false, error: `A prompt named "${fileName}" already exists.` };
+        }
+        writeFileSync(path, body, { encoding: 'utf8', flag: 'wx' });
+        return { success: true, profile: name, fileName, path };
+    }
+    catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function promptTooLongError() {
+    return `The prompt is too long (max ${MAX_SYSTEM_PROMPT_LENGTH.toLocaleString('en-US')} characters).`;
+}
+function promptFileIdentity(profile, lang, baseDir) {
+    if (!PROFILE_PATTERN.test(profile))
+        return null;
+    if (lang !== undefined && !LANG_PATTERN.test(lang))
+        return null;
+    const fileName = lang ? `${profile}.${lang}.md` : `${profile}.md`;
+    return { fileName, path: join(systemPromptsDir(baseDir), fileName) };
+}
+export function readSystemPromptFile(profile, lang, baseDir) {
+    const identity = promptFileIdentity(profile, lang, baseDir);
+    if (!identity)
+        return { success: false, error: 'Invalid prompt name.' };
+    try {
+        const content = readFileSync(identity.path, 'utf8');
+        return { success: true, profile, lang, content, ...identity };
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return { success: true, profile, lang, content: '', ...identity };
+        }
+        return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function saveSystemPromptFile(profile, content, lang, baseDir) {
+    const identity = promptFileIdentity(profile, lang, baseDir);
+    if (!identity)
+        return { success: false, error: 'Invalid prompt name.' };
+    if (typeof content !== 'string')
+        return { success: false, error: 'Nothing to save.' };
+    if (content.length > MAX_SYSTEM_PROMPT_LENGTH) {
+        return { success: false, error: promptTooLongError() };
+    }
+    try {
+        mkdirSync(systemPromptsDir(baseDir), { recursive: true });
+        writeFileSync(identity.path, content, 'utf8');
+        return { success: true, profile, lang, ...identity };
+    }
+    catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function deleteSystemPromptProfile(profile, baseDir) {
+    if (!PROFILE_PATTERN.test(profile))
+        return { success: false, error: 'Invalid prompt name.' };
+    const dir = systemPromptsDir(baseDir);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return { success: true, profile, removed: [] };
+    }
+    const removed = [];
+    for (const entry of entries) {
+        if (parsePromptFileName(entry)?.profile !== profile)
+            continue;
+        try {
+            unlinkSync(join(dir, entry));
+            removed.push(entry);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                continue;
+            return {
+                success: false,
+                profile,
+                removed,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    return { success: true, profile, removed };
+}

package/dist/server/services/terminal/pty-manager.js

@@ -0,0 +1,206 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { EventEmitter } from 'node:events';
+import { homedir, platform } from 'node:os';
+import { detectShell, getPty, getPtyInstallInstructions, getShellName, isPtyAvailable, SCROLLBACK_MAX_LENGTH, ScrollbackBuffer, } from './pty-utils.js';
+export { isPtyAvailable, reloadPty } from './pty-utils.js';
+export class PTYManager extends EventEmitter {
+    terminals = new Map();
+    e2eeActiveProvider = null;
+    constructor() {
+        super();
+        this.setMaxListeners(50);
+    }
+    setE2eeActiveProvider(provider) {
+        this.e2eeActiveProvider = provider;
+    }
+    exists(terminalId) {
+        return this.terminals.has(terminalId);
+    }
+    getSessionInfo(terminalId) {
+        const session = this.terminals.get(terminalId);
+        if (!session)
+            return null;
+        return {
+            shell: session.shell,
+            cwd: session.cwd,
+            cols: session.cols,
+            rows: session.rows,
+            ...(session.ownerLabel !== undefined ? { ownerLabel: session.ownerLabel } : {}),
+        };
+    }
+    isPtyAvailable() {
+        return isPtyAvailable();
+    }
+    getPtyInstallInstructions() {
+        return getPtyInstallInstructions();
+    }
+    async create(terminalId, workingDir, cols = 80, rows = 24, requestedShell, ownerLabel) {
+        const pty = getPty();
+        if (!pty) {
+            throw new Error(`PTY_NOT_AVAILABLE:${getPtyInstallInstructions()}`);
+        }
+        if (this.terminals.has(terminalId)) {
+            const existingSession = this.terminals.get(terminalId);
+            existingSession.pty.resize(cols, rows);
+            existingSession.cols = cols;
+            existingSession.rows = rows;
+            return { shell: existingSession.shell, cwd: existingSession.cwd, isReconnect: true, platform: platform() };
+        }
+        const ALLOWED_SHELLS = new Set([
+            '/bin/sh', '/bin/bash', '/bin/zsh', '/usr/bin/bash', '/usr/bin/zsh',
+            '/usr/bin/fish', '/usr/local/bin/bash', '/usr/local/bin/zsh', '/usr/local/bin/fish',
+            '/bin/dash', '/usr/bin/dash',
+            'powershell.exe', 'pwsh.exe', 'cmd.exe',
+        ]);
+        const shell = (requestedShell && ALLOWED_SHELLS.has(requestedShell)) ? requestedShell : detectShell();
+        const cwd = workingDir || homedir();
+        try {
+            const env = { ...process.env, HOME: homedir(), TERM: 'xterm-256color', COLORTERM: 'truecolor', FORCE_HYPERLINK: '1' };
+            const ptyProcess = pty.spawn(shell, [], { name: 'xterm-256color', cols, rows, cwd, env });
+            const session = {
+                id: terminalId,
+                pty: ptyProcess,
+                shell: getShellName(shell),
+                cwd,
+                createdAt: Date.now(),
+                lastActivityAt: Date.now(),
+                cols,
+                rows,
+                ...(ownerLabel !== undefined ? { ownerLabel } : {}),
+                _outputBuffer: '',
+                _outputTimer: null,
+                scrollback: new ScrollbackBuffer(SCROLLBACK_MAX_LENGTH),
+            };
+            this.terminals.set(terminalId, session);
+            this.attachOutputHandlers(session, terminalId);
+            return { shell: session.shell, cwd, isReconnect: false, platform: platform() };
+        }
+        catch (error) {
+            console.error(`[PTYManager] Failed to create terminal ${terminalId}:`, error);
+            this.emit('error', terminalId, error instanceof Error ? error.message : 'Failed to create terminal');
+            throw error;
+        }
+    }
+    attachOutputHandlers(session, terminalId) {
+        const OUTPUT_COALESCE_MS = platform() === 'darwin' ? 32 : 8;
+        const OUTPUT_BUFFER_LIMIT = 64 * 1024;
+        const E2EE_OUTPUT_BUFFER_LIMIT = 256 * 1024;
+        const outputLimit = () => this.e2eeActiveProvider?.() ? E2EE_OUTPUT_BUFFER_LIMIT : OUTPUT_BUFFER_LIMIT;
+        const flushOutputBuffer = () => {
+            if (session._outputTimer) {
+                clearTimeout(session._outputTimer);
+                session._outputTimer = null;
+            }
+            const buffered = session._outputBuffer;
+            session._outputBuffer = '';
+            const chunkSize = outputLimit();
+            for (let i = 0; i < buffered.length; i += chunkSize) {
+                this.emit('output', terminalId, buffered.slice(i, i + chunkSize));
+            }
+        };
+        session.pty.onData((data) => {
+            session.scrollback.append(data);
+            session.lastActivityAt = Date.now();
+            session._outputBuffer += data;
+            if (session._outputBuffer.length >= outputLimit()) {
+                flushOutputBuffer();
+            }
+            else if (!session._outputTimer) {
+                session._outputTimer = setTimeout(flushOutputBuffer, OUTPUT_COALESCE_MS);
+            }
+        });
+        session.pty.onExit(({ exitCode }) => {
+            if (session._outputBuffer) {
+                flushOutputBuffer();
+            }
+            else if (session._outputTimer) {
+                clearTimeout(session._outputTimer);
+                session._outputTimer = null;
+            }
+            this.emit('exit', terminalId, exitCode);
+            this.terminals.delete(terminalId);
+        });
+    }
+    write(terminalId, data) {
+        const session = this.terminals.get(terminalId);
+        if (!session) {
+            console.warn(`[PTYManager] Terminal ${terminalId} not found for write`);
+            return false;
+        }
+        try {
+            session.pty.write(data);
+            return true;
+        }
+        catch (error) {
+            console.error(`[PTYManager] Error writing to terminal ${terminalId}:`, error);
+            this.emit('error', terminalId, error instanceof Error ? error.message : 'Write failed');
+            return false;
+        }
+    }
+    resize(terminalId, cols, rows) {
+        const session = this.terminals.get(terminalId);
+        if (!session) {
+            console.warn(`[PTYManager] Terminal ${terminalId} not found for resize`);
+            return false;
+        }
+        try {
+            session.pty.resize(cols, rows);
+            return true;
+        }
+        catch (error) {
+            console.error(`[PTYManager] Error resizing terminal ${terminalId}:`, error);
+            return false;
+        }
+    }
+    close(terminalId) {
+        const session = this.terminals.get(terminalId);
+        if (!session)
+            return false;
+        try {
+            if (session._outputTimer) {
+                clearTimeout(session._outputTimer);
+                if (session._outputBuffer) {
+                    this.emit('output', terminalId, session._outputBuffer);
+                    session._outputBuffer = '';
+                }
+                session._outputTimer = null;
+            }
+            session.pty.kill();
+            this.terminals.delete(terminalId);
+            return true;
+        }
+        catch (error) {
+            console.error(`[PTYManager] Error closing terminal ${terminalId}:`, error);
+            this.terminals.delete(terminalId);
+            return false;
+        }
+    }
+    getScrollback(terminalId) {
+        const session = this.terminals.get(terminalId);
+        if (!session)
+            return null;
+        return session.scrollback.getContents();
+    }
+    getSession(terminalId) {
+        return this.terminals.get(terminalId);
+    }
+    has(terminalId) {
+        return this.terminals.has(terminalId);
+    }
+    getActiveTerminals() {
+        return Array.from(this.terminals.keys());
+    }
+    closeAll() {
+        for (const terminalId of this.terminals.keys()) {
+            this.close(terminalId);
+        }
+    }
+}
+let ptyManagerInstance = null;
+export function getPTYManager() {
+    if (!ptyManagerInstance) {
+        ptyManagerInstance = new PTYManager();
+    }
+    return ptyManagerInstance;
+}