@desplega.ai/agent-swarm 1.0.2 → 1.2.0

package/deploy/install.ts

@@ -7,10 +7,14 @@ const SERVICE_FILE = "/etc/systemd/system/agent-swarm.service";
 const SCRIPT_DIR = import.meta.dir;
 const PROJECT_DIR = `${SCRIPT_DIR}/..`;
 
+// Detect bun path
+const bunPath = (await $`which bun`.text()).trim();
+console.log(`Using bun at: ${bunPath}`);
+
 // Copy project files
 await $`mkdir -p ${APP_DIR}`;
 await $`cp -r ${PROJECT_DIR}/src ${APP_DIR}/`;
-await $`cp ${PROJECT_DIR}/package.json ${PROJECT_DIR}/bun.lock ${APP_DIR}/`;
+await $`cp ${PROJECT_DIR}/package.json ${PROJECT_DIR}/bun.lock ${PROJECT_DIR}/tsconfig.json ${APP_DIR}/`;
 
 // Install dependencies
 await $`cd ${APP_DIR} && bun install --frozen-lockfile --production`;
@@ -25,11 +29,57 @@ API_KEY=
 }
 
 // Set ownership
-await $`chown -R www-data:www-data ${APP_DIR}`;
+await $`chown -R root:root ${APP_DIR}`;
+
+// Install systemd service with detected bun path
+const serviceContent = `[Unit]
+Description=Agent Swarm MCP Server
+After=network.target
+
+[Service]
+Type=simple
+User=root
+Group=root
+WorkingDirectory=${APP_DIR}
+ExecStart=${bunPath} run start:http
+ExecStartPost=/bin/sh -c 'sleep 2 && curl -sf http://localhost:3013/health || exit 1'
+Restart=always
+RestartSec=5
+EnvironmentFile=${APP_DIR}/.env
+
+[Install]
+WantedBy=multi-user.target
+`;
+
+await Bun.write(SERVICE_FILE, serviceContent);
+
+// Healthcheck service (runs curl, restarts main service on failure)
+const healthcheckService = `[Unit]
+Description=Agent Swarm Health Check
+
+[Service]
+Type=oneshot
+ExecStart=/bin/sh -c 'curl -sf http://localhost:3013/health || systemctl restart agent-swarm'
+`;
+
+// Timer to run healthcheck every 30 seconds
+const healthcheckTimer = `[Unit]
+Description=Agent Swarm Health Check Timer
+
+[Timer]
+OnBootSec=30s
+OnUnitActiveSec=30s
+
+[Install]
+WantedBy=timers.target
+`;
+
+await Bun.write("/etc/systemd/system/agent-swarm-healthcheck.service", healthcheckService);
+await Bun.write("/etc/systemd/system/agent-swarm-healthcheck.timer", healthcheckTimer);
 
-// Install systemd service
-await $`cp ${SCRIPT_DIR}/agent-swarm.service ${SERVICE_FILE}`;
 await $`systemctl daemon-reload`;
-await $`systemctl enable agent-swarm`;
+await $`systemctl enable agent-swarm agent-swarm-healthcheck.timer`;
+await $`systemctl restart agent-swarm`;
+await $`systemctl start agent-swarm-healthcheck.timer`;
 
-console.log("Installed. Edit /opt/agent-swarm/.env then run: systemctl start agent-swarm");
+console.log("Installed and running with health checks every 30s.");

