@desplega.ai/agent-swarm 1.20.0 → 1.49.0

package/.github/workflows/merge-gate.yml

@@ -0,0 +1,233 @@
+name: Merge Gate
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  detect-changes:
+    name: Detect Changes
+    runs-on: ubuntu-latest
+    outputs:
+      code: ${{ steps.check.outputs.code }}
+      new-ui: ${{ steps.check.outputs.new-ui }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Fetch base branch
+        run: git fetch origin ${{ github.base_ref }}
+
+      - name: Check for code changes
+        id: check
+        run: |
+          CHANGED=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)
+          CODE_CHANGED=$(echo "$CHANGED" | grep -v '^docs-site/' | grep -v '^landing/' | grep -v '^$' || true)
+          if [ -n "$CODE_CHANGED" ]; then
+            echo "code=true" >> $GITHUB_OUTPUT
+            echo "Code files changed:"
+            echo "$CODE_CHANGED"
+          else
+            echo "code=false" >> $GITHUB_OUTPUT
+            echo "No code files changed (only docs-site/ or landing/)"
+          fi
+          UI_CHANGED=$(echo "$CHANGED" | grep '^new-ui/' || true)
+          if [ -n "$UI_CHANGED" ]; then
+            echo "new-ui=true" >> $GITHUB_OUTPUT
+            echo "new-ui files changed:"
+            echo "$UI_CHANGED"
+          else
+            echo "new-ui=false" >> $GITHUB_OUTPUT
+          fi
+
+  lint-and-typecheck:
+    name: Lint and Type Check
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run Biome linter
+        run: bun run lint
+
+      - name: Run TypeScript type check
+        run: bun run tsc:check
+
+      - name: Check worker/API DB boundary
+        run: bash scripts/check-db-boundary.sh
+
+  test:
+    name: Run Tests
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run tests
+        run: bun test
+
+  pi-skills-freshness:
+    name: Pi-Skills Freshness Check
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Rebuild pi-skills and check for drift
+        run: |
+          bun run build:pi-skills
+          if [ -n "$(git diff --name-only plugin/pi-skills/)" ]; then
+            echo "::error::pi-skills are out of date! Run 'bun run build:pi-skills' and commit the changes."
+            git diff --stat plugin/pi-skills/
+            exit 1
+          fi
+          echo "pi-skills are up to date."
+
+  openapi-freshness:
+    name: OpenAPI Spec Freshness Check
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+      - name: Rebuild OpenAPI spec and check for drift
+        run: |
+          bun run docs:openapi
+          if [ -n "$(git diff --name-only openapi.json)" ]; then
+            echo "::error::openapi.json is out of date! Run 'bun run docs:openapi' and commit the changes."
+            git diff --stat openapi.json
+            exit 1
+          fi
+          echo "OpenAPI spec is up to date."
+      - name: Check generated API docs for drift
+        run: |
+          if [ -n "$(git diff --name-only docs-site/content/docs/api-reference/)" ]; then
+            echo "::error::API reference docs are out of date! Run 'bun run docs:openapi' and commit the changes."
+            git diff --stat docs-site/content/docs/api-reference/
+            exit 1
+          fi
+          echo "API reference docs are up to date."
+      - name: Check for raw matchRoute usage
+        run: |
+          UNREGISTERED=$(grep -rn "matchRoute(" src/http/ --include="*.ts" | grep -v "route-def.ts" | grep -v "utils.ts" || true)
+          if [ -n "$UNREGISTERED" ]; then
+            echo "::error::Found raw matchRoute() calls. Convert to route() definitions:"
+            echo "$UNREGISTERED"
+            exit 1
+          fi
+          echo "No raw matchRoute() calls found."
+
+  docker-build:
+    name: Docker Build Test
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        dockerfile: [Dockerfile, Dockerfile.worker]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./${{ matrix.dockerfile }}
+          push: false
+          tags: test-image:latest
+
+  new-ui-lint:
+    name: New UI Lint and Type Check
+    needs: detect-changes
+    if: needs.detect-changes.outputs.new-ui == 'true'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: new-ui
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install pnpm
+        run: npm install -g pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run Biome linter
+        run: pnpm lint
+
+      - name: Run TypeScript type check
+        run: pnpm exec tsc --noEmit
+
+  gate:
+    name: Merge Gate
+    needs: [detect-changes, lint-and-typecheck, test, pi-skills-freshness, openapi-freshness, docker-build, new-ui-lint]
+    if: always()
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check results
+        run: |
+          results='${{ toJSON(needs.*.result) }}'
+          echo "Job results: $results"
+          if echo "$results" | jq -e 'map(select(. != "success" and . != "skipped")) | length > 0' > /dev/null 2>&1; then
+            echo "::error::Some required jobs failed!"
+            exit 1
+          fi
+          echo "All jobs passed or were skipped."

