@runeya/runeya 2.0.11 → 2.0.14

package/{dist-2H7XZQCV.js → dist-TI3HFRUW.js}

@@ -34,7 +34,7 @@ import {
   nativeParsers,
   serviceStore,
   traefikManager
-} from "./chunk-6547GLUJ.js";
+} from "./chunk-AJW7LDO5.js";
 import {
   generateKanbanPopulatePrompt,
   generateKanbanSystemPrompt,
@@ -408,7 +408,7 @@ function requireEnvAction(ctx, environmentId, action, serviceId) {
   });
 }
 var startedAt = Date.now();
-var appVersion = process.env["RUNEYA_VERSION"] ?? (true ? "2.0.10" : "dev");
+var appVersion = process.env["RUNEYA_VERSION"] ?? (true ? "2.0.14" : "dev");
 var healthRouter = router({
   check: publicProcedure.meta({ openapi: { method: "GET", path: "/health", tags: ["health"], summary: "Health check" } }).output(z.object({ status: z.literal("ok"), uptime: z.number(), version: z.string() })).query(() => {
     return {
@@ -439,6 +439,7 @@ var ProjectStore = class {
         this.projects.set(p.id, {
           ...p,
           environmentIds: p.environmentIds ?? [],
+          groupOrder: p.groupOrder ?? [],
           // Prefer the env marked default, fall back to first env
           activeEnvironmentId: defaultEnv?.id ?? p.environmentIds?.[0]
         });
@@ -474,7 +475,8 @@ var ProjectStore = class {
       description: input.description ?? "",
       serviceIds: input.serviceIds ?? [],
       environmentIds: input.environmentIds ?? [],
-      activeEnvironmentId: input.activeEnvironmentId
+      activeEnvironmentId: input.activeEnvironmentId,
+      groupOrder: input.groupOrder ?? []
     };
     this.projects.set(project.id, project);
     await this.save();
@@ -491,7 +493,8 @@ var ProjectStore = class {
       ...input.serviceIds !== void 0 && { serviceIds: input.serviceIds },
       ...input.environmentIds !== void 0 && { environmentIds: input.environmentIds },
       ...input.activeEnvironmentId !== void 0 && { activeEnvironmentId: input.activeEnvironmentId },
-      ...input.orgId !== void 0 && { orgId: input.orgId }
+      ...input.orgId !== void 0 && { orgId: input.orgId },
+      ...input.groupOrder !== void 0 && { groupOrder: input.groupOrder }
     };
     this.projects.set(input.id, updated);
     await this.save();
@@ -1037,7 +1040,8 @@ var projectRouter = router({
       name: z2.string().min(1).max(200).optional(),
       description: z2.string().max(1e4).optional(),
       orgId: z2.string().max(128).nullable().optional(),
-      serviceIds: z2.array(z2.string().max(128)).max(1e4).optional()
+      serviceIds: z2.array(z2.string().max(128)).max(1e4).optional(),
+      groupOrder: z2.array(z2.string().max(200)).max(100).optional()
     })
   ).mutation(async ({ input }) => {
     const project = await projectStore.update(input);
@@ -5066,7 +5070,7 @@ function tailTranscript(opts) {
   };
 }
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-3DHUF2DC-KN6O7WSA.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -5239,7 +5243,7 @@ async function runClaudeViaPty(params) {
   });
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-3DHUF2DC-KN6O7WSA.js");
   return agentManager2;
 }
 function createClaudeStreamState() {
@@ -5812,7 +5816,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager3() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-V47DLMYP-26VYXTSG.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-3DHUF2DC-KN6O7WSA.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -6729,6 +6733,19 @@ var chatRouter = router({
     delete: protectedProcedure.input(z14.object({ id: Id128Schema })).mutation(async ({ input }) => {
       const existing = await conversationStore.get(input.id);
       if (!existing) throw new TRPCError10({ code: "NOT_FOUND", message: "Conversation not found" });
+      for (const agent of agentManager.listAgents()) {
+        const agentId = agent.config.id;
+        agentManager.agentQuery(
+          agentId,
+          "ai.findPtyBySession",
+          { sessionId: input.id }
+        ).then((pty3) => {
+          if (pty3?.status === "running") {
+            return agentManager.agentMutation(agentId, "ai.kill", { spawnId: pty3.spawnId });
+          }
+        }).catch(() => {
+        });
+      }
       await conversationStore.delete(input.id);
       await scenarioRunStore.deleteRunDir(input.id);
       imageStorageService.deleteByContextId(input.id).catch(
@@ -7482,80 +7499,97 @@ async function resolveServiceContext(serviceId) {
   }
   return { agentId, cwd: service.cwd || "." };
 }
+var gitTargetShape = {
+  serviceId: SERVICE_ID_SCHEMA.optional(),
+  agentId: z15.string().max(128).optional()
+};
+async function resolveGitContext(input) {
+  if (input.serviceId) return resolveServiceContext(input.serviceId);
+  const agentId = input.agentId ?? agentManager.getDefaultAgentId();
+  if (!agentId) {
+    throw new TRPCError11({ code: "BAD_REQUEST", message: "No agent available" });
+  }
+  return { agentId, cwd: "." };
+}
 var gitRouter = router({
   /** Get full git status */
-  status: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).query(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  status: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.status", { cwd });
   }),
   /** Get commit log */
-  log: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, limit: z15.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  log: protectedProcedure.input(z15.object({ ...gitTargetShape, limit: z15.number().int().min(1).max(200).default(50) })).query(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.log", { cwd, limit: input.limit });
   }),
   /** List local and remote branches */
-  branches: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).query(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  branches: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.branches", { cwd });
   }),
   /** Checkout a branch */
-  checkout: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, branch: BRANCH_SCHEMA, create: z15.boolean().default(false) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  checkout: protectedProcedure.input(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, create: z15.boolean().default(false) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.checkout", { cwd, branch: input.branch, create: input.create });
   }),
   /** Stage files */
-  stage: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  stage: protectedProcedure.input(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stage", { cwd, paths: input.paths });
   }),
   /** Stage all files */
-  stageAll: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  stageAll: protectedProcedure.input(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.stageAll", { cwd });
   }),
   /** Unstage files */
-  unstage: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  unstage: protectedProcedure.input(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.unstage", { cwd, paths: input.paths });
   }),
+  /** Unstage all files */
+  unstageAll: protectedProcedure.input(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentMutation(agentId, "git.unstageAll", { cwd });
+  }),
   /** Commit staged changes */
-  commit: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, message: z15.string().min(1).max(4096) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  commit: protectedProcedure.input(z15.object({ ...gitTargetShape, message: z15.string().min(1).max(4096) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.commit", { cwd, message: input.message });
   }),
   /** Push to remote */
-  push: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z15.boolean().default(false) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  push: protectedProcedure.input(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin"), setUpstream: z15.boolean().default(false) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.push", { cwd, remote: input.remote, setUpstream: input.setUpstream });
   }),
   /** Pull from remote */