package/deploy/prod-db.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+import * as readline from "node:readline";
+
+const DB_PATH = "/opt/agent-swarm/agent-swarm-db.sqlite";
+const SSH_HOST = process.argv[2] || "hetzner";
+
+console.log(`Connected to ${SSH_HOST}:${DB_PATH}`);
+console.log("Type SQL queries or .tables, .schema, etc. Ctrl+C to exit.\n");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: "sqlite> ",
+});
+
+rl.prompt();
+
+rl.on("line", async (line) => {
+  const query = line.trim();
+  if (!query) {
+    rl.prompt();
+    return;
+  }
+
+  try {
+    // Escape single quotes in query and wrap in single quotes for remote shell
+    const escaped = query.replace(/'/g, "'\\''");
+    const result = await $`ssh ${SSH_HOST} sqlite3 -header -column ${DB_PATH} ${"'" + escaped + "'"}`.text();
+    if (result) console.log(result);
+  } catch (e: any) {
+    console.error(e.stderr?.toString() || e.message);
+  }
+
+  rl.prompt();
+});
+
+rl.on("close", () => {
+  console.log("\nBye!");
+  process.exit(0);
+});

package/deploy/uninstall.ts

@@ -2,9 +2,11 @@
 
 import { $ } from "bun";
 
-await $`systemctl stop agent-swarm`.nothrow();
-await $`systemctl disable agent-swarm`.nothrow();
+await $`systemctl stop agent-swarm agent-swarm-healthcheck.timer`.nothrow();
+await $`systemctl disable agent-swarm agent-swarm-healthcheck.timer`.nothrow();
 await $`rm -f /etc/systemd/system/agent-swarm.service`;
+await $`rm -f /etc/systemd/system/agent-swarm-healthcheck.service`;
+await $`rm -f /etc/systemd/system/agent-swarm-healthcheck.timer`;
 await $`systemctl daemon-reload`;
 
 console.log("Service removed. Data remains at /opt/agent-swarm");

package/deploy/update.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun";
+
+const APP_DIR = "/opt/agent-swarm";
+const SCRIPT_DIR = import.meta.dir;
+const PROJECT_DIR = `${SCRIPT_DIR}/..`;
+
+console.log("Updating agent-swarm...");
+
+// Copy project files
+await $`cp -r ${PROJECT_DIR}/src ${APP_DIR}/`;
+await $`cp ${PROJECT_DIR}/package.json ${PROJECT_DIR}/bun.lock ${PROJECT_DIR}/tsconfig.json ${APP_DIR}/`;
+
+// Install dependencies
+await $`cd ${APP_DIR} && bun install --frozen-lockfile --production`;
+
+// Restart service
+await $`systemctl restart agent-swarm`;
+
+console.log("Updated and restarted.");

package/docker-compose.worker.yml

@@ -0,0 +1,35 @@
+# Docker Compose for Agent Swarm Worker
+#
+# Usage:
+#   docker-compose -f docker-compose.worker.yml up --build
+#
+# Required environment variables (in .env.docker or passed directly):
+#   - CLAUDE_CODE_OAUTH_TOKEN: OAuth token for Claude CLI
+#   - API_KEY: API key for MCP server authentication
+#
+# Optional environment variables:
+#   - AGENT_ID: UUID for agent identification (assigned on join if not set)
+#   - MCP_BASE_URL: MCP server URL (default: http://host.docker.internal:3013)
+#   - SESSION_ID: Folder name for logs (auto-generated if not provided)
+#   - WORKER_YOLO: If "true", continue on errors (default: false)
+
+services:
+  worker:
+    build:
+      context: .
+      dockerfile: Dockerfile.worker
+    environment:
+      - CLAUDE_CODE_OAUTH_TOKEN=${CLAUDE_CODE_OAUTH_TOKEN}
+      - API_KEY=${API_KEY}
+      - AGENT_ID=${AGENT_ID:-}
+      # Use host.docker.internal to reach host's localhost on Mac/Windows
+      # On Linux, use --add-host=host.docker.internal:host-gateway or --network host
+      - MCP_BASE_URL=${MCP_BASE_URL:-http://host.docker.internal:3013}
+      - SESSION_ID=${SESSION_ID:-}
+      - WORKER_YOLO=${WORKER_YOLO:-false}
+    volumes:
+      - ./logs:/logs
+      # Optional: mount a workspace directory for persistent work
+      # - ./workspace:/workspace
+    restart: unless-stopped
+    # No port mappings needed - worker only makes outbound connections

package/docker-entrypoint.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+set -e
+
+# Validate required environment variables
+if [ -z "$CLAUDE_CODE_OAUTH_TOKEN" ]; then
+    echo "Error: CLAUDE_CODE_OAUTH_TOKEN environment variable is required"
+    exit 1
+fi
+
+if [ -z "$API_KEY" ]; then
+    echo "Error: API_KEY environment variable is required"
+    exit 1
+fi
+
+MCP_URL="${MCP_BASE_URL:-http://host.docker.internal:3013}"
+
+echo "=== Agent Swarm Worker ==="
+echo "Agent ID: ${AGENT_ID:-<not set>}"
+echo "MCP Base URL: $MCP_URL"
+echo "YOLO Mode: ${WORKER_YOLO:-false}"
+echo "Session ID: ${SESSION_ID:-<auto-generated>}"
+echo "Working Directory: /workspace"
+echo "=========================="
+
+# Create .mcp.json in /workspace (project-level config)
+echo "Creating MCP config in /workspace..."
+if [ -n "$AGENT_ID" ]; then
+    # With AGENT_ID header
+    cat > /workspace/.mcp.json << EOF
+{
+  "mcpServers": {
+    "agent-swarm": {
+      "type": "http",
+      "url": "${MCP_URL}/mcp",
+      "headers": {
+        "Authorization": "Bearer ${API_KEY}",
+        "X-Agent-ID": "${AGENT_ID}"
+      }
+    }
+  }
+}
+EOF
+else
+    # Without AGENT_ID header
+    cat > /workspace/.mcp.json << EOF
+{
+  "mcpServers": {
+    "agent-swarm": {
+      "type": "http",
+      "url": "${MCP_URL}/mcp",
+      "headers": {
+        "Authorization": "Bearer ${API_KEY}"
+      }
+    }
+  }
+}
+EOF
+fi
+
+# Run the worker using compiled binary
+echo "Starting worker..."
+exec /usr/local/bin/agent-swarm worker "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Agent orchestration layer MCP for Claude Code, Codex, Gemini CLI, and more!",
   "module": "src/stdio.ts",
   "type": "module",
@@ -17,6 +17,8 @@
     "hook": "bun src/hooks/hook.ts",
     "claude": "bun src/cli.tsx claude",
     "claude:headless": "bun src/cli.tsx claude --headless",
+    "worker": "bun src/cli.tsx worker",
+    "worker:yolo": "bun src/cli.tsx worker --yolo",
     "dev": "bun --hot src/stdio.ts",
     "dev:http": "bun --hot src/http.ts",
     "start": "bun src/stdio.ts",
@@ -25,7 +27,11 @@
     "inspector:http": "bunx @modelcontextprotocol/inspector --transport http http://localhost:3013/mcp",
     "lint": "biome check src",
     "lint:fix": "biome check --write src",
-    "format": "biome format --write src"
+    "format": "biome format --write src",
+    "build:binary": "bun build ./src/cli.tsx --compile --target=bun-linux-x64 --outfile ./dist/agent-swarm",
+    "build:binary:arm64": "bun build ./src/cli.tsx --compile --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
+    "docker:build:worker": "docker build -f Dockerfile.worker -t agent-swarm-worker .",
+    "docker:run:worker": "docker run --rm -it --env-file .env.docker -v ./logs:/logs agent-swarm-worker"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.9",
@@ -41,6 +47,7 @@
     "date-fns": "^4.1.0",
     "ink": "^6.5.1",
     "react": "^19.2.3",
+    "react-devtools-core": "^7.0.1",
     "zod": "^4.2.1"
   }
 }

