mixdog 1.3.1 → 1.3.3

package/src/runtime/shared/agent-store.mjs

@@ -5,8 +5,9 @@
 // before that — or if it never could run — every reader sees agents/ as
 // before. The ids the split copied are bots for good: their agents/ originals
 // stay on disk for rollback but no catalog reads them again.
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { readJsonStateSync, writeJsonAtomicSync } from './atomic-file.mjs';
 import { setBotRouteResolver } from './agent-route-config.mjs';
 
 export const BOTS_DIR = 'bots';
@@ -15,10 +16,18 @@ export const BOT_MIGRATION_VERSION = 1;
 /** Mixy's bot id once it has its own folder. */
 export const MIXY_BOT_ID = 'mixy';
 
+function requireObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('not a JSON object');
+  return value;
+}
+
+// A damaged file (NUL, truncated, not an object) is kept aside and its last
+// good copy (agent.json.bak, left by writeBotRoute) restored; otherwise it
+// stays in place — the connector policy reader treats a missing agent.json as
+// "every connector on" — and reads as absent. Any read failure reads as absent.
 function readJson(file) {
   try {
-    const value = JSON.parse(readFileSync(file, 'utf8'));
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    return readJsonStateSync(file, { validate: requireObject, keepWithoutBackup: true });
   } catch {
     return null;
   }
@@ -91,13 +100,11 @@ export function readBotRoute(dataDir, id) {
 /** Stores (or with null removes) a store bot's route in its agent.json; every
  *  other key is kept. */
 export function writeBotRoute(dataDir, id, route) {
-  const dir = botDir(dataDir, id);
-  const file = join(dir, 'agent.json');
+  const file = join(botDir(dataDir, id), 'agent.json');
   const manifest = readJson(file) || {};
   if (route) manifest.route = route;
   else delete manifest.route;
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+  writeJsonAtomicSync(file, manifest, { backup: true });
   fileCache.delete(file);
 }
 
@@ -127,6 +134,16 @@ export function writeMixyRoute(dataDir, route) {
 
 /** Every config route read (configuredAgentRouteCandidates) asks the bot
  *  store first: a bot's route lives with the bot, never in the config. */
+let botDataDir = () => '';
 export function registerBotRouteStore(getDataDir) {
+  botDataDir = getDataDir;
   setBotRouteResolver((id) => readBotRoute(getDataDir(), id));
 }
+
+/** The own route (fallbacks included) of the bot a session acts as, Mixy
+ *  (runtime id `lead`) from bots/mixy; null when it has none. */
+export function storedBotRoute(agentId) {
+  const dataDir = botDataDir();
+  if (!dataDir) return null;
+  return (agentId === 'lead' ? readMixyRoute(dataDir) : readBotRoute(dataDir, agentId)) || null;
+}

package/src/runtime/shared/agent-task-starts.mjs

@@ -0,0 +1,27 @@
+// The agent task ids each `agent` tool call started (a spawn, or a send that
+// began a new job), keyed by the tool call id: the agent tool records them
+// from its own job objects (agent-tool spawn-flow/job-start.mjs) and the tool
+// batch stores them on that call's result message as `agentTaskIds`
+// (tool-batch/finalize.mjs) — the structured provenance a task session's
+// report follows to the turns its agents' results wake.
+const startsByCall = new Map();
+const MAX_CALLS = 1000;
+
+/** Record that tool call `toolCallId` started agent task `taskId`. */
+export function recordAgentTaskStart(toolCallId, taskId) {
+  const callId = String(toolCallId || '').trim();
+  const id = String(taskId || '').trim();
+  if (!callId || !id) return;
+  const ids = startsByCall.get(callId) || [];
+  if (!ids.includes(id)) ids.push(id);
+  startsByCall.set(callId, ids);
+  while (startsByCall.size > MAX_CALLS) startsByCall.delete(startsByCall.keys().next().value);
+}
+
+/** The task ids tool call `toolCallId` started (empty when none), forgotten once taken. */
+export function takeAgentTaskStarts(toolCallId) {
+  const callId = String(toolCallId || '').trim();
+  const ids = startsByCall.get(callId) || [];
+  startsByCall.delete(callId);
+  return ids;
+}

package/src/runtime/shared/atomic-file.d.mts

@@ -5,6 +5,12 @@ export interface AtomicFileOptions {
   encoding?: BufferEncoding;
   fsync?: boolean;
   fsyncDir?: boolean;
+  /** Serialize with other writers through `${path}.lock`. */
+  lock?: boolean;
+  /** Keep the replaced version as `<path>.bak` (JSON writes: only if it still parses). */
+  backup?: boolean;
+  /** With `backup`: whether the replaced content may become the backup. */
+  backupAccepts?: (content: Buffer) => boolean;
 }
 
 export function writeFileAtomicAsync(
@@ -13,6 +19,8 @@ export function writeFileAtomicAsync(
   options?: AtomicFileOptions
 ): Promise<boolean>;
 
+export function writeFileAtomicSync(filePath: string, data: string | Uint8Array, options?: AtomicFileOptions): boolean;
+
 /** Atomic JSON publication used by TypeScript desktop hosts. */
 export function writeJsonAtomicAsync(
   filePath: string,
@@ -20,6 +28,48 @@ export function writeJsonAtomicAsync(
   options?: AtomicFileOptions & { compact?: boolean }
 ): Promise<boolean>;
 
+export function writeJsonAtomicSync(
+  filePath: string,
+  value: unknown,
+  options?: AtomicFileOptions & { compact?: boolean }
+): boolean;
+
+export interface JsonStateOptions<T> {
+  /** Maps the parsed value; throwing marks the file damaged. */
+  validate?: (value: unknown) => T;
+  /** Maps the file's bytes to JSON text (e.g. unsealing); throwing marks it damaged. */
+  decode?: (content: Buffer) => string;
+  /** Returned as is when the file is missing or damaged with no good backup. */
+  fallback?: T;
+  /** Leave a damaged file in place when there is no good `.bak` (for files where "missing" is permissive). */
+  keepWithoutBackup?: boolean;
+  /** false: never restore `.bak` (an older copy is worse than none, e.g. revoked grants). */
+  restoreBackup?: boolean;
+  secret?: boolean;
+  mode?: number;
+}
+
+/** Reads a JSON state file that must never block its feature: a damaged file
+ *  is kept aside as `<path>.corrupt-<ts>` and `<path>.bak` restored when valid. */
+export function readJsonState<T = unknown>(filePath: string, options?: JsonStateOptions<T>): Promise<T>;
+
+export function readJsonStateSync<T = unknown>(filePath: string, options?: JsonStateOptions<T>): T;
+
+/** A collision-proof, non-dot-prefixed destination for a damaged copy: `<path>.corrupt-<ms>` (the first ms whose name is unused). Call under the file's lock. */
+export function quarantinePath(filePath: string): string;
+
+/** For `validate`: an intact file in a newer build's format; it is left in place and the read answers the fallback. */
+export function unsupportedState(message: string): Error;
+
+/** True when `err` is a filesystem refusing fsync on a file (EPERM, ENOTSUP, EINVAL), not a real I/O error. */
+export function isFileFsyncUnsupported(err: unknown): boolean;
+
+/** True when the content is only NUL bytes and whitespace (what a crash leaves). */
+export function holdsNoData(content: string | Uint8Array): boolean;
+
+/** JSON.parse that also accepts a leading byte order mark. */
+export function parseJsonText(text: string): unknown;
+
 export function withFileLock<T>(
   lockPath: string,
   task: () => T | Promise<T>,