@runeya/runeya 2.0.13 → 2.0.16

package/agent/index.js

@@ -920,7 +920,9 @@ var SettingsSchema = z5.object({
   mode: z5.enum(["local-simple", "cloud"]),
   cloudUrl: z5.string().url().max(2048).nullable().optional(),
   logParsers: z5.array(JSLogParserSchema).max(100).default([]),
-  scenarios: z5.array(ScenarioSchema).max(100).default([])
+  scenarios: z5.array(ScenarioSchema).max(100).default([]),
+  /** Absolute path to the folder where the global wiki/docs markdown files live. Optional. */
+  globalDocsPath: z5.string().max(4096).optional()
 });
 var TraefikConfigSchema = z5.object({
   enabled: z5.boolean().default(false),
@@ -1106,6 +1108,8 @@ var ServiceConfigSchema = z7.object({
   // Metadata fields (migration from old Runeya)
   groups: z7.array(z7.string().max(200)).max(20).optional().default([]),
   description: z7.string().max(2e3).optional(),
+  /** Path (relative to service.cwd or absolute) where the service's docs/wiki markdown files live. Optional — defaults to service.cwd. */
+  docsPath: z7.string().max(4096).optional(),
   url: z7.string().max(2048).optional(),
   localUrls: z7.array(z7.object({
     url: z7.string().max(253).regex(/^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/),
@@ -2048,8 +2052,8 @@ var FileLogSource = class extends EventEmitter2 {
       }
     }
     if (this.config.startFromEnd) {
-      const stat2 = await fsPromises.stat(this.config.path);
-      this.offset = stat2.size;
+      const stat3 = await fsPromises.stat(this.config.path);
+      this.offset = stat3.size;
     } else {
       this.offset = 0;
     }
@@ -2082,17 +2086,17 @@ var FileLogSource = class extends EventEmitter2 {
     return this.logBuffer.getByProcessId(processId);
   }
   async readNewLines(processId) {
-    let stat2;
+    let stat3;
     try {
-      stat2 = await fsPromises.stat(this.config.path);
+      stat3 = await fsPromises.stat(this.config.path);
     } catch {
       return;
     }
-    if (stat2.size < this.offset) {
+    if (stat3.size < this.offset) {
       this.offset = 0;
     }
-    if (stat2.size === this.offset) return;
-    const length = stat2.size - this.offset;
+    if (stat3.size === this.offset) return;
+    const length = stat3.size - this.offset;
     const buf = Buffer.alloc(length);
     let fd = null;
     try {
@@ -2890,8 +2894,8 @@ var TraefikManager = class {
     const walk = async (dir, base) => {
       let entries;
       try {
-        const { readdir } = await import("fs/promises");
-        entries = await readdir(dir);
+        const { readdir: readdir2 } = await import("fs/promises");
+        entries = await readdir2(dir);
       } catch {
         return;
       }
@@ -2899,8 +2903,8 @@ var TraefikManager = class {
         const full = join2(dir, entry);
         const rel = join2(base, entry);
         try {
-          const { stat: stat2 } = await import("fs/promises");
-          const s = await stat2(full);
+          const { stat: stat3 } = await import("fs/promises");
+          const s = await stat3(full);
           if (s.isDirectory()) {
             await walk(full, rel);
           } else {
@@ -4923,10 +4927,11 @@ function resolveMcpServerPath() {
   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 MAX_CONCURRENT_SPAWNS = 100;
 var CLEANUP_INTERVAL_MS = 6e4;
 var TTL_ACKED_MS = 5 * 6e4;
 var TTL_UNACKED_MS = 24 * 36e5;
+var TTL_IDLE_PTY_MS = 30 * 6e4;
 function resolveSpawnEnvAndArgs(opts) {
   const runeyaEnv = {
     ...opts.mcpApiBaseUrl ? { RUNEYA_BASE_URL: opts.mcpApiBaseUrl } : {},
@@ -5200,7 +5205,19 @@ var AiSpawnManager = class {
   cleanup() {
     const now = Date.now();
     for (const [id, entry] of this.spawns) {
-      if (entry.status === "running") continue;
+      if (entry.status === "running") {
+        if (entry.ptyProc) {
+          const idle = now - (entry.lastChunkAt ?? entry.createdAt);
+          if (idle > TTL_IDLE_PTY_MS) {
+            try {
+              entry.ptyProc.kill();
+            } catch {
+            }
+            console.log(`[ai-spawn-manager] Reaped idle PTY ${id} (idle ${Math.round(idle / 1e3)}s)`);
+          }
+        }
+        continue;
+      }
       const age = now - (entry.doneAt ?? entry.createdAt);
       if (entry.acked && age > TTL_ACKED_MS) {
         this.spawns.delete(id);
@@ -5669,6 +5686,209 @@ var aiRouter = router({
   })
 });
 
+// src/trpc/routers/wiki.ts
+import { z as z26 } from "zod";
+import { TRPCError as TRPCError6 } from "@trpc/server";
+import { readFile as readFile2, readdir, stat as stat2, realpath, writeFile as writeFile6, mkdir as mkdir6, rename as rename2, rm } from "fs/promises";
+import { dirname } from "path";
+import { resolve as resolvePath2, join as join5, relative, sep } from "path";
+var CWD_SCHEMA2 = z26.string().min(1).max(4096);
+var REL_PATH_SCHEMA = z26.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
+  message: "Path must be a relative path without traversal"
+});
+var MAX_FILES = 500;
+var MAX_DEPTH = 8;
+var MAX_FILE_BYTES = 2e6;
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".yarn",
+  ".pnpm-store",
+  "target",
+  "out"
+]);
+var RepoEntrySchema = z26.lazy(() => z26.union([
+  z26.object({ type: z26.literal("file"), name: z26.string(), path: z26.string() }),
+  z26.object({ type: z26.literal("dir"), name: z26.string(), path: z26.string(), children: z26.array(RepoEntrySchema) })
+]));
+async function walkMarkdown(root, dir, depth, counter) {
+  if (depth > MAX_DEPTH || counter.n >= MAX_FILES) return [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    if (counter.n >= MAX_FILES) break;
+    if (e.name.startsWith(".") && e.name !== ".") continue;
+    const abs = join5(dir, e.name);
+    const rel = relative(root, abs).split(sep).join("/");
+    if (e.isDirectory()) {
+      if (IGNORED_DIRS.has(e.name)) continue;
+      const children = await walkMarkdown(root, abs, depth + 1, counter);
+      out.push({ type: "dir", name: e.name, path: rel, children });
+    } else if (e.isFile() && /\.(md|markdown)$/i.test(e.name)) {
+      counter.n += 1;
+      out.push({ type: "file", name: e.name, path: rel });
+    }
+  }
+  out.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  return out;
+}
+async function resolveSafePath(root, relPath, requireExist) {
+  if (relPath.includes("..") || relPath.startsWith("/")) {
+    throw new TRPCError6({ code: "BAD_REQUEST", message: "Chemin invalide" });
+  }
+  const target = resolvePath2(root, relPath);
+  if (requireExist) {
+    let real;
+    try {
+      real = await realpath(target);
+    } catch {
+      throw new TRPCError6({ code: "NOT_FOUND", message: "Chemin introuvable" });
+    }
+    if (real !== root && !(real + sep).startsWith(root + sep)) {
+      throw new TRPCError6({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+    }
+    return real;
+  }
+  const parent = dirname(target);
+  let realParent;
+  try {
+    realParent = await realpath(parent);
+  } catch {
+    realParent = parent;
+  }
+  if (realParent !== root && !(realParent + sep).startsWith(root + sep)) {
+    throw new TRPCError6({ code: "FORBIDDEN", message: "Hors du dossier autoris\xE9" });
+  }
+  return resolvePath2(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
+}
+async function resolveRoot(cwd) {
+  const expanded = expandEnvVar(cwd);
+  const abs = resolvePath2(expanded);
+  try {
+    return await realpath(abs);
+  } catch {
+    throw new TRPCError6({ code: "NOT_FOUND", message: `Dossier introuvable: ${abs}` });
+  }
+}
+var wikiRouter = router({
+  listRepoMarkdown: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2 })).query(async ({ input }) => {
+    const root = await resolveRoot(input.cwd);
+    const counter = { n: 0 };
+    const entries = await walkMarkdown(root, root, 0, counter);
+    return { root, entries, truncated: counter.n >= MAX_FILES };
+  }),
+  readRepoMarkdown: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).query(async ({ input }) => {
+    if (!/\.(md|markdown)$/i.test(input.path)) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md sont autoris\xE9s" });
+    }
+    const root = await resolveRoot(input.cwd);
+    const target = resolvePath2(root, input.path);
+    let realTarget;
+    try {
+      realTarget = await realpath(target);
+    } catch {
+      throw new TRPCError6({ code: "NOT_FOUND", message: "Fichier introuvable" });
+    }
+    const realTargetWithSep = realTarget + sep;
+    if (realTarget !== root && !realTargetWithSep.startsWith(root + sep)) {
+      throw new TRPCError6({ code: "FORBIDDEN", message: "Hors du dossier du service" });
+    }
+    const s = await stat2(realTarget);
+    if (!s.isFile()) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "Pas un fichier" });
+    }
+    if (s.size > MAX_FILE_BYTES) {
+      throw new TRPCError6({ code: "PAYLOAD_TOO_LARGE", message: "Fichier trop volumineux" });
+    }
+    const content = await readFile2(realTarget, "utf-8");
+    return { path: input.path, content };
+  }),
+  writeMarkdown: protectedProcedure.input(z26.object({
+    cwd: CWD_SCHEMA2,
+    path: REL_PATH_SCHEMA,
+    content: z26.string().max(5e6)
+  })).mutation(async ({ input }) => {
+    if (!/\.(md|markdown)$/i.test(input.path)) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+    }
+    const root = await resolveRoot(input.cwd);
+    const target = await resolveSafePath(root, input.path, false);
+    await mkdir6(dirname(target), { recursive: true });
+    await writeFile6(target, input.content, "utf-8");
+    return { path: input.path, ok: true };
+  }),
+  createFile: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+    if (!/\.(md|markdown)$/i.test(input.path)) {
+      throw new TRPCError6({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
+    }
+    const root = await resolveRoot(input.cwd);
+    const target = await resolveSafePath(root, input.path, false);
+    try {
+      await stat2(target);
+      throw new TRPCError6({ code: "CONFLICT", message: "Fichier d\xE9j\xE0 existant" });
+    } catch (err) {
+      if (err instanceof TRPCError6) throw err;
+    }
+    await mkdir6(dirname(target), { recursive: true });
+    await writeFile6(target, "", "utf-8");
+    return { path: input.path, ok: true };
+  }),
+  createDir: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+    const root = await resolveRoot(input.cwd);
+    const target = await resolveSafePath(root, input.path, false);
+    await mkdir6(target, { recursive: true });
+    return { path: input.path, ok: true };
+  }),
+  renamePath: protectedProcedure.input(z26.object({
+    cwd: CWD_SCHEMA2,
+    fromPath: REL_PATH_SCHEMA,
+    toPath: REL_PATH_SCHEMA
+  })).mutation(async ({ input }) => {
+    const root = await resolveRoot(input.cwd);
+    const from = await resolveSafePath(root, input.fromPath, true);
+    const to = await resolveSafePath(root, input.toPath, false);
+    try {
+      await stat2(to);
+      throw new TRPCError6({ code: "CONFLICT", message: "La cible existe d\xE9j\xE0" });
+    } catch (err) {
+      if (err instanceof TRPCError6) throw err;
+    }
+    await mkdir6(dirname(to), { recursive: true });
+    await rename2(from, to);
+    return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
+  }),
+  ensureRoot: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2 })).mutation(async ({ input }) => {
+    const expanded = expandEnvVar(input.cwd);
+    const abs = resolvePath2(expanded);
+    await mkdir6(abs, { recursive: true });
+    const root = await realpath(abs);
+    return { root, ok: true };
+  }),
+  deletePath: protectedProcedure.input(z26.object({ cwd: CWD_SCHEMA2, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+    const root = await resolveRoot(input.cwd);
+    const target = await resolveSafePath(root, input.path, true);
+    if (target === root) {
+      throw new TRPCError6({ code: "FORBIDDEN", message: "Impossible de supprimer la racine" });
+    }
+    await rm(target, { recursive: true, force: true });
+    return { path: input.path, ok: true };
+  })
+});
+
 // src/trpc/router.ts
 var appRouter = router({
   process: processRouter,
@@ -5676,7 +5896,8 @@ var appRouter = router({
   config: configRouter,
   terminal: terminalRouter,
   git: gitRouter,
-  ai: aiRouter
+  ai: aiRouter,
+  wiki: wikiRouter
 });
 
 // src/create-agent.ts