package/src/be/db.ts

@@ -1,5 +1,13 @@
 import { Database } from "bun:sqlite";
-import type { Agent, AgentLog, AgentLogEventType, AgentStatus, AgentTask, AgentTaskStatus, AgentWithTasks } from "../types";
+import type {
+  Agent,
+  AgentLog,
+  AgentLogEventType,
+  AgentStatus,
+  AgentTask,
+  AgentTaskStatus,
+  AgentWithTasks,
+} from "../types";
 
 let db: Database | null = null;
 
@@ -141,7 +149,12 @@ export function updateAgentStatus(id: string, status: AgentStatus): Agent | null
   const row = agentQueries.updateStatus().get(status, id);
   if (row && oldAgent) {
     try {
-      createLogEntry({ eventType: "agent_status_change", agentId: id, oldValue: oldAgent.status, newValue: status });
+      createLogEntry({
+        eventType: "agent_status_change",
+        agentId: id,
+        oldValue: oldAgent.status,
+        newValue: status,
+      });
     } catch {}
   }
   return row ? rowToAgent(row) : null;
@@ -262,7 +275,13 @@ export function startTask(taskId: string): AgentTask | null {
     .get(taskId);
   if (row && oldTask) {
     try {
-      createLogEntry({ eventType: "task_status_change", taskId, agentId: row.agentId, oldValue: oldTask.status, newValue: "in_progress" });
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "in_progress",
+      });
     } catch {}
   }
   return row ? rowToAgentTask(row) : null;
