@minionry/minion 0.7.36

package/dist/server/services/sdk/grant-store.js

@@ -0,0 +1,318 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync } from 'node:fs';
+import { isScope } from '@minionry/app-manifest';
+import { ensureMachineDir, machineFile, machineLockPath } from '../../../bin/machine-layout.js';
+import { withFileLock, writeFileAtomic } from '../../utils/file-store.js';
+import { isLocalhostFamilyOrigin } from './local-app-bindings.js';
+import { isValidAppId } from './sandbox.js';
+const GRANTS_VERSION = 1;
+function grantsFilePath() {
+    return machineFile('appGrants');
+}
+function ensureMinionryDir() {
+    ensureMachineDir('state');
+}
+function emptyGrantsFile() {
+    return { version: GRANTS_VERSION, grants: {} };
+}
+function sanitizeGrant(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const raw = value;
+    if (typeof raw.appId !== 'string' ||
+        !isValidAppId(raw.appId) ||
+        typeof raw.spaceKey !== 'string' ||
+        raw.spaceKey === '' ||
+        typeof raw.origin !== 'string' ||
+        raw.origin === '' ||
+        typeof raw.manifestHash !== 'string' ||
+        raw.manifestHash === '' ||
+        typeof raw.createdAt !== 'string' ||
+        typeof raw.lastUsedAt !== 'string' ||
+        !Array.isArray(raw.scopes)) {
+        return null;
+    }
+    const grant = {
+        appId: raw.appId,
+        spaceKey: raw.spaceKey,
+        origin: raw.origin,
+        scopes: raw.scopes.filter(isScope),
+        manifestHash: raw.manifestHash,
+        createdAt: raw.createdAt,
+        lastUsedAt: raw.lastUsedAt,
+    };
+    if (typeof raw.config === 'object' && raw.config !== null && !Array.isArray(raw.config)) {
+        grant.config = raw.config;
+    }
+    const usage = sanitizeUsage(raw.usage);
+    if (usage)
+        grant.usage = usage;
+    if (raw.verifiedLocalBinding === true)
+        grant.verifiedLocalBinding = true;
+    return grant;
+}
+function sanitizeUsage(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const raw = value;
+    if (typeof raw.day !== 'string' ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(raw.day) ||
+        typeof raw.runs !== 'number' ||
+        !Number.isFinite(raw.runs) ||
+        raw.runs < 0 ||
+        typeof raw.tokens !== 'number' ||
+        !Number.isFinite(raw.tokens) ||
+        raw.tokens < 0) {
+        return null;
+    }
+    return { day: raw.day, runs: raw.runs, tokens: raw.tokens };
+}
+function mergeSpaceEntries(file, spaceKey, apps) {
+    if (typeof apps !== 'object' || apps === null)
+        return;
+    for (const [appId, value] of Object.entries(apps)) {
+        const grant = sanitizeGrant(value);
+        if (grant && grant.appId === appId && grant.spaceKey === spaceKey) {
+            (file.grants[spaceKey] ??= {})[appId] = grant;
+        }
+    }
+}
+function readGrantsFile() {
+    const path = grantsFilePath();
+    if (!existsSync(path))
+        return emptyGrantsFile();
+    try {
+        const stored = JSON.parse(readFileSync(path, 'utf-8'));
+        const file = emptyGrantsFile();
+        if (typeof stored !== 'object' || stored === null)
+            return file;
+        const rawGrants = stored.grants;
+        if (typeof rawGrants !== 'object' || rawGrants === null)
+            return file;
+        for (const [spaceKey, apps] of Object.entries(rawGrants)) {
+            mergeSpaceEntries(file, spaceKey, apps);
+        }
+        return file;
+    }
+    catch (err) {
+        console.warn('[GrantStore] Failed to read app-grants.json, treating as empty (apps will need re-consent):', err);
+        return emptyGrantsFile();
+    }
+}
+function grantsLockPath() {
+    return machineLockPath('app-grants');
+}
+function withGrantsLock(fn) {
+    return withFileLock(grantsLockPath(), fn);
+}
+function writeGrantsFile(file) {
+    ensureMinionryDir();
+    writeFileAtomic(grantsFilePath(), JSON.stringify(file, null, 2), { mode: 0o600 });
+}
+function assertGrantInput(input, persisted) {
+    if (!isValidAppId(input.appId)) {
+        throw new Error(`Invalid appId '${input.appId}' — expected the D5 grammar (lowercase [a-z0-9-])`);
+    }
+    if (typeof input.spaceKey !== 'string' || input.spaceKey === '') {
+        throw new Error('spaceKey must be a non-empty string (build it with makeSpaceKey from settings.ts)');
+    }
+    if (typeof input.origin !== 'string' || input.origin === '') {
+        throw new Error('origin must be a non-empty string');
+    }
+    if (typeof input.manifestHash !== 'string' || input.manifestHash === '') {
+        throw new Error('manifestHash must be a non-empty string');
+    }
+    if (!Array.isArray(input.scopes) || !input.scopes.every((scope) => isScope(scope))) {
+        throw new Error('scopes must contain only known v1 scopes (fail closed, invariant 5)');
+    }
+    if (persisted && isLocalhostFamilyOrigin(input.origin) && input.verifiedLocalBinding !== true) {
+        throw new Error(`Refusing to persist a grant keyed on localhost-family origin '${input.origin}' without a ` +
+            'CLI-verified port↔appId binding (Epic 8) — dev ports are reassigned across sessions, ' +
+            'so a persisted localhost grant could be inherited by a different app. ' +
+            'Keep this consent session-scoped instead.');
+    }
+}
+function buildGrant(input, createdAt) {
+    const grant = {
+        appId: input.appId,
+        spaceKey: input.spaceKey,
+        origin: input.origin,
+        scopes: [...input.scopes],
+        manifestHash: input.manifestHash,
+        createdAt,
+        lastUsedAt: new Date().toISOString(),
+    };
+    if (input.config !== undefined)
+        grant.config = { ...input.config };
+    if (input.verifiedLocalBinding === true)
+        grant.verifiedLocalBinding = true;
+    return grant;
+}
+export function getGrant(appId, spaceKey) {
+    return readGrantsFile().grants[spaceKey]?.[appId];
+}
+export function listGrants(spaceKey) {
+    return Object.values(readGrantsFile().grants[spaceKey] ?? {});
+}
+export function sdkGrantStateSnapshot(spaceKey) {
+    return {
+        grants: listGrants(spaceKey).map((grant) => ({
+            appId: grant.appId,
+            origin: grant.origin,
+            scopes: [...grant.scopes],
+        })),
+    };
+}
+let persistedGrantsListener = null;
+export function setPersistedGrantsListener(listener) {
+    persistedGrantsListener = listener;
+}
+function notifyPersistedGrantsChanged(spaceKey) {
+    try {
+        persistedGrantsListener?.(spaceKey);
+    }
+    catch (err) {
+        console.warn('[GrantStore] persisted-grants listener failed:', err);
+    }
+}
+export function setGrant(input) {
+    assertGrantInput(input, true);
+    const grant = withGrantsLock(() => {
+        const file = readGrantsFile();
+        const existing = file.grants[input.spaceKey]?.[input.appId];
+        const next = buildGrant(input, existing?.createdAt ?? new Date().toISOString());
+        if (existing?.usage)
+            next.usage = existing.usage;
+        (file.grants[input.spaceKey] ??= {})[input.appId] = next;
+        writeGrantsFile(file);
+        return next;
+    });
+    notifyPersistedGrantsChanged(input.spaceKey);
+    return grant;
+}
+export function updateGrant(appId, spaceKey, update) {
+    const merged = withGrantsLock(() => {
+        const file = readGrantsFile();
+        const existing = file.grants[spaceKey]?.[appId];
+        if (!existing) {
+            throw new Error(`No persisted grant for app '${appId}' in Space '${spaceKey}'`);
+        }
+        const next = { ...existing, ...update };
+        assertGrantInput(next, true);
+        file.grants[spaceKey][appId] = next;
+        writeGrantsFile(file);
+        return next;
+    });
+    notifyPersistedGrantsChanged(spaceKey);
+    return merged;
+}
+export function removeGrant(appId, spaceKey) {
+    const removed = withGrantsLock(() => {
+        const file = readGrantsFile();
+        const space = file.grants[spaceKey];
+        if (!space || !(appId in space))
+            return false;
+        delete space[appId];
+        if (Object.keys(space).length === 0)
+            delete file.grants[spaceKey];
+        writeGrantsFile(file);
+        return true;
+    });
+    if (removed)
+        notifyPersistedGrantsChanged(spaceKey);
+    return removed;
+}
+export function touchLastUsed(appId, spaceKey) {
+    withGrantsLock(() => {
+        const file = readGrantsFile();
+        const grant = file.grants[spaceKey]?.[appId];
+        if (!grant)
+            return;
+        grant.lastUsedAt = new Date().toISOString();
+        writeGrantsFile(file);
+    });
+}
+export function addGrantUsage(appId, spaceKey, day, delta) {
+    return withGrantsLock(() => {
+        const file = readGrantsFile();
+        const grant = file.grants[spaceKey]?.[appId];
+        if (!grant)
+            return undefined;
+        const prior = grant.usage?.day === day ? grant.usage : { day, runs: 0, tokens: 0 };
+        grant.usage = {
+            day,
+            runs: prior.runs + (delta.runs ?? 0),
+            tokens: prior.tokens + (delta.tokens ?? 0),
+        };
+        writeGrantsFile(file);
+        return { ...grant.usage };
+    });
+}
+export function computeScopeDelta(requested, granted) {
+    const have = new Set(granted);
+    const missing = [];
+    for (const scope of requested) {
+        if (!have.has(scope) && !missing.includes(scope))
+            missing.push(scope);
+    }
+    return missing;
+}
+const sessionGrants = new Map();
+function sessionEntryKey(appId, spaceKey) {
+    return `${appId}\u0000${spaceKey}`;
+}
+export function setSessionGrant(viewerId, input) {
+    if (typeof viewerId !== 'string' || viewerId === '') {
+        throw new Error('viewerId must be a non-empty string for session-scoped grants');
+    }
+    assertGrantInput(input, false);
+    const entryKey = sessionEntryKey(input.appId, input.spaceKey);
+    let viewerGrants = sessionGrants.get(viewerId);
+    if (!viewerGrants) {
+        viewerGrants = new Map();
+        sessionGrants.set(viewerId, viewerGrants);
+    }
+    const existing = viewerGrants.get(entryKey);
+    const grant = buildGrant(input, existing?.createdAt ?? new Date().toISOString());
+    viewerGrants.set(entryKey, grant);
+    return grant;
+}
+export function getSessionGrant(viewerId, appId, spaceKey) {
+    return sessionGrants.get(viewerId)?.get(sessionEntryKey(appId, spaceKey));
+}
+export function listSessionGrants(viewerId, spaceKey) {
+    const viewerGrants = sessionGrants.get(viewerId);
+    if (!viewerGrants)
+        return [];
+    return [...viewerGrants.values()].filter((grant) => grant.spaceKey === spaceKey);
+}
+export function removeSessionGrant(viewerId, appId, spaceKey) {
+    const viewerGrants = sessionGrants.get(viewerId);
+    if (!viewerGrants)
+        return false;
+    const removed = viewerGrants.delete(sessionEntryKey(appId, spaceKey));
+    if (viewerGrants.size === 0)
+        sessionGrants.delete(viewerId);
+    return removed;
+}
+export function removeSessionGrantsForApp(appId, spaceKey) {
+    const entryKey = sessionEntryKey(appId, spaceKey);
+    let removed = 0;
+    for (const [viewerId, viewerGrants] of sessionGrants) {
+        if (viewerGrants.delete(entryKey)) {
+            removed += 1;
+            if (viewerGrants.size === 0)
+                sessionGrants.delete(viewerId);
+        }
+    }
+    return removed;
+}
+export function clearSessionGrants(viewerId) {
+    const viewerGrants = sessionGrants.get(viewerId);
+    sessionGrants.delete(viewerId);
+    return viewerGrants?.size ?? 0;
+}
+export function clearAllSessionGrants() {
+    sessionGrants.clear();
+}

