airaknit 1.1.2-rc.9

package/src/server/update-manager.ts

@@ -0,0 +1,230 @@
+import type { UpdateInstallResult, UpdateSnapshot } from "../shared/types"
+import { APP_NAME, PACKAGE_NAME } from "../shared/branding"
+import { compareVersions, type UpdateInstallAttemptResult } from "./cli-runtime"
+
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000
+
+export interface UpdateManagerDeps {
+  currentVersion: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  devMode?: boolean
+}
+
+export class UpdateManager {
+  private readonly deps: UpdateManagerDeps
+  private readonly listeners = new Set<(snapshot: UpdateSnapshot) => void>()
+  private snapshot: UpdateSnapshot
+  private checkPromise: Promise<UpdateSnapshot> | null = null
+  private installPromise: Promise<UpdateInstallResult> | null = null
+
+  constructor(deps: UpdateManagerDeps) {
+    this.deps = deps
+    this.snapshot = {
+      currentVersion: deps.currentVersion,
+      latestVersion: deps.devMode ? `${deps.currentVersion}-dev` : null,
+      status: deps.devMode ? "available" : "idle",
+      updateAvailable: Boolean(deps.devMode),
+      lastCheckedAt: deps.devMode ? Date.now() : null,
+      error: null,
+      installAction: "restart",
+    }
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: UpdateSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async checkForUpdates(options: { force?: boolean } = {}) {
+    if (this.deps.devMode) {
+      return this.snapshot
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return this.snapshot
+    }
+
+    if (this.checkPromise) {
+      return this.checkPromise
+    }
+
+    if (!options.force && this.snapshot.lastCheckedAt && Date.now() - this.snapshot.lastCheckedAt < UPDATE_CACHE_TTL_MS) {
+      return this.snapshot
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "checking",
+      error: null,
+    })
+
+    const checkPromise = this.runCheck()
+    this.checkPromise = checkPromise
+
+    try {
+      return await checkPromise
+    } finally {
+      if (this.checkPromise === checkPromise) {
+        this.checkPromise = null
+      }
+    }
+  }
+
+  async installUpdate(): Promise<UpdateInstallResult> {
+    if (this.deps.devMode) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "updating",
+        error: null,
+      })
+
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "restart_pending",
+        updateAvailable: false,
+        error: null,
+      })
+
+      return {
+        ok: true,
+        action: "restart",
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return {
+        ok: this.snapshot.updateAvailable,
+        action: "restart",
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }
+    }
+
+    if (this.installPromise) {
+      return this.installPromise
+    }
+
+    const installPromise = this.runInstall()
+    this.installPromise = installPromise
+
+    try {
+      return await installPromise
+    } finally {
+      if (this.installPromise === installPromise) {
+        this.installPromise = null
+      }
+    }
+  }
+
+  private async runCheck() {
+    try {
+      const latestVersion = await this.deps.fetchLatestVersion(PACKAGE_NAME)
+      const updateAvailable = compareVersions(this.snapshot.currentVersion, latestVersion) < 0
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        latestVersion,
+        updateAvailable,
+        status: updateAvailable ? "available" : "up_to_date",
+        lastCheckedAt: Date.now(),
+        error: null,
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    } catch (error) {
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        status: "error",
+        lastCheckedAt: Date.now(),
+        error: error instanceof Error ? error.message : String(error),
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    }
+  }
+
+  private async runInstall(): Promise<UpdateInstallResult> {
+    if (!this.snapshot.updateAvailable) {
+      const snapshot = await this.checkForUpdates({ force: true })
+      if (!snapshot.updateAvailable) {
+        return {
+          ok: false,
+          action: "restart",
+          errorCode: null,
+          userTitle: null,
+          userMessage: null,
+        }
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "updating",
+      error: null,
+    })
+
+    const targetVersion = this.snapshot.latestVersion
+    if (!targetVersion) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: "Unable to determine which version to install.",
+      })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: "install_failed",
+        userTitle: "Update failed",
+        userMessage: `${APP_NAME} could not determine which version to install.`,
+      }
+    }
+
+    const installed = this.deps.installVersion(PACKAGE_NAME, targetVersion)
+    if (!installed.ok) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: installed.userMessage ?? "Unable to install the latest version.",
+      })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: installed.errorCode,
+        userTitle: installed.userTitle,
+        userMessage: installed.userMessage,
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      currentVersion: this.snapshot.latestVersion ?? this.snapshot.currentVersion,
+      status: "restart_pending",
+      updateAvailable: false,
+      error: null,
+    })
+    return {
+      ok: true,
+      action: "restart",
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    }
+  }
+
+  private setSnapshot(snapshot: UpdateSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+}