@@ -308,7 +327,13 @@ export function completeTask(id: string, output?: string): AgentTask | null {
 
   if (row && oldTask) {
     try {
-      createLogEntry({ eventType: "task_status_change", taskId: id, agentId: row.agentId, oldValue: oldTask.status, newValue: "completed" });
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId: id,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "completed",
+      });
     } catch {}
   }
 
@@ -321,7 +346,14 @@ export function failTask(id: string, reason: string): AgentTask | null {
   const row = taskQueries.setFailure().get(reason, finishedAt, id);
   if (row && oldTask) {
     try {
-      createLogEntry({ eventType: "task_status_change", taskId: id, agentId: row.agentId, oldValue: oldTask.status, newValue: "failed", metadata: { reason } });
+      createLogEntry({
+        eventType: "task_status_change",
+        taskId: id,
+        agentId: row.agentId,
+        oldValue: oldTask.status,
+        newValue: "failed",
+        metadata: { reason },
+      });
     } catch {}
   }
   return row ? rowToAgentTask(row) : null;
@@ -336,7 +368,12 @@ export function updateTaskProgress(id: string, progress: string): AgentTask | nu
   const row = taskQueries.setProgress().get(progress, id);
   if (row) {
     try {
-      createLogEntry({ eventType: "task_progress", taskId: id, agentId: row.agentId, newValue: progress });
+      createLogEntry({
+        eventType: "task_progress",
+        taskId: id,
+        agentId: row.agentId,
+        newValue: progress,
+      });
     } catch {}
   }
   return row ? rowToAgentTask(row) : null;
@@ -400,7 +437,10 @@ function rowToAgentLog(row: AgentLogRow): AgentLog {
 
 export const logQueries = {
   insert: () =>
-    getDb().prepare<AgentLogRow, [string, string, string | null, string | null, string | null, string | null, string | null]>(
+    getDb().prepare<
+      AgentLogRow,
+      [string, string, string | null, string | null, string | null, string | null, string | null]
+    >(
       `INSERT INTO agent_log (id, eventType, agentId, taskId, oldValue, newValue, metadata, createdAt)
        VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
     ),
@@ -420,10 +460,7 @@ export const logQueries = {
       "SELECT * FROM agent_log WHERE eventType = ? ORDER BY createdAt DESC",
     ),
 
-  getAll: () =>
-    getDb().prepare<AgentLogRow, []>(
-      "SELECT * FROM agent_log ORDER BY createdAt DESC",
-    ),
+  getAll: () => getDb().prepare<AgentLogRow, []>("SELECT * FROM agent_log ORDER BY createdAt DESC"),
 };
 
 export function createLogEntry(entry: {
@@ -435,15 +472,17 @@ export function createLogEntry(entry: {
   metadata?: Record<string, unknown>;
 }): AgentLog {
   const id = crypto.randomUUID();
-  const row = logQueries.insert().get(
-    id,
-    entry.eventType,
-    entry.agentId ?? null,
-    entry.taskId ?? null,
-    entry.oldValue ?? null,
-    entry.newValue ?? null,
-    entry.metadata ? JSON.stringify(entry.metadata) : null,
-  );
+  const row = logQueries
+    .insert()
+    .get(
+      id,
+      entry.eventType,
+      entry.agentId ?? null,
+      entry.taskId ?? null,
+      entry.oldValue ?? null,
+      entry.newValue ?? null,
+      entry.metadata ? JSON.stringify(entry.metadata) : null,
+    );
   if (!row) throw new Error("Failed to create log entry");
   return rowToAgentLog(row);
 }
@@ -456,6 +495,15 @@ export function getLogsByTaskId(taskId: string): AgentLog[] {
   return logQueries.getByTaskId().all(taskId).map(rowToAgentLog);
 }
 
+export function getLogsByTaskIdChronological(taskId: string): AgentLog[] {
+  return getDb()
+    .prepare<AgentLogRow, [string]>(
+      "SELECT * FROM agent_log WHERE taskId = ? ORDER BY createdAt ASC",
+    )
+    .all(taskId)
+    .map(rowToAgentLog);
+}
+
 export function getAllLogs(limit?: number): AgentLog[] {
   if (limit) {
     return getDb()

package/src/cli.tsx

@@ -6,6 +6,7 @@ import pkg from "../package.json";
 import { runClaude } from "./claude.ts";
 import { runHook } from "./commands/hook.ts";
 import { Setup } from "./commands/setup.tsx";
+import { runWorker } from "./commands/worker.ts";
 
 // Get CLI name from bin field (assumes single key)
 const binName = Object.keys(pkg.bin)[0];
@@ -26,6 +27,8 @@ interface ParsedArgs {
   headless: boolean;
   dryRun: boolean;
   restore: boolean;
+  yes: boolean;
+  yolo: boolean;
   additionalArgs: string[];
 }
 
@@ -37,6 +40,8 @@ function parseArgs(args: string[]): ParsedArgs {
   let headless = false;
   let dryRun = false;
   let restore = false;
+  let yes = false;
+  let yolo = false;
   let additionalArgs: string[] = [];
 
   // Find if there's a "--" separator for additional args
@@ -61,10 +66,14 @@ function parseArgs(args: string[]): ParsedArgs {
       dryRun = true;
     } else if (arg === "--restore") {
       restore = true;
+    } else if (arg === "-y" || arg === "--yes") {
+      yes = true;
+    } else if (arg === "--yolo") {
+      yolo = true;
     }
   }
 
-  return { command, port, key, msg, headless, dryRun, restore, additionalArgs };
+  return { command, port, key, msg, headless, dryRun, restore, yes, yolo, additionalArgs };
 }
 
 function Help() {
@@ -121,6 +130,12 @@ function Help() {
           </Box>
           <Text>Run Claude CLI</Text>
         </Box>
+        <Box>
+          <Box width={12}>
+            <Text color="green">worker</Text>
+          </Box>
+          <Text>Run Claude in headless loop mode</Text>
+        </Box>
         <Box>
           <Box width={12}>
             <Text color="green">version</Text>
@@ -149,6 +164,12 @@ function Help() {
           </Box>
           <Text>Restore files from .bak backups</Text>
         </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">-y, --yes</Text>
+          </Box>
+          <Text>Non-interactive mode (use env vars)</Text>
+        </Box>
       </Box>
 
       <Box marginTop={1} flexDirection="column">
@@ -189,38 +210,82 @@ function Help() {
         </Box>
       </Box>
 
+      <Box marginTop={1} flexDirection="column">
+        <Text bold>Options for 'worker':</Text>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">-m, --msg {"<prompt>"}</Text>
+          </Box>
+          <Text>Custom prompt (default: /agent-swarm:start-worker)</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--yolo</Text>
+          </Box>
+          <Text>Continue on errors instead of stopping</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">-- {"<args...>"}</Text>
+          </Box>
+          <Text>Additional arguments to pass to Claude CLI</Text>
+        </Box>
+      </Box>
+
       <Box marginTop={1} flexDirection="column">
         <Text bold>Examples:</Text>
         <Text dimColor> {binName} setup</Text>
         <Text dimColor> {binName} setup --dry-run</Text>
+        <Text dimColor> {binName} setup -y</Text>
         <Text dimColor> {binName} mcp</Text>
         <Text dimColor> {binName} mcp --port 8080</Text>
         <Text dimColor> {binName} mcp -p 8080 -k my-secret-key</Text>
         <Text dimColor> {binName} claude</Text>
         <Text dimColor> {binName} claude --headless -m "Hello"</Text>
         <Text dimColor> {binName} claude -- --resume</Text>
+        <Text dimColor> {binName} worker</Text>
+        <Text dimColor> {binName} worker --yolo</Text>
+        <Text dimColor> {binName} worker -m "Custom prompt"</Text>
       </Box>
 
       <Box marginTop={1} flexDirection="column">
         <Text bold>Environment variables:</Text>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="magenta">PORT</Text>
           </Box>
           <Text>Default port for the MCP server</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="magenta">API_KEY</Text>
           </Box>
           <Text>API key for authentication (Bearer token)</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="magenta">MCP_BASE_URL</Text>
           </Box>
           <Text>Base URL for the MCP server (used by setup)</Text>
         </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="magenta">AGENT_ID</Text>
+          </Box>
+          <Text>UUID for agent identification</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="magenta">SESSION_ID</Text>
+          </Box>
+          <Text>Folder name for worker logs (auto-generated)</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="magenta">WORKER_YOLO</Text>
+          </Box>
+          <Text>If "true", worker continues on errors</Text>
+        </Box>
       </Box>
     </Box>
   );
@@ -298,6 +363,27 @@ function ClaudeRunner({ msg, headless, additionalArgs }: ClaudeRunnerProps) {
   return null;
 }
 
+interface WorkerRunnerProps {
+  prompt: string;
+  yolo: boolean;
+  additionalArgs: string[];
+}
+
+function WorkerRunner({ prompt, yolo, additionalArgs }: WorkerRunnerProps) {
+  const { exit } = useApp();
+
+  useEffect(() => {
+    runWorker({
+      prompt: prompt || undefined,
+      yolo,
+      additionalArgs,
+    }).catch((err) => exit(err));
+    // Note: runWorker runs indefinitely, so we don't call exit() on success
+  }, [prompt, yolo, additionalArgs, exit]);
+
+  return null;
+}
+
 function UnknownCommand({ command }: { command: string }) {
   const { exit } = useApp();
   useEffect(() => {
@@ -328,15 +414,17 @@ function Version() {
 }
 
 function App({ args }: { args: ParsedArgs }) {
-  const { command, port, key, msg, headless, dryRun, restore, additionalArgs } = args;
+  const { command, port, key, msg, headless, dryRun, restore, yes, yolo, additionalArgs } = args;
 
   switch (command) {
     case "setup":
-      return <Setup dryRun={dryRun} restore={restore} />;
+      return <Setup dryRun={dryRun} restore={restore} yes={yes} />;
     case "mcp":
       return <McpServer port={port} apiKey={key} />;
     case "claude":
       return <ClaudeRunner msg={msg} headless={headless} additionalArgs={additionalArgs} />;
+    case "worker":
+      return <WorkerRunner prompt={msg} yolo={yolo} additionalArgs={additionalArgs} />;
     case "version":
       return <Version />;
     case "help":
@@ -351,7 +439,7 @@ const args = parseArgs(process.argv.slice(2));
 
 // Handle hook command separately (no UI needed)
 if (args.command === "hook") {
-	runHook();
+  runHook();
 } else {
-	render(<App args={args} />);
+  render(<App args={args} />);
 }

package/src/commands/hook.ts

@@ -1,6 +1,6 @@
 import { handleHook } from "../hooks/hook";
 
 export async function runHook(): Promise<void> {
-	await handleHook();
-	process.exit(0);
+  await handleHook();
+  process.exit(0);
 }