@runeya/runeya 2.0.9 → 2.0.11

package/agent/index.js

@@ -397,6 +397,7 @@ var DockerRunner = class {
     );
     return {
       pid: void 0,
+      containerName,
       stdout,
       stderr,
       exitPromise,
@@ -526,6 +527,7 @@ var DockerRunner = class {
     })();
     return {
       pid: void 0,
+      containerName,
       stdout,
       stderr,
       exitPromise,
@@ -572,6 +574,7 @@ var DockerRunner = class {
     );
     return {
       pid: void 0,
+      containerName,
       stdout,
       stderr,
       exitPromise,
@@ -902,7 +905,13 @@ var NotificationPreferencesSchema = z5.object({
   ai_conversation_error: z5.boolean().default(true),
   service_error_log: z5.boolean().default(true),
   service_status_changed: z5.boolean().default(true),
-  service_health_changed: z5.boolean().default(true)
+  service_health_changed: z5.boolean().default(true),
+  /** Service IDs excluded from error-log notifications */
+  service_error_log_excluded: z5.array(z5.string().max(100)).max(500).default([]),
+  /** Service IDs excluded from status-change notifications */
+  service_status_changed_excluded: z5.array(z5.string().max(100)).max(500).default([]),
+  /** Service IDs excluded from health-change notifications */
+  service_health_changed_excluded: z5.array(z5.string().max(100)).max(500).default([])
 });
 var SettingsSchema = z5.object({
   mode: z5.enum(["local-simple", "cloud"]),
@@ -931,7 +940,10 @@ var SettingsPrivateSchema = z5.object({
     ai_conversation_error: true,
     service_error_log: true,
     service_status_changed: true,
-    service_health_changed: true
+    service_health_changed: true,
+    service_error_log_excluded: [],
+    service_status_changed_excluded: [],
+    service_health_changed_excluded: []
   })),
   traefikConfig: TraefikConfigSchema.optional()
 });
@@ -948,9 +960,6 @@ var safePath = z6.string().min(1).max(4096).refine(
 ).refine(
   (p) => !/(^|[/\\])\.\.([/\\]|$)/.test(p),
   { message: "path must not contain path-traversal sequences (..)" }
-).refine(
-  (p) => p.startsWith("/") || /^[A-Za-z]:[/\\]/.test(p),
-  { message: "path must be absolute" }
 );
 var ConsoleLogSourceSchema = z6.object({
   type: z6.literal("console")
@@ -959,7 +968,8 @@ var FileLogSourceSchema = z6.object({
   type: z6.literal("file"),
   path: safePath,
   encoding: z6.string().max(32).default("utf-8"),
-  startFromEnd: z6.boolean().default(true)
+  startFromEnd: z6.boolean().default(true),
+  createIfNotExists: z6.boolean().default(false)
 });
 var MongoLogSourceSchema = z6.object({
   type: z6.literal("mongo"),
@@ -2010,6 +2020,21 @@ var FileLogSource = class extends EventEmitter2 {
           this.emitSystemLog(processId, `[FileLogSource] Permission denied: ${this.config.path}`, "error");
           return;
         }
+        if (nodeErr.code === "ENOENT" && this.config.createIfNotExists) {
+          try {
+            await fsPromises.mkdir(
+              (await import("path")).dirname(this.config.path),
+              { recursive: true }
+            );
+            await fsPromises.writeFile(this.config.path, "", { flag: "a" });
+            this.emitSystemLog(processId, `[FileLogSource] File created: ${this.config.path}`, "info");
+            break;
+          } catch (createErr) {
+            const ce = createErr;
+            this.emitSystemLog(processId, `[FileLogSource] Failed to create file: ${ce.message}`, "error");
+            return;
+          }
+        }
         attempts++;
         if (attempts >= RETRY_ATTEMPTS) {
           this.emitSystemLog(processId, `[FileLogSource] File not found after ${RETRY_ATTEMPTS} retries: ${this.config.path}`, "error");
@@ -2475,7 +2500,47 @@ function createLogSource(config, logBuffer, logParser) {
 
 // src/services/metrics-collector.ts
 import pidusage from "pidusage";
+import { execFile } from "child_process";
 import { EventEmitter as EventEmitter5 } from "events";
+async function getDockerStats(containerName) {
+  return new Promise((resolve) => {
+    execFile(
+      "docker",
+      ["stats", "--no-stream", "--format", "{{json .}}", containerName],
+      { timeout: 5e3 },
+      (err, stdout) => {
+        if (err || !stdout.trim()) {
+          resolve(null);
+          return;
+        }
+        try {
+          const data = JSON.parse(stdout.trim());
+          const cpu = parseFloat(data.CPUPerc.replace("%", ""));
+          const memStr = data.MemUsage.split("/")[0].trim();
+          const memory = parseMemBytes(memStr);
+          resolve({ cpu: isNaN(cpu) ? 0 : cpu, memory });
+        } catch {
+          resolve(null);
+        }
+      }
+    );
+  });
+}
+function parseMemBytes(str) {
+  const m = str.match(/^([\d.]+)\s*(B|kB|MB|MiB|GiB|GB)$/i);
+  if (!m) return 0;
+  const val = parseFloat(m[1]);
+  const unit = m[2].toLowerCase();
+  const multipliers = {
+    b: 1,
+    kb: 1e3,
+    mb: 1e6,
+    mib: 1024 * 1024,
+    gib: 1024 ** 3,
+    gb: 1e9
+  };
+  return Math.round(val * (multipliers[unit] ?? 1));
+}
 var MetricsCollector = class extends EventEmitter5 {
   intervals = /* @__PURE__ */ new Map();
   intervalMs;
@@ -2483,7 +2548,7 @@ var MetricsCollector = class extends EventEmitter5 {
     super();
     this.intervalMs = intervalMs;
   }
-  /** Start collecting metrics for a process */
+  /** Start collecting metrics for a native process (by PID). */
   startCollecting(processId, pid) {
     this.stopCollecting(processId);
     const interval = setInterval(async () => {
@@ -2502,6 +2567,25 @@ var MetricsCollector = class extends EventEmitter5 {
     }, this.intervalMs);
     this.intervals.set(processId, interval);
   }
+  /** Start collecting metrics for a Docker container (by container name). */
+  startCollectingDocker(processId, containerName) {
+    this.stopCollecting(processId);
+    const interval = setInterval(async () => {
+      const stats = await getDockerStats(containerName);
+      if (!stats) {
+        this.stopCollecting(processId);
+        return;
+      }
+      const metrics = {
+        processId,
+        cpu: stats.cpu,
+        memory: stats.memory,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.emit("metrics", metrics);
+    }, this.intervalMs);
+    this.intervals.set(processId, interval);
+  }
   /** Stop collecting metrics for a process */
   stopCollecting(processId) {
     const interval = this.intervals.get(processId);
@@ -2510,23 +2594,31 @@ var MetricsCollector = class extends EventEmitter5 {
       this.intervals.delete(processId);
     }
   }
-  /** Get current metrics for a process (one-shot, uses first active PID) */
+  /** Get current metrics for a process (one-shot, uses first active PID or container name). */
   async getMetrics(processId) {
     const proc = processStore.get(processId);
     if (!proc) return null;
     const activePid = proc.commandProcesses.find((cp) => cp.pid !== null)?.pid;
-    if (!activePid) return null;
-    try {
-      const stats = await pidusage(activePid);
-      return {
-        processId,
-        cpu: stats.cpu,
-        memory: stats.memory,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    } catch {
-      return null;
+    if (activePid) {
+      try {
+        const stats = await pidusage(activePid);
+        return {
+          processId,
+          cpu: stats.cpu,
+          memory: stats.memory,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      } catch {
+      }
+    }
+    const containerName = proc.commandProcesses.find((cp) => cp.containerName)?.containerName;
+    if (containerName) {
+      const stats = await getDockerStats(containerName);
+      if (stats) {
+        return { processId, ...stats, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+      }
     }
+    return null;
   }
   /** Stop all collection intervals */
   stopAll() {
@@ -2548,8 +2640,8 @@ import { homedir as homedir4 } from "os";
 import { z as z20 } from "zod";
 
 // src/services/traefik-manager.ts
-import { spawn, execFile } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile2, rename, chmod, access as access2, readFile } from "fs/promises";
+import { spawn, execFile as execFile2 } from "child_process";
+import { mkdir as mkdir3, writeFile as writeFile3, rename, chmod, access as access2, readFile } from "fs/promises";
 import { X509Certificate } from "crypto";
 import { join as join2 } from "path";
 import { homedir as homedir3, platform } from "os";
@@ -2575,7 +2667,7 @@ var TraefikManager = class {
   }
   async atomicWrite(filePath, content) {
     const tmpPath = filePath + ".tmp";
-    await writeFile2(tmpPath, content, "utf-8");
+    await writeFile3(tmpPath, content, "utf-8");
     await rename(tmpPath, filePath);
   }
   async applyConfig(config) {
@@ -2584,7 +2676,7 @@ var TraefikManager = class {
       await this.stop();
       return;
     }
-    await mkdir2(this.dynamicDir, { recursive: true });
+    await mkdir3(this.dynamicDir, { recursive: true });
     await this.writeStaticConfig(config);
     await this.regenerateDynamic();
     await this.stop();
@@ -2629,7 +2721,7 @@ var TraefikManager = class {
     await this.atomicWrite(this.staticConfigPath, yaml);
   }
   async regenerateDynamic() {
-    await mkdir2(this.dynamicDir, { recursive: true });
+    await mkdir3(this.dynamicDir, { recursive: true });
     const processes = processStore.getAll();
     const entries = processes.flatMap(
       (p) => (p.serviceConfig.localUrls ?? []).map((lu) => ({ url: lu.url, port: lu.port }))
@@ -2714,7 +2806,7 @@ var TraefikManager = class {
   }
   async ensureAcmeJson() {
     try {
-      await writeFile2(this.acmeStorePath, "{}", { flag: "wx" });
+      await writeFile3(this.acmeStorePath, "{}", { flag: "wx" });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
     }
@@ -2779,7 +2871,7 @@ var TraefikManager = class {
       this.debounceTimer = null;
     }
     await new Promise((resolve) => {
-      execFile("docker", ["rm", "-f", "runeya-traefik"], { timeout: 1e4 }, () => resolve());
+      execFile2("docker", ["rm", "-f", "runeya-traefik"], { timeout: 1e4 }, () => resolve());
     });
     await new Promise((resolve) => setTimeout(resolve, 500));
   }
@@ -2821,7 +2913,7 @@ var TraefikManager = class {
   }
   async getLogs(lines = 100) {
     return new Promise((resolve) => {
-      execFile("docker", ["logs", "--tail", String(lines), "runeya-traefik"], { timeout: 1e4 }, (err, stdout, stderr) => {
+      execFile2("docker", ["logs", "--tail", String(lines), "runeya-traefik"], { timeout: 1e4 }, (err, stdout, stderr) => {
         if (err) {
           resolve("");
           return;
@@ -2840,7 +2932,7 @@ var TraefikManager = class {
   }
   async forceRenewCert() {
     if (!this.config?.enabled) throw new Error("Traefik non activ\xE9");
-    await writeFile2(this.acmeStorePath, "{}", "utf-8");
+    await writeFile3(this.acmeStorePath, "{}", "utf-8");
     await chmod(this.acmeStorePath, 384);
     await this.stop();
     await this.spawnTraefik(this.config);
@@ -2872,7 +2964,7 @@ var TraefikManager = class {
     let dockerAvailable = false;
     try {
       await new Promise((resolve, reject) => {
-        execFile("docker", ["info", "--format", "{{.ServerVersion}}"], { timeout: 5e3 }, (err) => {
+        execFile2("docker", ["info", "--format", "{{.ServerVersion}}"], { timeout: 5e3 }, (err) => {
           if (err) reject(err);
           else resolve();
         });
@@ -2892,7 +2984,7 @@ var TraefikManager = class {
     if (dockerAvailable) {
       try {
         const output = await new Promise((resolve, reject) => {
-          execFile("docker", ["inspect", "--format", "{{.State.Running}}", "runeya-traefik"], { timeout: 5e3 }, (err, stdout) => {
+          execFile2("docker", ["inspect", "--format", "{{.State.Running}}", "runeya-traefik"], { timeout: 5e3 }, (err, stdout) => {
             if (err) reject(err);
             else resolve(stdout.trim());
           });
@@ -3061,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);
@@ -3072,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, {
@@ -3390,6 +3482,7 @@ var ProcessManager = class extends EventEmitter7 {
           commandId: cmd.id,
           runnerProcess,
           pid: null,
+          containerName: runnerProcess.containerName ?? null,
           exitCode: null
         };
         proc.commandProcesses = [...proc.commandProcesses, cmdProcess];
@@ -3475,6 +3568,7 @@ var ProcessManager = class extends EventEmitter7 {
         commandId: cmd.id,
         runnerProcess,
         pid: runnerProcess.pid ?? null,
+        containerName: runnerProcess.containerName ?? null,
         exitCode: null
       };
       proc.commandProcesses = [...proc.commandProcesses, cmdProcess];
@@ -3489,6 +3583,8 @@ var ProcessManager = class extends EventEmitter7 {
       this.consoleLogSource.attach(processId, runnerProcess.stdout, runnerProcess.stderr, runnerProcess.pid ?? null);
       if (runnerProcess.pid) {
         this.metricsCollector.startCollecting(processId, runnerProcess.pid);
+      } else if (runnerProcess.containerName) {
+        this.metricsCollector.startCollectingDocker(processId, runnerProcess.containerName);
       }
       runnerProcess.exitPromise.then(({ exitCode, signal, error }) => {
         const current = processStore.get(processId);
@@ -3650,9 +3746,26 @@ var ProcessManager = class extends EventEmitter7 {
     const proc = this.activeShortcuts.get(key);
     if (proc) proc.kill("SIGTERM");
   }
-  cancelAdHocCommand(processId) {
-    const proc = this.activeAdHocCommands.get(processId);
-    if (proc) proc.kill("SIGTERM");
+  cancelAdHocCommand(processId, commandId) {
+    const targets = [];
+    if (commandId) {
+      const key = `${processId}:${commandId}`;
+      const proc = this.activeAdHocCommands.get(key);
+      if (proc) targets.push(proc);
+    } else {
+      for (const [key, proc] of this.activeAdHocCommands) {
+        if (key.startsWith(`${processId}:`)) targets.push(proc);
+      }
+    }
+    for (const proc of targets) {
+      proc.kill("SIGTERM");
+      void Promise.race([
+        proc.exitPromise,
+        new Promise((resolve) => setTimeout(resolve, 3e3))
+      ]).then((result) => {
+        if (result === void 0) proc.kill("SIGKILL");
+      });
+    }
   }
   /** Execute a shortcut command and stream its output as logs for the given process */
   async executeShortcut(processId, shortcut) {
@@ -3692,7 +3805,7 @@ var ProcessManager = class extends EventEmitter7 {
     return { exitCode };
   }
   /** Execute an ad-hoc command and stream its output as logs for the given process */
-  async executeAdHocCommand(processId, command, cwd) {
+  async executeAdHocCommand(processId, command, cwd, commandId) {
     const proc = processStore.get(processId);
     if (!proc) throw new Error(`Process ${processId} not found`);
     const jsParsers = proc.serviceConfig.resolvedLogParsers ?? [];
@@ -3712,10 +3825,11 @@ var ProcessManager = class extends EventEmitter7 {
       this.consoleLogSource.addSystemLog(processId, `Failed to start: ${err instanceof Error ? err.message : String(err)}`, "error", { id: randomUUID3(), type: "command-fail", header: command, state: "self" });
       return { exitCode: 1 };
     }
-    this.activeAdHocCommands.set(processId, runnerProcess);
+    const cmdKey = `${processId}:${commandId ?? randomUUID3()}`;
+    this.activeAdHocCommands.set(cmdKey, runnerProcess);
     this.consoleLogSource.attach(processId, runnerProcess.stdout, runnerProcess.stderr, runnerProcess.pid ?? null);
     const { exitCode, signal, error } = await runnerProcess.exitPromise;
-    this.activeAdHocCommands.delete(processId);
+    this.activeAdHocCommands.delete(cmdKey);
     if (signal) {
       this.consoleLogSource.addSystemLog(processId, `command cancelled`, "info");
     } else if (exitCode !== 0) {
@@ -3967,17 +4081,18 @@ var processRouter = router({
     return { success: true };
   }),
   /** Cancel a running ad-hoc command */
-  cancelAdHocCommand: protectedProcedure.input(z22.object({ id: z22.string().max(128) })).mutation(({ input }) => {
-    processManager.cancelAdHocCommand(input.id);
+  cancelAdHocCommand: protectedProcedure.input(z22.object({ id: z22.string().max(128), commandId: z22.string().max(128).optional() })).mutation(({ input }) => {
+    processManager.cancelAdHocCommand(input.id, input.commandId);
     return { success: true };
   }),
   /** Execute an ad-hoc command and stream output into the process log */
   executeAdHocCommand: protectedProcedure.input(z22.object({
     id: z22.string().max(128),
     command: z22.string().min(1).max(4096),
-    cwd: z22.string().max(4096).optional()
+    cwd: z22.string().max(4096).optional(),
+    commandId: z22.string().max(128).optional()
   })).mutation(async ({ input }) => {
-    const result = await processManager.executeAdHocCommand(input.id, input.command, input.cwd);
+    const result = await processManager.executeAdHocCommand(input.id, input.command, input.cwd, input.commandId);
     return result;
   }),
   /** List active log source types for a process */
@@ -4113,9 +4228,9 @@ var processRouter = router({
 
 // src/trpc/routers/health.ts
 import { networkInterfaces as networkInterfaces2 } from "os";
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
-var execFileAsync = promisify(execFile2);
+var execFileAsync = promisify(execFile3);
 var startedAt = Date.now();
 function getLanIp2() {
   const nets = networkInterfaces2();
@@ -4280,12 +4395,12 @@ var terminalRouter = router({
 // src/trpc/routers/git.ts
 import { z as z24 } from "zod";
 import { TRPCError as TRPCError4 } from "@trpc/server";
-import { execFile as execFile3, spawn as spawn3 } from "child_process";
+import { execFile as execFile4, spawn as spawn3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { existsSync, watch as fsWatch } from "fs";
 import { promises as fsPromises2 } from "fs";
 import { join as join4, resolve as resolvePath } from "path";
-var execFileAsync2 = promisify2(execFile3);
+var execFileAsync2 = promisify2(execFile4);
 var GIT_TIMEOUT = 15e3;
 var DIFF_MAX_BYTES = 512 * 1024;
 var CWD_SCHEMA = z24.string().min(1).max(4096);
@@ -4716,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;
@@ -4737,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 } : {}
+              }
             }
           }
         });
@@ -4765,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) {
@@ -4853,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,
@@ -4863,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) {
@@ -4878,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");
@@ -4910,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;
@@ -4944,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 }
     });
@@ -5055,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({
@@ -5086,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);