@saeed42/worktree-worker 1.0.0

package/README.md

@@ -0,0 +1,200 @@
+# @orgn/worktree-worker
+
+Git worktree management service for AI agent trials. Runs as an npm package in CodeSandbox or any Node.js environment.
+
+## Installation
+
+```bash
+# Install globally
+npm install -g @orgn/worktree-worker
+
+# Or add to your project
+npm install @orgn/worktree-worker
+```
+
+## Quick Start
+
+### Run as CLI
+
+```bash
+# Set environment variables
+export WORKER_TOKEN=your-secret-token
+export PORT=8787
+
+# Run the service
+worktree-worker
+```
+
+### Run in CodeSandbox
+
+Add to your `package.json`:
+
+```json
+{
+  "dependencies": {
+    "@orgn/worktree-worker": "^1.0.0"
+  },
+  "scripts": {
+    "worktree-worker": "worktree-worker"
+  }
+}
+```
+
+Or run directly:
+
+```bash
+npx @orgn/worktree-worker
+```
+
+### Run Programmatically
+
+```typescript
+import { app } from '@orgn/worktree-worker';
+
+// The app is a Hono instance
+// You can extend it or use it as middleware
+```
+
+## Architecture
+
+```
+/project/
+├── sandbox/              # BASE_WORKSPACE_DIR - Main repo clone
+└── workspaces/
+    └── trials/           # TRIALS_WORKSPACE_DIR - Worktrees
+        ├── feature-auth-a1b2c3d4/
+        ├── fix-bug-xyz-5e6f7g8h/
+        └── ...
+```
+
+## API Endpoints
+
+### Health Checks
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /health` | Basic health check |
+| `GET /health/ready` | Readiness check |
+| `GET /health/live` | Liveness check |
+
+### Repository Management
+
+| Endpoint | Description |
+|----------|-------------|
+| `POST /v1/repo/init` | Clone repository |
+| `POST /v1/repo/update` | Fetch/pull latest |
+| `GET /v1/repo/status` | Get repo status |
+| `GET /v1/repo/branches` | List branches |
+
+### Worktree Management
+
+| Endpoint | Description |
+|----------|-------------|
+| `POST /v1/trials/:trialId/worktree/reset` | Create/reset worktree |
+| `DELETE /v1/trials/:trialId/worktree` | Delete worktree |
+| `GET /v1/trials/:trialId/worktree/status` | Get status |
+| `GET /v1/trials/:trialId/worktree/diff` | Get diff |
+| `POST /v1/trials/:trialId/worktree/commit` | Commit changes |
+| `POST /v1/trials/:trialId/worktree/push` | Push to remote |
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PORT` | `8787` | HTTP server port |
+| `NODE_ENV` | `development` | Environment mode |
+| `WORKER_TOKEN` | `` | Auth token (empty = no auth) |
+| `BASE_WORKSPACE_DIR` | `/project/sandbox` | Main repo path |
+| `TRIALS_WORKSPACE_DIR` | `/project/workspaces/trials` | Worktrees path |
+| `DEFAULT_BRANCH` | `main` | Default base branch |
+| `GIT_TIMEOUT_MS` | `60000` | Git timeout |
+| `CLEANUP_AFTER_HOURS` | `24` | Stale worktree cleanup |
+
+## Usage Examples
+
+### Initialize Repository
+
+```bash
+curl -X POST http://localhost:8787/v1/repo/init \
+  -H "Authorization: Bearer your-token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "repoUrl": "https://github.com/owner/repo",
+    "branch": "main",
+    "githubToken": "ghp_xxx"
+  }'
+```
+
+### Create Worktree
+
+```bash
+curl -X POST http://localhost:8787/v1/trials/abc123/worktree/reset \
+  -H "Authorization: Bearer your-token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "baseBranch": "main",
+    "trialBranch": "feature/my-feature"
+  }'
+```
+
+Response:
+
+```json
+{
+  "success": true,
+  "data": {
+    "worktreePath": "/project/workspaces/trials/feature-my-feature-abc12345",
+    "branch": "feature/my-feature",
+    "headSha": "a1b2c3d4e5f6..."
+  }
+}
+```
+
+### Commit Changes
+
+```bash
+curl -X POST http://localhost:8787/v1/trials/abc123/worktree/commit \
+  -H "Authorization: Bearer your-token" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "feat: implement auth",
+    "author": {
+      "name": "AI Agent",
+      "email": "agent@origin.ai"
+    }
+  }'
+```
+
+## Development
+
+```bash
+# Clone the repo
+cd worker-service-node
+
+# Install dependencies
+npm install
+
+# Run in dev mode (with watch)
+npm run dev
+
+# Type check
+npm run typecheck
+
+# Build
+npm run build
+
+# Run production build
+npm start
+```
+
+## Publishing
+
+```bash
+# Build and publish to npm
+npm publish --access public
+```
+
+## License
+
+MIT
+

package/dist/main.d.ts

@@ -0,0 +1,6 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+declare const app: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+
+export { app };

package/dist/main.js

