@runeya/runeya 2.0.10 → 2.0.11

package/agent/index.js

@@ -3153,7 +3153,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 +3164,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, {
@@ -4831,6 +4831,26 @@ 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;
@@ -4852,13 +4872,16 @@ var AiSpawnManager = class {
     const args = [...opts.args];
     if (opts.enableMcp && opts.cli === "claude") {
       try {
-        const mcpServerPath = fileURLToPath(new URL("../mcp-server/index.js", import.meta.url));
+        const mcpServerPath = resolveMcpServerPath();
         const mcpConfig = JSON.stringify({
           mcpServers: {
             runeya: {
               command: "node",
               args: [mcpServerPath],
-              env: opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {}
+              env: {
+                ...opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {},
+                ...opts.mcpApiToken ? { RUNEYA_API_TOKEN: opts.mcpApiToken } : {}
+              }
             }
           }
         });
@@ -4880,10 +4903,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 +4993,119 @@ 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 args = [...opts.args];
+    if (opts.enableMcp && opts.cli === "claude") {
+      try {
+        const mcpServerPath = resolveMcpServerPath();
+        const mcpConfig = JSON.stringify({
+          mcpServers: {
+            runeya: {
+              command: "node",
+              args: [mcpServerPath],
+              env: {
+                ...opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {},
+                ...opts.mcpApiToken ? { RUNEYA_API_TOKEN: opts.mcpApiToken } : {}
+              }
+            }
+          }
+        });
+        args.push("--mcp-config", mcpConfig);
+      } catch (err) {
+        console.warn("[ai-spawn-manager] Failed to resolve MCP server path:", err.message);
+      }
+    }
+    const env2 = opts.env ? { ...process.env, ...opts.env } : process.env;
+    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 +5114,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 +5130,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 +5165,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 +5205,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 +5316,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({
@@ -5201,6 +5482,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);