@minionry/minion 0.7.36 → 0.7.39

package/dist/server/services/sdk/app-tools.js

@@ -11,6 +11,7 @@ export const APP_TOOL_MAX_RESULT_BYTES = 1024 * 1024;
 const registrations = new Map();
 const senders = new Map();
 const pending = new Map();
+const detachedViewers = new Set();
 export class AppToolCallError extends Error {
     code;
     constructor(code, message) {
@@ -222,6 +223,13 @@ export function callAppTool(args) {
     const spec = registration.tools.get(args.tool);
     const timeoutMs = Math.min(args.timeoutMs ?? spec.timeoutMs ?? APP_TOOL_CALL_TIMEOUT_MS, APP_TOOL_CALL_TIMEOUT_MAX_MS);
     const callId = `tc-${randomUUID()}`;
+    const frame = {
+        op: 'call',
+        callId,
+        requestId: registration.requestId,
+        tool: args.tool,
+        ...(args.input !== undefined ? { input: args.input } : {}),
+    };
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             const call = pending.get(callId);
@@ -238,19 +246,44 @@ export function callAppTool(args) {
             appId: args.appId,
             spaceKey: args.spaceKey,
             tool: args.tool,
+            frame,
             timer,
             settle: resolve,
             fail: reject,
         });
-        sendToolCall(registration, {
-            op: 'call',
-            callId,
-            requestId: registration.requestId,
-            tool: args.tool,
-            ...(args.input !== undefined ? { input: args.input } : {}),
-        });
+        if (!isDetached(registration))
+            sendToolCall(registration, frame);
     });
 }
