@minionry/minion 0.7.36

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

@@ -0,0 +1,196 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const CHAT_TIMELINE_CONTRACT_VERSION = 1;
+export function timelineEventEntryId(event) {
+    return 'entryId' in event ? event.entryId : null;
+}
+export const TIMELINE_PROMPT_PREVIEW_CHARS = 240;
+export const TIMELINE_PROMPT_INDEX_MAX_ENTRIES = 500;
+export const TIMELINE_PROMPT_INDEX_MAX_BYTES = 64 * 1024;
+export const TIMELINE_PROMPT_INDEX_HEAD_ENTRIES = 10;
+export function emptyTimelineState() {
+    return { entries: [], status: { executing: false }, tokens: null, truncated: false };
+}
+export function timelineStateFromSnapshot(snapshot) {
+    return {
+        entries: snapshot.entries,
+        status: snapshot.status,
+        tokens: snapshot.tokens ?? null,
+        truncated: snapshot.truncated === true,
+    };
+}
+export function applyTimelineEvent(state, event) {
+    switch (event.kind) {
+        case 'text':
+        case 'thinking':
+            return applyStreamDelta(state, event);
+        case 'user':
+            return appendEntry(state, userEntry(event));
+        case 'tool_use':
+            return applyToolUse(state, event);
+        case 'tool_result':
+            return applyToolResult(state, event);
+        case 'notice':
+            return appendEntry(state, noticeEntry(event));
+        case 'question':
+            return applyQuestion(state, event);
+        case 'question_state':
+            return applyQuestionState(state, event);
+        case 'tokens':
+            state.tokens = normalizeUsage(event.usage);
+            return state;
+        case 'status':
+            return applyStatus(state, event);
+        case 'truncate':
+            return applyTruncate(state, event);
+        default:
+            return state;
+    }
+}
+function appendEntry(state, entry) {
+    closeOpenEntries(state.entries);
+    state.entries.push(entry);
+    return state;
+}
+function applyStreamDelta(state, event) {
+    const last = state.entries[state.entries.length - 1];
+    if (last && last.kind === event.kind && last.open && last.id === event.entryId) {
+        last.text += event.delta;
+        return state;
+    }
+    return appendEntry(state, {
+        id: event.entryId,
+        kind: event.kind,
+        at: event.at,
+        ...(event.engine ? { engine: event.engine } : {}),
+        text: event.delta,
+        open: true,
+    });
+}
+function userEntry(event) {
+    return {
+        id: event.entryId,
+        kind: 'user',
+        at: event.at,
+        ...(event.engine ? { engine: event.engine } : {}),
+        text: event.text,
+        ...(event.attachments ? { attachments: event.attachments } : {}),
+        ...(event.turn !== undefined ? { turn: event.turn } : {}),
+    };
+}
+function noticeEntry(event) {
+    return {
+        id: event.entryId,
+        kind: 'notice',
+        at: event.at,
+        ...(event.engine ? { engine: event.engine } : {}),
+        level: event.level,
+        text: event.text,
+        ...(event.code ? { code: event.code } : {}),
+        ...(event.data ? { data: event.data } : {}),
+    };
+}
+function applyToolUse(state, event) {
+    const existing = findEntry(state.entries, event.entryId);
+    if (existing?.kind === 'tool') {
+        existing.input = event.input;
+        if (event.toolUseId)
+            existing.toolUseId = event.toolUseId;
+        return state;
+    }
+    return appendEntry(state, {
+        id: event.entryId,
+        kind: 'tool',
+        at: event.at,
+        ...(event.engine ? { engine: event.engine } : {}),
+        toolName: event.toolName,
+        ...(event.toolUseId ? { toolUseId: event.toolUseId } : {}),
+        input: event.input,
+        status: 'running',
+    });
+}
+function applyToolResult(state, event) {
+    const entry = findEntry(state.entries, event.entryId);
+    if (entry?.kind === 'tool') {
+        entry.status = event.ok ? 'success' : 'error';
+        entry.result = event.result;
+        entry.completedAt = event.at;
+    }
+    return state;
+}
+function applyQuestion(state, event) {
+    if (findEntry(state.entries, event.entryId))
+        return state;
+    return appendEntry(state, {
+        id: event.entryId,
+        kind: 'question',
+        at: event.at,
+        ...(event.engine ? { engine: event.engine } : {}),
+        toolUseId: event.toolUseId,
+        questions: event.questions,
+        state: 'pending',
+    });
+}
+function applyQuestionState(state, event) {
+    const entry = findEntry(state.entries, event.entryId);
+    if (entry?.kind === 'question')
+        entry.state = event.state;
+    return state;
+}
+function normalizeUsage(usage) {
+    return {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheCreationTokens: usage.cacheCreationTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        currentTurnInputTokens: usage.currentTurnInputTokens,
+        ...(usage.isFinal ? { isFinal: true } : {}),
+    };
+}
+function applyStatus(state, event) {
+    state.status = {
+        executing: event.executing,
+        ...(event.startedAt !== undefined ? { startedAt: event.startedAt } : {}),
+        ...(event.turn !== undefined ? { turn: event.turn } : {}),
+    };
+    if (!event.executing)
+        closeOpenEntries(state.entries);
+    return state;
+}
+function applyTruncate(state, event) {
+    state.truncated = true;
+    const through = Number(event.throughEntryId);
+    if (!Number.isFinite(through))
+        return state;
+    let drop = 0;
+    while (drop < state.entries.length && Number(state.entries[drop].id) <= through)
+        drop++;
+    if (drop > 0)
+        state.entries.splice(0, drop);
+    return state;
+}
+export function applyTimelineEvents(state, events) {
+    for (const event of events)
+        applyTimelineEvent(state, event);
+    return state;
+}
+export function foldTimeline(snapshot, tail) {
+    return applyTimelineEvents(timelineStateFromSnapshot(snapshot), tail);
+}
+function closeOpenEntries(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== 'text' && entry.kind !== 'thinking')
+            return;
+        if (!entry.open)
+            return;
+        entry.open = false;
+    }
+}
+function findEntry(entries, id) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        if (entries[i].id === id)
+            return entries[i];
+    }
+    return undefined;
+}

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