-  pull: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  pull: protectedProcedure.input(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.pull", { cwd, remote: input.remote });
   }),
   /** Fetch from remote */
-  fetch: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  fetch: protectedProcedure.input(z15.object({ ...gitTargetShape, remote: REMOTE_SCHEMA.default("origin") })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.fetch", { cwd, remote: input.remote });
   }),
   /** Get diff for a file or the whole index */
   diff: protectedProcedure.input(z15.object({
-    serviceId: SERVICE_ID_SCHEMA,
+    ...gitTargetShape,
     path: z15.string().max(4096).optional(),
     staged: z15.boolean().default(false),
     untracked: z15.boolean().default(false)
   })).query(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.diff", { cwd, path: input.path, staged: input.staged, untracked: input.untracked });
   }),
   /** Discard changes to working tree files */
-  discard: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  discard: protectedProcedure.input(z15.object({ ...gitTargetShape, paths: z15.array(SAFE_PATH_SCHEMA).min(1).max(500) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.discard", { cwd, paths: input.paths });
   }),
   /** Generate a commit message from staged diffs using AI (diff fetched from agent, AI runs on server) */
-  generateCommitMessage: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  generateCommitMessage: protectedProcedure.input(z15.object({ ...gitTargetShape })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     const { diff } = await agentManager.agentQuery(agentId, "git.stagedDiff", { cwd });
     if (!diff.trim()) {
       throw new TRPCError11({ code: "BAD_REQUEST", message: "No staged changes to generate a commit message from" });
@@ -7598,18 +7632,43 @@ Rules:
     throw new TRPCError11({ code: "BAD_REQUEST", message: "Unsupported AI provider" });
   }),
   /** Merge a branch into the current branch */
-  merge: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, branch: BRANCH_SCHEMA, noFf: z15.boolean().default(false) })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  merge: protectedProcedure.input(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA, noFf: z15.boolean().default(false) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.merge", { cwd, branch: input.branch, noFf: input.noFf });
   }),
   /** Rebase current branch onto another branch */
-  rebase: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  rebase: protectedProcedure.input(z15.object({ ...gitTargetShape, branch: BRANCH_SCHEMA })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentMutation(agentId, "git.rebase", { cwd, branch: input.branch });
   }),
+  /** List stash entries */
+  stashList: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentQuery(agentId, "git.stashList", { cwd });
+  }),
+  /** Stash current changes */
+  stashPush: protectedProcedure.input(z15.object({ ...gitTargetShape, message: z15.string().max(4096).optional(), includeUntracked: z15.boolean().default(true) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentMutation(agentId, "git.stashPush", { cwd, message: input.message, includeUntracked: input.includeUntracked });
+  }),
+  /** Pop a stash entry */
+  stashPop: protectedProcedure.input(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentMutation(agentId, "git.stashPop", { cwd, index: input.index });
+  }),
+  /** Apply a stash entry without dropping it */
+  stashApply: protectedProcedure.input(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentMutation(agentId, "git.stashApply", { cwd, index: input.index });
+  }),
+  /** Drop a stash entry */
+  stashDrop: protectedProcedure.input(z15.object({ ...gitTargetShape, index: z15.number().int().min(0).max(1e3).default(0) })).mutation(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
+    return agentManager.agentMutation(agentId, "git.stashDrop", { cwd, index: input.index });
+  }),
   /** Watch .git/ for changes and stream updated status */
-  onStatusChange: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).subscription(async function* ({ input }) {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  onStatusChange: protectedProcedure.input(z15.object({ ...gitTargetShape })).subscription(async function* ({ input }) {
+    const { agentId, cwd } = await resolveGitContext(input);
     const queue = [];
     let resolve5 = null;
     let done = false;
@@ -7655,8 +7714,8 @@ Rules:
     }
   }),
   /** List remotes */
-  remotes: protectedProcedure.input(z15.object({ serviceId: SERVICE_ID_SCHEMA })).query(async ({ input }) => {
-    const { agentId, cwd } = await resolveServiceContext(input.serviceId);
+  remotes: protectedProcedure.input(z15.object({ ...gitTargetShape })).query(async ({ input }) => {
+    const { agentId, cwd } = await resolveGitContext(input);
     return agentManager.agentQuery(agentId, "git.remotes", { cwd });
   })
 });
@@ -11943,4 +12002,4 @@ export {
   createLocalServer,
   pullEnv
 };
-//# sourceMappingURL=dist-2H7XZQCV.js.map
+//# sourceMappingURL=dist-TI3HFRUW.js.map