package/.opencode/plugins/entire.ts

@@ -0,0 +1,133 @@
+// Entire CLI plugin for OpenCode
+// Auto-generated by `entire enable --agent opencode`
+// Do not edit manually — changes will be overwritten on next install.
+// Requires Bun runtime (used by OpenCode's plugin system for loading ESM plugins).
+import type { Plugin } from "@opencode-ai/plugin"
+
+export const EntirePlugin: Plugin = async ({ $, directory }) => {
+  const ENTIRE_CMD = "entire"
+  // Track seen user messages to fire turn-start only once per message
+  const seenUserMessages = new Set<string>()
+  // Track current session ID for message events (which don't include sessionID)
+  let currentSessionID: string | null = null
+  // In-memory store for message metadata (role, tokens, etc.)
+  const messageStore = new Map<string, any>()
+
+  /**
+   * Pipe JSON payload to an entire hooks command (async).
+   * Errors are logged but never thrown — plugin failures must not crash OpenCode.
+   */
+  async function callHook(hookName: string, payload: Record<string, unknown>) {
+    try {
+      const json = JSON.stringify(payload)
+      await $`echo ${json} | ${ENTIRE_CMD} hooks opencode ${hookName}`.quiet().nothrow()
+    } catch {
+      // Silently ignore — plugin failures must not crash OpenCode
+    }
+  }
+
+  /**
+   * Synchronous variant for hooks that fire near process exit (turn-end, session-end).
+   * `opencode run` breaks its event loop on the same session.status idle event that
+   * triggers turn-end. The async callHook would be killed before completing.
+   * Bun.spawnSync blocks the event loop, preventing exit until the hook finishes.
+   */
+  function callHookSync(hookName: string, payload: Record<string, unknown>) {
+    try {
+      const json = JSON.stringify(payload)
+      Bun.spawnSync(["sh", "-c", `${ENTIRE_CMD} hooks opencode ${hookName}`], {
+        cwd: directory,
+        stdin: new TextEncoder().encode(json + "\n"),
+        stdout: "ignore",
+        stderr: "ignore",
+      })
+    } catch {
+      // Silently ignore — plugin failures must not crash OpenCode
+    }
+  }
+
+  return {
+    event: async ({ event }) => {
+      switch (event.type) {
+        case "session.created": {
+          const session = (event as any).properties?.info
+          if (!session?.id) break
+          // Reset per-session tracking state when switching sessions.
+          if (currentSessionID !== session.id) {
+            seenUserMessages.clear()
+            messageStore.clear()
+          }
+          currentSessionID = session.id
+          await callHook("session-start", {
+            session_id: session.id,
+          })
+          break
+        }
+
+        case "message.updated": {
+          const msg = (event as any).properties?.info
+          if (!msg) break
+          // Store message metadata (role, time, tokens, etc.)
+          messageStore.set(msg.id, msg)
+          break
+        }
+
+        case "message.part.updated": {
+          const part = (event as any).properties?.part
+          if (!part?.messageID) break
+
+          // Fire turn-start on the first text part of a new user message
+          const msg = messageStore.get(part.messageID)
+          if (msg?.role === "user" && part.type === "text" && !seenUserMessages.has(msg.id)) {
+            seenUserMessages.add(msg.id)
+            const sessionID = msg.sessionID ?? currentSessionID
+            if (sessionID) {
+              await callHook("turn-start", {
+                session_id: sessionID,
+                prompt: part.text ?? "",
+              })
+            }
+          }
+          break
+        }
+
+        case "session.status": {
+          // session.status fires in both TUI and non-interactive (run) mode.
+          // session.idle is deprecated and not reliably emitted in run mode.
+          const props = (event as any).properties
+          if (props?.status?.type !== "idle") break
+          const sessionID = props?.sessionID
+          if (!sessionID) break
+          // Use sync variant: `opencode run` exits on the same idle event,
+          // so an async hook would be killed before completing.
+          callHookSync("turn-end", {
+            session_id: sessionID,
+          })
+          break
+        }
+
+        case "session.compacted": {
+          const sessionID = (event as any).properties?.sessionID
+          if (!sessionID) break
+          await callHook("compaction", {
+            session_id: sessionID,
+          })
+          break
+        }
+
+        case "session.deleted": {
+          const session = (event as any).properties?.info
+          if (!session?.id) break
+          seenUserMessages.clear()
+          messageStore.clear()
+          currentSessionID = null
+          // Use sync variant: session-end may fire during shutdown.
+          callHookSync("session-end", {
+            session_id: session.id,
+          })
+          break
+        }
+      }
+    },
+  }
+}