package/src/server/workflow-engine.test.ts

@@ -0,0 +1,251 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import type { WorkflowDefinition } from "../shared/workflow-types"
+import { WorkflowEngine, type McpDispatcher, type WorkflowEventEmitter } from "./workflow-engine"
+
+function makeDef(overrides?: Partial<WorkflowDefinition>): WorkflowDefinition {
+  return {
+    id: "test-workflow",
+    name: "Test Workflow",
+    trigger: "manual",
+    target: "all",
+    steps: [
+      { mcp_tool: "tool_a", params: { key: "val" } },
+      { mcp_tool: "tool_b", params: {} },
+    ],
+    on_failure: "stop",
+    ...overrides,
+  }
+}
+
+function makeEmitter(): WorkflowEventEmitter & { calls: Array<{ method: string; args: unknown[] }> } {
+  const calls: Array<{ method: string; args: unknown[] }> = []
+  const handler = (method: string) =>
+    async (...args: unknown[]) => {
+      calls.push({ method, args })
+    }
+  return {
+    calls,
+    emitWorkflowStarted: handler("emitWorkflowStarted") as WorkflowEventEmitter["emitWorkflowStarted"],
+    emitWorkflowStepStarted: handler("emitWorkflowStepStarted") as WorkflowEventEmitter["emitWorkflowStepStarted"],
+    emitWorkflowStepCompleted: handler("emitWorkflowStepCompleted") as WorkflowEventEmitter["emitWorkflowStepCompleted"],
+    emitWorkflowStepFailed: handler("emitWorkflowStepFailed") as WorkflowEventEmitter["emitWorkflowStepFailed"],
+    emitWorkflowCompleted: handler("emitWorkflowCompleted") as WorkflowEventEmitter["emitWorkflowCompleted"],
+    emitWorkflowFailed: handler("emitWorkflowFailed") as WorkflowEventEmitter["emitWorkflowFailed"],
+    emitWorkflowCancelled: handler("emitWorkflowCancelled") as WorkflowEventEmitter["emitWorkflowCancelled"],
+  }
+}
+
+function makeDispatcher(fn?: (tool: string, params: Record<string, unknown>) => Promise<string>): McpDispatcher {
+  return {
+    dispatch: fn ?? (async () => "ok"),
+  }
+}
+
+describe("WorkflowEngine", () => {
+  let engine: WorkflowEngine
+
+  afterEach(() => {
+    engine = undefined as unknown as WorkflowEngine
+  })
+
+  test("successful 2-step run emits correct event sequence", async () => {
+    const emitter = makeEmitter()
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    const runId = await engine.run("wf-1", "ws-1", makeDef(), "user-1")
+
+    expect(typeof runId).toBe("string")
+    expect(runId.length).toBeGreaterThan(0)
+
+    const methods = emitter.calls.map((c: { method: string; args: unknown[] }) => c.method)
+    expect(methods).toEqual([
+      "emitWorkflowStarted",
+      "emitWorkflowStepStarted",
+      "emitWorkflowStepCompleted",
+      "emitWorkflowStepStarted",
+      "emitWorkflowStepCompleted",
+      "emitWorkflowCompleted",
+    ])
+  })
+
+  test("on_failure: stop — halts on first failure", async () => {
+    const emitter = makeEmitter()
+    const dispatched: string[] = []
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool) => {
+        dispatched.push(tool)
+        if (tool === "tool_b") throw new Error("boom")
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    await engine.run("wf-1", "ws-1", makeDef({ on_failure: "stop" }), "user-1")
+
+    const methods = emitter.calls.map((c: { method: string; args: unknown[] }) => c.method)
+    expect(methods).toContain("emitWorkflowStepFailed")
+    expect(methods).toContain("emitWorkflowFailed")
+    expect(methods).not.toContain("emitWorkflowCompleted")
+    // tool_b was attempted but failed; no further steps
+    expect(dispatched).toEqual(["tool_a", "tool_b"])
+  })
+
+  test("on_failure: continue — proceeds after failure", async () => {
+    const emitter = makeEmitter()
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool) => {
+        if (tool === "tool_a") throw new Error("fail-a")
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    await engine.run("wf-1", "ws-1", makeDef({ on_failure: "continue" }), "user-1")
+
+    const methods = emitter.calls.map((c: { method: string; args: unknown[] }) => c.method)
+    expect(methods).toContain("emitWorkflowStepFailed")
+    expect(methods).toContain("emitWorkflowStepCompleted")
+    expect(methods).toContain("emitWorkflowCompleted")
+    expect(methods).not.toContain("emitWorkflowFailed")
+  })
+
+  test("on_failure: rollback — re-dispatches previous steps with _rollback", async () => {
+    const emitter = makeEmitter()
+    const dispatched: Array<{ tool: string; params: Record<string, unknown> }> = []
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool, params) => {
+        dispatched.push({ tool, params })
+        if (tool === "tool_b" && !params._rollback) throw new Error("fail-b")
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    await engine.run("wf-1", "ws-1", makeDef({ on_failure: "rollback" }), "user-1")
+
+    // After tool_b fails, tool_a should be re-dispatched with _rollback: true
+    const rollbackCalls = dispatched.filter((d) => d.params._rollback === true)
+    expect(rollbackCalls.length).toBe(1)
+    expect(rollbackCalls[0].tool).toBe("tool_a")
+
+    const methods = emitter.calls.map((c: { method: string; args: unknown[] }) => c.method)
+    expect(methods).toContain("emitWorkflowStepFailed")
+    expect(methods).toContain("emitWorkflowFailed")
+    expect(methods).not.toContain("emitWorkflowCompleted")
+  })
+
+  test("cancel() aborts a running workflow", async () => {
+    const emitter = makeEmitter()
+    let resolveStep: (() => void) | undefined
+    const stepPromise = new Promise<void>((r) => {
+      resolveStep = r
+    })
+
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool) => {
+        if (tool === "tool_a") {
+          await stepPromise
+        }
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    const def = makeDef()
+    const runPromise = engine.run("wf-1", "ws-1", def, "user-1")
+
+    // Wait for step_started to be emitted
+    await new Promise((r) => setTimeout(r, 10))
+
+    expect(engine.isRunning(runPromise as unknown as string)).toBe(false) // runId not returned yet
+    // Cancel using the emitted runId
+    const startedCall = emitter.calls.find((c: { method: string; args: unknown[] }) => c.method === "emitWorkflowStarted")
+    expect(startedCall).toBeDefined()
+    const runId = startedCall!.args[0] as string
+
+    expect(engine.isRunning(runId)).toBe(true)
+    await engine.cancel(runId, "ws-1")
+
+    // Unblock the step so the run can finish
+    resolveStep!()
+    await runPromise
+
+    const methods = emitter.calls.map((c: { method: string; args: unknown[] }) => c.method)
+    expect(methods).toContain("emitWorkflowCancelled")
+  })
+
+  test("target: all — dispatches each step per repo", async () => {
+    const emitter = makeEmitter()
+    const dispatched: Array<{ tool: string; params: Record<string, unknown> }> = []
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool, params) => {
+        dispatched.push({ tool, params })
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1", "repo-2"],
+    })
+
+    await engine.run("wf-1", "ws-1", makeDef({ target: "all" }), "user-1")
+
+    // Each step dispatched once per repo
+    const toolACalls = dispatched.filter((d) => d.tool === "tool_a")
+    expect(toolACalls.length).toBe(2)
+    expect(toolACalls.map((c) => c.params.repoId)).toEqual(["repo-1", "repo-2"])
+
+    // Events include repoId
+    const stepStarted = emitter.calls.filter((c: { method: string; args: unknown[] }) => c.method === "emitWorkflowStepStarted")
+    expect(stepStarted.length).toBe(4) // 2 steps × 2 repos
+  })
+
+  test("target: specific repoId — dispatches with that single repoId", async () => {
+    const emitter = makeEmitter()
+    const dispatched: Array<{ tool: string; params: Record<string, unknown> }> = []
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async (tool, params) => {
+        dispatched.push({ tool, params })
+        return "ok"
+      }),
+      resolveRepos: async () => {
+        throw new Error("should not be called")
+      },
+    })
+
+    await engine.run("wf-1", "ws-1", makeDef({ target: "my-repo" }), "user-1")
+
+    expect(dispatched.every((d) => d.params.repoId === "my-repo")).toBe(true)
+    expect(dispatched.length).toBe(2)
+  })
+
+  test("isRunning() returns true during run, false after", async () => {
+    const emitter = makeEmitter()
+    let capturedRunning = false
+
+    engine = new WorkflowEngine({
+      emitter,
+      dispatcher: makeDispatcher(async () => {
+        // Check isRunning mid-execution
+        const startCall = emitter.calls.find((c: { method: string; args: unknown[] }) => c.method === "emitWorkflowStarted")
+        if (startCall) {
+          capturedRunning = engine.isRunning(startCall.args[0] as string)
+        }
+        return "ok"
+      }),
+      resolveRepos: async () => ["repo-1"],
+    })
+
+    const runId = await engine.run("wf-1", "ws-1", makeDef(), "user-1")
+
+    expect(capturedRunning).toBe(true)
+    expect(engine.isRunning(runId)).toBe(false)
+  })
+})