+function isDetached(registration) {
+    return registration.viewerId !== undefined && detachedViewers.has(registration.viewerId);
+}
+export function holdAppToolCallsFor(viewerId) {
+    if (servesAnything(viewerId))
+        detachedViewers.add(viewerId);
+}
+function servesAnything(viewerId) {
+    for (const registration of registrations.values()) {
+        if (registration.viewerId === viewerId)
+            return true;
+    }
+    return false;
+}
+export function resumeAppToolCallsFor(viewerId) {
+    if (!detachedViewers.delete(viewerId))
+        return 0;
+    let sent = 0;
+    for (const call of [...pending.values()]) {
+        if (!pending.has(call.callId))
+            continue;
+        const registration = registrations.get(call.registrationId);
+        if (registration?.viewerId !== viewerId)
+            continue;
+        sendToolCall(registration, call.frame);
+        sent += 1;
+    }
+    return sent;
+}
 export function cancelAppToolCall(callId, cause = 'cancelled by the host') {
     const call = pending.get(callId);
     if (!call)
@@ -267,6 +300,9 @@ export function retireAppToolRegistration(requestId, cause) {
         return false;
     registrations.delete(requestId);
     senders.delete(requestId);
+    if (registration.viewerId !== undefined && !servesAnything(registration.viewerId)) {
+        detachedViewers.delete(registration.viewerId);
+    }
     for (const call of [...pending.values()]) {
         if (call.registrationId !== requestId)
             continue;
@@ -300,4 +336,5 @@ export function resetAppTools() {
     pending.clear();
     registrations.clear();
     senders.clear();
+    detachedViewers.clear();
 }

package/dist/server/services/sdk/atomic-write.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { closeSync, fchmodSync, fsyncSync, mkdirSync, openSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { SdkMethodError } from './registry.js';
+export const MTIME_TOLERANCE_MS = 1;
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
+export function parseExpectedModifiedAt(params, method) {
+    const value = params.expectedModifiedAt;
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !ISO_DATE_TIME.test(value) || Number.isNaN(Date.parse(value))) {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: expectedModifiedAt must be an ISO-8601 timestamp with a zone, such as the modifiedAt files.readEntry returns`);
+    }
+    return value;
+}
+let tempCounter = 0;
+function statOrUndefined(path) {
+    try {
+        return statSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function refuseUnlessUnmodified(existing, expected, displayPath) {
+    if (!existing) {
+        throw new SdkMethodError('CONFLICT', `'${displayPath}' no longer exists (expected it unmodified since ${expected}) — nothing was written`);
+    }
+    if (Math.abs(existing.mtimeMs - Date.parse(expected)) > MTIME_TOLERANCE_MS) {
+        throw new SdkMethodError('CONFLICT', `'${displayPath}' was modified at ${existing.mtime.toISOString()}, not ${expected} — nothing was written; files.readEntry returns its current content and modifiedAt`);
+    }
+}
+export function writeFileAtomic({ target, content, expectedModifiedAt, displayPath }) {
+    const existing = statOrUndefined(target);
+    if (expectedModifiedAt !== undefined)
+        refuseUnlessUnmodified(existing, expectedModifiedAt, displayPath);
+    const dir = dirname(target);
+    mkdirSync(dir, { recursive: true });
+    const temp = join(dir, `.${basename(target).slice(0, 64)}.${process.pid}.${++tempCounter}.tmp`);
+    let fd;
+    let created = false;
+    try {
+        fd = openSync(temp, 'wx');
+        created = true;
+        if (existing)
+            fchmodSync(fd, existing.mode & 0o7777);
+        writeFileSync(fd, content, 'utf-8');
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temp, target);
+    }
+    catch (error) {
+        if (fd !== undefined)
+            closeQuietly(fd);
+        if (created)
+            unlinkQuietly(temp);
+        throw error;
+    }
+}
+function closeQuietly(fd) {
+    try {
+        closeSync(fd);
+    }
+    catch {
+    }
+}
+function unlinkQuietly(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch {
+    }
+}

package/dist/server/services/sdk/browser.js

@@ -130,7 +130,11 @@ export async function browserOpenHandler(args) {
     const raw = paramsObject(args.params);
     const url = requireWebUrlParam(raw, 'url', args.method);
     const pinnedApp = raw.pinnedApp === true;
-    return requireHost(args.method).open({ url, ...(pinnedApp ? { reuseOrigin: args.origin } : {}) });
+    return requireHost(args.method).open({
+        url,
+        ...(pinnedApp ? { reuseOrigin: args.origin } : {}),
+        opener: { appId: args.appId, origin: args.origin },
+    });
 }
 export async function browserCloseHandler(args) {
     const raw = paramsObject(args.params);

package/dist/server/services/sdk/composer.js

@@ -6,6 +6,7 @@ import { peekModelCatalog } from '../model-catalog.js';
 import { getEffortLevel, getEngine, getFastMode, getModel } from '../settings.js';
 import { collectAllSkills } from '../websocket/skill-handlers.js';
 import { rankAllSnippets, rankQuerySnippets } from '../websocket/snippet-handlers.js';
+import { appRunEngines } from './agents.js';
 import { isAppOwnedProfile } from './app-endpoints.js';
 import { inferenceEngines } from './inference.js';
 import { SdkMethodError } from './registry.js';
@@ -125,5 +126,6 @@ export function composerSettingsHandler(_args) {
         modelsStatus: catalog.status,
         effortLevels: Object.fromEntries(ENGINE_IDS.map((engine) => [engine, [...ENGINE_EFFORT_LEVELS[engine]]])),
         inferenceEngines: inferenceEngines(),
+        agentRunEngines: appRunEngines(),
     };
 }

package/dist/server/services/sdk/file-change-notify.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { realpathSync } from 'node:fs';
-import { join, relative, sep } from 'node:path';
+import { basename, dirname, join, relative, sep } from 'node:path';
 const listeners = new Set();
 export function registerFileChangeListener(spaceKey, root, cb) {
     const listener = { spaceKey, root, cb };
@@ -10,26 +10,73 @@ export function registerFileChangeListener(spaceKey, root, cb) {
         listeners.delete(listener);
     };
 }
-export function notifyFileChangedAbsolute(spaceKey, absolutePath, kind) {
+function within(root, absolutePath) {
+    if (absolutePath === root)
+        return '';
+    return absolutePath.startsWith(root + sep) ? relative(root, absolutePath) : undefined;
+}
+function deliveryFor(root, source, kind, target, dir) {
+    const facts = dir ? { dir: true } : {};
+    const path = within(root, source);
+    if (kind === 'renamed') {
+        const newPath = target === undefined ? undefined : within(root, target);
+        if (path !== undefined && newPath !== undefined)
+            return { path, kind, newPath, ...facts };
+        if (path !== undefined)
+            return { path, kind: 'deleted', ...facts };
+        if (newPath !== undefined)
+            return { path: newPath, kind: 'created', ...facts };
+    }
+    else if (path !== undefined) {
+        return { path, kind, ...facts };
+    }
+    return undefined;
+}
+let observer;
+export function setFileChangeObserver(next) {
+    observer = next;
+}
+function deliver(spaceKey, source, kind, target, dir) {
+    if (kind !== 'opened')
+        observer?.(spaceKey, source, target);
     for (const listener of listeners) {
         if (listener.spaceKey !== spaceKey)
             continue;
-        if (absolutePath !== listener.root && !absolutePath.startsWith(listener.root + sep))
-            continue;
-        listener.cb({ path: relative(listener.root, absolutePath), kind });
+        const change = deliveryFor(listener.root, source, kind, target, dir);
+        if (change)
+            listener.cb(change);
     }
 }
-export function notifyFileChanged(spaceKey, workingDir, path, kind) {
+export function notifyFileChangedAbsolute(spaceKey, absolutePath, kind, facts = {}) {
+    deliver(spaceKey, absolutePath, kind, facts.newPath, facts.dir === true);
+}
+function realpathLenient(absolutePath) {
+    const rest = [];
+    let current = absolutePath;
+    for (;;) {
+        try {
+            return join(realpathSync(current), ...rest);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return undefined;
+            rest.unshift(basename(current));
+            current = parent;
+        }
+    }
+}
+export function notifyFileChanged(spaceKey, workingDir, path, kind, facts = {}) {
     if (listeners.size === 0)
         return;
-    let absolute;
-    try {
-        absolute = realpathSync(path.startsWith('/') ? path : join(workingDir, path));
-    }
-    catch {
+    const toReal = (p) => realpathLenient(p.startsWith('/') ? p : join(workingDir, p));
+    const source = toReal(path);
+    if (source === undefined)
         return;
-    }
-    notifyFileChangedAbsolute(spaceKey, absolute, kind);
+    const target = facts.newPath === undefined ? undefined : toReal(facts.newPath);
+    if (kind === 'renamed' && target === undefined)
+        return;
+    deliver(spaceKey, source, kind, target, facts.dir === true);
 }
 export function resetFileChangeListeners() {
     listeners.clear();

package/dist/server/services/sdk/files-app.js

@@ -1,12 +1,19 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
-import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, isAbsolute } from 'node:path';
+import { readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
 import { createDirectory, renameFile } from '../files.js';
 import { readFileContent } from '../websocket/file-utils.js';
+import { parseExpectedModifiedAt, writeFileAtomic } from './atomic-write.js';
 import { SdkMethodError } from './registry.js';
 import { provisionAppSandbox, resolveWithinRoot } from './sandbox.js';
 export const FILES_APP_MAX_WRITE_BYTES = 5 * 1024 * 1024;
+export function readEntryResult(result, stat) {
+    const meta = { modifiedAt: stat.mtime.toISOString(), size: stat.size };
+    return result.isImage
+        ? { kind: 'binary', content: result.content, mimeType: result.mimeType ?? 'application/octet-stream', ...meta }
+        : { kind: 'text', content: result.content, ...meta };
+}
 function paramsObject(params) {
     return typeof params === 'object' && params !== null && !Array.isArray(params)
         ? params
@@ -85,9 +92,7 @@ export function filesReadEntryHandler(args) {
     const result = readFileContent(resolved, dataDir);
     if (result.error)
         throw serviceError(result.error);
-    return result.isImage
-        ? { kind: 'binary', content: result.content, mimeType: result.mimeType ?? 'application/octet-stream' }
-        : { kind: 'text', content: result.content };
+    return readEntryResult(result, stat);
 }
 export function filesWriteHandler(args) {
     const path = parsePathParam(args.params, args.method);
@@ -95,6 +100,7 @@ export function filesWriteHandler(args) {
     if (typeof raw.content !== 'string') {
         throw new SdkMethodError('BAD_REQUEST', `${args.method} requires params { path, content } with string content`);
     }
+    const expectedModifiedAt = parseExpectedModifiedAt(raw, args.method);
     const bytes = Buffer.byteLength(raw.content, 'utf-8');
     if (bytes > FILES_APP_MAX_WRITE_BYTES) {
         throw new SdkMethodError('BAD_REQUEST', `content is ${bytes} bytes — exceeds the ${FILES_APP_MAX_WRITE_BYTES}-byte per-file files.write cap`);
@@ -103,8 +109,7 @@ export function filesWriteHandler(args) {
     if (statOrUndefined(resolved)?.isDirectory()) {
         throw new SdkMethodError('BAD_REQUEST', `'${path}' is a directory — cannot write over it`);
     }
-    mkdirSync(dirname(resolved), { recursive: true });
-    writeFileSync(resolved, raw.content, 'utf-8');
+    writeFileAtomic({ target: resolved, content: raw.content, expectedModifiedAt, displayPath: path });
     return null;
 }
 export function filesListHandler(args) {

package/dist/server/services/sdk/files-search.js

@@ -5,6 +5,7 @@ import { findDefinitions } from '../websocket/file-definition-handlers.js';
 import { streamRgSearch } from '../websocket/file-search-handlers.js';
 import { registerFileChangeListener } from './file-change-notify.js';
 import { appDataDir, guardAppDataPath } from './files-app.js';
+import { acquireRootWatch } from './files-watch.js';
 import { guardWorkspacePath, parseWorkspacePath, resolveFilesReadScopes } from './files-workspace.js';
 import { getGrant } from './grant-store.js';
 import { listLiveSubscriptions, registerLiveSubscription } from './live-registry.js';
@@ -115,6 +116,18 @@ export function filesSubscribeChangesHandler(args) {
             return;
         args.emit('changed', change);
     });
+    const releaseWatch = parseWorkspacePath({ path }) === null
+        ? () => { }
+        : acquireRootWatch({
+            spaceKey: args.spaceKey,
+            appId: args.appId,
+            workingDir: args.workingDir,
+            realRoot: root,
+            onGap: (gap) => {
+                if (active)
+                    args.emit('gap', gap);
+            },
+        });
     registerLiveSubscription({
         requestId: args.requestId,
         appId: args.appId,
@@ -125,6 +138,7 @@ export function filesSubscribeChangesHandler(args) {
         teardown: () => {
             active = false;
             unsubscribe();
+            releaseWatch();
         },
     });
     return { subscribed: true };

package/dist/server/services/sdk/files-transfer.js

@@ -137,7 +137,7 @@ function finishUpload(args, uploadId, session) {
     writeFileSync(resolvedPath, Buffer.concat(session.chunks));
     uploads.delete(uploadId);
     if (session.guard.rooting === 'workspace') {
-        notifyFileChangedAbsolute(session.spaceKey, resolvedPath, 'changed');
+        notifyFileChangedAbsolute(session.spaceKey, resolvedPath, stat ? 'changed' : 'created');
     }
 }
 export function filesUploadChunkHandler(args) {