package/dist/server/services/sdk/host-ops.js

@@ -0,0 +1,84 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { can } from '@minionry/roles';
+import { readAppAudit } from './audit.js';
+import { listGrants, listSessionGrants } from './grant-store.js';
+import { SdkMethodError } from './registry.js';
+import { isValidAppId } from './sandbox.js';
+export const SDK_HOST_APP_ID = 'minionry-host';
+export const AUDIT_RECENT_DEFAULT_LIMIT = 50;
+export const AUDIT_RECENT_MAX_LIMIT = 200;
+function assertHostOriginated(args) {
+    if (args.appId !== SDK_HOST_APP_ID) {
+        throw new SdkMethodError('SCOPE_DENIED', `'${args.method}' is a host-originated management read — apps cannot call it`);
+    }
+}
+function canReadSpaceGrantState(args) {
+    return can(args.role, 'execute');
+}
+function toGrantListEntry(grant, kind) {
+    return {
+        appId: grant.appId,
+        origin: grant.origin,
+        scopes: [...grant.scopes],
+        createdAt: grant.createdAt,
+        lastUsedAt: grant.lastUsedAt,
+        kind,
+    };
+}
+export function listGrantsHandler(args) {
+    assertHostOriginated(args);
+    const rows = [];
+    if (canReadSpaceGrantState(args)) {
+        for (const grant of listGrants(args.spaceKey)) {
+            rows.push(toGrantListEntry(grant, 'persisted'));
+        }
+    }
+    if (args.viewerId) {
+        for (const grant of listSessionGrants(args.viewerId, args.spaceKey)) {
+            rows.push(toGrantListEntry(grant, 'session'));
+        }
+    }
+    rows.sort((a, b) => (a.lastUsedAt < b.lastUsedAt ? 1 : a.lastUsedAt > b.lastUsedAt ? -1 : 0));
+    return { grants: rows };
+}
+function parseAuditParams(params) {
+    if (params === undefined || params === null)
+        return { limit: AUDIT_RECENT_DEFAULT_LIMIT };
+    if (typeof params !== 'object' || Array.isArray(params)) {
+        throw new SdkMethodError('BAD_REQUEST', 'audit.recent params must be an object');
+    }
+    const raw = params;
+    let appId;
+    if (raw.appId !== undefined) {
+        if (typeof raw.appId !== 'string' || !isValidAppId(raw.appId)) {
+            throw new SdkMethodError('BAD_REQUEST', 'audit.recent params.appId must be a valid app id');
+        }
+        appId = raw.appId;
+    }
+    let limit = AUDIT_RECENT_DEFAULT_LIMIT;
+    if (raw.limit !== undefined) {
+        if (typeof raw.limit !== 'number' || !Number.isInteger(raw.limit) || raw.limit < 1) {
+            throw new SdkMethodError('BAD_REQUEST', 'audit.recent params.limit must be a positive integer');
+        }
+        limit = Math.min(raw.limit, AUDIT_RECENT_MAX_LIMIT);
+    }
+    return { appId, limit };
+}
+export function auditRecentHandler(args) {
+    assertHostOriginated(args);
+    if (!canReadSpaceGrantState(args)) {
+        throw new SdkMethodError('SCOPE_DENIED', `role '${args.role}' cannot read the Space activity feed`);
+    }
+    const { appId, limit } = parseAuditParams(args.params);
+    const entries = [];
+    for (const entry of readAppAudit()) {
+        if (entry.spaceKey !== args.spaceKey)
+            continue;
+        if (appId !== undefined && entry.appId !== appId)
+            continue;
+        const { spaceKey: _spaceKey, ...row } = entry;
+        entries.push(row);
+    }
+    return { entries: entries.slice(-limit).reverse() };
+}

