npm - volute - Versions diffs - 0.52.0 → 0.53.0 - Mend

volute 0.52.0 → 0.53.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (105) hide show

package/dist/web-assets/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Averia+Serif+Libre:wght@300;400;700&family=Fira+Code:wght@300;400;500;600&family=Averia+Sans+Libre:ital,wght@0,300;0,400;0,500;0,600;1,400&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-B_eYTa3R.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DhZrzddW.css">
+    <script type="module" crossorigin src="/assets/index-b7G7ZsVk.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BHSU9r-4.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "volute",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "CLI for creating and managing self-modifying AI minds powered by the Claude Agent SDK",
   "type": "module",
   "license": "MIT",

package/templates/_base/.init/.config/prompts.json CHANGED Viewed

@@ -1,5 +1,5 @@
 {
-  "compaction_warning": "Compaction approaching — this conversation will be summarized soon. Take a moment to save anything important to your files (MEMORY.md, memory/journal/${date}.md) so it's preserved. Focus on decisions made, open threads, and anything you'd want to pick up again.",
+  "compaction_warning": "Context limit approaching — this session will rotate shortly. Turns before ${cutoff} will be collapsed to their summaries; turns from ${cutoff} on are kept verbatim in the continued session, so there's no need to re-describe them.\n\nFor the turns that will collapse, make sure they read the way you'd want: `volute mind history --provisional` shows the provisional summaries, and `volute mind history --write --turn <id> --text \"...\"` replaces any with your own account. Also save anything important to your files (memory/journal/${date}.md, or a memory/ file). Provisional summaries are kept if you write nothing — nothing blocks on this.\n\nYour MEMORY.md is currently ${memory_size}. It is loaded into every request, so consolidate rather than append — distill detail into memory/ files and keep MEMORY.md lean (see the memory skill).",
   "compaction_instructions": "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
   "reply_instructions": "To reply to this message, use: volute chat send ${channel} \"your message\"",
   "event_instructions": "This is a system event from your environment — not a message from anyone, and nothing awaits a reply. If it calls for action, use your normal channels. Your closing thoughts on an event turn are kept as a private reflection in your history.",

package/templates/_base/src/lib/codex-session-seed.ts ADDED Viewed

@@ -0,0 +1,463 @@
+/**
+ * Codex session seeding.
+ *
+ * When a codex mind starts a fresh *persistent* session (no saved thread id —
+ * e.g. after a sleep archived the pointer), we seed the new thread by copying
+ * the tail of the previous session's Codex rollout into a new synthetic rollout
+ * file. The Codex SDK (`codex exec resume <threadId>`) then finds and resumes it
+ * natively, so the mind experiences the conversation continuing rather than
+ * waking into an empty context.
+ *
+ * The rollout is reconstructed selectively, not verbatim:
+ *   - The `session_meta` header is copied with a fresh thread id (`session_id`
+ *     and `id`) and an updated timestamp; `parent_thread_id` is dropped.
+ *   - Body `response_item` lines of type `message` and COMPLETE
+ *     `custom_tool_call`/`custom_tool_call_output` pairs are kept verbatim.
+ *   - `reasoning` items are dropped: their `encrypted_content` is opaque and
+ *     provider-bound, the likeliest thing to poison a resume.
+ *   - `event_msg` (telemetry), `turn_context`, and `world_state` are dropped;
+ *     they carry no conversation content and `turn_context`'s recorded model
+ *     would otherwise trigger a spurious model-mismatch warning on resume.
+ *
+ * Verified against @openai/codex-sdk 0.144.x: `resumeThread` shells out to
+ * `codex exec resume <threadId>`, which locates the rollout by scanning
+ * CODEX_HOME/sessions for a filename containing the thread id, then reconstructs
+ * the conversation from the `response_item` lines. A synthetic rollout with the
+ * dropped line types above (and a tail starting at a user message) loads and
+ * resumes cleanly.
+ *
+ * Nothing here throws: any failure returns null so session start is never blocked.
+ */
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { findCodexSessionFile } from "./context-breakdown.js";
+import { log } from "./logger.js";
+import { parseArchiveTimestamp } from "./seed-note.js";
+import { archivePointerTimestamp } from "./session-seed.js";
+/** Default seed budget (estimated tokens) when config omits continuity.seedTokens. */
+export const DEFAULT_SEED_TOKENS = 30000;
+// Archived pointers are named `<name>-<timestamp>.json`, where the timestamp is
+// `new Date().toISOString().replace(/[:.]/g, "-").slice(0, 16)` → `YYYY-MM-DDTHH-MM`
+// (see archiveSessions in the daemon's sleep-manager). Matching the strict shape
+// after the `<name>-` prefix disambiguates `main-...` from a `main-thread-...`.
+const ARCHIVE_SUFFIX = /^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2})\.json$/;
+type RolloutLine = Record<string, unknown> & {
+  type?: string;
+  timestamp?: string;
+  payload?: Record<string, unknown> & {
+    type?: string;
+    role?: string;
+    call_id?: string;
+  };
+};
+/** A resolved archive pointer: the previous thread id and when it was archived. */
+export type ArchivedThread = { threadId: string; archivedAt: number | null };
+/**
+ * Newest archived codex thread for `<name>` under `<sessionsDir>/archive/`, or
+ * null if there's no matching pointer (or it can't be read). Codex pointer files
+ * hold `{ threadId }` (see the codex template's session-store). `archivedAt` is
+ * the archive timestamp in epoch millis (null if unparseable).
+ */
+export function findLatestArchivedThread(sessionsDir: string, name: string): ArchivedThread | null {
+  const archiveDir = resolve(sessionsDir, "archive");
+  let files: string[];
+  try {
+    files = readdirSync(archiveDir);
+  } catch {
+    return null;
+  }
+  const prefix = `${name}-`;
+  let bestTs = "";
+  let bestFile: string | null = null;
+  for (const file of files) {
+    if (!file.startsWith(prefix)) continue;
+    const match = file.slice(prefix.length).match(ARCHIVE_SUFFIX);
+    if (!match) continue;
+    // Timestamps are zero-padded ISO, so lexicographic comparison is chronological.
+    if (match[1] > bestTs) {
+      bestTs = match[1];
+      bestFile = file;
+    }
+  }
+  if (!bestFile) return null;
+  try {
+    const data = JSON.parse(readFileSync(resolve(archiveDir, bestFile), "utf-8"));
+    if (typeof data.threadId !== "string") return null;
+    return { threadId: data.threadId, archivedAt: parseArchiveTimestamp(bestTs) };
+  } catch {
+    return null;
+  }
+}
+/** Estimate tokens for a raw JSONL line as its JSON text length / 4. */
+function estimateTokens(raw: string): number {
+  return raw.length / 4;
+}
+/** A turn starts at a user `message` response_item (the incoming prompt). */
+function isTurnBoundary(o: RolloutLine): boolean {
+  return o.payload?.type === "message" && o.payload?.role === "user";
+}
+/** Response-item payload types that carry conversation content we keep. */
+function isKeptBody(o: RolloutLine): boolean {
+  if (o.type !== "response_item") return false;
+  const pt = o.payload?.type;
+  return pt === "message" || pt === "custom_tool_call" || pt === "custom_tool_call_output";
+}
+/**
+ * Generate a UUIDv7 thread id, matching the shape Codex uses (`019f…`): a 48-bit
+ * millisecond timestamp prefix plus randomness. The value only needs to be a
+ * valid, unique id embedded in the rollout filename and `session_meta`.
+ */
+export function generateThreadId(now: Date = new Date()): string {
+  const bytes = new Uint8Array(16);
+  const ms = BigInt(now.getTime());
+  for (let i = 0; i < 6; i++) {
+    bytes[i] = Number((ms >> BigInt(40 - i * 8)) & 0xffn);
+  }
+  const rand = randomBytes(10);
+  for (let i = 0; i < 10; i++) bytes[6 + i] = rand[i];
+  bytes[6] = (bytes[6] & 0x0f) | 0x70; // version 7
+  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export type SeededRollout = { threadId: string; lines: string[] };
+/** A kept body line paired with its raw JSON text (for token estimation). */
+type KeptLine = { obj: RolloutLine; raw: string };
+/** The session_meta header plus the response_items we keep (messages + tool pairs). */
+type ParsedRollout = { meta: RolloutLine; kept: KeptLine[] };
+/**
+ * Parse a rollout into its session_meta header and the kept body lines. In strict
+ * mode a corrupt body line aborts (returns null — a broken line means we can't
+ * faithfully reconstruct). In lenient mode corrupt lines are skipped (used when
+ * reading a live rollout that may still be mid-write, e.g. computing the cut point
+ * while Codex is streaming). Returns null if the first line isn't session_meta.
+ */
+function parseRollout(jsonl: string, lenient: boolean): ParsedRollout | null {
+  const rawLines = jsonl.split("\n").filter((l) => l.trim().length > 0);
+  if (rawLines.length === 0) return null;
+  let meta: RolloutLine;
+  try {
+    meta = JSON.parse(rawLines[0]);
+  } catch {
+    return null;
+  }
+  if (meta.type !== "session_meta" || typeof meta.payload !== "object" || meta.payload === null) {
+    return null;
+  }
+  const kept: KeptLine[] = [];
+  for (let i = 1; i < rawLines.length; i++) {
+    let obj: RolloutLine;
+    try {
+      obj = JSON.parse(rawLines[i]);
+    } catch {
+      if (lenient) continue;
+      return null;
+    }
+    if (isKeptBody(obj)) kept.push({ obj, raw: rawLines[i] });
+  }
+  return { meta, kept };
+}
+/** Indices (into kept) of the user-message turn boundaries. */
+function keptBoundaries(kept: KeptLine[]): number[] {
+  const boundaries: number[] = [];
+  for (let i = 0; i < kept.length; i++) {
+    if (isTurnBoundary(kept[i].obj)) boundaries.push(i);
+  }
+  return boundaries;
+}
+/**
+ * Choose the first-kept boundary index: walk backward from the final turn, taking
+ * as many whole turns as fit in `seedTokens` (always at least the final turn even
+ * if it alone exceeds the budget). Assumes at least one boundary exists.
+ */
+function tailStartByBudget(kept: KeptLine[], seedTokens: number): number {
+  const boundaries = keptBoundaries(kept);
+  // Turn t spans kept[boundaries[t], boundaries[t+1]); the last turn runs to end.
+  const turnTokens = (t: number): number => {
+    const start = boundaries[t];
+    const end = t + 1 < boundaries.length ? boundaries[t + 1] : kept.length;
+    let sum = 0;
+    for (let i = start; i < end; i++) sum += estimateTokens(kept[i].raw);
+    return sum;
+  };
+  const last = boundaries.length - 1;
+  let startTurn = last;
+  let accum = turnTokens(last);
+  for (let t = last - 1; t >= 0; t--) {
+    const cost = turnTokens(t);
+    if (accum + cost > seedTokens) break;
+    accum += cost;
+    startTurn = t;
+  }
+  return boundaries[startTurn];
+}
+/**
+ * Emit the seeded rollout: rewrite the header to `threadId`/`now` (detached from
+ * its parent), then the tail from `startIdx` to end, dropping any tool call/output
+ * whose partner isn't in the tail. Returns null if the tail ends up empty.
+ */
+function emitFromKept(
+  meta: RolloutLine,
+  kept: KeptLine[],
+  startIdx: number,
+  threadId: string,
+  now: Date,
+): SeededRollout | null {
+  // Rewrite the header: fresh thread id and timestamp, detached from its parent.
+  const iso = now.toISOString();
+  const mp = meta.payload as Record<string, unknown>;
+  mp.session_id = threadId;
+  mp.id = threadId;
+  delete mp.parent_thread_id;
+  mp.timestamp = iso;
+  meta.timestamp = iso;
+  let tail = kept.slice(startIdx);
+  // Keep only tool calls/outputs whose call_id has BOTH a call and an output in
+  // the tail — never an orphaned call (e.g. a truncated final turn) or output.
+  const callIds = new Set<string>();
+  const outputIds = new Set<string>();
+  for (const { obj } of tail) {
+    const p = obj.payload;
+    if (typeof p?.call_id !== "string") continue;
+    if (p.type === "custom_tool_call") callIds.add(p.call_id);
+    else if (p.type === "custom_tool_call_output") outputIds.add(p.call_id);
+  }
+  tail = tail.filter(({ obj }) => {
+    const p = obj.payload;
+    if (p?.type === "custom_tool_call" || p?.type === "custom_tool_call_output") {
+      return typeof p.call_id === "string" && callIds.has(p.call_id) && outputIds.has(p.call_id);
+    }
+    return true;
+  });
+  if (tail.length === 0) return null;
+  const lines = [JSON.stringify(meta), ...tail.map((t) => JSON.stringify(t.obj))];
+  return { threadId, lines };
+}
+/**
+ * Build the seeded rollout from a previous rollout's raw jsonl text: rewrite the
+ * `session_meta` header to `threadId` with an updated timestamp, then take as
+ * many whole trailing turns as fit in `seedTokens` (always at least the final
+ * turn), keeping message and complete tool-call pairs. Returns null if there's
+ * nothing seedable (empty, no session_meta, no genuine turn, or a corrupt line).
+ */
+export function buildSeededRollout(
+  jsonl: string,
+  threadId: string,
+  seedTokens: number,
+  now: Date = new Date(),
+): SeededRollout | null {
+  const p = parseRollout(jsonl, false);
+  if (!p || p.kept.length === 0) return null;
+  if (keptBoundaries(p.kept).length === 0) return null;
+  return emitFromKept(p.meta, p.kept, tailStartByBudget(p.kept, seedTokens), threadId, now);
+}
+/**
+ * A pinned cut point for rotation. Codex `response_item` message lines carry no
+ * stable id, so we pin the boundary by its top-level `timestamp` (millisecond
+ * precision — unique in practice). Rotation locates the same turn by matching it.
+ */
+export type CodexSeedCut = { boundaryTimestamp: string };
+/**
+ * Compute the cut point (the first-kept turn's timestamp) for a `seedTokens` budget,
+ * from raw jsonl. Parsed leniently because the live rollout may still be mid-write
+ * when this runs at warn time. Returns null if there's no genuine turn or the chosen
+ * boundary lacks a timestamp to pin on.
+ */
+export function computeCodexSeedCut(jsonl: string, seedTokens: number): CodexSeedCut | null {
+  const p = parseRollout(jsonl, true);
+  if (!p || p.kept.length === 0) return null;
+  if (keptBoundaries(p.kept).length === 0) return null;
+  const boundary = p.kept[tailStartByBudget(p.kept, seedTokens)].obj;
+  if (typeof boundary.timestamp !== "string") return null;
+  return { boundaryTimestamp: boundary.timestamp };
+}
+/**
+ * Build the seeded rollout starting at a pinned boundary timestamp (the whole tail
+ * from that turn through EOF). Used by rotation to honor the cut point the mind was
+ * warned about, regardless of how much the rollout grew after the warning. Returns
+ * null if the boundary isn't found or a line is corrupt.
+ */
+export function buildSeededRolloutFromCut(
+  jsonl: string,
+  threadId: string,
+  boundaryTimestamp: string,
+  now: Date = new Date(),
+): SeededRollout | null {
+  const p = parseRollout(jsonl, false);
+  if (!p || p.kept.length === 0) return null;
+  const startIdx = p.kept.findIndex(
+    (k) => isTurnBoundary(k.obj) && k.obj.timestamp === boundaryTimestamp,
+  );
+  if (startIdx < 0) return null;
+  return emitFromKept(p.meta, p.kept, startIdx, threadId, now);
+}
+/** Two-digit zero-padded string for date/time components. */
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+/** Result of a successful codex seed: the new thread id and when the source was archived. */
+export type SeededThreadOutcome = { threadId: string; archivedAt: number | null };
+/**
+ * Seed a fresh persistent codex session from the mind's previous archived
+ * rollout. Writes the synthetic rollout under `.mind/codex/sessions/YYYY/MM/DD/`
+ * (matching the real Codex layout) and returns the new thread id plus the
+ * archived-at time (for the gap note), or null if there's nothing to seed. Never
+ * throws — any failure returns null so session start is never blocked.
+ */
+export function seedCodexSession(opts: {
+  mindDir: string;
+  name: string;
+  seedTokens: number;
+  now?: Date;
+}): SeededThreadOutcome | null {
+  const { mindDir, name, seedTokens } = opts;
+  const now = opts.now ?? new Date();
+  // Ephemeral `new-*` sessions are never persisted or archived, so they never
+  // seed. The agent caller already gates on this; guard here too.
+  if (name.startsWith("new-")) return null;
+  if (seedTokens <= 0) return null; // seeding disabled
+  try {
+    const sessionsDir = resolve(mindDir, ".mind", "codex-sessions");
+    const archived = findLatestArchivedThread(sessionsDir, name);
+    if (!archived) return null;
+    const oldThreadId = archived.threadId;
+    const sourcePath = findCodexSessionFile(oldThreadId, mindDir);
+    if (!sourcePath) return null; // rollout didn't survive archival — start clean
+    const threadId = generateThreadId(now);
+    const seeded = buildSeededRollout(readFileSync(sourcePath, "utf-8"), threadId, seedTokens, now);
+    if (!seeded) return null;
+    writeSeededRollout(sourcePath, seeded, now);
+    log(
+      "mind",
+      `session "${name}": seeded ${seeded.lines.length} line(s) from ${oldThreadId} → ${threadId}`,
+    );
+    return { threadId, archivedAt: archived.archivedAt };
+  } catch (err) {
+    log("mind", `session "${name}": codex seeding failed, starting fresh:`, err);
+    return null;
+  }
+}
+/**
+ * Write a seeded rollout next to its source: into the SAME sessions root the source
+ * rollout was found in, so it lands wherever Codex will look on resume — that root is
+ * CODEX_HOME/sessions (`.mind/codex/sessions` when CODEX_HOME is set) or ~/.codex/sessions
+ * otherwise. `sourcePath` is `<sessionsRoot>/YYYY/MM/DD/rollout-*.jsonl`; climb three
+ * levels. Rollouts live under a local-time YYYY/MM/DD tree with a local-time filename
+ * timestamp, mirroring how Codex itself names them.
+ */
+function writeSeededRollout(sourcePath: string, seeded: SeededRollout, now: Date): void {
+  const sessionsRoot = resolve(dirname(sourcePath), "..", "..", "..");
+  const y = String(now.getFullYear());
+  const mo = pad2(now.getMonth() + 1);
+  const d = pad2(now.getDate());
+  const fnTs = `${y}-${mo}-${d}T${pad2(now.getHours())}-${pad2(now.getMinutes())}-${pad2(now.getSeconds())}`;
+  const destDir = resolve(sessionsRoot, y, mo, d);
+  mkdirSync(destDir, { recursive: true });
+  writeFileSync(
+    resolve(destDir, `rollout-${fnTs}-${seeded.threadId}.jsonl`),
+    `${seeded.lines.join("\n")}\n`,
+  );
+}
+/**
+ * Write an archive pointer for a rotated-out codex thread, matching how sleep archival
+ * preserves the live pointer: `<sessionsDir>/archive/<name>-<UTC-ts>.json` holding
+ * `{ threadId }` (the codex session-store format). Reuses the shared timestamp format
+ * (archivePointerTimestamp) so the byte layout matches sleep-manager's codex branch and
+ * findLatestArchivedThread keeps finding it.
+ */
+export function writeCodexRotationArchivePointer(
+  sessionsDir: string,
+  name: string,
+  threadId: string,
+  now: Date = new Date(),
+): void {
+  const archiveDir = resolve(sessionsDir, "archive");
+  mkdirSync(archiveDir, { recursive: true });
+  const dest = resolve(archiveDir, `${name}-${archivePointerTimestamp(now)}.json`);
+  writeFileSync(dest, JSON.stringify({ threadId }));
+}
+/**
+ * Rotate a codex session in place at the context limit. Reads the live rollout, builds
+ * a seeded tail from the pinned `cut` (falling back to a budget-based tail when the pin
+ * can't be honored), writes it as a new synthetic rollout next to the source, and — for
+ * persistent sessions — archives the rotated-out thread pointer so the full transcript
+ * stays findable. Returns the new thread id, or null if rotation can't proceed (the
+ * caller then leaves the old thread in place). Never throws.
+ */
+export function rotateCodexSession(opts: {
+  mindDir: string;
+  name: string;
+  oldThreadId: string;
+  cut: CodexSeedCut | null;
+  seedTokens: number;
+  now?: Date;
+}): string | null {
+  const { mindDir, name, oldThreadId, cut, seedTokens } = opts;
+  const now = opts.now ?? new Date();
+  try {
+    const sourcePath = findCodexSessionFile(oldThreadId, mindDir);
+    if (!sourcePath) return null; // live rollout not found — leave the old thread
+    const jsonl = readFileSync(sourcePath, "utf-8");
+    const threadId = generateThreadId(now);
+    // Honor the pinned boundary the mind was warned about; only fall back to a
+    // budget-based tail if the pin can't be resolved (missing/renamed boundary).
+    const seeded =
+      (cut ? buildSeededRolloutFromCut(jsonl, threadId, cut.boundaryTimestamp, now) : null) ??
+      buildSeededRollout(jsonl, threadId, seedTokens, now);
+    if (!seeded) return null;
+    writeSeededRollout(sourcePath, seeded, now);
+    // Ephemeral `new-*` sessions rotate too, but leave no pointer/archive behind.
+    if (!name.startsWith("new-")) {
+      const sessionsDir = resolve(mindDir, ".mind", "codex-sessions");
+      writeCodexRotationArchivePointer(sessionsDir, name, oldThreadId, now);
+    }
+    log(
+      "mind",
+      `session "${name}": rotated ${oldThreadId} → ${threadId} (${seeded.lines.length} lines)`,
+    );
+    return threadId;
+  } catch (err) {
+    log("mind", `session "${name}": rotation failed:`, err);
+    return null;
+  }
+}

package/templates/_base/src/lib/daemon-client.ts CHANGED Viewed

@@ -124,6 +124,41 @@ export async function daemonEmit(event: DaemonEvent): Promise<void> {
   }
 }
+/**
+ * Record a notice with the daemon — it reaches the mind through the next-turn
+ * notices drain (the pre-prompt hook). Use for failures the daemon can't see
+ * itself, like context loss inside the mind process. `thread` scopes the notice
+ * to one thread's drain; omitted, any thread's next turn picks it up.
+ * Best-effort: logs on failure, never throws.
+ */
+export async function daemonNotice(input: {
+  kind: string;
+  message: string;
+  thread?: string;
+}): Promise<void> {
+  if (!port || !mind) {
+    console.error("[volute] daemonNotice: VOLUTE_DAEMON_PORT or VOLUTE_MIND not set");
+    return;
+  }
+  try {
+    const res = await fetch(
+      `http://127.0.0.1:${port}/api/minds/${encodeURIComponent(mind)}/notices`,
+      {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(input),
+      },
+    );
+    if (!res.ok) {
+      console.error(
+        `[volute] daemonNotice failed: ${res.status} ${await res.text().catch(() => "")}`,
+      );
+    }
+  } catch (err) {
+    console.error("[volute] daemonNotice request errored:", err);
+  }
+}
 export async function daemonSendFile(
   targetMind: string,
   filePath: string,