@runeya/runeya 2.0.9 → 2.0.10

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());
           });
@@ -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);