mixdog 0.9.68 → 0.9.69

package/src/session-runtime/workflow.mjs

@@ -3,10 +3,12 @@
 // keep this module free of the runtime's path/provider constants.
 import { basename, join } from 'node:path';
 import { existsSync, readdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { clean } from './session-text.mjs';
 import { normalizeEffortInput } from './effort.mjs';
 import { isLikelyRawModelId } from './config-helpers.mjs';
 import { readTextSafe, readJsonSafe } from './fs-utils.mjs';
+import { isHiddenAgent } from '../runtime/agent/orchestrator/internal-agents.mjs';
 
 export const WORKFLOW_ROUTE_SLOTS = ['lead', 'agent', 'explorer', 'memory'];
 export const FIXED_AGENT_SLOTS = Object.freeze([
@@ -42,6 +44,18 @@ function setAgentDefinitionCache(key, value) {
   agentDefinitionCache.set(key, value);
 }
 
+// Editor writes must invalidate the definition cache or a saved AGENT.md
+// stays stale for the session lifetime (keys are `${dir}\n${agentId}`).
+export function clearAgentDefinitionCache(agentId = '') {
+  if (!agentId) {
+    agentDefinitionCache.clear();
+    return;
+  }
+  for (const key of [...agentDefinitionCache.keys()]) {
+    if (key.endsWith(`\n${agentId}`)) agentDefinitionCache.delete(key);
+  }
+}
+
 export function workflowPresetId(slot) {
   return `workflow-${slot}`;
 }
@@ -69,6 +83,41 @@ export function normalizeWorkflowId(value, fallback = '') {
   return /^[a-z0-9][a-z0-9_.-]*$/.test(id) ? id : fallback;
 }
 
+function internalIdFromName(value, fallbackPrefix) {
+  const name = clean(value);
+  const readable = name
+    .normalize('NFKD')
+    .replace(/\p{M}+/gu, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9_.-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '');
+  const id = normalizeWorkflowId(readable, '');
+  if (id) return id;
+  return `${fallbackPrefix}-${createHash('sha256').update(name).digest('hex').slice(0, 10)}`;
+}
+
+export function workflowIdFromName(value) {
+  return internalIdFromName(value, 'workflow');
+}
+
+export function agentIdFromName(value) {
+  return internalIdFromName(value, 'agent');
+}
+
+export function availableWorkflowId(baseId, isTaken) {
+  const id = normalizeWorkflowId(baseId, '');
+  if (!id) return '';
+  if (!isTaken(id)) return id;
+  let suffix = 2;
+  while (isTaken(`${id}-${suffix}`)) suffix += 1;
+  return `${id}-${suffix}`;
+}
+
+export function availableAgentId(name, isTaken) {
+  return availableWorkflowId(agentIdFromName(name), isTaken);
+}
+
 // A workflow/agent pack loader is created per data/root layout via
 // createWorkflowHelpers, and the config-aware route helpers via
 // createWorkflowRouteHelpers.
@@ -87,6 +136,29 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     ];
   }
 
+  // Custom agents (user-authored roles beyond FIXED_AGENT_SLOTS): every
+  // agents/<id>/AGENT.md directory whose id is not a fixed role. Mixdog-managed
+  // hidden roles (defaults/agents.json: scheduler-task, webhook-handler, …) ship
+  // the same directory layout, so they are excluded here — at the data source —
+  // instead of per-surface, or the TUI /agents list exposes internal roles the
+  // desktop UI happens to filter out.
+  function listCustomAgentIds(dir) {
+    const ids = new Set();
+    for (const root of [join(dir || dataDir, 'agents'), join(rootDir, 'agents')]) {
+      if (!existsSync(root)) continue;
+      let entries = [];
+      try { entries = readdirSync(root, { withFileTypes: true }); } catch { entries = []; }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const id = normalizeWorkflowId(entry.name);
+        if (!id || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
+        if (!existsSync(join(root, entry.name, 'AGENT.md'))) continue;
+        ids.add(id);
+      }
+    }
+    return [...ids].sort();
+  }
+
   function readWorkflowPackFromDir(dir, source = 'built-in', dirName = '') {
     const entry = 'WORKFLOW.md';
     const doc = readMarkdownDocument(readTextSafe(join(dir, entry)));
@@ -184,21 +256,10 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
       setAgentDefinitionCache(cacheKey, definition);
       return definition;
     }
-    const legacyDoc = readMarkdownDocument(readTextSafe(join(rootDir, 'agents', `${agentId}.md`)));
-    if (!legacyDoc.body) {
-      setAgentDefinitionCache(cacheKey, null);
-      return null;
-    }
-    const definition = {
-      id: agentId,
-      name: FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
-      description: '',
-      permission: normalizeAgentPermissionOrNone(legacyDoc.frontmatter.permission),
-      frontmatter: legacyDoc.frontmatter,
-      body: legacyDoc.body,
-    };
-    setAgentDefinitionCache(cacheKey, definition);
-    return definition;
+    // Every shipped and user role lives at agents/<id>/AGENT.md; there is no
+    // flat agents/<id>.md layout left to fall back to.
+    setAgentDefinitionCache(cacheKey, null);
+    return null;
   }
 
   function workflowContextBlock(config, dir) {
@@ -210,7 +271,10 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     const lines = [`# Active Workflow: ${pack.name}`];
     if (pack.description) lines.push(pack.description);
     lines.push(pack.body);
-    const agentIds = pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id);
+    // A hand-edited pack may name a hidden role in its `agents:` frontmatter;
+    // internal roles are never delegatable, so they never enter the catalog.
+    const agentIds = (pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id))
+      .filter((id) => !isHiddenAgent(id));
     const agentBlocks = agentIds.map((id) => loadAgentDefinition(dir, id)).filter(Boolean);
     if (agentBlocks.length) {
       lines.push('# Available Agents');
@@ -241,6 +305,7 @@ export function createWorkflowHelpers({ rootDir, dataDir, readMarkdownDocument,
     workflowSummary,
     activeWorkflowSummary,
     loadAgentDefinition,
+    listCustomAgentIds,
     workflowContextBlock,
     activeWorkflowContext,
   };
@@ -349,7 +414,9 @@ export function createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset
   }
 
   function agentRouteFromConfig(config, agentId, _dataDir) {
-    const id = normalizeAgentId(agentId);
+    // Custom agents (user-authored roles) pass through as workflow-style ids;
+    // their routes live in config.agents[<id>] like the fixed roles.
+    const id = normalizeAgentId(agentId) || normalizeWorkflowId(agentId);
     if (!id) return null;
     // Read/interpret path: inject config.defaultProvider (then DEFAULT_PROVIDER)
     // when a stored route omits its provider.

package/src/standalone/agent-tool/worker-index.mjs

@@ -0,0 +1,287 @@
+// Worker-index persistence for the agent tool: the on-disk row store (tag →
+// session), its mtime-keyed parse cache, the batched atomic writer and the
+// tag-map projection. Extracted from agent-tool.mjs, which now owns spawn /
+// dispatch flow only. The tag Maps are passed in by reference so the facade
+// and this store observe the same live state.
+import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { updateJsonAtomicSync } from '../../runtime/shared/atomic-file.mjs';
+import { resolveAgentTerminalReapMs } from '../../session-runtime/config-helpers.mjs';
+import { WORKER_INDEX_FILE } from './tool-def.mjs';
+import { agentTagOf, clean, positiveInt, rowMatchesContext } from './helpers.mjs';
+import {
+  applyWorkerRowUpsert,
+  isTerminalWorkerStatus,
+  normalizeTagTombstones,
+  tagTombstoneKey,
+  workerRowKey,
+  workerRowTime,
+} from './worker-rows.mjs';
+
+export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCwds }) {
+  const pendingMutators = [];
+  let flushTimer = null;
+  // Mtime-keyed parse cache. A single spawn calls refreshTagsFromSessions /
+  // resolveTag / nextTag, which each re-read and re-parse this file; across a
+  // parallel fanout that is O(spawns^2) synchronous reads of the same bytes.
+  let cache = null; // { mtimeMs, size, rows, tombstones }
+  let cacheDirty = true;
+
+  function workerIndexPath() {
+    return dataDir ? resolve(dataDir, WORKER_INDEX_FILE) : null;
+  }
+
+  // A terminal row ages out after the configured reap window so the index does
+  // not grow without bound; live rows are always kept.
+  function keepWorkerRow(row = {}) {
+    if (!clean(row.tag) || !clean(row.sessionId)) return false;
+    const t = workerRowTime(row);
+    if (!t) return true;
+    if (!isTerminalWorkerStatus(row.status || row.stage)) return true;
+    const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row.provider);
+    return reapMs == null || Date.now() - t < reapMs;
+  }
+
+  function normalizeWorkerRows(value) {
+    const source = Array.isArray(value?.workers)
+      ? value.workers
+      : (value?.workers && typeof value.workers === 'object'
+        ? Object.values(value.workers)
+        : (Array.isArray(value) ? value : []));
+    return source
+      .filter((row) => row && typeof row === 'object')
+      .map((row) => ({
+        tag: clean(row.tag),
+        sessionId: clean(row.sessionId),
+        agent: clean(row.agent) || null,
+        provider: clean(row.provider) || null,
+        model: clean(row.model) || null,
+        preset: clean(row.preset) || null,
+        effort: clean(row.effort) || null,
+        fast: row.fast === true ? true : (row.fast === false ? false : null),
+        status: clean(row.status) || 'idle',
+        stage: clean(row.stage) || clean(row.status) || 'idle',
+        createdAt: clean(row.createdAt) || null,
+        updatedAt: clean(row.updatedAt) || null,
+        lastUsedAt: clean(row.lastUsedAt) || null,
+        finishedAt: clean(row.finishedAt) || null,
+        clientHostPid: positiveInt(row.clientHostPid),
+        cwd: clean(row.cwd) || null,
+        task_id: clean(row.task_id || row.taskId) || null,
+        error: clean(row.error) || null,
+        permission: clean(row.permission) || null,
+        toolPermission: clean(row.toolPermission) || null,
+        messages: positiveInt(row.messages) || 0,
+        tools: positiveInt(row.tools) || 0,
+      }))
+      .filter(keepWorkerRow);
+  }
+
+  function invalidateCache() {
+    cacheDirty = true;
+  }
+
+  function readAllWorkerRows() {
+    const file = workerIndexPath();
+    if (!file) return [];
+    let st = null;
+    try { st = statSync(file); } catch { cache = null; return []; }
+    if (!cacheDirty && cache && cache.mtimeMs === st.mtimeMs && cache.size === st.size) {
+      return cache.rows;
+    }
+    let rows = [];
+    let tombstones = [];
+    try {
+      const parsed = JSON.parse(readFileSync(file, 'utf8'));
+      rows = normalizeWorkerRows(parsed);
+      tombstones = normalizeTagTombstones(parsed);
+    } catch {
+      rows = [];
+      tombstones = [];
+    }
+    cache = { mtimeMs: st.mtimeMs, size: st.size, rows, tombstones };
+    cacheDirty = false;
+    return rows;
+  }
+
+  function readAllTagTombstones() {
+    readAllWorkerRows();
+    return cache?.tombstones || [];
+  }
+
+  function readTagTombstones(context = {}) {
+    return readAllTagTombstones().filter((row) => rowMatchesContext(row, context));
+  }
+
+  function readWorkerRows(context = {}) {
+    const rows = readAllWorkerRows();
+    if (rows.length === 0) return rows;
+    return rows.filter((row) => rowMatchesContext(row, context));
+  }
+
+  // Single writer path: every mutation re-reads under the file lock, applies
+  // the caller's mutator over keyed maps, then republishes rows + tombstones.
+  function writeWorkerRows(mutator) {
+    const file = workerIndexPath();
+    if (!file || typeof mutator !== 'function') return null;
+    try {
+      const result = updateJsonAtomicSync(file, (cur) => {
+        const byKey = new Map();
+        for (const row of normalizeWorkerRows(cur)) {
+          const key = workerRowKey(row);
+          if (key) byKey.set(key, row);
+        }
+        const tombstonesByKey = new Map();
+        for (const row of normalizeTagTombstones(cur, { cap: false })) {
+          tombstonesByKey.set(tagTombstoneKey(row), row);
+        }
+        const priorityTombstoneKeys = new Set();
+        mutator(byKey, tombstonesByKey, priorityTombstoneKeys);
+        const workers = {};
+        for (const row of [...byKey.values()].filter(keepWorkerRow)) {
+          const key = workerRowKey(row);
+          if (key) workers[key] = row;
+        }
+        const tombstones = {};
+        for (const row of normalizeTagTombstones(
+          { tombstones: [...tombstonesByKey.values()] },
+          { priorityKeys: priorityTombstoneKeys },
+        )) {
+          tombstones[tagTombstoneKey(row)] = row;
+        }
+        return { version: 2, updatedAt: new Date().toISOString(), workers, tombstones };
+      }, { lock: true });
+      // This process just rewrote the index; force the next read to re-parse
+      // even if the new mtime/size happen to collide with the cached stat.
+      invalidateCache();
+      return result;
+    } catch {
+      return null;
+    }
+  }
+
+  // Spawn-path writes are batched onto one microtask so a parallel fanout pays
+  // a single locked rewrite instead of one per worker.
+  function flushWorkerIndexMutations() {
+    if (flushTimer) {
+      try { clearImmediate(flushTimer); } catch { /* already fired */ }
+      flushTimer = null;
+    }
+    if (pendingMutators.length === 0) return;
+    const batch = pendingMutators.splice(0, pendingMutators.length);
+    writeWorkerRows((byKey) => {
+      for (const mutator of batch) {
+        try { mutator(byKey); } catch { /* one bad row never drops the batch */ }
+      }
+    });
+  }
+
+  function queueWorkerIndexMutation(mutator) {
+    if (typeof mutator !== 'function') return false;
+    if (!workerIndexPath()) return false;
+    pendingMutators.push(mutator);
+    if (!flushTimer) {
+      flushTimer = setImmediate(flushWorkerIndexMutations);
+      flushTimer.unref?.();
+    }
+    return true;
+  }
+
+  function workerRowFromSession(session, fallbackTag = '', extra = {}) {
+    const tag = agentTagOf(session) || clean(fallbackTag) || clean(extra.tag);
+    const sessionId = clean(session?.id || extra.sessionId);
+    if (!tag || !sessionId) return null;
+    const runtime = mgr.getSessionRuntime?.(sessionId);
+    const status = clean(extra.status) || (session?.closed === true ? 'closed' : clean(session?.status) || 'idle');
+    const stage = clean(extra.stage) || clean(runtime?.stage) || status;
+    const nowIso = new Date().toISOString();
+    return {
+      tag,
+      sessionId,
+      agent: clean(extra.agent) || clean(session?.agent) || null,
+      provider: clean(extra.provider) || clean(session?.provider) || null,
+      model: clean(extra.model) || clean(session?.model) || null,
+      preset: clean(extra.preset) || clean(session?.presetName) || null,
+      effort: clean(extra.effort) || clean(session?.effort) || null,
+      fast: extra.fast === true || extra.fast === false ? extra.fast : (session?.fast === true ? true : null),
+      status,
+      stage,
+      createdAt: clean(session?.createdAt) || clean(extra.createdAt) || nowIso,
+      updatedAt: clean(extra.updatedAt) || nowIso,
+      lastUsedAt: clean(session?.lastUsedAt) || null,
+      finishedAt: clean(extra.finishedAt) || null,
+      clientHostPid: positiveInt(extra.clientHostPid) || positiveInt(session?.clientHostPid),
+      cwd: clean(session?.cwd) || clean(extra.cwd) || null,
+      task_id: clean(extra.task_id || extra.taskId) || null,
+      error: clean(extra.error) || null,
+      permission: clean(session?.permission) || null,
+      toolPermission: clean(session?.toolPermission) || null,
+      messages: Array.isArray(session?.messages) ? session.messages.length : 0,
+      tools: Array.isArray(session?.tools) ? session.tools.length : 0,
+    };
+  }
+
+  // Every upsert also projects the row into the in-memory tag maps so tag
+  // lookups never wait on a disk round-trip.
+  function upsertWorkerRow(row, { defer = false } = {}) {
+    const normalized = normalizeWorkerRows({ workers: [row] })[0];
+    if (!normalized) return false;
+    tags.set(normalized.tag, normalized.sessionId);
+    if (normalized.agent) tagAgents.set(normalized.tag, normalized.agent);
+    if (normalized.cwd) tagCwds.set(normalized.tag, normalized.cwd);
+    if (defer) return queueWorkerIndexMutation((byKey) => applyWorkerRowUpsert(byKey, normalized));
+    writeWorkerRows((byKey) => { applyWorkerRowUpsert(byKey, normalized); });
+    return true;
+  }
+
+  function upsertWorkerSession(session, fallbackTag = '', extra = {}) {
+    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra));
+  }
+
+  function upsertWorkerSessionDeferred(session, fallbackTag = '', extra = {}) {
+    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra), { defer: true });
+  }
+
+  function removeWorkerRow({ tag = '', sessionId = '' } = {}) {
+    const targetTag = clean(tag);
+    const targetSessionId = clean(sessionId);
+    flushWorkerIndexMutations();
+    writeWorkerRows((byKey) => {
+      for (const [key, row] of [...byKey.entries()]) {
+        if ((targetSessionId && row.sessionId === targetSessionId) || (targetTag && row.tag === targetTag)) {
+          byKey.delete(key);
+        }
+      }
+    });
+  }
+
+  function refreshTagsFromIndex(context = {}) {
+    const rows = readWorkerRows(context);
+    for (const row of rows) {
+      if (!row.tag || !row.sessionId) continue;
+      tags.set(row.tag, row.sessionId);
+      if (row.agent) tagAgents.set(row.tag, row.agent);
+      if (row.cwd) tagCwds.set(row.tag, row.cwd);
+    }
+    return rows;
+  }
+
+  return {
+    workerIndexPath,
+    invalidateWorkerRowsCache: invalidateCache,
+    readAllWorkerRows,
+    readAllTagTombstones,
+    readTagTombstones,
+    readWorkerRows,
+    writeWorkerRows,
+    flushWorkerIndexMutations,
+    queueWorkerIndexMutation,
+    workerRowFromSession,
+    upsertWorkerRow,
+    upsertWorkerSession,
+    upsertWorkerSessionDeferred,
+    removeWorkerRow,
+    refreshTagsFromIndex,
+  };
+}