package/src/server/workflow-engine.ts

@@ -0,0 +1,169 @@
+import { LOG_PREFIX } from "../shared/branding"
+import type { WorkflowDefinition } from "../shared/workflow-types"
+
+export interface McpDispatcher {
+  dispatch(tool: string, params: Record<string, unknown>): Promise<string>
+}
+
+export interface WorkflowEventEmitter {
+  emitWorkflowStarted(runId: string, workflowId: string, workspaceId: string, targetRepoIds: string[], triggeredBy: string): Promise<void>
+  emitWorkflowStepStarted(runId: string, workspaceId: string, stepIndex: number, mcpTool: string, repoId?: string): Promise<void>
+  emitWorkflowStepCompleted(runId: string, workspaceId: string, stepIndex: number, output: string, repoId?: string): Promise<void>
+  emitWorkflowStepFailed(runId: string, workspaceId: string, stepIndex: number, error: string, repoId?: string): Promise<void>
+  emitWorkflowCompleted(runId: string, workspaceId: string): Promise<void>
+  emitWorkflowFailed(runId: string, workspaceId: string, error: string, failedStep: number): Promise<void>
+  emitWorkflowCancelled(runId: string, workspaceId: string): Promise<void>
+}
+
+export interface WorkflowEngineOptions {
+  emitter: WorkflowEventEmitter
+  dispatcher: McpDispatcher
+  resolveRepos(workspaceId: string): Promise<string[]>
+  onProgress?: () => void
+}
+
+export class WorkflowEngine {
+  private readonly activeRuns = new Map<string, AbortController>()
+
+  constructor(private readonly opts: WorkflowEngineOptions) {}
+
+  /**
+   * Start a workflow run. Returns the runId immediately after emitting
+   * workflow_started. Step execution continues in the background.
+   */
+  async start(
+    workflowId: string,
+    workspaceId: string,
+    definition: WorkflowDefinition,
+    triggeredBy: string,
+  ): Promise<string> {
+    const runId = crypto.randomUUID()
+    const controller = new AbortController()
+    this.activeRuns.set(runId, controller)
+
+    const targetRepoIds =
+      definition.target === "all"
+        ? await this.opts.resolveRepos(workspaceId)
+        : [definition.target]
+
+    await this.opts.emitter.emitWorkflowStarted(runId, workflowId, workspaceId, targetRepoIds, triggeredBy)
+    this.opts.onProgress?.()
+
+    // Execute steps in background
+    this.executeSteps(runId, workspaceId, definition, targetRepoIds, controller).catch((err: unknown) => {
+      console.warn(LOG_PREFIX, `workflow ${runId} failed unexpectedly: ${err instanceof Error ? err.message : String(err)}`)
+    })
+
+    return runId
+  }
+
+  /**
+   * Run a workflow synchronously (all steps awaited). Used in tests.
+   */
+  async run(
+    workflowId: string,
+    workspaceId: string,
+    definition: WorkflowDefinition,
+    triggeredBy: string,
+  ): Promise<string> {
+    const runId = crypto.randomUUID()
+    const controller = new AbortController()
+    this.activeRuns.set(runId, controller)
+
+    const targetRepoIds =
+      definition.target === "all"
+        ? await this.opts.resolveRepos(workspaceId)
+        : [definition.target]
+
+    await this.opts.emitter.emitWorkflowStarted(runId, workflowId, workspaceId, targetRepoIds, triggeredBy)
+
+    await this.executeSteps(runId, workspaceId, definition, targetRepoIds, controller)
+
+    return runId
+  }
+
+  private async executeSteps(
+    runId: string,
+    workspaceId: string,
+    definition: WorkflowDefinition,
+    targetRepoIds: string[],
+    controller: AbortController,
+  ): Promise<void> {
+    const repos = targetRepoIds.length > 0 ? targetRepoIds : [undefined]
+
+    try {
+      for (let stepIdx = 0; stepIdx < definition.steps.length; stepIdx++) {
+        if (controller.signal.aborted) break
+
+        const step = definition.steps[stepIdx]
+
+        for (const repoId of repos) {
+          if (controller.signal.aborted) break
+
+          await this.opts.emitter.emitWorkflowStepStarted(runId, workspaceId, stepIdx, step.mcp_tool, repoId)
+          this.opts.onProgress?.()
+
+          try {
+            const params: Record<string, unknown> = { ...step.params, ...(repoId ? { repoId } : {}) }
+            const output = await this.opts.dispatcher.dispatch(step.mcp_tool, params)
+            await this.opts.emitter.emitWorkflowStepCompleted(runId, workspaceId, stepIdx, output, repoId)
+            this.opts.onProgress?.()
+          } catch (err: unknown) {
+            const errorMsg = err instanceof Error ? err.message : String(err)
+            await this.opts.emitter.emitWorkflowStepFailed(runId, workspaceId, stepIdx, errorMsg, repoId)
+            this.opts.onProgress?.()
+
+            if (definition.on_failure === "stop") {
+              await this.opts.emitter.emitWorkflowFailed(runId, workspaceId, errorMsg, stepIdx)
+              this.opts.onProgress?.()
+              return
+            }
+
+            if (definition.on_failure === "rollback") {
+              for (let rb = stepIdx - 1; rb >= 0; rb--) {
+                const rbStep = definition.steps[rb]
+                for (const rbRepo of repos) {
+                  const rbParams: Record<string, unknown> = {
+                    ...rbStep.params,
+                    ...(rbRepo ? { repoId: rbRepo } : {}),
+                    _rollback: true,
+                  }
+                  try {
+                    await this.opts.dispatcher.dispatch(rbStep.mcp_tool, rbParams)
+                  } catch {
+                    // Best-effort rollback — ignore errors
+                  }
+                }
+              }
+              await this.opts.emitter.emitWorkflowFailed(runId, workspaceId, errorMsg, stepIdx)
+              this.opts.onProgress?.()
+              return
+            }
+
+            // on_failure === "continue": proceed
+          }
+        }
+      }
+
+      if (!controller.signal.aborted) {
+        await this.opts.emitter.emitWorkflowCompleted(runId, workspaceId)
+        this.opts.onProgress?.()
+      }
+    } finally {
+      this.activeRuns.delete(runId)
+    }
+  }
+
+  async cancel(runId: string, workspaceId: string): Promise<void> {
+    const controller = this.activeRuns.get(runId)
+    if (!controller) return
+    controller.abort()
+    this.activeRuns.delete(runId)
+    await this.opts.emitter.emitWorkflowCancelled(runId, workspaceId)
+    this.opts.onProgress?.()
+  }
+
+  isRunning(runId: string): boolean {
+    return this.activeRuns.has(runId)
+  }
+}

