Add restart endpoint

src/backend/main.ts

@@ -76,7 +76,7 @@ app.use("*", requestLogger());
 
 // REST API
 app.route("/api/tickets", ticketsRouter(orchestrator));
-app.route("/api/agents", agentsRouter);
+app.route("/api/agents", agentsRouter(orchestrator));
 app.route("/api/hooks", hooksRouter);
 app.route("/api/remote", remoteRouter);
 app.route("/api/shell", shellRouter);

src/backend/routes/agents.ts

@@ -3,156 +3,181 @@ import { agentStmts, remoteStmts, ticketStmts } from "../db/index.ts";
 import { errorMeta, logger } from "../lib/logger.ts";
 import { agentProcessManager } from "../services/AgentProcessManager.ts";
 import { GitWorktreeManager } from "../services/GitWorktreeManager.ts";
+import type { OrchestratorService } from "../services/OrchestratorService.ts";
 import { broadcastNotification } from "../ws/hub.ts";
 
 const log = logger.child("agents");
 
-export const agentsRouter = new Hono();
+export function agentsRouter(orchestrator: OrchestratorService) {
+ const app = new Hono();
 
-agentsRouter.get("/:id", (c) => {
- const agent = agentStmts.get.get(c.req.param("id"));
- if (!agent) return c.json({ error: "agent not found" }, 404);
- return c.json(agent);
-});
+ app.get("/:id", (c) => {
+const agent = agentStmts.get.get(c.req.param("id"));
+if (!agent) return c.json({ error: "agent not found" }, 404);
+return c.json(agent);
+});
 
-agentsRouter.get("/:id/diff", async (c) => {
- const agent = agentStmts.get.get(c.req.param("id"));
- if (!agent) return c.json({ error: "agent not found" }, 404);
+ app.get("/:id/diff", async (c) => {
+const agent = agentStmts.get.get(c.req.param("id"));
+if (!agent) return c.json({ error: "agent not found" }, 404);
 
- const remoteConfig = remoteStmts.get.get();
- if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
+const remoteConfig = remoteStmts.get.get();
+if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
 
- log.debug("fetching diff", {
- agentId: agent.id,
- worktreePath: agent.worktreePath,
- baseBranch: agent.baseBranch,
- });
- try {
- const git = new GitWorktreeManager(remoteConfig.localPath);
- const diff = await git.getDiff(agent.worktreePath, agent.baseBranch);
- log.debug("diff fetched", { agentId: agent.id, files: diff.files.length });
- return c.json(diff);
- } catch (err) {
- log.error("failed to fetch diff", { agentId: agent.id, ...errorMeta(err) });
- return c.json({ error: (err as Error).message }, 500);
- }
-});
-
-agentsRouter.post("/:id/merge", async (c) => {
- const agent = agentStmts.get.get(c.req.param("id"));
- if (!agent) return c.json({ error: "agent not found" }, 404);
-
- const remoteConfig = remoteStmts.get.get();
- if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
-
- log.info("merge requested", {
- agentId: agent.id,
- branch: agent.branch,
- baseBranch: agent.baseBranch,
+ log.debug("fetching diff", {
+ agentId: agent.id,
+ worktreePath: agent.worktreePath,
+ baseBranch: agent.baseBranch,
+ });
+ try {
+ const git = new GitWorktreeManager(remoteConfig.localPath);
+ const diff = await git.getDiff(agent.worktreePath, agent.baseBranch);
+ log.debug("diff fetched", { agentId: agent.id, files: diff.files.length });
+ return c.json(diff);
+ } catch (err) {
+ log.error("failed to fetch diff", { agentId: agent.id, ...errorMeta(err) });
+ return c.json({ error: (err as Error).message }, 500);
+ }
  });
- try {
- const git = new GitWorktreeManager(remoteConfig.localPath);
- const result = await git.mergeToBase(agent.worktreePath, agent.branch, agent.baseBranch);
-
- if (result.success) {
- log.info("merge succeeded", { agentId: agent.id, branch: agent.branch });
- const ticket = ticketStmts.get.get(agent.ticketId);
- if (ticket) {
- ticketStmts.updateStatus.run({ $status: "done", $updatedAt: Date.now(), $id: ticket.id });
- const updatedTicket = ticketStmts.get.get(ticket.id);
- if (updatedTicket) broadcastNotification({ type: "ticket-updated", ticket: updatedTicket });
- broadcastNotification({ type: "kanban-sync", tickets: ticketStmts.list.all() });
+
+ app.post("/:id/merge", async (c) => {
+ const agent = agentStmts.get.get(c.req.param("id"));
+ if (!agent) return c.json({ error: "agent not found" }, 404);
+
+ const remoteConfig = remoteStmts.get.get();
+ if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
+
+ log.info("merge requested", {
+ agentId: agent.id,
+ branch: agent.branch,
+ baseBranch: agent.baseBranch,
+ });
+ try {
+ const git = new GitWorktreeManager(remoteConfig.localPath);
+ const result = await git.mergeToBase(agent.worktreePath, agent.branch, agent.baseBranch);
+
+ if (result.success) {
+ log.info("merge succeeded", { agentId: agent.id, branch: agent.branch });
+ const ticket = ticketStmts.get.get(agent.ticketId);
+ if (ticket) {
+ ticketStmts.updateStatus.run({ $status: "done", $updatedAt: Date.now(), $id: ticket.id });
+ const updatedTicket = ticketStmts.get.get(ticket.id);
+ if (updatedTicket)
+ broadcastNotification({ type: "ticket-updated", ticket: updatedTicket });
+ orchestrator.onTicketMoved(ticket.id, "done").catch((err) => {
+ log.error("orchestrator cleanup failed after merge", {
+ agentId: agent.id,
+ ...errorMeta(err),
+ });
+ });
+ }
+ } else if (result.conflicted) {
+ log.warn("merge aborted: rebase conflict", { agentId: agent.id, branch: agent.branch });
+ } else {
+ log.warn("merge failed", { agentId: agent.id, branch: agent.branch, error: result.error });
  }
- } else if (result.conflicted) {
- log.warn("merge aborted: rebase conflict", { agentId: agent.id, branch: agent.branch });
- } else {
- log.warn("merge failed", { agentId: agent.id, branch: agent.branch, error: result.error });
+
+ return c.json(result);
+ } catch (err) {
+ log.error("merge threw unexpected error", {
+ agentId: agent.id,
+ branch: agent.branch,
+ ...errorMeta(err),
+ });
+ return c.json({ success: false, conflicted: false, error: (err as Error).message }, 500);
  }
+ });
+
+ app.post("/:id/commit", async (c) => {
+ const agent = agentStmts.get.get(c.req.param("id"));
+ if (!agent) return c.json({ error: "agent not found" }, 404);
+
+ const remoteConfig = remoteStmts.get.get();
+ if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
+
+ const body = await c.req.json<{ message?: string }>().catch(() => ({ message: undefined }));
+ const message = body.message?.trim() || "chore: commit agent changes";
+
+ log.info("commit requested", { agentId: agent.id, message });
+ try {
+ const git = new GitWorktreeManager(remoteConfig.localPath);
+ await git.commitWorktree(agent.worktreePath, message);
+ log.info("commit succeeded", { agentId: agent.id });
+ return c.json({ ok: true });
+ } catch (err) {
+ log.error("commit failed", { agentId: agent.id, ...errorMeta(err) });
+ return c.json({ error: (err as Error).message }, 500);
+ }
+ });
 
- return c.json(result);
- } catch (err) {
- log.error("merge threw unexpected error", {
+ app.post("/:id/rebase", async (c) => {
+ const agent = agentStmts.get.get(c.req.param("id"));
+ if (!agent) return c.json({ error: "agent not found" }, 404);
+
+ const remoteConfig = remoteStmts.get.get();
+ if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
+
+ const abortOnConflict = agent.status !== "running";
+ log.info("rebase requested", {
  agentId: agent.id,
-branch: agent.branch,
-...errorMeta(err),
+baseBranch: agent.baseBranch,
+abortOnConflict,
  });
- return c.json({ success: false, conflicted: false, error: (err as Error).message }, 500);
- }
-});
-
-agentsRouter.post("/:id/commit", async (c) => {
- const agent = agentStmts.get.get(c.req.param("id"));
- if (!agent) return c.json({ error: "agent not found" }, 404);
-
- const remoteConfig = remoteStmts.get.get();
- if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
-
- const body = await c.req.json<{ message?: string }>().catch(() => ({ message: undefined }));
- const message = body.message?.trim() || "chore: commit agent changes";
-
- log.info("commit requested", { agentId: agent.id, message });
- try {
- const git = new GitWorktreeManager(remoteConfig.localPath);
- await git.commitWorktree(agent.worktreePath, message);
- log.info("commit succeeded", { agentId: agent.id });
- return c.json({ ok: true });
- } catch (err) {
- log.error("commit failed", { agentId: agent.id, ...errorMeta(err) });
- return c.json({ error: (err as Error).message }, 500);
- }
-});
-
-agentsRouter.post("/:id/rebase", async (c) => {
- const agent = agentStmts.get.get(c.req.param("id"));
- if (!agent) return c.json({ error: "agent not found" }, 404);
-
- const remoteConfig = remoteStmts.get.get();
- if (!remoteConfig) return c.json({ error: "no remote configured" }, 400);
-
- // Only abort on conflict when the agent isn't running — if it is running,
- // leave the worktree in the conflicted state so the agent can resolve it.
- const abortOnConflict = agent.status !== "running";
- log.info("rebase requested", {
- agentId: agent.id,
- baseBranch: agent.baseBranch,
- abortOnConflict,
+ try {
+ const git = new GitWorktreeManager(remoteConfig.localPath);
+ const result = await git.rebase(agent.worktreePath, agent.baseBranch, abortOnConflict);
+ if (result.success) {
+ log.info("rebase succeeded", { agentId: agent.id });
+ } else if (result.conflicted) {
+ log.warn("rebase conflict detected", { agentId: agent.id, abortOnConflict });
+ }
+ return c.json(result);
+ } catch (err) {
+ log.error("rebase threw unexpected error", { agentId: agent.id, ...errorMeta(err) });
+ return c.json({ success: false, conflicted: false, error: (err as Error).message }, 500);
+ }
+ });
+
+ app.post("/:id/kill", (c) => {
+ const id = c.req.param("id");
+ const agent = agentStmts.get.get(id);
+ if (!agent) return c.json({ error: "agent not found" }, 404);
+
+ log.info("killing agent", { agentId: id });
+ agentProcessManager.kill(id);
+ agentStmts.updateStatus.run({ $id: id, $status: "error", $endedAt: Date.now() });
+ return c.body(null, 204);
  });
- try {
- const git = new GitWorktreeManager(remoteConfig.localPath);
- const result = await git.rebase(agent.worktreePath, agent.baseBranch, abortOnConflict);
- if (result.success) {
- log.info("rebase succeeded", { agentId: agent.id });
- } else if (result.conflicted) {
- log.warn("rebase conflict detected", { agentId: agent.id, abortOnConflict });
+
+ app.post("/:id/restart", async (c) => {
+ const id = c.req.param("id");
+ const agent = agentStmts.get.get(id);
+ if (!agent) return c.json({ error: "agent not found" }, 404);
+
+ log.info("restarting agent", { agentId: id });
+ await agentProcessManager.killAndWait(id);
+ await orchestrator.resumeAgent(agent);
+ return c.body(null, 204);
+ });
+
+ app.post("/:id/input", async (c) => {
+ const id = c.req.param("id");
+ let body: { input?: string };
+ try {
+ body = await c.req.json<{ input?: string }>();
+ } catch {
+ return c.json({ error: "invalid JSON" }, 400);
  }
- return c.json(result);
- } catch (err) {
- log.error("rebase threw unexpected error", { agentId: agent.id, ...errorMeta(err) });
- return c.json({ success: false, conflicted: false, error: (err as Error).message }, 500);
- }
-});
-
-agentsRouter.post("/:id/kill", (c) => {
- const id = c.req.param("id");
- const agent = agentStmts.get.get(id);
- if (!agent) return c.json({ error: "agent not found" }, 404);
-
- log.info("killing agent", { agentId: id });
- agentProcessManager.kill(id);
- agentStmts.updateStatus.run({ $id: id, $status: "error", $endedAt: Date.now() });
- return c.body(null, 204);
-});
-
-agentsRouter.post("/:id/input", async (c) => {
- const id = c.req.param("id");
- const body = await c.req.json<{ input?: string }>();
- if (!body.input) return c.json({ error: "input is required" }, 400);
-
- try {
- agentProcessManager.write(id, body.input);
- return c.json({ ok: true });
- } catch (err) {
- log.error("failed to write input to agent", { agentId: id, ...errorMeta(err) });
- return c.json({ error: (err as Error).message }, 500);
- }
-});
+ if (!body.input) return c.json({ error: "input is required" }, 400);
+
+ try {
+ agentProcessManager.write(id, body.input);
+ return c.json({ ok: true });
+ } catch (err) {
+ log.error("failed to write input to agent", { agentId: id, ...errorMeta(err) });
+ return c.json({ error: (err as Error).message }, 500);
+ }
+ });
+
+ return app;
+}

src/backend/routes/tickets.ts

@@ -89,9 +89,6 @@ export function ticketsRouter(orchestrator: OrchestratorService) {
 
  const ticket = ticketStmts.get.get(id);
  if (!ticket) return c.json({ error: "ticket not found" }, 404);
- if (ticket.status !== "in-progress") {
- return c.json({ error: "ticket must be in-progress to spawn an agent" }, 400);
- }
  if (ticket.agentId && agentProcessManager.isRunning(ticket.agentId)) {
  return c.json({ error: "agent already running for this ticket" }, 409);
  }

src/backend/services/AgentProcessManager.ts

@@ -8,6 +8,7 @@ export interface AgentProcess {
  id: string;
  proc: ReturnType<typeof Bun.spawn>;
  emitter: EventEmitter;
+ terminating: boolean;
 }
 
 const processes = new Map<string, AgentProcess>();
@@ -66,14 +67,20 @@ export class AgentProcessManager {
 
  agentStmts.updatePid.run({ $pid: proc.pid, $id: agentId });
 
- const ap: AgentProcess = { id: agentId, proc, emitter };
+ const ap: AgentProcess = { id: agentId, proc, emitter, terminating: false };
  processes.set(agentId, ap);
  return ap;
  }
 
  write(agentId: string, input: string | Buffer): void {
  const ap = processes.get(agentId);
- if (!ap) throw new Error(`No process for agent ${agentId}`);
+ if (!ap || ap.terminating) throw new Error(`No process for agent ${agentId}`);
+ ap.proc.terminal!.write(input);
+ }
+
+ tryWrite(agentId: string, input: string | Buffer): void {
+ const ap = processes.get(agentId);
+ if (!ap || ap.terminating) return;
  ap.proc.terminal!.write(input);
  }
 
@@ -84,6 +91,18 @@ export class AgentProcessManager {
  processes.delete(agentId);
  }
 
+ async killAndWait(agentId: string): Promise<void> {
+ const ap = processes.get(agentId);
+ if (!ap) return;
+ ap.terminating = true;
+ ap.proc.kill();
+ await ap.proc.exited;
+ // proc.exited.then() registered in spawn() runs first (registered earlier),
+ // so the DB update, onExit callback, and processes.delete() all complete
+ // before this line; the delete here is a safe no-op guard.
+ processes.delete(agentId);
+ }
+
  subscribe(agentId: string): EventEmitter | null {
  return processes.get(agentId)?.emitter ?? null;
  }
@@ -96,6 +115,11 @@ export class AgentProcessManager {
  return processes.has(agentId);
  }
 
+ isAcceptingInput(agentId: string): boolean {
+ const ap = processes.get(agentId);
+ return ap !== undefined && !ap.terminating;
+ }
+
  listRunning(): string[] {
  return [...processes.keys()];
  }