@@ -0,0 +1,1121 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { serve } from "@hono/node-server";
+import { Hono as Hono4 } from "hono";
+import { cors } from "hono/cors";
+import { logger as honoLogger } from "hono/logger";
+import { secureHeaders } from "hono/secure-headers";
+
+// src/config/env.ts
+var env = {
+  PORT: parseInt(process.env.PORT || "8787", 10),
+  NODE_ENV: process.env.NODE_ENV || "development",
+  WORKER_TOKEN: process.env.WORKER_TOKEN || "",
+  BASE_WORKSPACE_DIR: process.env.BASE_WORKSPACE_DIR || "/project/sandbox",
+  WORKSPACES_ROOT: process.env.WORKSPACES_ROOT || "/project/workspaces",
+  TRIALS_WORKSPACE_DIR: process.env.TRIALS_WORKSPACE_DIR || "/project/workspaces/trials",
+  DEFAULT_BRANCH: process.env.DEFAULT_BRANCH || "main",
+  GIT_TIMEOUT_MS: parseInt(process.env.GIT_TIMEOUT_MS || "60000", 10),
+  CLEANUP_AFTER_HOURS: parseInt(process.env.CLEANUP_AFTER_HOURS || "24", 10)
+};
+
+// src/config/logger.ts
+import pino from "pino";
+var isDev = env.NODE_ENV === "development";
+var baseLogger = pino({
+  level: isDev ? "debug" : "info",
+  transport: isDev ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
+    }
+  } : void 0,
+  base: {
+    service: "worktree-worker"
+  }
+});
+var logger = {
+  info: (msgOrObj, obj) => {
+    if (typeof msgOrObj === "string") {
+      baseLogger.info(obj || {}, msgOrObj);
+    } else {
+      const { msg, ...rest } = msgOrObj;
+      baseLogger.info(rest, msg);
+    }
+  },
+  error: (msgOrObj, obj) => {
+    if (typeof msgOrObj === "string") {
+      baseLogger.error(obj || {}, msgOrObj);
+    } else {
+      const { msg, ...rest } = msgOrObj;
+      baseLogger.error(rest, msg);
+    }
+  },
+  warn: (msgOrObj, obj) => {
+    if (typeof msgOrObj === "string") {
+      baseLogger.warn(obj || {}, msgOrObj);
+    } else {
+      const { msg, ...rest } = msgOrObj;
+      baseLogger.warn(rest, msg);
+    }
+  },
+  debug: (msgOrObj, obj) => {
+    if (typeof msgOrObj === "string") {
+      baseLogger.debug(obj || {}, msgOrObj);
+    } else {
+      const { msg, ...rest } = msgOrObj;
+      baseLogger.debug(rest, msg);
+    }
+  },
+  child: (bindings) => {
+    const childLogger = baseLogger.child(bindings);
+    return {
+      info: (msgOrObj, obj) => {
+        if (typeof msgOrObj === "string") {
+          childLogger.info(obj || {}, msgOrObj);
+        } else {
+          const { msg, ...rest } = msgOrObj;
+          childLogger.info(rest, msg);
+        }
+      },
+      error: (msgOrObj, obj) => {
+        if (typeof msgOrObj === "string") {
+          childLogger.error(obj || {}, msgOrObj);
+        } else {
+          const { msg, ...rest } = msgOrObj;
+          childLogger.error(rest, msg);
+        }
+      },
+      warn: (msgOrObj, obj) => {
+        if (typeof msgOrObj === "string") {
+          childLogger.warn(obj || {}, msgOrObj);
+        } else {
+          const { msg, ...rest } = msgOrObj;
+          childLogger.warn(rest, msg);
+        }
+      },
+      debug: (msgOrObj, obj) => {
+        if (typeof msgOrObj === "string") {
+          childLogger.debug(obj || {}, msgOrObj);
+        } else {
+          const { msg, ...rest } = msgOrObj;
+          childLogger.debug(rest, msg);
+        }
+      }
+    };
+  }
+};
+
+// src/middleware/auth.ts
+async function authMiddleware(c, next) {
+  if (!env.WORKER_TOKEN) {
+    return next();
+  }
+  const authHeader = c.req.header("Authorization");
+  if (!authHeader) {
+    return c.json({ success: false, error: { code: "UNAUTHORIZED", message: "Missing Authorization header" } }, 401);
+  }
+  const [scheme, token] = authHeader.split(" ");
+  if (scheme !== "Bearer" || !token) {
+    return c.json({ success: false, error: { code: "UNAUTHORIZED", message: "Invalid Authorization format" } }, 401);
+  }
+  if (token !== env.WORKER_TOKEN) {
+    return c.json({ success: false, error: { code: "UNAUTHORIZED", message: "Invalid token" } }, 401);
+  }
+  return next();
+}
+
+// src/routes/health.routes.ts
+import { Hono } from "hono";
+import { stat, mkdir } from "fs/promises";
+
+// src/services/git.service.ts
+import { spawn } from "child_process";
+var GitService = class {
+  /**
+   * Execute a git command
+   */
+  async exec(args, cwd) {
+    const workDir = cwd || env.BASE_WORKSPACE_DIR;
+    const log = logger.child({ git: args.slice(0, 2).join(" "), cwd: workDir });
+    return new Promise((resolve, reject) => {
+      const child = spawn("git", args, {
+        cwd: workDir,
+        timeout: env.GIT_TIMEOUT_MS,
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: ""
+        }
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        const exitCode = code ?? 1;
+        log.debug("Git command completed", { exitCode, stdoutLen: stdout.length });
+        resolve({ code: exitCode, stdout, stderr });
+      });
+      child.on("error", (err) => {
+        log.error("Git command error", { error: err.message });
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Execute git command and throw on error
+   */
+  async execOrThrow(args, cwd) {
+    const result = await this.exec(args, cwd);
+    if (result.code !== 0) {
+      throw new Error(`Git command failed: ${result.stderr || result.stdout}`);
+    }
+    return result;
+  }
+  /**
+   * Get git version
+   */
+  async getVersion() {
+    const result = await this.execOrThrow(["--version"]);
+    return result.stdout.trim();
+  }
+  /**
+   * Fetch from remote
+   */
+  async fetch(remote = "origin", cwd) {
+    await this.execOrThrow(["fetch", remote], cwd);
+  }
+  /**
+   * Clone a repository
+   */
+  async cloneRepo(repoUrl, targetDir, options) {
+    const args = ["clone"];
+    if (options?.blobless) {
+      args.push("--filter=blob:none");
+    } else if (options?.depth) {
+      args.push("--depth", String(options.depth));
+    }
+    if (options?.branch) {
+      args.push("--branch", options.branch);
+    }
+    args.push(repoUrl, targetDir);
+    const parentDir = targetDir.split("/").slice(0, -1).join("/") || "/";
+    await this.execOrThrow(args, parentDir);
+  }
+  /**
+   * List worktrees
+   */
+  async listWorktrees(cwd) {
+    const result = await this.exec(["worktree", "list", "--porcelain"], cwd);
+    if (result.code !== 0) return [];
+    const worktrees = [];
+    let current = {};
+    for (const line of result.stdout.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current.path) {
+          worktrees.push({
+            path: current.path,
+            branch: current.branch || "",
+            head: current.head || ""
+          });
+        }
+        current = { path: line.slice(9) };
+      } else if (line.startsWith("HEAD ")) {
+        current.head = line.slice(5);
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.slice(7).replace("refs/heads/", "");
+      }
+    }
+    if (current.path) {
+      worktrees.push({
+        path: current.path,
+        branch: current.branch || "",
+        head: current.head || ""
+      });
+    }
+    return worktrees;
+  }
+  /**
+   * Add a worktree with a new branch
+   */
+  async addWorktreeWithNewBranch(path, newBranch, fromRef, cwd) {
+    const branchResult = await this.exec(["branch", newBranch, fromRef], cwd);
+    if (branchResult.code === 0) {
+      await this.execOrThrow(["worktree", "add", path, newBranch], cwd);
+    } else {
+      await this.execOrThrow(["worktree", "add", "-b", newBranch, path, fromRef], cwd);
+    }
+  }
+  /**
+   * Remove a worktree
+   */
+  async removeWorktree(path, force = false, cwd) {
+    const args = ["worktree", "remove", path];
+    if (force) args.push("--force");
+    await this.exec(args, cwd);
+  }
+  /**
+   * Prune worktrees
+   */
+  async pruneWorktrees(cwd) {
+    await this.exec(["worktree", "prune"], cwd);
+  }
+  /**
+   * Delete a branch
+   */
+  async deleteBranch(branch, force = false, cwd) {
+    const args = ["branch", force ? "-D" : "-d", branch];
+    await this.exec(args, cwd);
+  }
+  /**
+   * Get HEAD SHA
+   */
+  async getHeadSha(cwd) {
+    const result = await this.execOrThrow(["rev-parse", "HEAD"], cwd);
+    return result.stdout.trim();
+  }
+  /**
+   * Get current branch
+   */
+  async getCurrentBranch(cwd) {
+    const result = await this.execOrThrow(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+    return result.stdout.trim();
+  }
+  /**
+   * Check if branch exists
+   */
+  async branchExists(branch, cwd) {
+    const result = await this.exec(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], cwd);
+    return result.code === 0;
+  }
+  /**
+   * Get status
+   */
+  async getStatus(cwd) {
+    const result = await this.exec(["status", "--porcelain"], cwd);
+    const files = result.stdout.split("\n").filter((line) => line.trim()).map((line) => line.slice(3));
+    return { hasChanges: files.length > 0, files };
+  }
+  /**
+   * Get diff
+   */
+  async getDiff(cwd) {
+    const result = await this.exec(["diff", "--no-color"], cwd);
+    return result.stdout;
+  }
+  /**
+   * Add all files
+   */
+  async addAll(cwd) {
+    await this.execOrThrow(["add", "-A"], cwd);
+  }
+  /**
+   * Commit
+   */
+  async commit(message, author, cwd) {
+    const args = ["commit", "-m", message];
+    if (author) {
+      args.push("--author", `${author.name} <${author.email}>`);
+    }
+    await this.execOrThrow(args, cwd);
+    return this.getHeadSha(cwd);
+  }
+  /**
+   * Push
+   */
+  async push(remote, branch, force = false, cwd) {
+    const args = ["push", remote, branch];
+    if (force) args.push("--force");
+    await this.execOrThrow(args, cwd);
+  }
+  /**
+   * List branches
+   */
+  async listBranches(cwd) {
+    const localResult = await this.exec(["branch", "--format=%(refname:short)"], cwd);
+    const remoteResult = await this.exec(["branch", "-r", "--format=%(refname:short)"], cwd);
+    return {
+      local: localResult.stdout.split("\n").filter((b) => b.trim()),
+      remote: remoteResult.stdout.split("\n").filter((b) => b.trim())
+    };
+  }
+  /**
+   * Get remote URL
+   */
+  async getRemoteUrl(remote = "origin", cwd) {
+    const result = await this.exec(["remote", "get-url", remote], cwd);
+    return result.code === 0 ? result.stdout.trim() : null;
+  }
+};
+var gitService = new GitService();
+
+// src/routes/health.routes.ts
+var health = new Hono();
+health.get("/", (c) => {
+  return c.json({
+    status: "ok",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    service: "worktree-worker",
+    version: "1.0.0"
+  });
+});
+health.get("/ready", async (c) => {
+  const checks = {};
+  try {
+    const version = await gitService.getVersion();
+    checks.git = { status: "ok", message: version };
+  } catch (err) {
+    checks.git = { status: "error", message: err.message };
+  }
+  try {
+    const stats = await stat(env.BASE_WORKSPACE_DIR);
+    checks.baseWorkspaceDir = {
+      status: stats.isDirectory() ? "ok" : "error",
+      message: env.BASE_WORKSPACE_DIR
+    };
+  } catch {
+    checks.baseWorkspaceDir = {
+      status: "warn",
+      message: `${env.BASE_WORKSPACE_DIR} not found (repo not cloned yet)`
+    };
+  }
+  try {
+    await mkdir(env.TRIALS_WORKSPACE_DIR, { recursive: true });
+    checks.trialsWorkspaceDir = { status: "ok", message: env.TRIALS_WORKSPACE_DIR };
+  } catch (err) {
+    checks.trialsWorkspaceDir = { status: "error", message: err.message };
+  }
+  const hasError = Object.values(checks).some((c2) => c2.status === "error");
+  const hasWarn = Object.values(checks).some((c2) => c2.status === "warn");
+  return c.json(
+    {
+      status: hasError ? "degraded" : hasWarn ? "ready-warn" : "ready",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checks
+    },
+    hasError ? 503 : 200
+  );
+});
+health.get("/live", (c) => {
+  return c.json({
+    status: "alive",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    uptime: Math.floor(process.uptime())
+  });
+});
+
+// src/routes/repo.routes.ts
+import { Hono as Hono2 } from "hono";
+import { z } from "zod";
+
+// src/services/repo.service.ts
+import { mkdir as mkdir2, rm, stat as stat2, writeFile } from "fs/promises";
+var RepoService = class {
+  /**
+   * Check if the repository is initialized
+   */
+  async getStatus() {
+    const repoRoot = env.BASE_WORKSPACE_DIR;
+    try {
+      const stats = await stat2(repoRoot);
+      if (!stats.isDirectory()) {
+        return {
+          initialized: false,
+          path: repoRoot,
+          branch: null,
+          remote: null,
+          headSha: null
+        };
+      }
+      const gitDir = await stat2(`${repoRoot}/.git`).catch(() => null);
+      if (!gitDir) {
+        return {
+          initialized: false,
+          path: repoRoot,
+          branch: null,
+          remote: null,
+          headSha: null
+        };
+      }
+      const branch = await gitService.getCurrentBranch(repoRoot).catch(() => null);
+      const headSha = await gitService.getHeadSha(repoRoot).catch(() => null);
+      const remote = await gitService.getRemoteUrl("origin", repoRoot);
+      return {
+        initialized: true,
+        path: repoRoot,
+        branch,
+        remote,
+        headSha
+      };
+    } catch {
+      return {
+        initialized: false,
+        path: repoRoot,
+        branch: null,
+        remote: null,
+        headSha: null
+      };
+    }
+  }
+  /**
+   * Initialize/clone the repository
+   */
+  async initRepo(options) {
+    const log = logger.child({ service: "repo", action: "init" });
+    const repoRoot = env.BASE_WORKSPACE_DIR;
+    log.info("Initializing repository", {
+      repoUrl: options.repoUrl.replace(/ghp_[a-zA-Z0-9]+/, "ghp_***"),
+      branch: options.branch,
+      force: options.force
+    });
+    const status = await this.getStatus();
+    if (status.initialized && !options.force) {
+      log.info("Repository already initialized");
+      return {
+        path: repoRoot,
+        branch: status.branch || env.DEFAULT_BRANCH,
+        headSha: status.headSha || "",
+        remote: status.remote
+      };
+    }
+    if (options.force && status.initialized) {
+      log.info("Force flag set, removing existing repo");
+      await rm(repoRoot, { recursive: true, force: true });
+    }
+    const parentDir = repoRoot.split("/").slice(0, -1).join("/");
+    await mkdir2(parentDir, { recursive: true });
+    await mkdir2(env.TRIALS_WORKSPACE_DIR, { recursive: true });
+    let cloneUrl = options.repoUrl;
+    if (options.githubToken) {
+      const urlWithoutProtocol = options.repoUrl.replace(/^https?:\/\//, "");
+      cloneUrl = `https://x-access-token:${options.githubToken}@${urlWithoutProtocol}`;
+    }
+    const branch = options.branch || env.DEFAULT_BRANCH;
+    log.info("Cloning repository", { branch });
+    await gitService.cloneRepo(cloneUrl, repoRoot, {
+      branch,
+      blobless: true
+    });
+    await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], repoRoot);
+    await gitService.exec(["config", "--local", "user.email", "origin-agent[bot]@users.noreply.github.com"], repoRoot);
+    await gitService.exec(["config", "--local", "safe.directory", repoRoot], repoRoot);
+    const cleanUrl = options.repoUrl.replace(/^https:\/\/[^@]+@/, "https://");
+    await gitService.exec(["remote", "set-url", "origin", cleanUrl], repoRoot);
+    if (options.githubToken) {
+      await this.updateCredentials(options.githubToken);
+    }
+    const headSha = await gitService.getHeadSha(repoRoot);
+    const remote = await gitService.getRemoteUrl("origin", repoRoot);
+    log.info("Repository initialized", { branch, headSha });
+    return { path: repoRoot, branch, headSha, remote };
+  }
+  /**
+   * Update/pull the repository
+   */
+  async updateRepo(options) {
+    const log = logger.child({ service: "repo", action: "update" });
+    const repoRoot = env.BASE_WORKSPACE_DIR;
+    const status = await this.getStatus();
+    if (!status.initialized) {
+      throw new Error("Repository not initialized");
+    }
+    if (options?.githubToken) {
+      await this.updateCredentials(options.githubToken);
+    }
+    log.info("Fetching from remote");
+    await gitService.fetch("origin", repoRoot);
+    if (options?.branch && options.branch !== status.branch) {
+      log.info("Checking out branch", { branch: options.branch });
+      await gitService.execOrThrow(["checkout", options.branch], repoRoot);
+    }
+    if (options?.pull) {
+      log.info("Pulling latest changes");
+      await gitService.exec(["pull", "--ff-only"], repoRoot);
+    }
+    const headSha = await gitService.getHeadSha(repoRoot);
+    const branch = await gitService.getCurrentBranch(repoRoot);
+    const remote = await gitService.getRemoteUrl("origin", repoRoot);
+    return { path: repoRoot, branch, headSha, remote };
+  }
+  /**
+   * Update git credentials
+   */
+  async updateCredentials(githubToken) {
+    const log = logger.child({ service: "repo", action: "updateCredentials" });
+    const repoRoot = env.BASE_WORKSPACE_DIR;
+    await gitService.exec(["config", "--global", "credential.helper", "store --file=/tmp/.git-credentials"], repoRoot);
+    await gitService.exec(["config", "--global", "core.askPass", ""], repoRoot);
+    const credentialsContent = `https://x-access-token:${githubToken}@github.com
+`;
+    await writeFile("/tmp/.git-credentials", credentialsContent, { mode: 384 });
+    log.info("Credentials updated");
+  }
+  /**
+   * List branches
+   */
+  async listBranches() {
+    const repoRoot = env.BASE_WORKSPACE_DIR;
+    const status = await this.getStatus();
+    if (!status.initialized) {
+      return { local: [], remote: [] };
+    }
+    return gitService.listBranches(repoRoot);
+  }
+};
+var repoService = new RepoService();
+
+// src/routes/repo.routes.ts
+var repo = new Hono2();
+var initRepoSchema = z.object({
+  repoUrl: z.string().url(),
+  branch: z.string().optional(),
+  githubToken: z.string().optional(),
+  force: z.boolean().default(false)
+});
+var updateRepoSchema = z.object({
+  branch: z.string().optional(),
+  pull: z.boolean().default(false),
+  githubToken: z.string().optional()
+});
+repo.get("/status", async (c) => {
+  try {
+    const status = await repoService.getStatus();
+    return c.json({ success: true, data: status });
+  } catch (err) {
+    const error = err;
+    logger.error("Failed to get repo status", { error: error.message });
+    return c.json({ success: false, error: { code: "INTERNAL_ERROR", message: error.message } }, 500);
+  }
+});
+repo.get("/branches", async (c) => {
+  try {
+    const branches = await repoService.listBranches();
+    return c.json({ success: true, data: branches });
+  } catch (err) {
+    const error = err;
+    logger.error("Failed to list branches", { error: error.message });
+    return c.json({ success: false, error: { code: "INTERNAL_ERROR", message: error.message } }, 500);
+  }
+});
+repo.post("/init", async (c) => {
+  const log = logger.child({ route: "repo/init" });
+  try {
+    const body = await c.req.json();
+    const parsed = initRepoSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        { success: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message } },
+        400
+      );
+    }
+    log.info("Initializing repository", { repoUrl: parsed.data.repoUrl, branch: parsed.data.branch });
+    const result = await repoService.initRepo(parsed.data);
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to initialize repo", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+repo.post("/update", async (c) => {
+  const log = logger.child({ route: "repo/update" });
+  try {
+    const body = await c.req.json().catch(() => ({}));
+    const parsed = updateRepoSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        { success: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message } },
+        400
+      );
+    }
+    log.info("Updating repository", { branch: parsed.data.branch, pull: parsed.data.pull });
+    const result = await repoService.updateRepo(parsed.data);
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to update repo", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+
+// src/routes/worktree.routes.ts
+import { Hono as Hono3 } from "hono";
+import { z as z2 } from "zod";
+
+// src/services/worktree.service.ts
+import { mkdir as mkdir3, rm as rm2, stat as stat3, readdir } from "fs/promises";
+var WorktreeService = class {
+  /**
+   * Get the isolated workspace directory for a specific trial.
+   * Matches orgn branch-manager.ts getTrialWorkspaceDir()
+   */
+  getWorktreePath(trialId, trialBranch) {
+    const branch = trialBranch || `trial/${trialId}`;
+    const safeBranchName = branch.replace(/[^a-zA-Z0-9-_]/g, "-");
+    const shortTrialId = trialId.replace(/-/g, "").slice(0, 8);
+    if (!safeBranchName.endsWith(shortTrialId)) {
+      return `${env.TRIALS_WORKSPACE_DIR}/${safeBranchName}-${shortTrialId}`;
+    }
+    return `${env.TRIALS_WORKSPACE_DIR}/${safeBranchName}`;
+  }
+  /**
+   * Get the branch name for a trial
+   */
+  getBranchName(trialId) {
+    return `trial/${trialId}`;
+  }
+  /**
+   * Reset or create a worktree for a trial
+   */
+  async resetWorktree(trialId, options) {
+    const log = logger.child({ trialId, service: "worktree" });
+    const branchName = options.trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    const baseBranch = options.baseBranch || env.DEFAULT_BRANCH;
+    const baseRepoDir = env.BASE_WORKSPACE_DIR;
+    log.info("Starting worktree reset (v3 architecture)", {
+      worktreePath,
+      branchName,
+      baseBranch,
+      baseRepoDir
+    });
+    await mkdir3(env.TRIALS_WORKSPACE_DIR, { recursive: true });
+    try {
+      const stats = await stat3(worktreePath);
+      if (stats.isDirectory()) {
+        const gitFile = await stat3(`${worktreePath}/.git`).catch(() => null);
+        if (gitFile) {
+          log.info("Worktree already exists, fetching latest");
+          await gitService.fetch("origin", worktreePath).catch(() => {
+          });
+          const headSha2 = await gitService.getHeadSha(worktreePath);
+          return { worktreePath, branch: branchName, headSha: headSha2 };
+        }
+      }
+    } catch {
+    }
+    log.info("Fetching from remote");
+    await gitService.fetch("origin", baseRepoDir);
+    try {
+      await gitService.removeWorktree(worktreePath, true, baseRepoDir);
+    } catch {
+    }
+    await rm2(worktreePath, { recursive: true, force: true }).catch(() => {
+    });
+    const worktreeFolderName = worktreePath.split("/").pop() || branchName;
+    await rm2(`${baseRepoDir}/.git/worktrees/${worktreeFolderName}`, {
+      recursive: true,
+      force: true
+    }).catch(() => {
+    });
+    await gitService.pruneWorktrees(baseRepoDir);
+    const localBranchExists = await gitService.branchExists(branchName, baseRepoDir);
+    const remoteBranchExists = await gitService.branchExists(`origin/${branchName}`, baseRepoDir);
+    if (localBranchExists) {
+      log.info("Creating worktree from existing local branch", { branchName });
+      await gitService.execOrThrow(["worktree", "add", worktreePath, branchName], baseRepoDir);
+    } else if (remoteBranchExists) {
+      log.info("Creating worktree from remote branch", { branchName });
+      await gitService.exec(["fetch", "origin", `${branchName}:${branchName}`], baseRepoDir);
+      await gitService.execOrThrow(["worktree", "add", worktreePath, branchName], baseRepoDir);
+    } else {
+      const baseRef = `origin/${baseBranch}`;
+      log.info("Creating worktree with new branch from base", { baseRef, branchName });
+      await gitService.addWorktreeWithNewBranch(worktreePath, branchName, baseRef, baseRepoDir);
+    }
+    await gitService.exec(["config", "--local", "user.name", "origin-agent[bot]"], worktreePath).catch(() => {
+    });
+    await gitService.exec(["config", "--local", "user.email", "origin-agent[bot]@users.noreply.github.com"], worktreePath).catch(() => {
+    });
+    await gitService.exec(["config", "--local", "safe.directory", worktreePath], worktreePath).catch(() => {
+    });
+    const headSha = await gitService.getHeadSha(worktreePath);
+    log.info("Worktree created successfully", { headSha });
+    return { worktreePath, branch: branchName, headSha };
+  }
+  /**
+   * Delete a worktree for a trial
+   */
+  async deleteWorktree(trialId, trialBranch) {
+    const log = logger.child({ trialId, service: "worktree" });
+    const branchName = trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    const baseRepoDir = env.BASE_WORKSPACE_DIR;
+    log.info("Deleting worktree", { worktreePath, branchName });
+    try {
+      await gitService.removeWorktree(worktreePath, true, baseRepoDir);
+    } catch {
+      log.warn("Worktree removal failed, cleaning up manually");
+      await rm2(worktreePath, { recursive: true, force: true }).catch(() => {
+      });
+      const worktreeFolderName = worktreePath.split("/").pop() || branchName;
+      await rm2(`${baseRepoDir}/.git/worktrees/${worktreeFolderName}`, {
+        recursive: true,
+        force: true
+      }).catch(() => {
+      });
+      await gitService.pruneWorktrees(baseRepoDir);
+    }
+    try {
+      await gitService.deleteBranch(branchName, true, baseRepoDir);
+    } catch {
+    }
+    log.info("Worktree deleted");
+  }
+  /**
+   * Get worktree status
+   */
+  async getWorktreeStatus(trialId, trialBranch) {
+    const branchName = trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    try {
+      const stats = await stat3(worktreePath);
+      if (!stats.isDirectory()) {
+        return {
+          exists: false,
+          worktreePath: null,
+          branch: null,
+          headSha: null,
+          hasChanges: false,
+          changedFiles: 0
+        };
+      }
+      const gitFile = await stat3(`${worktreePath}/.git`).catch(() => null);
+      if (!gitFile) {
+        return {
+          exists: false,
+          worktreePath: null,
+          branch: null,
+          headSha: null,
+          hasChanges: false,
+          changedFiles: 0
+        };
+      }
+      const headSha = await gitService.getHeadSha(worktreePath);
+      const branch = await gitService.getCurrentBranch(worktreePath);
+      const status = await gitService.getStatus(worktreePath);
+      return {
+        exists: true,
+        worktreePath,
+        branch,
+        headSha,
+        hasChanges: status.hasChanges,
+        changedFiles: status.files.length
+      };
+    } catch {
+      return {
+        exists: false,
+        worktreePath: null,
+        branch: null,
+        headSha: null,
+        hasChanges: false,
+        changedFiles: 0
+      };
+    }
+  }
+  /**
+   * Get worktree diff
+   */
+  async getWorktreeDiff(trialId, trialBranch) {
+    const branchName = trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    const status = await gitService.getStatus(worktreePath);
+    const diff = await gitService.getDiff(worktreePath);
+    return {
+      hasChanges: status.hasChanges,
+      changedFiles: status.files,
+      diff
+    };
+  }
+  /**
+   * Commit changes in worktree
+   */
+  async commitChanges(trialId, message, author, trialBranch) {
+    const branchName = trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    await gitService.addAll(worktreePath);
+    const commitSha = await gitService.commit(message, author, worktreePath);
+    const branch = await gitService.getCurrentBranch(worktreePath);
+    return { commitSha, branch };
+  }
+  /**
+   * Push branch
+   */
+  async pushBranch(trialId, remote = "origin", force = false, trialBranch) {
+    const branchName = trialBranch || this.getBranchName(trialId);
+    const worktreePath = this.getWorktreePath(trialId, branchName);
+    const branch = await gitService.getCurrentBranch(worktreePath);
+    await gitService.push(remote, branch, force, worktreePath);
+    return { branch, pushed: true };
+  }
+  /**
+   * Cleanup stale worktrees
+   */
+  async cleanupStaleWorktrees() {
+    const log = logger.child({ service: "worktree", action: "cleanup" });
+    let cleaned = 0;
+    const errors = [];
+    const cutoffTime = Date.now() - env.CLEANUP_AFTER_HOURS * 60 * 60 * 1e3;
+    try {
+      const entries = await readdir(env.TRIALS_WORKSPACE_DIR, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const worktreePath = `${env.TRIALS_WORKSPACE_DIR}/${entry.name}`;
+        try {
+          const stats = await stat3(worktreePath);
+          if (stats.mtimeMs < cutoffTime) {
+            log.info("Cleaning up stale worktree", { path: worktreePath });
+            await rm2(worktreePath, { recursive: true, force: true });
+            cleaned++;
+          }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          errors.push(`${worktreePath}: ${errMsg}`);
+        }
+      }
+      await gitService.pruneWorktrees(env.BASE_WORKSPACE_DIR);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      errors.push(`readdir: ${errMsg}`);
+    }
+    log.info("Cleanup completed", { cleaned, errorCount: errors.length });
+    return { cleaned, errors };
+  }
+};
+var worktreeService = new WorktreeService();
+
+// src/routes/worktree.routes.ts
+var worktree = new Hono3();
+var resetWorktreeSchema = z2.object({
+  baseBranch: z2.string().default("main"),
+  trialBranch: z2.string().optional(),
+  force: z2.boolean().default(false)
+});
+var commitSchema = z2.object({
+  message: z2.string().min(1),
+  author: z2.object({
+    name: z2.string(),
+    email: z2.string().email()
+  }).optional()
+});
+var pushSchema = z2.object({
+  remote: z2.string().default("origin"),
+  force: z2.boolean().default(false)
+});
+worktree.post("/trials/:trialId/worktree/reset", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/reset", trialId });
+  try {
+    const body = await c.req.json().catch(() => ({}));
+    const parsed = resetWorktreeSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        { success: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message } },
+        400
+      );
+    }
+    const input = parsed.data;
+    log.info("Creating/resetting worktree", {
+      baseBranch: input.baseBranch,
+      trialBranch: input.trialBranch,
+      force: input.force
+    });
+    const result = await worktreeService.resetWorktree(trialId, {
+      baseBranch: input.baseBranch,
+      trialBranch: input.trialBranch,
+      force: input.force
+    });
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to reset worktree", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.delete("/trials/:trialId/worktree", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/delete", trialId });
+  try {
+    log.info("Deleting worktree");
+    await worktreeService.deleteWorktree(trialId);
+    return c.json({ success: true, data: { deleted: true } });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to delete worktree", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.get("/trials/:trialId/worktree/status", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/status", trialId });
+  try {
+    const status = await worktreeService.getWorktreeStatus(trialId);
+    return c.json({ success: true, data: status });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to get worktree status", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.get("/trials/:trialId/worktree/diff", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/diff", trialId });
+  try {
+    const diff = await worktreeService.getWorktreeDiff(trialId);
+    return c.json({ success: true, data: diff });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to get worktree diff", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.post("/trials/:trialId/worktree/commit", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/commit", trialId });
+  try {
+    const body = await c.req.json();
+    const parsed = commitSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        { success: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message } },
+        400
+      );
+    }
+    log.info("Committing changes", { message: parsed.data.message.slice(0, 50) });
+    const result = await worktreeService.commitChanges(
+      trialId,
+      parsed.data.message,
+      parsed.data.author
+    );
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to commit changes", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.post("/trials/:trialId/worktree/push", async (c) => {
+  const trialId = c.req.param("trialId");
+  const log = logger.child({ route: "worktree/push", trialId });
+  try {
+    const body = await c.req.json().catch(() => ({}));
+    const parsed = pushSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json(
+        { success: false, error: { code: "VALIDATION_ERROR", message: parsed.error.message } },
+        400
+      );
+    }
+    log.info("Pushing to remote", { remote: parsed.data.remote, force: parsed.data.force });
+    const result = await worktreeService.pushBranch(
+      trialId,
+      parsed.data.remote,
+      parsed.data.force
+    );
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to push", { error: error.message });
+    return c.json({ success: false, error: { code: "GIT_ERROR", message: error.message } }, 500);
+  }
+});
+worktree.post("/worktrees/cleanup", async (c) => {
+  const log = logger.child({ route: "worktrees/cleanup" });
+  try {
+    log.info("Starting worktree cleanup");
+    const result = await worktreeService.cleanupStaleWorktrees();
+    return c.json({ success: true, data: result });
+  } catch (err) {
+    const error = err;
+    log.error("Failed to cleanup worktrees", { error: error.message });
+    return c.json({ success: false, error: { code: "INTERNAL_ERROR", message: error.message } }, 500);
+  }
+});
+
+// src/main.ts
+var app = new Hono4();
+app.use("*", secureHeaders());
+app.use(
+  "*",
+  cors({
+    origin: "*",
+    allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowHeaders: ["Content-Type", "Authorization", "X-Request-ID"],
+    exposeHeaders: ["X-Request-ID"],
+    maxAge: 86400
+  })
+);
+if (env.NODE_ENV === "development") {
+  app.use("*", honoLogger());
+}
+app.use("*", async (c, next) => {
+  const requestId = c.req.header("X-Request-ID") || crypto.randomUUID();
+  c.res.headers.set("X-Request-ID", requestId);
+  await next();
+});
+app.route("/health", health);
+app.get("/", (c) => {
+  return c.json({
+    service: "worktree-worker",
+    version: "1.0.0",
+    status: "ok",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.use("/v1/*", authMiddleware);
+app.route("/v1/repo", repo);
+app.route("/v1", worktree);
+app.onError((err, c) => {
+  const requestId = c.req.header("X-Request-ID") || "unknown";
+  logger.error("Unhandled error", {
+    requestId,
+    error: err.message,
+    stack: err.stack,
+    path: c.req.path,
+    method: c.req.method
+  });
+  return c.json(
+    {
+      success: false,
+      error: {
+        code: "INTERNAL_ERROR",
+        message: env.NODE_ENV === "development" ? err.message : "Internal server error",
+        requestId
+      }
+    },
+    500
+  );
+});
+app.notFound((c) => {
+  return c.json(
+    {
+      success: false,
+      error: {
+        code: "NOT_FOUND",
+        message: `Route ${c.req.method} ${c.req.path} not found`
+      }
+    },
+    404
+  );
+});
+var port = env.PORT;
+logger.info(`Worktree Worker starting on port ${port}`, {
+  port,
+  baseWorkspaceDir: env.BASE_WORKSPACE_DIR,
+  trialsWorkspaceDir: env.TRIALS_WORKSPACE_DIR
+});
+serve({
+  fetch: app.fetch,
+  port
+});
+export {
+  app
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@saeed42/worktree-worker",
+  "version": "1.0.0",
+  "description": "Git worktree management service for AI agent trials",
+  "type": "module",
+  "main": "dist/main.js",
+  "bin": {
+    "opencode-ai": "./dist/main.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx watch src/main.ts",
+    "start": "node dist/main.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "worktree",
+    "codesandbox",
+    "agent",
+    "trial"
+  ],
+  "author": "Origin",
+  "license": "MIT",
+  "dependencies": {
+    "@hono/node-server": "^1.13.7",
+    "hono": "^4.6.0",
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.0.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}
+