@@ -0,0 +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 { 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

@@ -0,0 +1,217 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { can } from '@minionry/roles';
+import { getAgentScheduler } from '../schedule/agent-scheduler.js';
+import { dispatchByType } from './dispatch-util.js';
+import { parseTabEngineOverride } from './tab-handlers.js';
+export function handleAgentScheduleMessage(ctx, ws, msg, workingDir, role) {
+    const executeGate = can(role, 'execute') ? undefined : 'view';
+    const handlers = {
+        agentScheduleCreate: () => handleAgentScheduleCreate(ctx, ws, msg, workingDir, executeGate),
+        agentScheduleUpdate: () => handleAgentScheduleUpdate(ctx, ws, msg, workingDir, executeGate),
+        agentScheduleDelete: () => handleAgentScheduleDelete(ctx, ws, msg, workingDir, executeGate),
+        agentScheduleList: () => handleAgentScheduleList(ctx, ws, msg, workingDir),
+    };
+    try {
+        dispatchByType(handlers, 'agentSchedule', msg.type, (type) => {
+            ctx.send(ws, {
+                type: 'agentScheduleListResult',
+                data: { success: false, schedules: [], error: `Unknown agent schedule message type: ${type}` },
+            });
+        });
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        console.error('[agentSchedule] handler failed:', error);
+        ctx.send(ws, {
+            type: 'agentScheduleListResult',
+            data: { requestId: msg.data?.requestId, success: false, schedules: [], error: errMsg },
+        });
+    }
+}
+function parseAgentTiming(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const t = raw;
+    if (t.kind === 'once') {
+        return typeof t.at === 'string' && !Number.isNaN(Date.parse(t.at)) ? { kind: 'once', at: t.at } : null;
+    }
+    if (t.kind === 'interval') {
+        return typeof t.everyMs === 'number' && Number.isFinite(t.everyMs)
+            ? { kind: 'interval', everyMs: t.everyMs }
+            : null;
+    }
+    return null;
+}
+function parsePrompt(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function parseEngineOverrideField(raw, present) {
+    if (!present)
+        return { ok: true, value: undefined };
+    if (raw === null)
+        return { ok: true, value: null };
+    const parsed = parseTabEngineOverride(raw);
+    return parsed ? { ok: true, value: parsed } : { ok: false };
+}
+function handleAgentScheduleCreate(ctx, ws, msg, workingDir, permission) {
+    const data = (msg.data || {});
+    const { requestId } = data;
+    const reply = (payload) => ctx.send(ws, { type: 'agentScheduleCreated', data: { requestId, ...payload } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    if (!requestId) {
+        reply({ success: false, error: 'requestId required' });
+        return;
+    }
+    const prompt = parsePrompt(data.prompt);
+    if (!prompt) {
+        reply({ success: false, error: 'prompt is required' });
+        return;
+    }
+    const timing = parseAgentTiming(data.timing);
+    if (!timing) {
+        reply({ success: false, error: 'Invalid timing (expected {kind:"once",at} or {kind:"interval",everyMs})' });
+        return;
+    }
+    const override = parseEngineOverrideField(data.engineOverride, 'engineOverride' in data);
+    if (!override.ok) {
+        reply({ success: false, error: 'Invalid engineOverride' });
+        return;
+    }
+    const store = getAgentScheduleStore(ctx, workingDir);
+    if (!store) {
+        reply({ success: false, error: 'No working directory for this Space' });
+        return;
+    }
+    const record = store.create({
+        name: data.name,
+        prompt,
+        engineOverride: override.value ?? undefined,
+        timing,
+        enabled: data.enabled,
+    });
+    notifySchedulerAndBroadcast(ctx, workingDir);
+    reply({ success: true, schedule: record });
+}
+function handleAgentScheduleUpdate(ctx, ws, msg, workingDir, permission) {
+    const { requestId, scheduleId, patch } = (msg.data || {});
+    const reply = (payload) => ctx.send(ws, { type: 'agentScheduleUpdated', data: { requestId, ...payload } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    if (!requestId || !scheduleId) {
+        reply({ success: false, error: 'requestId and scheduleId required' });
+        return;
+    }
+    const safePatch = parseUpdatePatch(patch);
+    if (!safePatch) {
+        reply({ success: false, error: 'Invalid patch' });
+        return;
+    }
+    const store = getAgentScheduleStore(ctx, workingDir);
+    if (!store) {
+        reply({ success: false, error: 'No working directory for this Space' });
+        return;
+    }
+    const record = store.update(scheduleId, safePatch);
+    if (!record) {
+        reply({ success: false, error: 'Schedule not found' });
+        return;
+    }
+    notifySchedulerAndBroadcast(ctx, workingDir);
+    reply({ success: true, schedule: record });
+}
+function parseUpdatePatch(patch) {
+    if (!patch || typeof patch !== 'object')
+        return null;
+    const safe = {};
+    if (patch.name !== undefined) {
+        if (typeof patch.name !== 'string')
+            return null;
+        safe.name = patch.name;
+    }
+    if (patch.prompt !== undefined) {
+        const prompt = parsePrompt(patch.prompt);
+        if (!prompt)
+            return null;
+        safe.prompt = prompt;
+    }
+    if (patch.enabled !== undefined) {
+        if (typeof patch.enabled !== 'boolean')
+            return null;
+        safe.enabled = patch.enabled;
+    }
+    return applyStructuredPatchFields(patch, safe);
+}
+function applyStructuredPatchFields(patch, safe) {
+    if (patch.timing !== undefined) {
+        const timing = parseAgentTiming(patch.timing);
+        if (!timing)
+            return null;
+        safe.timing = timing;
+    }
+    if ('engineOverride' in patch) {
+        const override = parseEngineOverrideField(patch.engineOverride, true);
+        if (!override.ok)
+            return null;
+        if (override.value !== undefined)
+            safe.engineOverride = override.value;
+    }
+    return safe;
+}
+function handleAgentScheduleDelete(ctx, ws, msg, workingDir, permission) {
+    const { requestId, scheduleId } = (msg.data || {});
+    const reply = (payload) => ctx.send(ws, { type: 'agentScheduleDeleted', data: { requestId, scheduleId, ...payload } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    if (!requestId || !scheduleId) {
+        reply({ success: false, error: 'requestId and scheduleId required' });
+        return;
+    }
+    const store = getAgentScheduleStore(ctx, workingDir);
+    if (!store) {
+        reply({ success: false, error: 'No working directory for this Space' });
+        return;
+    }
+    if (!store.delete(scheduleId)) {
+        reply({ success: false, error: 'Schedule not found' });
+        return;
+    }
+    notifySchedulerAndBroadcast(ctx, workingDir);
+    reply({ success: true });
+}
+function handleAgentScheduleList(ctx, ws, msg, workingDir) {
+    const { requestId } = (msg.data || {});
+    const reply = (payload) => ctx.send(ws, { type: 'agentScheduleListResult', data: { requestId, ...payload } });
+    if (!requestId) {
+        reply({ success: false, schedules: [], error: 'requestId required' });
+        return;
+    }
+    const store = getAgentScheduleStore(ctx, workingDir);
+    if (!store) {
+        reply({ success: false, schedules: [], error: 'No working directory for this Space' });
+        return;
+    }
+    reply({ success: true, schedules: store.list() });
+}
+function getAgentScheduleStore(ctx, workingDir) {
+    const engine = getAgentScheduler(workingDir, ctx);
+    engine.start();
+    return engine.getStore();
+}
+function notifySchedulerAndBroadcast(ctx, workingDir) {
+    const engine = getAgentScheduler(workingDir, ctx);
+    engine.tick();
+    const store = engine.getStore();
+    if (store)
+        ctx.broadcastToAll({ type: 'agentSchedulesChanged', data: { schedules: store.list() } });
+}