package/dist/server/services/sdk/inference-claude.js

@@ -0,0 +1,214 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildSpawnEnv, resolveClaudeEffort } from '../../cli/headless/claude-invoker-process.js';
+import { classifyEngineNotice, isSyntheticModel } from '../../cli/headless/engine-notice.js';
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { resolveModelProfile } from '../../engines/credentials/model-profiles.js';
+import { SdkInferenceError, } from './inference.js';
+const DEFAULT_SYSTEM_PROMPT = 'You are a helpful assistant.';
+const KILL_GRACE_MS = 5_000;
+const STDERR_TAIL_BYTES = 4_000;
+function neutralCwd() {
+    const dir = join(tmpdir(), 'minionry-sdk-inference');
+    try {
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    catch {
+        return tmpdir();
+    }
+}
+export function renderInferencePrompt(messages) {
+    if (messages.length === 1)
+        return messages[0]?.content ?? '';
+    const turns = messages.map((message) => `${message.role === 'user' ? 'User' : 'Assistant'}: ${message.content}`);
+    return `The conversation so far:\n\n${turns.join('\n\n')}`;
+}
+export function buildClaudeInferenceArgs(exec) {
+    const args = ['--print', '--output-format', 'stream-json', '--verbose', '--include-partial-messages'];
+    const model = resolveModelProfile(exec.model)?.profile.model ?? exec.model;
+    if (model && model !== 'default')
+        args.push('--model', model);
+    const effort = resolveClaudeEffort(exec.model, exec.effortLevel ?? 'auto', true);
+    if (effort)
+        args.push('--effort', effort);
+    args.push('--tools', '', '--strict-mcp-config', '--no-session-persistence', '--system-prompt', exec.system?.trim() ? exec.system : DEFAULT_SYSTEM_PROMPT);
+    return args;
+}
+function parseStreamLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function forwardTextDelta(state, parsed, onDelta) {
+    const delta = parsed.event?.type === 'content_block_delta' ? parsed.event.delta : undefined;
+    if (delta?.type !== 'text_delta' || !delta.text)
+        return;
+    state.deltas += delta.text;
+    onDelta(delta.text);
+}
+function captureNotice(state, parsed) {
+    if (!isSyntheticModel(parsed.message?.model))
+        return;
+    const text = (parsed.message?.content ?? []).map((block) => block.text ?? '').join('');
+    if (text)
+        state.noticeText ??= text;
+}
+export function applyClaudeStreamLine(state, line, onDelta) {
+    const parsed = parseStreamLine(line);
+    if (!parsed || parsed.parent_tool_use_id)
+        return;
+    switch (parsed.type) {
+        case 'system':
+            if (parsed.subtype === 'init' && typeof parsed.model === 'string')
+                state.resolvedModel = parsed.model;
+            return;
+        case 'stream_event':
+            forwardTextDelta(state, parsed, onDelta);
+            return;
+        case 'assistant':
+            captureNotice(state, parsed);
+            return;
+        case 'result':
+            state.result = parsed;
+            return;
+    }
+}
+function classifyFailure(text, source) {
+    const notice = classifyEngineNotice(text, source);
+    const message = (notice?.text ?? text).trim() || 'Claude Code failed without a message';
+    if (notice?.kind === 'limit')
+        return new SdkInferenceError('ENGINE_LIMIT', message);
+    if (notice?.kind === 'auth')
+        return new SdkInferenceError('ENGINE_AUTH', message);
+    return new SdkInferenceError('UPSTREAM_ERROR', message);
+}
+function resultErrorText(result) {
+    const errors = (result.errors ?? []).filter((entry) => typeof entry === 'string' && entry !== '');
+    if (errors.length > 0)
+        return errors.join('; ');
+    return typeof result.result === 'string' ? result.result : '';
+}
+function usageOf(result) {
+    const usage = result.usage;
+    if (!usage)
+        return undefined;
+    return {
+        inputTokens: (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0),
+        outputTokens: usage.output_tokens ?? 0,
+    };
+}
+function successOutcome(state, result) {
+    const usage = usageOf(result);
+    return {
+        text: typeof result.result === 'string' && result.result !== '' ? result.result : state.deltas,
+        ...(state.resolvedModel ? { model: state.resolvedModel } : {}),
+        ...(usage ? { usage } : {}),
+    };
+}
+export function finishClaudeInference(state, exitCode, stderr) {
+    const result = state.result;
+    if (result && !result.is_error)
+        return successOutcome(state, result);
+    if (state.noticeText)
+        throw classifyFailure(state.noticeText, 'stream');
+    if (result)
+        throw classifyFailure(resultErrorText(result), 'result');
+    throw classifyFailure(stderr || `Claude Code exited with code ${exitCode ?? 'unknown'} before producing a result`, 'stderr');
+}
+function killGroup(child, signal) {
+    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
+        return;
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch {
+        try {
+            child.kill(signal);
+        }
+        catch {
+        }
+    }
+}
+export function runClaudeInference(exec, spawnImpl = spawn) {
+    return new Promise((resolve, reject) => {
+        const command = resolveClaudeCommand();
+        let child;
+        try {
+            child = spawnImpl(command, buildClaudeInferenceArgs(exec), {
+                cwd: neutralCwd(),
+                env: buildSpawnEnv({ model: exec.model }),
+                stdio: ['pipe', 'pipe', 'pipe'],
+                detached: true,
+            });
+        }
+        catch (error) {
+            reject(new SdkInferenceError('ENGINE_UNAVAILABLE', `could not start Claude Code: ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        const state = { deltas: '' };
+        let buffered = '';
+        let stderr = '';
+        let spawnError = null;
+        let killTimer;
+        const onAbort = () => {
+            killGroup(child, 'SIGTERM');
+            killTimer = setTimeout(() => killGroup(child, 'SIGKILL'), KILL_GRACE_MS);
+            killTimer.unref();
+        };
+        if (exec.signal.aborted)
+            onAbort();
+        else
+            exec.signal.addEventListener('abort', onAbort, { once: true });
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            buffered += chunk;
+            let newline = buffered.indexOf('\n');
+            while (newline !== -1) {
+                const line = buffered.slice(0, newline).trim();
+                buffered = buffered.slice(newline + 1);
+                if (line)
+                    applyClaudeStreamLine(state, line, exec.onDelta);
+                newline = buffered.indexOf('\n');
+            }
+        });
+        child.stderr?.setEncoding('utf8');
+        child.stderr?.on('data', (chunk) => {
+            stderr = (stderr + chunk).slice(-STDERR_TAIL_BYTES);
+        });
+        child.on('error', (error) => {
+            spawnError = error;
+        });
+        child.on('close', (code) => {
+            exec.signal.removeEventListener('abort', onAbort);
+            if (killTimer)
+                clearTimeout(killTimer);
+            if (buffered.trim())
+                applyClaudeStreamLine(state, buffered.trim(), exec.onDelta);
+            if (spawnError?.code === 'ENOENT') {
+                reject(new SdkInferenceError('ENGINE_UNAVAILABLE', `Claude Code is not installed on this machine ('${command}' was not found)`));
+                return;
+            }
+            if (exec.signal.aborted) {
+                reject(new SdkInferenceError('UPSTREAM_ERROR', 'the completion was stopped before it finished'));
+                return;
+            }
+            try {
+                resolve(finishClaudeInference(state, code, spawnError ? `${spawnError.message}\n${stderr}` : stderr));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin?.on('error', () => {
+        });
+        child.stdin?.end(renderInferencePrompt(exec.messages).replaceAll('\0', ''));
+    });
+}