@minionry/minion 0.7.36 → 0.7.39

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

@@ -2,7 +2,8 @@
 // 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';
+import { detectShell, foregroundProcessName, getPty, getPtyInstallInstructions, getShellName, isPtyAvailable, SCROLLBACK_MAX_LENGTH, ScrollbackBuffer, } from './pty-utils.js';
+import { OrphanedModeReaper, TerminalModeTracker } from './terminal-modes.js';
 export { isPtyAvailable, reloadPty } from './pty-utils.js';
 export class PTYManager extends EventEmitter {
     terminals = new Map();
@@ -35,16 +36,18 @@ export class PTYManager extends EventEmitter {
     getPtyInstallInstructions() {
         return getPtyInstallInstructions();
     }
-    async create(terminalId, workingDir, cols = 80, rows = 24, requestedShell, ownerLabel) {
+    async create(terminalId, workingDir, cols, rows, 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;
+            if (cols !== undefined && rows !== undefined) {
+                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([
@@ -55,22 +58,28 @@ export class PTYManager extends EventEmitter {
         ]);
         const shell = (requestedShell && ALLOWED_SHELLS.has(requestedShell)) ? requestedShell : detectShell();
         const cwd = workingDir || homedir();
+        const spawnCols = cols ?? 80;
+        const spawnRows = rows ?? 24;
         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 ptyProcess = pty.spawn(shell, [], { name: 'xterm-256color', cols: spawnCols, rows: spawnRows, cwd, env });
+            const shellName = getShellName(shell);
+            const modes = new TerminalModeTracker();
             const session = {
                 id: terminalId,
                 pty: ptyProcess,
-                shell: getShellName(shell),
+                shell: shellName,
                 cwd,
                 createdAt: Date.now(),
                 lastActivityAt: Date.now(),
-                cols,
-                rows,
+                cols: spawnCols,
+                rows: spawnRows,
                 ...(ownerLabel !== undefined ? { ownerLabel } : {}),
                 _outputBuffer: '',
                 _outputTimer: null,
                 scrollback: new ScrollbackBuffer(SCROLLBACK_MAX_LENGTH),
+                modes,
+                modeReaper: new OrphanedModeReaper(modes, shellName, () => foregroundProcessName(ptyProcess)),
             };
             this.terminals.set(terminalId, session);
             this.attachOutputHandlers(session, terminalId);
@@ -92,6 +101,11 @@ export class PTYManager extends EventEmitter {
                 clearTimeout(session._outputTimer);
                 session._outputTimer = null;
             }
+            const reaped = session.modeReaper.check();
+            if (reaped) {
+                session.scrollback.append(reaped);
+                session._outputBuffer += reaped;
+            }
             const buffered = session._outputBuffer;
             session._outputBuffer = '';
             const chunkSize = outputLimit();
@@ -101,6 +115,7 @@ export class PTYManager extends EventEmitter {
         };
         session.pty.onData((data) => {
             session.scrollback.append(data);
+            session.modes.observe(data);
             session.lastActivityAt = Date.now();
             session._outputBuffer += data;
             if (session._outputBuffer.length >= outputLimit()) {
@@ -166,8 +181,8 @@ export class PTYManager extends EventEmitter {
                 }
                 session._outputTimer = null;
             }
-            session.pty.kill();
             this.terminals.delete(terminalId);
+            session.pty.kill();
             return true;
         }
         catch (error) {
@@ -180,7 +195,7 @@ export class PTYManager extends EventEmitter {
         const session = this.terminals.get(terminalId);
         if (!session)
             return null;
-        return session.scrollback.getContents();
+        return session.scrollback.getContents() + session.modes.stateSequence();
     }
     getSession(terminalId) {
         return this.terminals.get(terminalId);

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { existsSync } from 'node:fs';
 import { platform } from 'node:os';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { MINIONRY_ROOT } from '../../utils/paths.js';
 const FALLBACK_SPECIFIERS = ['@lydell/node-pty', 'node-pty'];
@@ -119,6 +119,17 @@ export function getShellName(shellPath) {
     const parts = shellPath.split(/[/\\]/);
     return parts[parts.length - 1] || 'shell';
 }
+export function foregroundProcessName(pty) {
+    if (platform() === 'win32')
+        return null;
+    try {
+        const name = pty.process;
+        return typeof name === 'string' && name !== '' ? basename(name) : null;
+    }
+    catch {
+        return null;
+    }
+}
 export const SCROLLBACK_MAX_LENGTH = 256 * 1024;
 export class ScrollbackBuffer {
     chunks = [];

package/dist/server/services/terminal/terminal-modes.js

@@ -0,0 +1,87 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: FSL-1.1-ALv2
+const MOUSE_TRACKING_MODES = [9, 1000, 1001, 1002, 1003];
+const MOUSE_ENCODING_MODES = [1005, 1006, 1015, 1016];
+const FOCUS_REPORT_MODE = 1004;
+const BRACKETED_PASTE_MODE = 2004;
+export const REAPABLE_MODES = [
+    ...MOUSE_TRACKING_MODES,
+    ...MOUSE_ENCODING_MODES,
+    FOCUS_REPORT_MODE,
+];
+export const TRACKED_MODES = [...REAPABLE_MODES, BRACKETED_PASTE_MODE];
+const TRACKED = new Set(TRACKED_MODES);
+const DEC_PRIVATE_MODE_RE = /\x1b\[\?([0-9;]*)([hl])/g;
+const MAX_CARRY = 64;
+function trailingPartialSequence(text) {
+    const tail = text.slice(-MAX_CARRY);
+    const esc = tail.lastIndexOf('\x1b');
+    return esc === -1 ? '' : tail.slice(esc);
+}
+export class TerminalModeTracker {
+    active = new Set();
+    carry = '';
+    observe(data) {
+        const text = this.carry + data;
+        DEC_PRIVATE_MODE_RE.lastIndex = 0;
+        for (let match = DEC_PRIVATE_MODE_RE.exec(text); match !== null; match = DEC_PRIVATE_MODE_RE.exec(text)) {
+            const set = match[2] === 'h';
+            for (const param of match[1].split(';')) {
+                const mode = Number(param);
+                if (!TRACKED.has(mode))
+                    continue;
+                if (set)
+                    this.active.add(mode);
+                else
+                    this.active.delete(mode);
+            }
+        }
+        this.carry = trailingPartialSequence(text);
+    }
+    isActive(mode) {
+        return this.active.has(mode);
+    }
+    get reportingActive() {
+        return MOUSE_TRACKING_MODES.some((mode) => this.active.has(mode)) || this.active.has(FOCUS_REPORT_MODE);
+    }
+    stateSequence() {
+        if (this.active.size === 0)
+            return '';
+        return TRACKED_MODES.map((mode) => `\x1b[?${mode}${this.active.has(mode) ? 'h' : 'l'}`).join('');
+    }
+    clearReporting() {
+        for (const mode of REAPABLE_MODES)
+            this.active.delete(mode);
+        return REAPABLE_MODES.map((mode) => `\x1b[?${mode}l`).join('');
+    }
+}
+export class OrphanedModeReaper {
+    modes;
+    shellName;
+    probeForeground;
+    owner = null;
+    constructor(modes, 
+    shellName, 
+    probeForeground) {
+        this.modes = modes;
+        this.shellName = shellName;
+        this.probeForeground = probeForeground;
+    }
+    check() {
+        if (!this.modes.reportingActive) {
+            this.owner = null;
+            return '';
+        }
+        const foreground = this.probeForeground();
+        if (foreground === null)
+            return '';
+        if (this.owner === null) {
+            this.owner = foreground;
+            return '';
+        }
+        if (foreground === this.owner || foreground !== this.shellName)
+            return '';
+        this.owner = null;
+        return this.modes.clearReporting();
+    }
+}

package/dist/server/services/timeline/assembler.js

@@ -843,12 +843,12 @@ function tokenUsage(raw) {
         ...(raw.isFinal === true ? { isFinal: true } : {}),
     };
 }
-function clampText(text, max) {
+export function clampText(text, max) {
     if (text.length <= max)
         return text;
     return `${text.slice(0, max)}\n… [truncated ${text.length - max} chars]`;
 }
-function clampInput(value, max) {
+export function clampInput(value, max) {
     const input = asRecord(value);
     let size;
     try {

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

@@ -1,4 +1,4 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
-export { ChatTimeline, ChatTimelineRegistry, classifyEngineOutput, countMovementEntries, DEFAULT_CHAT_TIMELINE_LIMITS, formatErrorMarker, formatTimelineDuration, isTimelineTabEvent, LEGACY_THINKING_MARKER, legacyThinkingChunk, parseErrorMarker, } from './assembler.js';
+export { ChatTimeline, ChatTimelineRegistry, clampInput, clampText, classifyEngineOutput, countMovementEntries, DEFAULT_CHAT_TIMELINE_LIMITS, formatErrorMarker, formatTimelineDuration, isTimelineTabEvent, LEGACY_THINKING_MARKER, legacyThinkingChunk, parseErrorMarker, } from './assembler.js';
 export { applyTimelineEvent, applyTimelineEvents, CHAT_TIMELINE_CONTRACT_VERSION, emptyTimelineState, foldTimeline, TIMELINE_PROMPT_INDEX_HEAD_ENTRIES, TIMELINE_PROMPT_INDEX_MAX_ENTRIES, TIMELINE_PROMPT_PREVIEW_CHARS, timelineEventEntryId, timelineStateFromSnapshot, } from './contract.js';

package/dist/server/services/websocket/agent-schedule-handlers.js

@@ -1,7 +1,11 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { can } from '@minionry/roles';
+import { isValidMaxLatenessMs } from '../schedule/agent-schedule-store.js';
 import { getAgentScheduler } from '../schedule/agent-scheduler.js';
+import { normalizeWallClockTiming } from '../schedule/daily-timing.js';
+import { isValidPromptFilePath, readPromptFile } from '../schedule/prompt-file.js';
+import { parseMaxLatenessMs } from '../schedule/schedule-wire.js';
 import { dispatchByType } from './dispatch-util.js';
 import { parseTabEngineOverride } from './tab-handlers.js';
 export function handleAgentScheduleMessage(ctx, ws, msg, workingDir, role) {
@@ -41,14 +45,35 @@ function parseAgentTiming(raw) {
             ? { kind: 'interval', everyMs: t.everyMs }
             : null;
     }
+    if (t.kind === 'daily' || t.kind === 'monthly')
+        return normalizeWallClockTiming(raw);
     return null;
 }
+const INVALID_TIMING_ERROR = 'Invalid timing (expected {kind:"once",at}, {kind:"interval",everyMs}, {kind:"daily",time,timeZone,days?} or {kind:"monthly",time,timeZone,dayOfMonth})';
+const INVALID_MAX_LATENESS_ERROR = 'Invalid maxLatenessMs (integer >= 60000)';
+const INVALID_PROMPT_FILE_ERROR = "Invalid promptFile (must be a Space-relative POSIX path with no leading '/' and no '..' segment)";
 function parsePrompt(raw) {
     if (typeof raw !== 'string')
         return null;
     const trimmed = raw.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function resolveCreatePrompt(workingDir, rawPrompt, rawPromptFile) {
+    const hasPrompt = rawPrompt !== undefined;
+    const hasPromptFile = rawPromptFile !== undefined;
+    if (hasPrompt === hasPromptFile) {
+        return { ok: false, error: 'Provide exactly one of prompt or promptFile' };
+    }
+    if (!hasPromptFile) {
+        const prompt = parsePrompt(rawPrompt);
+        return prompt ? { ok: true, prompt } : { ok: false, error: 'prompt is required' };
+    }
+    if (typeof rawPromptFile !== 'string' || !isValidPromptFilePath(rawPromptFile)) {
+        return { ok: false, error: INVALID_PROMPT_FILE_ERROR };
+    }
+    const result = readPromptFile(workingDir, rawPromptFile);
+    return result.ok ? { ok: true, prompt: result.content, promptFile: rawPromptFile } : { ok: false, error: result.reason };
+}
 function parseEngineOverrideField(raw, present) {
     if (!present)
         return { ok: true, value: undefined };
@@ -69,14 +94,15 @@ function handleAgentScheduleCreate(ctx, ws, msg, workingDir, permission) {
         reply({ success: false, error: 'requestId required' });
         return;
     }
-    const prompt = parsePrompt(data.prompt);
-    if (!prompt) {
-        reply({ success: false, error: 'prompt is required' });
+    const resolved = resolveCreatePrompt(workingDir, data.prompt, data.promptFile);
+    if (!resolved.ok) {
+        reply({ success: false, error: resolved.error });
         return;
     }
+    const { prompt, promptFile } = resolved;
     const timing = parseAgentTiming(data.timing);
     if (!timing) {
-        reply({ success: false, error: 'Invalid timing (expected {kind:"once",at} or {kind:"interval",everyMs})' });
+        reply({ success: false, error: INVALID_TIMING_ERROR });
         return;
     }
     const override = parseEngineOverrideField(data.engineOverride, 'engineOverride' in data);
@@ -84,6 +110,11 @@ function handleAgentScheduleCreate(ctx, ws, msg, workingDir, permission) {
         reply({ success: false, error: 'Invalid engineOverride' });
         return;
     }
+    const maxLateness = parseMaxLatenessMs(data.maxLatenessMs);
+    if (!maxLateness.ok) {
+        reply({ success: false, error: INVALID_MAX_LATENESS_ERROR });
+        return;
+    }
     const store = getAgentScheduleStore(ctx, workingDir);
     if (!store) {
         reply({ success: false, error: 'No working directory for this Space' });
@@ -92,9 +123,11 @@ function handleAgentScheduleCreate(ctx, ws, msg, workingDir, permission) {
     const record = store.create({
         name: data.name,
         prompt,
+        ...(promptFile !== undefined ? { promptFile } : {}),
         engineOverride: override.value ?? undefined,
         timing,
         enabled: data.enabled,
+        maxLatenessMs: maxLateness.value,
     });
     notifySchedulerAndBroadcast(ctx, workingDir);
     reply({ success: true, schedule: record });
@@ -110,11 +143,28 @@ function handleAgentScheduleUpdate(ctx, ws, msg, workingDir, permission) {
         reply({ success: false, error: 'requestId and scheduleId required' });
         return;
     }
+    if (patch && typeof patch === 'object' && patch.prompt !== undefined && patch.promptFile !== undefined) {
+        reply({ success: false, error: 'Provide at most one of prompt or promptFile in a single update' });
+        return;
+    }
     const safePatch = parseUpdatePatch(patch);
     if (!safePatch) {
         reply({ success: false, error: 'Invalid patch' });
         return;
     }
+    if (patch?.promptFile !== undefined) {
+        if (typeof patch.promptFile !== 'string' || !isValidPromptFilePath(patch.promptFile)) {
+            reply({ success: false, error: INVALID_PROMPT_FILE_ERROR });
+            return;
+        }
+        const result = readPromptFile(workingDir, patch.promptFile);
+        if (!result.ok) {
+            reply({ success: false, error: result.reason });
+            return;
+        }
+        safePatch.prompt = result.content;
+        safePatch.promptFile = patch.promptFile;
+    }
     const store = getAgentScheduleStore(ctx, workingDir);
     if (!store) {
         reply({ success: false, error: 'No working directory for this Space' });
@@ -164,6 +214,14 @@ function applyStructuredPatchFields(patch, safe) {
         if (override.value !== undefined)
             safe.engineOverride = override.value;
     }
+    if (patch.maxLatenessMs === null) {
+        safe.maxLatenessMs = null;
+    }
+    else if (patch.maxLatenessMs !== undefined) {
+        if (!isValidMaxLatenessMs(patch.maxLatenessMs))
+            return null;
+        safe.maxLatenessMs = patch.maxLatenessMs;
+    }
     return safe;
 }
 function handleAgentScheduleDelete(ctx, ws, msg, workingDir, permission) {

package/dist/server/services/websocket/ask-user-question-bridge.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { randomUUID, timingSafeEqual } from 'node:crypto';
-const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+export const ASK_USER_QUESTION_TIMEOUT_MS = 30 * 60 * 1000;
 const pending = new Map();
 const bouncerSharedSecret = randomUUID();
 export function getBouncerSecret() {
@@ -43,7 +43,7 @@ export function mcpCapabilityTokenCount() {
     return capabilities.size;
 }
 export function registerPendingQuestion(opts) {
-    const { toolUseId, tabId, questions = [], timeoutMs = DEFAULT_TIMEOUT_MS, computeTimeoutAnswers } = opts;
+    const { toolUseId, tabId, questions = [], timeoutMs = ASK_USER_QUESTION_TIMEOUT_MS, computeTimeoutAnswers } = opts;
     const existing = pending.get(toolUseId);
     if (existing) {
         clearTimeout(existing.timer);

package/dist/server/services/websocket/browser-agent-runtime.js

@@ -92,7 +92,8 @@ export function _resetBrowserAgentsForTests() {
     agentPlannerOverride = (input) => [input.task];
     plannerByModel.clear();
 }
-export function startBrowserAgentRun(host, task, sink) {
+export function startBrowserAgentRun(host, task, sink, 
+opener) {
     const agentId = `browser-agent-${randomUUID()}`;
     const agentLabel = 'Browser Agent';
     log.info('agent.start', `agent=${agentId.slice(14, 22)} taskId=${task.taskId?.slice(0, 8) ?? '-'} tab=${task.tabId?.slice(0, 8) ?? 'new'} engine=${task.engine ?? 'default'} model=${task.model ?? 'default'} effort=${task.effortLevel ?? 'auto'} active=${activeAgents.size}`);
@@ -106,6 +107,7 @@ export function startBrowserAgentRun(host, task, sink) {
         task,
         agentId,
         agentLabel,
+        ...(opener !== undefined ? { opener } : {}),
         ...(task.tabId ? { tabId: task.tabId } : {}),
         ...(agentSettleDelayMsOverride !== null
             ? { settleDelayMs: agentSettleDelayMsOverride }

package/dist/server/services/websocket/browser-handlers.js

@@ -22,7 +22,10 @@ const IF_READY_TYPES = new Set([
     'browser_webrtc_state',
     'browser_lease_release',
 ]);
-const HOST_FREE_TYPES = new Set(['browser_agent_approve']);
+const HOST_FREE_TYPES = new Set([
+    'browser_agent_approve',
+    'browser_webrtc_ice_config',
+]);
 export function browserHostPolicy(type) {
     if (HOST_FREE_TYPES.has(type))
         return 'none';
@@ -131,7 +134,7 @@ const DISPATCH = {
     browser_tab_open: async (host, data, ctx) => {
         const url = extractString(data, 'url') ?? 'about:blank';
         log.info('tab.open', `viewer=${ctx.viewerId.slice(0, 8)} existingTabs=${host.getTabsSnapshot?.().tabs.length ?? '?'} url=${url === 'about:blank' ? 'about:blank' : 'set'}`);
-        const { id } = await host.openTab(url);
+        const { id } = await host.openTab(url, { kind: 'user' });
         if (isCapturableUrl(url)) {
             await ensureTabProfileCaptured(host, id, navigatingFormFactor(ctx.viewerId));
         }

package/dist/server/services/websocket/browser-viewer-lifecycle.js

@@ -59,6 +59,14 @@ export function onWsContextClosed(host, ws) {
             releaseDeviceInput(viewerId);
     }
 }
+export function moveViewerToContext(viewerId, from, to) {
+    const viewer = viewers.getByViewer(viewerId);
+    if (viewer?.ws === from)
+        viewer.ws = to;
+    const input = deviceInputTabs.get(viewerId);
+    if (input?.ws === from)
+        input.ws = to;
+}
 export function onViewerDisconnected(host, viewerId) {
     for (const sdkViewer of viewers.detachSdkByOwnerViewer(viewerId)) {
         log.info('viewer.detachSdkByOwner', `session=${sdkViewer.sessionId.slice(0, 8)} viewers=${viewers.size()}`);

package/dist/server/services/websocket/file-explorer-handlers.js

@@ -1,5 +1,6 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { statSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { can } from '@minionry/roles';
 import { getClientId } from '../client-id.js';
@@ -219,6 +220,14 @@ function handleWriteFile(ctx, ws, msg, tabId, workingDir, role) {
             notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, result.path, 'changed');
     }
 }
+function isDirectoryPath(path, workingDir) {
+    try {
+        return statSync(resolve(workingDir, path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function handleCreateFile(ctx, ws, msg, tabId, workingDir) {
     if (!msg.data?.filePath)
         throw new Error('File path is required');
@@ -230,6 +239,7 @@ function handleCreateFile(ctx, ws, msg, tabId, workingDir) {
             type: 'fileCreated',
             data: { path: result.path, name, size: 0, modifiedAt: new Date().toISOString() }
         });
+        notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, result.path, 'created');
     }
 }
 function handleCreateDirectory(ctx, ws, msg, tabId, workingDir) {
@@ -243,11 +253,13 @@ function handleCreateDirectory(ctx, ws, msg, tabId, workingDir) {
             type: 'directoryCreated',
             data: { path: result.path, name }
         });
+        notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, result.path, 'created', { dir: true });
     }
 }
 function handleDeleteFile(ctx, ws, msg, tabId, workingDir) {
     if (!msg.data?.filePath)
         throw new Error('File path is required');
+    const dir = isDirectoryPath(msg.data.filePath, workingDir);
     const result = deleteFile(msg.data.filePath, workingDir);
     sendFileResult(ctx, ws, 'fileDeleted', tabId, result);
     if (result.success && result.path) {
@@ -255,6 +267,7 @@ function handleDeleteFile(ctx, ws, msg, tabId, workingDir) {
             type: 'fileDeleted',
             data: { path: result.path }
         });
+        notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, result.path, 'deleted', { dir });
     }
 }
 function handleRenameFile(ctx, ws, msg, tabId, workingDir) {
@@ -271,6 +284,10 @@ function handleRenameFile(ctx, ws, msg, tabId, workingDir) {
             type: 'fileRenamed',
             data: { oldPath: msg.data.oldPath, newPath: result.path, name }
         });
+        notifyFileChanged(makeSpaceKey(getClientId(), workingDir), workingDir, msg.data.oldPath, 'renamed', {
+            newPath: result.path,
+            dir: isDirectoryPath(result.path, workingDir),
+        });
     }
 }
 function handleNotifyFileOpened(ctx, ws, msg, workingDir) {

package/dist/server/services/websocket/file-transfer-http.js

@@ -7,6 +7,7 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { can, normalizeStoredRole } from '@minionry/roles';
 import { buildDirectoryZipBuffer } from '../file-transfer-zip.js';
+import { RelayHttpClient, relayHttp } from '../relay-http-client.js';
 import { getMaxUploadBytes, uploadTooLargeMessage } from '../settings.js';
 import { resolveFileTreeTarget } from './file-upload-handler.js';
 import { isPathInSafeLocation } from './file-utils.js';
@@ -81,8 +82,10 @@ function parseRequestData(message) {
 export class FileTransferAgent {
     deps;
     active = 0;
+    http;
     constructor(deps) {
         this.deps = deps;
+        this.http = deps.http ?? (deps.fetchImpl ? new RelayHttpClient({ fetchImpl: deps.fetchImpl }) : relayHttp);
     }
     handleRequest(message) {
         const data = parseRequestData(message);
@@ -230,19 +233,22 @@ export class FileTransferAgent {
         if (payload.range)
             headers['x-mn-range'] = payload.range;
         const isStream = !(payload.body instanceof Uint8Array);
-        const res = await this.fetch()(this.dataUrl(data), {
+        const init = {
             method: 'POST',
             headers,
             body: payload.body,
             ...(isStream ? { duplex: 'half' } : {}),
-        });
+        };
+        const res = isStream
+            ? await this.fetch()(this.dataUrl(data), init)
+            : await this.http.fetch(this.dataUrl(data), init);
         if (!res.ok) {
             console.warn(`[FileTransfer] Relay refused data leg for ${data.transferId}: ${res.status}`);
         }
         await res.text().catch(() => { });
     }
     async pushError(data, status, message, extraHeaders = {}) {
-        const res = await this.fetch()(this.dataUrl(data), {
+        const res = await this.http.fetch(this.dataUrl(data), {
             method: 'POST',
             headers: {
                 authorization: `Bearer ${data.token}`,
@@ -304,7 +310,7 @@ export class FileTransferAgent {
         await this.postResult(data, { ok: false, error: `Upload failed: ${message}`, code: 'stream_failed' });
     }
     async pullUploadBytes(data, finalPath, tempPath) {
-        const res = await this.fetch()(this.dataUrl(data), {
+        const res = await this.http.fetch(this.dataUrl(data), {
             headers: { authorization: `Bearer ${data.token}` },
         });
         if (!res.ok || !res.body) {
@@ -332,7 +338,7 @@ export class FileTransferAgent {
     }
     async claimUploadLeg(data) {
         try {
-            const res = await this.fetch()(this.dataUrl(data), {
+            const res = await this.http.fetch(this.dataUrl(data), {
                 headers: { authorization: `Bearer ${data.token}` },
             });
             await res.body?.cancel().catch(() => { });
@@ -341,7 +347,7 @@ export class FileTransferAgent {
     }
     async postResult(data, result) {
         try {
-            const res = await this.fetch()(this.dataUrl(data, '/result'), {
+            const res = await this.http.fetch(this.dataUrl(data, '/result'), {
                 method: 'POST',
                 headers: {
                     authorization: `Bearer ${data.token}`,