@runeya/runeya 2.0.10 → 2.0.13

package/agent/index.js

@@ -766,7 +766,10 @@ var ProjectSchema = z3.object({
   // NOTE: activeEnvironmentId is runtime-only (not persisted to JSON)
   // It's initialized to 'local' by default at load time
   activeEnvironmentId: z3.string().max(128).optional(),
-  environmentIds: z3.array(z3.string().max(128)).max(100).default([])
+  environmentIds: z3.array(z3.string().max(128)).max(100).default([]),
+  // Ordre d'affichage des groupes de services dans la sidebar (noms de groupes).
+  // Les groupes absents de cette liste sont affichés après, par ordre alphabétique.
+  groupOrder: z3.array(z3.string().max(200)).max(100).default([])
 });
 var CreateProjectSchema = ProjectSchema.omit({ id: true }).partial().required({ name: true });
 var UpdateProjectSchema = ProjectSchema.partial().required({ id: true });
@@ -3153,7 +3156,7 @@ var HealthChecker = class extends EventEmitter6 {
       this.stopChecking(id);
     }
   }
-  async checkHttp(processId, path, timeout, maxRetries, method = "GET", expectedStatus = 200) {
+  async checkHttp(processId, path3, timeout, maxRetries, method = "GET", expectedStatus = 200) {
     const proc = processStore.get(processId);
     if (!proc || proc.state !== "running") {
       this.updateResult(processId, "unknown", 0);
@@ -3164,7 +3167,7 @@ var HealthChecker = class extends EventEmitter6 {
       this.updateResult(processId, "unknown", 0);
       return;
     }
-    const url = `http://localhost:${port}${path}`;
+    const url = `http://localhost:${port}${path3}`;
     let failures = this.failureCounts.get(processId) ?? 0;
     try {
       const response = await fetch(url, {
@@ -4509,7 +4512,20 @@ async function getGitStatus(cwd) {
     upstream = (await git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd, true)).trim();
   } catch {
   }
-  return { branch, staged, unstaged, untracked, ahead, behind, upstream };
+  let additions = 0;
+  let deletions = 0;
+  try {
+    const numstat = await git(["diff", "--numstat", "HEAD"], cwd, true);
+    for (const line of numstat.split("\n").filter(Boolean)) {
+      const [add, del] = line.split("	");
+      const a = parseInt(add ?? "", 10);
+      const d = parseInt(del ?? "", 10);
+      if (!Number.isNaN(a)) additions += a;
+      if (!Number.isNaN(d)) deletions += d;
+    }
+  } catch {
+  }
+  return { branch, staged, unstaged, untracked, ahead, behind, upstream, additions, deletions };
 }
 var gitRouter = router({
   /** Check if a working directory exists and optionally verify its git remote */
@@ -4667,6 +4683,13 @@ var gitRouter = router({
     await git(["restore", "--staged", "--", ...input.paths], cwd);
     return { ok: true };
   }),
+  /** Unstage all files */
+  unstageAll: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).mutation(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    await git(["reset", "--"], cwd);
+    return { ok: true };
+  }),
   /** Commit staged changes */
   commit: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, message: z24.string().min(1).max(4096) })).mutation(async ({ input }) => {
     const cwd = assertCwdExists(input.cwd);
@@ -4795,6 +4818,54 @@ var gitRouter = router({
       }
     }
     return remotes;
+  }),
+  /** List stash entries */
+  stashList: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA })).query(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    const output = await git(["stash", "list", "--format=%gd%s"], cwd, true);
+    const entries = [];
+    for (const line of output.split("\n").filter(Boolean)) {
+      const [ref, message = ""] = line.split("");
+      const m = /stash@\{(\d+)\}/.exec(ref ?? "");
+      if (m) entries.push({ index: parseInt(m[1], 10), ref, message });
+    }
+    return entries;
+  }),
+  /** Stash current changes */
+  stashPush: protectedProcedure.input(z24.object({
+    cwd: CWD_SCHEMA,
+    message: z24.string().max(4096).optional(),
+    includeUntracked: z24.boolean().default(true)
+  })).mutation(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    const args = ["stash", "push"];
+    if (input.includeUntracked) args.push("--include-untracked");
+    if (input.message) args.push("-m", input.message);
+    const output = await git(args, cwd);
+    return { ok: true, output: output.trim() };
+  }),
+  /** Apply a stash entry and remove it from the list */
+  stashPop: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    const output = await git(["stash", "pop", `stash@{${input.index}}`], cwd);
+    return { ok: true, output: output.trim() };
+  }),
+  /** Apply a stash entry without removing it from the list */
+  stashApply: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    const output = await git(["stash", "apply", `stash@{${input.index}}`], cwd);
+    return { ok: true, output: output.trim() };
+  }),
+  /** Drop a stash entry */
+  stashDrop: protectedProcedure.input(z24.object({ cwd: CWD_SCHEMA, index: z24.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const cwd = assertCwdExists(input.cwd);
+    await assertGitRepo(cwd);
+    const output = await git(["stash", "drop", `stash@{${input.index}}`], cwd);
+    return { ok: true, output: output.trim() };
   })
 });
 function runGitRaw(args, timeoutMs, extraEnv) {
@@ -4831,11 +4902,60 @@ import { spawn as spawn4 } from "child_process";
 import { EventEmitter as EventEmitter9 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { existsSync as existsSync2 } from "fs";
+import * as pty2 from "node-pty";
+function resolveMcpServerPath() {
+  try {
+    const req = createRequire(import.meta.url);
+    return req.resolve("@runeya/packages-mcp-server");
+  } catch {
+  }
+  const candidates = [
+    new URL("../../../packages/mcp-server/dist/index.js", import.meta.url),
+    new URL("../../../../packages/mcp-server/dist/index.js", import.meta.url),
+    new URL("../mcp-server/index.js", import.meta.url)
+  ];
+  for (const c of candidates) {
+    const p = fileURLToPath(c);
+    if (existsSync2(p)) return p;
+  }
+  throw new Error("Could not locate @runeya/packages-mcp-server (built dist not found)");
+}
 var MAX_BUFFER_LINES = 1e5;
 var MAX_CONCURRENT_SPAWNS = 10;
 var CLEANUP_INTERVAL_MS = 6e4;
 var TTL_ACKED_MS = 5 * 6e4;
 var TTL_UNACKED_MS = 24 * 36e5;
+function resolveSpawnEnvAndArgs(opts) {
+  const runeyaEnv = {
+    ...opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {},
+    ...opts.mcpApiToken ? { RUNEYA_API_TOKEN: opts.mcpApiToken } : {}
+  };
+  const env2 = { ...process.env, ...opts.env, ...runeyaEnv };
+  const args = [...opts.args];
+  if (opts.enableMcp && opts.cli === "claude") {
+    try {
+      const mcpServerPath = resolveMcpServerPath();
+      const mcpConfig = JSON.stringify({
+        mcpServers: {
+          runeya: {
+            command: "node",
+            args: [mcpServerPath],
+            env: {
+              ...env2.RUNEYA_BASE_URL ? { RUNEYA_BASE_URL: env2.RUNEYA_BASE_URL } : {},
+              ...env2.RUNEYA_API_TOKEN ? { RUNEYA_API_TOKEN: env2.RUNEYA_API_TOKEN } : {}
+            }
+          }
+        }
+      });
+      args.push("--mcp-config", mcpConfig);
+    } catch (err) {
+      console.warn("[ai-spawn-manager] Failed to resolve MCP server path:", err.message);
+    }
+  }
+  return { env: env2, args };
+}
 var AiSpawnManager = class {
   spawns = /* @__PURE__ */ new Map();
   cleanupInterval = null;
@@ -4849,28 +4969,11 @@ var AiSpawnManager = class {
     }
     const spawnId = randomUUID5();
     const emitter = new EventEmitter9();
-    const args = [...opts.args];
-    if (opts.enableMcp && opts.cli === "claude") {
-      try {
-        const mcpServerPath = fileURLToPath(new URL("../mcp-server/index.js", import.meta.url));
-        const mcpConfig = JSON.stringify({
-          mcpServers: {
-            runeya: {
-              command: "node",
-              args: [mcpServerPath],
-              env: opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {}
-            }
-          }
-        });
-        args.push("--mcp-config", mcpConfig);
-      } catch (err) {
-        console.warn("[ai-spawn-manager] Failed to resolve MCP server path:", err.message);
-      }
-    }
+    const { env: env2, args } = resolveSpawnEnvAndArgs(opts);
     const proc = spawn4(opts.cli, args, {
       stdio: ["pipe", "pipe", "pipe"],
       shell: false,
-      env: opts.env ? { ...process.env, ...opts.env } : process.env,
+      env: env2,
       cwd: opts.cwd || void 0
     });
     const entry = {
@@ -4880,10 +4983,12 @@ var AiSpawnManager = class {
       exitCode: null,
       buffer: [],
       proc,
+      ptyProc: null,
       emitter,
       createdAt: Date.now(),
       doneAt: null,
-      acked: false
+      acked: false,
+      lastChunkAt: null
     };
     this.spawns.set(spawnId, entry);
     if (opts.stdinData) {
@@ -4968,8 +5073,98 @@ var AiSpawnManager = class {
       }
       return true;
     }
+    if (entry.ptyProc) {
+      try {
+        entry.ptyProc.kill();
+      } catch {
+      }
+      return true;
+    }
     return false;
   }
+  // ── PTY mode ────────────────────────────────────────────────────────────
+  spawnPty(opts) {
+    const running = [...this.spawns.values()].filter((s) => s.status === "running").length;
+    if (running >= MAX_CONCURRENT_SPAWNS) {
+      throw new Error(`Max concurrent AI spawns reached (${MAX_CONCURRENT_SPAWNS})`);
+    }
+    const spawnId = randomUUID5();
+    const emitter = new EventEmitter9();
+    const { env: env2, args } = resolveSpawnEnvAndArgs(opts);
+    const ptyProc = pty2.spawn(opts.cli, args, {
+      name: "xterm-256color",
+      cols: opts.cols ?? 120,
+      rows: opts.rows ?? 30,
+      cwd: opts.cwd || process.cwd(),
+      env: env2
+    });
+    const entry = {
+      spawnId,
+      sessionId: opts.sessionId,
+      cli: opts.cli,
+      status: "running",
+      exitCode: null,
+      buffer: [],
+      proc: null,
+      ptyProc,
+      emitter,
+      createdAt: Date.now(),
+      doneAt: null,
+      acked: false,
+      lastChunkAt: null
+    };
+    this.spawns.set(spawnId, entry);
+    ptyProc.onData((data) => {
+      this.pushChunk(entry, { type: "pty-data", data });
+    });
+    ptyProc.onExit(({ exitCode }) => {
+      entry.status = exitCode === 0 ? "done" : "error";
+      entry.exitCode = exitCode;
+      entry.doneAt = Date.now();
+      entry.ptyProc = null;
+      this.pushChunk(entry, { type: "exit", data: "", code: exitCode });
+    });
+    console.log(`[ai-spawn-manager] Spawned PTY ${opts.cli} (${spawnId}), args: ${opts.args.length}, cwd: ${opts.cwd ?? "(default)"}, ${opts.cols ?? 120}x${opts.rows ?? 30}`);
+    return spawnId;
+  }
+  writePty(spawnId, data) {
+    const entry = this.spawns.get(spawnId);
+    if (!entry || !entry.ptyProc) return false;
+    try {
+      entry.ptyProc.write(data);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** Return a running PTY spawn matching the given logical sessionId, if any. */
+  findPtyBySessionId(sessionId) {
+    for (const entry of this.spawns.values()) {
+      if (entry.sessionId === sessionId && entry.status === "running" && entry.ptyProc !== null) {
+        return {
+          spawnId: entry.spawnId,
+          cli: entry.cli,
+          status: entry.status,
+          exitCode: entry.exitCode,
+          bufferLength: entry.buffer.length,
+          createdAt: entry.createdAt,
+          doneAt: entry.doneAt,
+          lastChunkAt: entry.lastChunkAt
+        };
+      }
+    }
+    return null;
+  }
+  resizePty(spawnId, cols, rows) {
+    const entry = this.spawns.get(spawnId);
+    if (!entry || !entry.ptyProc) return false;
+    try {
+      entry.ptyProc.resize(cols, rows);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   list() {
     return [...this.spawns.values()].map((e) => ({
       spawnId: e.spawnId,
@@ -4978,7 +5173,8 @@ var AiSpawnManager = class {
       exitCode: e.exitCode,
       bufferLength: e.buffer.length,
       createdAt: e.createdAt,
-      doneAt: e.doneAt
+      doneAt: e.doneAt,
+      lastChunkAt: e.lastChunkAt
     }));
   }
   ack(spawnId) {
@@ -4993,6 +5189,9 @@ var AiSpawnManager = class {
       entry.buffer.shift();
     }
     entry.buffer.push(chunk);
+    if (chunk.type === "stdout" || chunk.type === "stderr" || chunk.type === "pty-data") {
+      entry.lastChunkAt = Date.now();
+    }
     entry.emitter.emit("chunk");
     if (chunk.type === "exit") {
       entry.emitter.emit("done");
@@ -5025,13 +5224,19 @@ var AiSpawnManager = class {
         } catch {
         }
       }
+      if (entry.ptyProc) {
+        try {
+          entry.ptyProc.kill();
+        } catch {
+        }
+      }
     }
   }
 };
 var aiSpawnManager = new AiSpawnManager();
 
 // src/services/codex-app-server-manager.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import { EventEmitter as EventEmitter10 } from "events";
 var REQUEST_TIMEOUT_MS = 3e5;
@@ -5059,7 +5264,7 @@ var CodexAppServerManager = class extends EventEmitter10 {
     }
   }
   async doConnect() {
-    this.proc = spawn5("codex", ["app-server"], {
+    this.proc = spawn6("codex", ["app-server"], {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...this.extraEnv }
     });
@@ -5170,7 +5375,142 @@ var CodexAppServerManager = class extends EventEmitter10 {
 };
 var codexAppServerManager = new CodexAppServerManager();
 
+// src/services/ai-context-files.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import path from "path";
+import os2 from "os";
+var ROOT_DIR_NAME = "runeya-ai-context";
+function sanitizeName(name) {
+  let safe = name.replace(/[^A-Za-z0-9._-]/g, "_");
+  if (!safe || safe === "." || safe === "..") safe = "context";
+  if (!/\.[A-Za-z0-9]+$/.test(safe)) safe += ".md";
+  return safe;
+}
+function sanitizeSessionId(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, "_");
+  return safe || "session";
+}
+async function writeContextFiles(sessionId, files) {
+  const baseDir = path.join(os2.tmpdir(), ROOT_DIR_NAME, sanitizeSessionId(sessionId));
+  await mkdir4(baseDir, { recursive: true });
+  const paths = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    let name = sanitizeName(file.name);
+    if (usedNames.has(name)) {
+      const ext = path.extname(name);
+      const base = name.slice(0, name.length - ext.length);
+      name = `${base}-${i}${ext}`;
+    }
+    usedNames.add(name);
+    const fullPath = path.join(baseDir, name);
+    await writeFile4(fullPath, file.content, "utf8");
+    paths.push(fullPath);
+  }
+  return paths;
+}
+
+// src/services/ai-paste-image.ts
+import { mkdir as mkdir5, writeFile as writeFile5, unlink as unlink2 } from "fs/promises";
+import path2 from "path";
+import os3 from "os";
+import { randomUUID as randomUUID6 } from "crypto";
+import { spawn as spawn7 } from "child_process";
+var TMP_DIR_NAME = "runeya-ai-paste";
+var MIME_TO_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/bmp": "bmp"
+};
+function extForMime(mime) {
+  return MIME_TO_EXT[mime.toLowerCase()] ?? "png";
+}
+function runCmd(cmd, args, stdin, timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (code, stderr) => {
+      if (settled) return;
+      settled = true;
+      resolve({ code, stderr });
+    };
+    try {
+      const child = spawn7(cmd, args, { stdio: ["pipe", "ignore", "pipe"] });
+      let stderr = "";
+      child.stderr.on("data", (c) => {
+        stderr += c.toString();
+      });
+      child.on("error", (err) => settle(127, err.message));
+      child.on("exit", (code) => settle(code ?? 1, stderr));
+      const t2 = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        settle(124, "timeout");
+      }, timeoutMs);
+      child.on("exit", () => clearTimeout(t2));
+      if (stdin) {
+        child.stdin.on("error", () => {
+        });
+        child.stdin.end(stdin);
+      } else {
+        child.stdin.end();
+      }
+    } catch (err) {
+      settle(127, err.message);
+    }
+  });
+}
+async function savePastedImage(base64, mimeType, sessionId) {
+  const buf = Buffer.from(base64, "base64");
+  if (buf.length === 0) throw new Error("Empty image payload");
+  const ext = extForMime(mimeType);
+  const baseDir = path2.join(
+    os3.tmpdir(),
+    TMP_DIR_NAME,
+    sessionId ? sessionId.replace(/[^A-Za-z0-9._-]/g, "_") : "default"
+  );
+  await mkdir5(baseDir, { recursive: true });
+  const tmpPath = path2.join(baseDir, `paste-${Date.now()}-${randomUUID6().slice(0, 8)}.${ext}`);
+  await writeFile5(tmpPath, buf);
+  const { method, error } = await tryWriteClipboard(buf, mimeType, tmpPath);
+  return { tmpPath, clipboardMethod: method, clipboardError: error };
+}
+async function tryWriteClipboard(buf, mimeType, tmpPath) {
+  const normalizedMime = mimeType.toLowerCase();
+  const errors = [];
+  if (process.platform === "darwin") {
+    const klass = normalizedMime === "image/jpeg" || normalizedMime === "image/jpg" ? "JPEG picture" : "PNGf";
+    const script = `set the clipboard to (read (POSIX file "${tmpPath.replace(/"/g, '\\"')}") as \xABclass ${klass}\xBB)`;
+    const r = await runCmd("osascript", ["-e", script]);
+    if (r.code === 0) return { method: "pbcopy" };
+    errors.push(`osascript: ${r.stderr.trim()}`);
+  }
+  if (process.platform === "linux") {
+    const r = await runCmd("xclip", ["-selection", "clipboard", "-t", normalizedMime, "-i"], buf);
+    if (r.code === 0) return { method: "xclip" };
+    errors.push(`xclip: ${r.stderr.trim() || `exit ${r.code}`}`);
+    const r2 = await runCmd("wl-copy", ["--type", normalizedMime], buf);
+    if (r2.code === 0) return { method: "wl-copy" };
+    errors.push(`wl-copy: ${r2.stderr.trim() || `exit ${r2.code}`}`);
+  }
+  if (process.platform === "win32") {
+    const ps = `Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; $img = [System.Drawing.Image]::FromFile("${tmpPath.replace(/\\/g, "\\\\")}"); [System.Windows.Forms.Clipboard]::SetImage($img); $img.Dispose()`;
+    const r = await runCmd("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps]);
+    if (r.code === 0) return { method: "powershell" };
+    errors.push(`powershell: ${r.stderr.trim() || `exit ${r.code}`}`);
+  }
+  return { method: null, error: errors.join(" | ") || "no clipboard tool available" };
+}
+
 // src/trpc/routers/ai.ts
+var MAX_CONTEXT_FILES = 20;
+var MAX_CONTEXT_FILE_BYTES = 1e6;
+var MAX_CONTEXT_TOTAL_BYTES = 5e6;
 var aiRouter = router({
   /** Spawn an AI CLI process. Returns a spawnId for streaming. */
   spawn: protectedProcedure.input(z25.object({
@@ -5180,7 +5520,8 @@ var aiRouter = router({
     cwd: z25.string().max(4096).optional(),
     stdinData: z25.string().max(1e7).optional(),
     enableMcp: z25.boolean().optional(),
-    mcpApiBaseUrl: z25.string().max(512).optional()
+    mcpApiBaseUrl: z25.string().max(512).optional(),
+    mcpApiToken: z25.string().max(8192).optional()
   })).mutation(({ input }) => {
     const spawnId = aiSpawnManager.spawn(input);
     return { spawnId };
@@ -5201,6 +5542,71 @@ var aiRouter = router({
       });
     }
   }),
+  /** Spawn an AI CLI process in a PTY (interactive mode). Returns spawnId. */
+  spawnPty: protectedProcedure.input(z25.object({
+    cli: z25.string().max(64),
+    args: z25.array(z25.string().max(5e5)),
+    env: z25.record(z25.string().max(256), z25.string().max(5e5)).optional(),
+    cwd: z25.string().max(4096).optional(),
+    cols: z25.number().int().min(1).max(1e3).optional(),
+    rows: z25.number().int().min(1).max(1e3).optional(),
+    sessionId: z25.string().max(128).optional(),
+    enableMcp: z25.boolean().optional(),
+    mcpApiBaseUrl: z25.string().max(512).optional(),
+    mcpApiToken: z25.string().max(8192).optional()
+  })).mutation(({ input }) => {
+    const spawnId = aiSpawnManager.spawnPty(input);
+    return { spawnId };
+  }),
+  /** Find a running PTY spawn by its logical sessionId (for re-attach). */
+  findPtyBySession: protectedProcedure.input(z25.object({ sessionId: z25.string().max(128) })).query(({ input }) => {
+    return aiSpawnManager.findPtyBySessionId(input.sessionId);
+  }),
+  /** Write input to a PTY spawn (user keystrokes). */
+  writePty: protectedProcedure.input(z25.object({
+    spawnId: z25.string().max(128),
+    data: z25.string().max(1e6)
+  })).mutation(({ input }) => {
+    const ok = aiSpawnManager.writePty(input.spawnId, input.data);
+    return { ok };
+  }),
+  /** Write attached-context files for an AI session to a temp dir. Returns absolute paths. */
+  writeContextFiles: protectedProcedure.input(z25.object({
+    sessionId: z25.string().min(1).max(128),
+    files: z25.array(z25.object({
+      name: z25.string().min(1).max(256),
+      content: z25.string().max(MAX_CONTEXT_FILE_BYTES)
+    })).min(1).max(MAX_CONTEXT_FILES)
+  }).refine(
+    (val) => val.files.reduce((sum, f) => sum + f.content.length, 0) <= MAX_CONTEXT_TOTAL_BYTES,
+    { message: `Total context size exceeds ${MAX_CONTEXT_TOTAL_BYTES} bytes` }
+  )).mutation(async ({ input }) => {
+    const paths = await writeContextFiles(input.sessionId, input.files);
+    return { paths };
+  }),
+  /**
+   * Save a pasted image to disk and try to populate the agent's system clipboard
+   * so Claude's native paste detection picks it up. Returns the tmp path and
+   * which clipboard method (if any) succeeded — caller decides whether to send
+   * Ctrl+V (\x16) or inject `@<path>` into the PTY.
+   */
+  pasteImage: protectedProcedure.input(z25.object({
+    sessionId: z25.string().max(128).optional(),
+    mimeType: z25.string().max(64),
+    base64: z25.string().max(15e6)
+  })).mutation(async ({ input }) => {
+    const res = await savePastedImage(input.base64, input.mimeType, input.sessionId);
+    return res;
+  }),
+  /** Resize a PTY spawn. */
+  resizePty: protectedProcedure.input(z25.object({
+    spawnId: z25.string().max(128),
+    cols: z25.number().int().min(1).max(1e3),
+    rows: z25.number().int().min(1).max(1e3)
+  })).mutation(({ input }) => {
+    const ok = aiSpawnManager.resizePty(input.spawnId, input.cols, input.rows);
+    return { ok };
+  }),
   /** Kill a running AI spawn. */
   kill: protectedProcedure.input(z25.object({ spawnId: z25.string().max(128) })).mutation(({ input }) => {
     const killed = aiSpawnManager.kill(input.spawnId);