@minionry/minion 0.7.36

package/dist/server/services/settings.js

@@ -0,0 +1,374 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync } from 'node:fs';
+import { ensureMachineDir, machineFile, machineLockPath } from '../../bin/machine-layout.js';
+import { ENGINE_IDS, isEngineId } from '../engines/types.js';
+import { withFileLock, writeFileAtomic } from '../utils/file-store.js';
+import { getClientId } from './client-id.js';
+function settingsFile() {
+    return machineFile('settings');
+}
+function settingsLock() {
+    return machineLockPath('settings');
+}
+export const BOUNCER_ELIGIBLE_MODELS = {
+    'claude-code': ['haiku', 'sonnet'],
+    codex: [],
+    hermes: [],
+};
+export const DEFAULT_BOUNCER_CLASSIFIER = {
+    engine: 'claude-code',
+    model: 'haiku',
+};
+export const DEFAULT_SHADOW_EVAL_CONFIG = {
+    enabled: false,
+    sampleRate: 0.1,
+    referenceModel: 'sonnet',
+    divergenceThreshold: 0.2,
+    maxSamplesPerRun: 50,
+};
+function clampUnitInterval(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+export function normalizeShadowEvalConfig(config) {
+    if (config === null || typeof config !== 'object') {
+        return { ...DEFAULT_SHADOW_EVAL_CONFIG };
+    }
+    const c = config;
+    const referenceModel = typeof c.referenceModel === 'string' && c.referenceModel.trim().length > 0
+        ? c.referenceModel.trim()
+        : DEFAULT_SHADOW_EVAL_CONFIG.referenceModel;
+    const maxSamplesPerRun = typeof c.maxSamplesPerRun === 'number' &&
+        Number.isFinite(c.maxSamplesPerRun) &&
+        c.maxSamplesPerRun > 0
+        ? Math.floor(c.maxSamplesPerRun)
+        : DEFAULT_SHADOW_EVAL_CONFIG.maxSamplesPerRun;
+    return {
+        enabled: c.enabled === true,
+        sampleRate: clampUnitInterval(c.sampleRate, DEFAULT_SHADOW_EVAL_CONFIG.sampleRate),
+        referenceModel,
+        divergenceThreshold: clampUnitInterval(c.divergenceThreshold, DEFAULT_SHADOW_EVAL_CONFIG.divergenceThreshold),
+        maxSamplesPerRun,
+    };
+}
+export function validateBouncerClassifier(config) {
+    if (config === null || typeof config !== 'object') {
+        throw new Error('bouncerClassifier must be an object with { engine, model }');
+    }
+    const { engine, model } = config;
+    if (!isEngineId(engine)) {
+        throw new Error(`bouncerClassifier.engine must be one of ${ENGINE_IDS.join(', ')} (got ${String(engine)})`);
+    }
+    if (typeof model !== 'string' || model.length === 0) {
+        throw new Error('bouncerClassifier.model must be a non-empty string');
+    }
+    const eligible = BOUNCER_ELIGIBLE_MODELS[engine];
+    if (!eligible.includes(model)) {
+        throw new Error(`Model '${model}' is not bouncer-eligible for engine '${engine}'. ` +
+            `Eligible models: ${eligible.join(', ')}. ` +
+            `Frontier models (Opus, GPT-4o, etc.) are deliberately excluded to keep the classifier fast.`);
+    }
+    return { engine, model };
+}
+export const DEFAULT_MAX_CONCURRENT_SESSIONS = 0;
+const SETTINGS_SCHEMA_VERSION = 1;
+const DEFAULT_SETTINGS = {
+    schemaVersion: SETTINGS_SCHEMA_VERSION,
+    model: 'opus',
+    effortLevel: 'auto',
+    fastMode: false,
+    subagentModel: 'auto',
+    subagentModelForce: false,
+    maxConcurrentSessions: DEFAULT_MAX_CONCURRENT_SESSIONS,
+    engine: 'claude-code',
+    qualityModel: 'default',
+    qualityEngine: 'claude-code',
+    qualityEffortLevel: 'auto',
+    qualityFastMode: false,
+    qualityAgentNotes: true,
+    bouncerClassifier: { ...DEFAULT_BOUNCER_CLASSIFIER },
+    bouncerClassifierOverrides: {},
+    shadowEval: { ...DEFAULT_SHADOW_EVAL_CONFIG },
+    maxUploadSizeMb: 0,
+    browser: { allowlist: [] },
+};
+function ensureMinionryDir() {
+    ensureMachineDir('config');
+}
+function migrateStoredSettings(stored) {
+    if (stored === null || typeof stored !== 'object' || Array.isArray(stored))
+        return {};
+    const doc = stored;
+    const version = typeof doc.schemaVersion === 'number' ? doc.schemaVersion : 0;
+    if (version >= SETTINGS_SCHEMA_VERSION)
+        return doc;
+    const migrated = { ...doc, schemaVersion: SETTINGS_SCHEMA_VERSION };
+    if (migrated.maxConcurrentSessions === 3) {
+        migrated.maxConcurrentSessions = DEFAULT_MAX_CONCURRENT_SESSIONS;
+    }
+    return migrated;
+}
+export function getSettings() {
+    const file = settingsFile();
+    if (!existsSync(file)) {
+        return { ...DEFAULT_SETTINGS };
+    }
+    try {
+        const content = readFileSync(file, 'utf-8');
+        const stored = migrateStoredSettings(JSON.parse(content));
+        const merged = {
+            ...DEFAULT_SETTINGS,
+            ...stored,
+        };
+        if (stored && typeof stored === 'object' && 'bouncerClassifier' in stored) {
+            try {
+                merged.bouncerClassifier = validateBouncerClassifier(stored.bouncerClassifier);
+            }
+            catch (err) {
+                console.warn('[settings] Stored bouncerClassifier is not bouncer-eligible, falling back to default:', err instanceof Error ? err.message : String(err));
+                merged.bouncerClassifier = { ...DEFAULT_BOUNCER_CLASSIFIER };
+            }
+        }
+        merged.maxConcurrentSessions = normalizeMaxConcurrentSessions(merged.maxConcurrentSessions);
+        return merged;
+    }
+    catch (err) {
+        console.warn('Failed to read settings file, using defaults:', err);
+        return { ...DEFAULT_SETTINGS };
+    }
+}
+function writeSettingsFile(settings) {
+    if (settings.bouncerClassifier !== undefined) {
+        validateBouncerClassifier(settings.bouncerClassifier);
+    }
+    ensureMinionryDir();
+    writeFileAtomic(settingsFile(), JSON.stringify(settings, null, 2), { mode: 0o600 });
+}
+function mutateSettings(apply) {
+    return withFileLock(settingsLock(), () => {
+        const settings = getSettings();
+        const result = apply(settings);
+        writeSettingsFile(settings);
+        return result;
+    });
+}
+export function getModel() {
+    return getSettings().model;
+}
+export function setModel(model) {
+    mutateSettings((settings) => {
+        settings.model = model;
+    });
+}
+export function resolveEnabledEngineId(value) {
+    return isEngineId(value) ? value : 'claude-code';
+}
+export function getEngine() {
+    return resolveEnabledEngineId(getSettings().engine);
+}
+export function setEngine(engine) {
+    mutateSettings((settings) => {
+        settings.engine = engine;
+    });
+}
+export function getEffortLevel() {
+    return getSettings().effortLevel;
+}
+export function setEffortLevel(effortLevel) {
+    mutateSettings((settings) => {
+        settings.effortLevel = effortLevel;
+    });
+}
+export function getFastMode() {
+    return getSettings().fastMode === true;
+}
+export function setFastMode(fastMode) {
+    mutateSettings((settings) => {
+        settings.fastMode = fastMode;
+    });
+}
+export function getSubagentModel() {
+    const value = getSettings().subagentModel;
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : 'auto';
+}
+export function setSubagentModel(subagentModel) {
+    mutateSettings((settings) => {
+        settings.subagentModel = subagentModel.trim() || 'auto';
+    });
+}
+export function getSubagentModelForce() {
+    return getSettings().subagentModelForce === true;
+}
+export function setSubagentModelForce(force) {
+    mutateSettings((settings) => {
+        settings.subagentModelForce = force;
+    });
+}
+function normalizeMaxConcurrentSessions(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.floor(value)
+        : DEFAULT_MAX_CONCURRENT_SESSIONS;
+}
+export function getMaxConcurrentSessions() {
+    return normalizeMaxConcurrentSessions(getSettings().maxConcurrentSessions);
+}
+export function setMaxConcurrentSessions(max) {
+    mutateSettings((settings) => {
+        settings.maxConcurrentSessions = normalizeMaxConcurrentSessions(max);
+    });
+}
+export function getQualityModel() {
+    return getSettings().qualityModel ?? 'default';
+}
+export function setQualityModel(qualityModel) {
+    mutateSettings((settings) => {
+        settings.qualityModel = qualityModel;
+    });
+}
+export function getQualityEngine() {
+    const engine = getSettings().qualityEngine;
+    return isEngineId(engine) ? engine : 'claude-code';
+}
+export function setQualityEngine(qualityEngine) {
+    mutateSettings((settings) => {
+        settings.qualityEngine = qualityEngine;
+    });
+}
+export function getQualityEffortLevel() {
+    return getSettings().qualityEffortLevel ?? 'auto';
+}
+export function setQualityEffortLevel(qualityEffortLevel) {
+    mutateSettings((settings) => {
+        settings.qualityEffortLevel = qualityEffortLevel;
+    });
+}
+export function getQualityFastMode() {
+    return getSettings().qualityFastMode === true;
+}
+export function setQualityFastMode(qualityFastMode) {
+    mutateSettings((settings) => {
+        settings.qualityFastMode = qualityFastMode;
+    });
+}
+export function getQualityAgentNotes() {
+    return getSettings().qualityAgentNotes !== false;
+}
+export function setQualityAgentNotes(qualityAgentNotes) {
+    mutateSettings((settings) => {
+        settings.qualityAgentNotes = qualityAgentNotes;
+    });
+}
+export function updateQualitySettings(patch) {
+    const defined = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+    if (Object.keys(defined).length === 0)
+        return;
+    mutateSettings((settings) => {
+        Object.assign(settings, defined);
+    });
+}
+export function setMaxUploadSizeMb(maxUploadSizeMb) {
+    const safe = Number.isFinite(maxUploadSizeMb) && maxUploadSizeMb > 0 ? Math.floor(maxUploadSizeMb) : 0;
+    mutateSettings((settings) => {
+        settings.maxUploadSizeMb = safe;
+    });
+}
+export function getMaxUploadBytes() {
+    const mb = getSettings().maxUploadSizeMb;
+    return typeof mb === 'number' && Number.isFinite(mb) && mb > 0 ? Math.floor(mb) * 1024 * 1024 : 0;
+}
+export function uploadTooLargeMessage(bytes, limitBytes) {
+    const mb = (n) => (n / 1024 / 1024).toFixed(1).replace(/\.0$/, '');
+    return `File too large: ${mb(bytes)}MB exceeds the ${mb(limitBytes)}MB upload limit for this machine`;
+}
+export function getBouncerClassifier() {
+    const settings = getSettings();
+    if (settings.bouncerClassifier) {
+        try {
+            return validateBouncerClassifier(settings.bouncerClassifier);
+        }
+        catch {
+            return { ...DEFAULT_BOUNCER_CLASSIFIER };
+        }
+    }
+    return { ...DEFAULT_BOUNCER_CLASSIFIER };
+}
+export function setBouncerClassifier(config) {
+    const validated = validateBouncerClassifier(config);
+    return mutateSettings((settings) => {
+        settings.bouncerClassifier = validated;
+        return validated;
+    });
+}
+export function makeSpaceKey(clientId, workingDirectory) {
+    return `${clientId}:${workingDirectory}`;
+}
+export function getCurrentWorkingDirectory() {
+    return process.env.MINIONRY_WORKING_DIR || process.env.WORKING_DIR || process.cwd();
+}
+export function getCurrentSpaceIdentity() {
+    return { clientId: getClientId(), workingDirectory: getCurrentWorkingDirectory() };
+}
+export function getBouncerClassifierOverride(clientId, workingDirectory) {
+    const settings = getSettings();
+    const overrides = settings.bouncerClassifierOverrides;
+    if (!overrides || typeof overrides !== 'object')
+        return undefined;
+    return overrides[makeSpaceKey(clientId, workingDirectory)];
+}
+export function setBouncerClassifierOverride(clientId, workingDirectory, config) {
+    const validated = validateBouncerClassifier(config);
+    return mutateSettings((settings) => {
+        const overrides = { ...(settings.bouncerClassifierOverrides ?? {}) };
+        overrides[makeSpaceKey(clientId, workingDirectory)] = validated;
+        settings.bouncerClassifierOverrides = overrides;
+        return validated;
+    });
+}
+export function clearBouncerClassifierOverride(clientId, workingDirectory) {
+    mutateSettings((settings) => {
+        const overrides = { ...(settings.bouncerClassifierOverrides ?? {}) };
+        delete overrides[makeSpaceKey(clientId, workingDirectory)];
+        settings.bouncerClassifierOverrides = overrides;
+    });
+}
+export function getShadowEvalConfig() {
+    return normalizeShadowEvalConfig(getSettings().shadowEval);
+}
+export function setShadowEvalConfig(config) {
+    const normalized = normalizeShadowEvalConfig(config);
+    return mutateSettings((settings) => {
+        settings.shadowEval = normalized;
+        return normalized;
+    });
+}
+export function getBrowserAllowlist() {
+    const settings = getSettings();
+    const list = settings.browser?.allowlist;
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+}
+function normalizeRemoteUrl(remoteUrl) {
+    return remoteUrl
+        .replace(/^(https?:\/\/|git@)/, '')
+        .replace(/\.git$/, '')
+        .replace(/:/, '/');
+}
+export function getPrBaseBranch(remoteUrl) {
+    const settings = getSettings();
+    const key = normalizeRemoteUrl(remoteUrl);
+    return settings.prBaseBranches?.[key] ?? null;
+}
+export function setPrBaseBranch(remoteUrl, branch) {
+    mutateSettings((settings) => {
+        if (!settings.prBaseBranches)
+            settings.prBaseBranches = {};
+        settings.prBaseBranches[normalizeRemoteUrl(remoteUrl)] = branch;
+    });
+}

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

@@ -0,0 +1,87 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { findSnippetTokens } from './parser.js';
+export const MAX_DEPTH = 15;
+export const MAX_EXPANSIONS = 200;
+export function createExpander(resolver) {
+    return {
+        expand(text) {
+            const state = {
+                resolver,
+                diagnostics: [],
+                expanded: new Set(),
+                substitutionCount: 0,
+                fanoutHit: false,
+            };
+            const result = expandRecursive(text, new Set(), 0, state);
+            return {
+                text: result,
+                expanded: Array.from(state.expanded),
+                diagnostics: state.diagnostics,
+            };
+        },
+    };
+}
+function expandRecursive(text, visited, depth, state) {
+    if (state.fanoutHit)
+        return text;
+    const tokens = findSnippetTokens(text);
+    if (tokens.length === 0)
+        return text;
+    if (depth >= MAX_DEPTH) {
+        state.diagnostics.push({
+            kind: 'depth-exceeded',
+            name: tokens[0].name,
+            chain: Array.from(visited),
+        });
+        return text;
+    }
+    return rebuildWithSubstitutions(text, tokens, visited, depth, state);
+}
+function rebuildWithSubstitutions(text, tokens, visited, depth, state) {
+    let out = '';
+    let cursor = 0;
+    for (const token of tokens) {
+        out += text.slice(cursor, token.start);
+        out += resolveOne(token, visited, depth, state);
+        cursor = token.end;
+        if (state.fanoutHit) {
+            out += text.slice(cursor);
+            return out;
+        }
+    }
+    out += text.slice(cursor);
+    return out;
+}
+function resolveOne(token, visited, depth, state) {
+    const original = `#${token.name}`;
+    const snippet = state.resolver.resolve(token.name);
+    if (!snippet) {
+        state.diagnostics.push({ kind: 'missing', name: token.name });
+        return original;
+    }
+    if (visited.has(snippet.name)) {
+        state.diagnostics.push({
+            kind: 'cycle',
+            name: snippet.name,
+            chain: [...visited, snippet.name],
+        });
+        return original;
+    }
+    state.substitutionCount += 1;
+    if (state.substitutionCount > MAX_EXPANSIONS) {
+        if (!state.fanoutHit) {
+            state.fanoutHit = true;
+            state.diagnostics.push({
+                kind: 'depth-exceeded',
+                name: snippet.name,
+                chain: [...visited, snippet.name],
+            });
+        }
+        return original;
+    }
+    state.expanded.add(snippet.name);
+    const childVisited = new Set(visited);
+    childVisited.add(snippet.name);
+    return expandRecursive(snippet.body, childVisited, depth + 1, state);
+}

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

@@ -0,0 +1,6 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export { createExpander, MAX_DEPTH } from './expander.js';
+export { defaultSnippetSources, SnippetRegistry } from './loader.js';
+export { findSnippetTokens } from './parser.js';
+export { SnippetWatcher } from './watcher.js';

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

@@ -0,0 +1,119 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { machinePath } from '../../../bin/machine-layout.js';
+import { parseFrontMatter } from '../plan/parser-core.js';
+import { spacePath } from '../space-layout.js';
+const VALID_NAME_RE = /^[a-z][a-z0-9-]*$/;
+const MAX_DESCRIPTION_CHARS = 500;
+function sanitizeName(raw) {
+    const cleaned = raw.toLowerCase().trim();
+    return VALID_NAME_RE.test(cleaned) ? cleaned : null;
+}
+function extractAliases(value) {
+    const collect = (entries) => entries.flatMap((entry) => {
+        if (typeof entry !== 'string')
+            return [];
+        const cleaned = sanitizeName(entry);
+        return cleaned ? [cleaned] : [];
+    });
+    if (Array.isArray(value))
+        return collect(value);
+    if (typeof value === 'string') {
+        const cleaned = sanitizeName(value);
+        return cleaned ? [cleaned] : [];
+    }
+    return [];
+}
+function loadSnippetsFromDir(source) {
+    if (!existsSync(source.dir))
+        return [];
+    const snippets = [];
+    let entries;
+    try {
+        entries = readdirSync(source.dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.md'))
+            continue;
+        const filePath = join(source.dir, entry.name);
+        let raw;
+        try {
+            raw = readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const { frontMatter, body } = parseFrontMatter(raw);
+        const name = sanitizeName(basename(entry.name, extname(entry.name)));
+        if (!name)
+            continue;
+        const aliases = extractAliases(frontMatter.aliases);
+        const description = typeof frontMatter.description === 'string'
+            ? frontMatter.description.slice(0, MAX_DESCRIPTION_CHARS)
+            : '';
+        snippets.push({
+            name,
+            aliases,
+            description,
+            body: body.trim(),
+            sourcePath: filePath,
+            origin: source.origin,
+        });
+    }
+    return snippets;
+}
+export class SnippetRegistry {
+    sources;
+    byName = new Map();
+    all = [];
+    constructor(sources) {
+        this.sources = sources;
+        this.reload();
+    }
+    reload() {
+        const orderedSources = sortByPriority(this.sources);
+        const byName = new Map();
+        const canonical = new Map();
+        let anyDirReadable = false;
+        for (const source of orderedSources) {
+            const loaded = loadSnippetsFromDir(source);
+            if (loaded.length > 0)
+                anyDirReadable = true;
+            for (const snippet of loaded) {
+                canonical.set(snippet.name, snippet);
+                byName.set(snippet.name, snippet);
+                for (const alias of snippet.aliases) {
+                    byName.set(alias, snippet);
+                }
+            }
+        }
+        if (this.all.length > 0 && canonical.size === 0 && !anyDirReadable)
+            return;
+        this.byName = byName;
+        this.all = Array.from(canonical.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    resolve(name) {
+        return this.byName.get(name) ?? null;
+    }
+    list() {
+        return this.all;
+    }
+    sourceDir(origin) {
+        return this.sources.find((s) => s.origin === origin)?.dir ?? null;
+    }
+}
+function sortByPriority(sources) {
+    const rank = { personal: 0, project: 1 };
+    return [...sources].sort((a, b) => rank[a.origin] - rank[b.origin]);
+}
+export function defaultSnippetSources(workingDir) {
+    return [
+        { dir: spacePath(workingDir, 'snippets'), origin: 'project' },
+        { dir: machinePath('snippets'), origin: 'personal' },
+    ];
+}

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

@@ -0,0 +1,52 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const FENCED_RE = /```[\s\S]*?```/g;
+const INLINE_CODE_RE = /`[^`\n]*`/g;
+function collectRanges(text, regex) {
+    const ranges = [];
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        ranges.push({ start: match.index, end: match.index + match[0].length });
+    }
+    return ranges;
+}
+function isInside(pos, ranges) {
+    for (const r of ranges) {
+        if (pos >= r.start && pos < r.end)
+            return true;
+    }
+    return false;
+}
+function isWordChar(ch) {
+    return ch !== undefined && /[A-Za-z0-9_]/.test(ch);
+}
+function looksLikeUrlFragment(text, hashPos) {
+    let i = hashPos - 1;
+    while (i >= 0 && !/\s/.test(text[i]))
+        i--;
+    const segment = text.slice(i + 1, hashPos);
+    return segment.includes('://');
+}
+export function findSnippetTokens(text) {
+    if (!text.includes('#'))
+        return [];
+    const skipRegions = [
+        ...collectRanges(text, FENCED_RE),
+        ...collectRanges(text, INLINE_CODE_RE),
+    ];
+    const snippetNameRe = /#([a-z][a-z0-9-]*)/g;
+    const tokens = [];
+    let match;
+    while ((match = snippetNameRe.exec(text)) !== null) {
+        const start = match.index;
+        if (isInside(start, skipRegions))
+            continue;
+        if (looksLikeUrlFragment(text, start))
+            continue;
+        if (start > 0 && isWordChar(text[start - 1]))
+            continue;
+        tokens.push({ name: match[1], start, end: start + match[0].length });
+    }
+    return tokens;
+}

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

@@ -0,0 +1,3 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export {};