package/.superset/config.json

@@ -0,0 +1,6 @@
+{
+  "setup": [
+    "WTS_WORKTREE_PATH=\"/Users/taras/.superset/worktrees/agent-swarm/$SUPERSET_WORKSPACE_NAME\" \\\nWTS_GIT_ROOT=\"$SUPERSET_ROOT_PATH\" \\\n    bun .wts-setup.ts"
+  ],
+  "teardown": []
+}

package/.wts-setup.ts

@@ -14,46 +14,92 @@ const worktreeName = basename(worktreePath);
 
 console.log(`Setting up worktree "${worktreeName}" at ${worktreePath}...`);
 
-// Generate a unique port based on worktree index
-// Main repo uses 3013, worktrees use 3014+
-async function getUniquePort(): Promise<number> {
-  const basePort = 3013;
+// Pick a random available port in 3100-3999
+async function getRandomPort(maxAttempts = 10): Promise<number> {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = 3100 + Math.floor(Math.random() * 900);
+    const available = await isPortAvailable(port);
+    if (available) return port;
+  }
+  // Final fallback: hash-based port from worktree name
+  let hash = 0;
+  for (const char of worktreeName) {
+    hash = ((hash << 5) - hash + char.charCodeAt(0)) | 0;
+  }
+  return 3100 + (Math.abs(hash) % 900);
+}
+
+async function isPortAvailable(port: number): Promise<boolean> {
   try {
-    // Count existing worktrees to determine port offset
-    const worktreesDir = join(gitRoot, ".worktrees");
-    if (await exists(worktreesDir)) {
-      const worktrees = await readdir(worktreesDir);
-      return basePort + worktrees.length;
-    }
+    const result = await Bun.$`lsof -i :${port} -t`.quiet();
+    // If lsof returns output, port is in use
+    return result.stdout.toString().trim() === "";
   } catch {
-    // Fallback: use a hash of the worktree name
-    let hash = 0;
-    for (const char of worktreeName) {
-      hash = ((hash << 5) - hash + char.charCodeAt(0)) | 0;
-    }
-    return basePort + 1 + (Math.abs(hash) % 100);
+    // lsof exits non-zero when nothing found — port is available
+    return true;
   }
-  return basePort + 1;
 }
 
-const port = await getUniquePort();
-console.log(`Using port ${port} for this worktree`);
-
 // --- Copy and configure .env ---
 const mainEnv = join(gitRoot, ".env");
 const envExample = join(worktreePath, ".env.example");
 const targetEnv = join(worktreePath, ".env");
 
