@runeya/runeya 2.0.23 → 2.0.24

package/index.js

@@ -201,7 +201,7 @@ function listenWithRetry(server, port, host, wss, maxRetries = 20, delay = 500)
   });
 }
 async function main() {
-  const { createLocalServer, pullEnv, PullEnvError } = await import("./src-3TOPUVAK.js");
+  const { createLocalServer, pullEnv, PullEnvError } = await import("./src-EGBDYHL5.js");
   if (isPullEnv) {
     if (!serviceArg) {
       console.error("Error: --service (-s) is required with --pull-env");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runeya/runeya",
-  "version": "2.0.23",
+  "version": "2.0.24",
   "type": "module",
   "bin": {
     "runeya": "./index.js"

package/{src-3TOPUVAK.js → src-EGBDYHL5.js}

@@ -5671,6 +5671,119 @@ var KanbanStore = class {
 var kanbanStore = new KanbanStore();
 
 // ../server/src/services/kanban-commands.ts
+async function executeKanbanCommands(boardId, cardId, commands, conversationId) {
+  if (commands.length === 0) return;
+  let board = await kanbanStore.get(boardId);
+  if (!board) {
+    console.warn(`[kanban-commands] Board ${boardId} not found, skipping ${commands.length} command(s)`);
+    return;
+  }
+  const cardExistsInBoard = () => board.columns.some((col) => col.cards.some((c) => c.id === cardId));
+  if (!cardExistsInBoard()) {
+    for (let attempt = 1; attempt <= 5; attempt++) {
+      console.warn(`[kanban-commands] Card ${cardId} not found in board, retry ${attempt}/5...`);
+      await new Promise((r) => setTimeout(r, 500 * attempt));
+      board = await kanbanStore.get(boardId);
+      if (!board) return;
+      if (cardExistsInBoard()) break;
+    }
+    if (!cardExistsInBoard()) {
+      console.error(`[kanban-commands] Card ${cardId} still not found after retries, skipping ${commands.length} command(s)`);
+      return;
+    }
+  }
+  for (const cmd of commands) {
+    if (cmd.type === "move_card" && cmd.columnTitle) {
+      const moved = moveCard(board, cardId, cmd.columnTitle);
+      if (!moved) console.warn(`[kanban-commands] move_card failed: card=${cardId} target="${cmd.columnTitle}"`);
+    } else if (cmd.type === "add_comment" && cmd.comment) {
+      addComment(board, cardId, cmd.comment, conversationId);
+    } else if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
+      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
+    }
+  }
+  await kanbanStore.update({ id: board.id, columns: board.columns });
+}
+async function executeKanbanBoardCommands(boardId, commands) {
+  if (commands.length === 0) return;
+  const board = await kanbanStore.get(boardId);
+  if (!board) return;
+  for (const cmd of commands) {
+    if (cmd.type === "add_card" && cmd.columnTitle && cmd.cardTitle) {
+      addCardToColumn(board, cmd.columnTitle, cmd.cardTitle, cmd.cardContent);
+    }
+  }
+  await kanbanStore.update({ id: board.id, columns: board.columns });
+}
+function moveCard(board, cardId, targetColTitle) {
+  let sourceCol = "";
+  let card = null;
+  let sourceColIdx = -1;
+  let cardIdx = -1;
+  for (let ci = 0; ci < board.columns.length; ci++) {
+    const col = board.columns[ci];
+    const idx = col.cards.findIndex((c) => c.id === cardId);
+    if (idx !== -1) {
+      sourceCol = col.title;
+      card = col.cards[idx];
+      sourceColIdx = ci;
+      cardIdx = idx;
+      break;
+    }
+  }
+  if (!card || sourceColIdx === -1) return false;
+  const targetCol = board.columns.find(
+    (c) => c.title.toLowerCase() === targetColTitle.toLowerCase()
+  );
+  if (!targetCol) {
+    console.warn(`[kanban-commands] Target column "${targetColTitle}" not found. Available: ${board.columns.map((c) => c.title).join(", ")}`);
+    return false;
+  }
+  if (targetCol.id === board.columns[sourceColIdx].id) return true;
+  board.columns[sourceColIdx].cards.splice(cardIdx, 1);
+  card.order = targetCol.cards.length;
+  card.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  card.history = [...card.history ?? [], {
+    type: "moved",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    detail: `"${sourceCol}" \u2192 "${targetCol.title}"`,
+    author: "ai"
+  }];
+  targetCol.cards.push(card);
+  return true;
+}
+function addCardToColumn(board, columnTitle, cardTitle, cardContent) {
+  const col = board.columns.find((c) => c.title.toLowerCase() === columnTitle.toLowerCase());
+  if (!col) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const card = {
+    id: randomUUID5(),
+    title: cardTitle,
+    markdown: cardContent ?? "",
+    images: [],
+    order: col.cards.length,
+    history: [{ type: "created", timestamp: now, detail: `AI \u2014 In column "${col.title}"` }],
+    createdAt: now,
+    updatedAt: now
+  };
+  col.cards.push(card);
+}
+function addComment(board, cardId, comment, conversationId) {
+  for (const col of board.columns) {
+    const card = col.cards.find((c) => c.id === cardId);
+    if (card) {
+      card.history = [...card.history ?? [], {
+        type: "comment",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        detail: comment,
+        author: "ai",
+        ...conversationId ? { conversationId } : {}
+      }];
+      card.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return;
+    }
+  }
+}
 function generateKanbanSystemPrompt(board, cardId) {
   let currentColTitle = "";
   let card = null;
@@ -10701,16 +10814,52 @@ var kanbanQueueRouter = router({
   })
 });
 
-// ../server/src/trpc/routers/terminal.ts
+// ../server/src/trpc/routers/kanban.ts
 import { z as z20 } from "zod";
+var kanbanRouter = router({
+  moveCard: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    cardId: z20.string().max(128),
+    targetColumn: z20.string().max(256)
+  })).mutation(async ({ input }) => {
+    await executeKanbanCommands(input.boardId, input.cardId, [
+      { type: "move_card", columnTitle: input.targetColumn }
+    ]);
+    return { ok: true };
+  }),
+  addComment: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    cardId: z20.string().max(128),
+    comment: z20.string().max(2e4)
+  })).mutation(async ({ input }) => {
+    await executeKanbanCommands(input.boardId, input.cardId, [
+      { type: "add_comment", comment: input.comment }
+    ]);
+    return { ok: true };
+  }),
+  addCard: protectedProcedure.input(z20.object({
+    boardId: z20.string().max(128),
+    column: z20.string().max(256),
+    title: z20.string().max(512),
+    content: z20.string().max(2e4).optional()
+  })).mutation(async ({ input }) => {
+    await executeKanbanBoardCommands(input.boardId, [
+      { type: "add_card", columnTitle: input.column, cardTitle: input.title, cardContent: input.content }
+    ]);
+    return { ok: true };
+  })
+});
+
+// ../server/src/trpc/routers/terminal.ts
+import { z as z21 } from "zod";
 import { TRPCError as TRPCError17 } from "@trpc/server";
 var terminalRouter = router({
   /** Create a PTY shell session on the target agent */
-  create: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    cwd: z20.string().max(512).optional(),
-    cols: z20.number().int().min(1).max(512).optional(),
-    rows: z20.number().int().min(1).max(256).optional()
+  create: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    cwd: z21.string().max(512).optional(),
+    cols: z21.number().int().min(1).max(512).optional(),
+    rows: z21.number().int().min(1).max(256).optional()
   })).mutation(async ({ input }) => {
     const result = await agentManager.agentMutation(
       input.agentId,
@@ -10720,10 +10869,10 @@ var terminalRouter = router({
     return result;
   }),
   /** Send keystrokes / data to a PTY session */
-  write: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128),
-    data: z20.string().max(65536)
+  write: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128),
+    data: z21.string().max(65536)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10733,11 +10882,11 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Resize the PTY */
-  resize: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128),
-    cols: z20.number().int().min(1).max(512),
-    rows: z20.number().int().min(1).max(256)
+  resize: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128),
+    cols: z21.number().int().min(1).max(512),
+    rows: z21.number().int().min(1).max(256)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10747,9 +10896,9 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Destroy a PTY session */
-  destroy: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128)
+  destroy: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128)
   })).mutation(async ({ input }) => {
     await agentManager.agentMutation(
       input.agentId,
@@ -10759,9 +10908,9 @@ var terminalRouter = router({
     return { ok: true };
   }),
   /** Stream PTY output — proxied via AgentWSBridge dynamic subscription */
-  onData: protectedProcedure.input(z20.object({
-    agentId: z20.string().max(128),
-    sessionId: z20.string().max(128)
+  onData: protectedProcedure.input(z21.object({
+    agentId: z21.string().max(128),
+    sessionId: z21.string().max(128)
   })).subscription(async function* ({ input }) {
     const queue = [];
     let resolve6 = null;
@@ -10810,11 +10959,11 @@ var terminalRouter = router({
 });
 
 // ../server/src/trpc/routers/utility.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var MAX_WAIT_MS = 5 * 60 * 1e3;
 var utilityRouter = router({
-  wait: protectedProcedure.input(z21.object({
-    ms: z21.number().int().min(0).max(MAX_WAIT_MS)
+  wait: protectedProcedure.input(z22.object({
+    ms: z22.number().int().min(0).max(MAX_WAIT_MS)
   })).mutation(async ({ input }) => {
     await new Promise((resolve6) => setTimeout(resolve6, input.ms));
     return { waited: input.ms };
@@ -10822,15 +10971,15 @@ var utilityRouter = router({
 });
 
 // ../server/src/trpc/routers/wiki.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 import { TRPCError as TRPCError18 } from "@trpc/server";
 import { readFile as readFile13, readdir as readdir5, stat as stat3, realpath, writeFile as writeFile11, mkdir as mkdir14, rename as rename10, rm as rm2 } from "fs/promises";
 import { resolve as resolvePath, join as join16, relative, sep as sep3, dirname as dirname3 } from "path";
-var SCOPE_SCHEMA = z22.union([
-  z22.literal("global"),
-  z22.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
+var SCOPE_SCHEMA = z23.union([
+  z23.literal("global"),
+  z23.string().regex(/^service:[A-Za-z0-9_-]{1,128}$/, "Invalid service scope")
 ]);
-var REL_PATH_SCHEMA = z22.string().min(1).max(512).regex(/^[A-Za-z0-9_./-]+$/).refine((p) => !p.includes("..") && !p.startsWith("/"), {
+var REL_PATH_SCHEMA = z23.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;
@@ -10850,9 +10999,9 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "target",
   "out"
 ]);
-var DocsEntrySchema = z22.lazy(() => z22.union([
-  z22.object({ type: z22.literal("file"), name: z22.string(), path: z22.string() }),
-  z22.object({ type: z22.literal("dir"), name: z22.string(), path: z22.string(), children: z22.array(DocsEntrySchema) })
+var DocsEntrySchema = z23.lazy(() => z23.union([
+  z23.object({ type: z23.literal("file"), name: z23.string(), path: z23.string() }),
+  z23.object({ type: z23.literal("dir"), name: z23.string(), path: z23.string(), children: z23.array(DocsEntrySchema) })
 ]));
 async function resolveScope(scope) {
   if (scope === "global") {
@@ -10942,7 +11091,7 @@ async function resolveSafeLocal(root, relPath, requireExist) {
   return resolvePath(realParent, target.slice(parent.length).replace(/^[\\/]+/, ""));
 }
 var wikiRouter = router({
-  list: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA })).output(z22.object({ root: z22.string(), entries: z22.array(DocsEntrySchema), truncated: z22.boolean() })).query(async ({ input }) => {
+  list: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA })).output(z23.object({ root: z23.string(), entries: z23.array(DocsEntrySchema), truncated: z23.boolean() })).query(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentQuery(target.agentId, "wiki.listRepoMarkdown", { cwd: target.cwd });
@@ -10951,7 +11100,7 @@ var wikiRouter = router({
     const entries = await walkLocal(target.root, target.root, 0, counter);
     return { root: target.root, entries, truncated: counter.n >= MAX_FILES };
   }),
-  read: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z22.object({ path: z22.string(), content: z22.string() })).query(async ({ input }) => {
+  read: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).output(z23.object({ path: z23.string(), content: z23.string() })).query(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10966,7 +11115,7 @@ var wikiRouter = router({
     const content = await readFile13(file, "utf-8");
     return { path: input.path, content };
   }),
-  write: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z22.string().max(5e6) })).mutation(async ({ input }) => {
+  write: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA, content: z23.string().max(5e6) })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10979,7 +11128,7 @@ var wikiRouter = router({
     await writeFile11(file, input.content, "utf-8");
     return { path: input.path, ok: true };
   }),
-  createFile: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createFile: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     if (!/\.(md|markdown)$/i.test(input.path)) {
       throw new TRPCError18({ code: "BAD_REQUEST", message: "Seuls les .md/.markdown sont autoris\xE9s" });
     }
@@ -10998,7 +11147,7 @@ var wikiRouter = router({
     await writeFile11(file, "", "utf-8");
     return { path: input.path, ok: true };
   }),
-  createDir: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  createDir: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.createDir", { cwd: target.cwd, path: input.path });
@@ -11007,7 +11156,7 @@ var wikiRouter = router({
     await mkdir14(dir, { recursive: true });
     return { path: input.path, ok: true };
   }),
-  rename: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, fromPath: REL_PATH_SCHEMA, toPath: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  rename: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, fromPath: REL_PATH_SCHEMA, toPath: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.renamePath", { cwd: target.cwd, fromPath: input.fromPath, toPath: input.toPath });
@@ -11024,7 +11173,7 @@ var wikiRouter = router({
     await rename10(from, to);
     return { fromPath: input.fromPath, toPath: input.toPath, ok: true };
   }),
-  ensureRoot: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
+  ensureRoot: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA })).mutation(async ({ input }) => {
     if (input.scope === "global") {
       await resolveScope("global");
       return { ok: true };
@@ -11037,7 +11186,7 @@ var wikiRouter = router({
     const cwd = (service.docsPath?.trim() || service.cwd || ".").toString();
     return agentManager.agentMutation(agentId, "wiki.ensureRoot", { cwd });
   }),
-  delete: protectedProcedure.input(z22.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
+  delete: protectedProcedure.input(z23.object({ scope: SCOPE_SCHEMA, path: REL_PATH_SCHEMA })).mutation(async ({ input }) => {
     const target = await resolveScope(input.scope);
     if (target.mode === "agent") {
       return agentManager.agentMutation(target.agentId, "wiki.deletePath", { cwd: target.cwd, path: input.path });
@@ -11058,7 +11207,7 @@ var configRouter = router({
 });
 
 // ../server/src/trpc/routers/cloud-sync.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 import { TRPCError as TRPCError19 } from "@trpc/server";
 
 // ../server/src/services/cloud-sync-store.ts
@@ -11682,9 +11831,9 @@ var cloudSyncRouter = router({
    * to sync a project whose secrets will not open.
    */
   link: protectedProcedure.input(
-    z23.object({
-      orgId: z23.string().min(1).max(128),
-      cloudUrl: z23.string().url().max(2048)
+    z24.object({
+      orgId: z24.string().min(1).max(128),
+      cloudUrl: z24.string().url().max(2048)
     })
   ).mutation(async ({ input }) => {
     await reconcileOrgCanary(input.orgId);
@@ -11693,7 +11842,7 @@ var cloudSyncRouter = router({
     return { success: true };
   }),
   /** Stop syncing an org and forget its token. */
-  unlink: protectedProcedure.input(z23.object({ orgId: z23.string().min(1).max(128) })).mutation(async ({ input }) => {
+  unlink: protectedProcedure.input(z24.object({ orgId: z24.string().min(1).max(128) })).mutation(async ({ input }) => {
     cloudSyncBridge.disconnect(input.orgId);
     await cloudSyncStore.remove(input.orgId);
     return { success: true };
@@ -11731,6 +11880,7 @@ var appRouter = router({
   git: gitRouter,
   debug: debugRouter,
   kanbanQueue: kanbanQueueRouter,
+  kanban: kanbanRouter,
   terminal: terminalRouter,
   utility: utilityRouter,
   wiki: wikiRouter,
@@ -13811,4 +13961,4 @@ export {
   createLocalServer,
   pullEnv
 };
-//# sourceMappingURL=src-3TOPUVAK.js.map
+//# sourceMappingURL=src-EGBDYHL5.js.map