package/src/server/workflow-mcp.ts

@@ -0,0 +1,49 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk"
+import { z } from "zod/v4"
+import type { WorkflowEngine } from "./workflow-engine"
+import type { WorkflowStore } from "./workflow-store"
+
+function json(data: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(data) }] }
+}
+
+export function createWorkflowMcpServer(engine: WorkflowEngine, store: WorkflowStore) {
+  return createSdkMcpServer({
+    name: "workflow",
+    tools: [
+      tool(
+        "workflow_list",
+        "List available workflows in this workspace",
+        { workspaceId: z.string() },
+        async () => json(await store.list()),
+      ),
+      tool(
+        "workflow_run",
+        "Execute a workflow by ID",
+        {
+          workspaceId: z.string(),
+          workflowId: z.string(),
+          triggeredBy: z.string().optional(),
+        },
+        async (args) => {
+          const def = await store.get(args.workflowId)
+          if (!def) return json({ error: "workflow not found" })
+          const runId = await engine.start(args.workflowId, args.workspaceId, def, args.triggeredBy ?? "agent")
+          return json({ runId })
+        },
+      ),
+      tool(
+        "workflow_cancel",
+        "Cancel an active workflow run",
+        {
+          workspaceId: z.string(),
+          runId: z.string(),
+        },
+        async (args) => {
+          await engine.cancel(args.runId, args.workspaceId)
+          return json({ ok: true })
+        },
+      ),
+    ],
+  })
+}