-if (await exists(mainEnv)) {
-  console.log("Copying .env from main repo...");
-  let envContent = await readFile(mainEnv, "utf-8");
-  // Update PORT to the unique port
-  envContent = envContent.replace(/^PORT=\d+/m, `PORT=${port}`);
-  await writeFile(targetEnv, envContent);
-} else if (await exists(envExample)) {
-  console.log("Creating .env from .env.example...");
-  let envContent = await readFile(envExample, "utf-8");
-  envContent = envContent.replace(/^PORT=\d+/m, `PORT=${port}`);
+// Read main .env to detect portless mode
+const mainEnvContent = (await exists(mainEnv))
+  ? await readFile(mainEnv, "utf-8")
+  : (await exists(envExample))
+    ? await readFile(envExample, "utf-8")
+    : "";
+
+const isPortless = mainEnvContent.includes("localhost:1355");
+const slug = worktreeName.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+
+if (isPortless) {
+  console.log(`Portless mode: using ${slug}.api.swarm.localhost:1355`);
+} else {
+  console.log(`Port mode: allocating unique port`);
+}
+
+const port = isPortless ? 0 : await getRandomPort();
+const uiPort = isPortless ? 0 : port + 1000;
+
+if (!isPortless) {
+  console.log(`Using port ${port} for this worktree`);
+}
+
+if (mainEnvContent) {
+  console.log(
+    (await exists(mainEnv))
+      ? "Copying .env from main repo..."
+      : "Creating .env from .env.example...",
+  );
+  let envContent = mainEnvContent;
+
+  if (isPortless) {
+    // Rewrite portless URLs with worktree subdomain
+    envContent = envContent.replace(
+      /(MCP_BASE_URL=https?:\/\/)([\w.-]*)(api\.swarm\.localhost:1355)/m,
+      `$1${slug}.$3`,
+    );
+    envContent = envContent.replace(
+      /(APP_URL=https?:\/\/)([\w.-]*)(ui\.swarm\.localhost:1355)/m,
+      `$1${slug}.$3`,
+    );
+    envContent = envContent.replace(
+      /(LINEAR_REDIRECT_URI=https?:\/\/)([\w.-]*)(api\.swarm\.localhost:1355)/m,
+      `$1${slug}.$3`,
+    );
+  } else {
+    // Port-based rewriting (existing logic)
+    envContent = envContent.replace(/^PORT=\d+/m, `PORT=${port}`);
+    envContent = envContent.replace(/:\d+/g, `:${port}`);
+    envContent = envContent.replace(
+      /APP_URL=http:\/\/localhost:\d+/m,
+      `APP_URL=http://localhost:${uiPort}`,
+    );
+  }
+
   await writeFile(targetEnv, envContent);
 }
 
@@ -62,13 +108,30 @@ const mainMcp = join(gitRoot, ".mcp.json");
 const targetMcp = join(worktreePath, ".mcp.json");
 
 if (await exists(mainMcp)) {
-  console.log("Copying .mcp.json with updated port...");
+  console.log("Copying .mcp.json with updated URL...");
   let mcpContent = await readFile(mainMcp, "utf-8");
-  // Update the port in the MCP URL
-  mcpContent = mcpContent.replace(/localhost:\d+/g, `localhost:${port}`);
+
+  if (isPortless) {
+    mcpContent = mcpContent.replace(
+      /https?:\/\/[\w.-]*api\.swarm\.localhost:1355/g,
+      `https://${slug}.api.swarm.localhost:1355`,
+    );
+  } else {
+    mcpContent = mcpContent.replace(/localhost:\d+/g, `localhost:${port}`);
+  }
+
   await writeFile(targetMcp, mcpContent);
 }
 
+const mainQa = join(gitRoot, ".qa-use-tests.json");
+const targetQa = join(worktreePath, ".qa-use-tests.json");
+
+if (await exists(mainQa)) {
+  console.log("Copying .qa-use-tests.json...");
+  let qaContent = await readFile(mainQa, "utf-8");
+  await writeFile(targetQa, qaContent);
+}
+
 // --- Copy .claude directory ---
 const mainClaude = join(gitRoot, ".claude");
 const targetClaude = join(worktreePath, ".claude");
@@ -98,5 +161,11 @@ for (const envFile of dockerEnvFiles) {
 console.log("Installing dependencies...");
 await Bun.$`bun install`;
 
-console.log(`\nSetup complete! Worktree running on port ${port}`);
+if (isPortless) {
+  console.log(`\nSetup complete! Worktree using portless subdomain: ${slug}`);
+  console.log(`API: https://${slug}.api.swarm.localhost:1355`);
+  console.log(`UI:  https://${slug}.ui.swarm.localhost:1355`);
+} else {
+  console.log(`\nSetup complete! Worktree running on port ${port}`);
+}
 console.log(`Start the server with: bun run dev:http`);