@desplega.ai/agent-swarm 1.87.0 → 1.89.0

package/src/commands/onboard/dashboard-url.ts

@@ -0,0 +1,29 @@
+/**
+ * Build the swarm-dashboard deep-link the SPA reads after a local onboard.
+ *
+ * IMPORTANT: the dashboard SPA reads **camelCase** `apiUrl` / `apiKey` query
+ * params (see ui/src/hooks/use-config.ts → extractUrlParams) and silently
+ * ignores snake_case. An earlier version of these builders emitted snake_case
+ * `api_url` / `api_key`, so the auto-connect deep-link never worked. Keep these
+ * camelCase.
+ */
+
+const DEFAULT_DASHBOARD_BASE = "https://app.agent-swarm.dev";
+
+export type DashboardUrlParts = {
+  apiUrl: string;
+  apiKey?: string;
+  /** Optional connection name shown in the dashboard (camelCase `name`). */
+  name?: string;
+  /** Override the dashboard base (defaults to the production app). */
+  base?: string;
+};
+
+export function buildOnboardDashboardUrl(parts: DashboardUrlParts): string {
+  const params = new URLSearchParams();
+  params.set("apiUrl", parts.apiUrl);
+  if (parts.apiKey) params.set("apiKey", parts.apiKey);
+  if (parts.name) params.set("name", parts.name);
+  const base = (parts.base ?? DEFAULT_DASHBOARD_BASE).replace(/\/+$/, "");
+  return `${base}?${params.toString()}`;
+}

package/src/commands/onboard/steps/post-dashboard.tsx

@@ -1,10 +1,12 @@
 import { Select } from "@inkjs/ui";
 import { Box, Text } from "ink";
+import { buildOnboardDashboardUrl } from "../dashboard-url.ts";
 import type { StepProps } from "../types.ts";
 
 export function PostDashboardStep({ state, addLog, goToNext }: StepProps) {
   const apiUrl = `http://localhost:${state.apiPort || 3013}`;
-  const dashboardUrl = `https://app.agent-swarm.dev?api_url=${apiUrl}&api_key=${state.apiKey}`;
+  // camelCase params — the SPA ignores snake_case (see dashboard-url.ts).
+  const dashboardUrl = buildOnboardDashboardUrl({ apiUrl, apiKey: state.apiKey });
 
   return (
     <Box flexDirection="column" padding={1}>

package/src/commands/onboard.tsx

@@ -4,6 +4,7 @@ import { Box, Text, useApp, useInput } from "ink";
 import { useCallback, useEffect, useRef, useState } from "react";
 import pkg from "../../package.json";
 import { getApiKey } from "../utils/api-key.ts";
+import { buildOnboardDashboardUrl } from "./onboard/dashboard-url.ts";
 import { getAgentSummary, getPresetById, PRESETS } from "./onboard/presets.ts";
 import { CoreCredentialsStep } from "./onboard/steps/core-credentials.tsx";
 import { CustomTemplatesStep } from "./onboard/steps/custom-templates.tsx";
@@ -244,7 +245,8 @@ export function Onboard({ dryRun = false, yes = false, preset }: OnboardProps) {
 
   if (state.step === "done") {
     const apiUrl = `http://localhost:${state.apiPort || 3013}`;
-    const dashUrl = `https://app.agent-swarm.dev?api_url=${apiUrl}&api_key=${state.apiKey}`;
+    // camelCase params — the SPA ignores snake_case (see dashboard-url.ts).
+    const dashUrl = buildOnboardDashboardUrl({ apiUrl, apiKey: state.apiKey });
     const agentCount = state.services.reduce((sum, s) => sum + s.count, 0);
 
     return (

package/src/commands/runner.ts

@@ -126,14 +126,88 @@ async function readClaudeMd(clonePath: string, role: string): Promise<string | n
   return null;
 }
 
+export type SwarmAutostash = { ref: string; message: string };
+
+async function listSwarmAutostashes(clonePath: string, role: string): Promise<SwarmAutostash[]> {
+  try {
+    const result = await Bun.$`cd ${clonePath} && git stash list --format=%gd%x09%s`.quiet();
+    return result
+      .text()
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.includes("swarm-autostash"))
+      .flatMap((line) => {
+        const [ref, ...messageParts] = line.split("\t");
+        if (!ref) return [];
+        return [{ ref, message: messageParts.join("\t") || line }];
+      });
+  } catch (err) {
+    console.warn(
+      `[${role}] Could not inspect git stashes for ${clonePath}: ${scrubSecrets((err as Error).message)}`,
+    );
+    return [];
+  }
+}
+
+async function refreshExistingRepoForTask(
+  repoConfig: { name: string; clonePath: string; defaultBranch: string },
+  role: string,
+): Promise<string | null> {
+  const { name, clonePath, defaultBranch } = repoConfig;
+  const statusResult = await Bun.$`cd ${clonePath} && git status --porcelain`.quiet();
+  const statusOutput = statusResult.text().trim();
+  let stashMessage: string | null = null;
+
+  if (statusOutput !== "") {
+    stashMessage = `swarm-autostash ${defaultBranch} ${new Date().toISOString()}`;
+    try {
+      console.log(`[${role}] Auto-stashing pending work in ${name}: ${stashMessage}`);
+      await Bun.$`cd ${clonePath} && git stash push --include-untracked -m ${stashMessage}`.quiet();
+      console.log(`[${role}] Auto-stashed pending work in ${name}`);
+    } catch (err) {
+      const errorMsg = scrubSecrets((err as Error).message);
+      console.warn(`[${role}] Could not auto-stash ${name}, skipping pull: ${errorMsg}`);
+      return `The repo "${name}" at ${clonePath} has uncommitted changes, but auto-stash failed: ${errorMsg}. A git pull was skipped to avoid losing work.`;
+    }
+  }
+
+  try {
+    console.log(`[${role}] Refreshing ${name} from origin/${defaultBranch}...`);
+    const fetchSpec = `${defaultBranch}:refs/remotes/origin/${defaultBranch}`;
+    const remoteRef = `refs/remotes/origin/${defaultBranch}`;
+    await Bun.$`cd ${clonePath} && git fetch origin ${fetchSpec}`.quiet();
+    await Bun.$`cd ${clonePath} && git merge --no-edit --no-stat ${remoteRef}`.quiet();
+    console.log(`[${role}] Refreshed ${name}`);
+    return null;
+  } catch (err) {
+    const errorMsg = scrubSecrets((err as Error).message);
+    console.warn(`[${role}] Could not refresh ${name}: ${errorMsg}`);
+    try {
+      await Bun.$`cd ${clonePath} && git merge --abort`.quiet();
+    } catch {
+      // No merge in progress, or abort failed. The original refresh warning is
+      // the actionable signal; repo setup remains best-effort.
+    }
+    const stashNote = stashMessage
+      ? ` Pending work was preserved in git stash "${stashMessage}".`
+      : "";
+    return `The repo "${name}" at ${clonePath} could not be refreshed from origin/${defaultBranch}: ${errorMsg}.${stashNote}`;
+  }
+}
+
 /**
  * Ensure a repo is cloned and up-to-date for a task.
  * Returns { clonePath, claudeMd, warning }.
  */
-async function ensureRepoForTask(
+export async function ensureRepoForTask(
   repoConfig: { url: string; name: string; clonePath: string; defaultBranch: string },
   role: string,
-): Promise<{ clonePath: string; claudeMd: string | null; warning: string | null }> {
+): Promise<{
+  clonePath: string;
+  claudeMd: string | null;
+  warning: string | null;
+  autoStashes: SwarmAutostash[];
+}> {
   const { url, name, clonePath, defaultBranch } = repoConfig;
 
   try {
@@ -158,28 +232,20 @@ async function ensureRepoForTask(
       console.log(`[${role}] Cloned ${name}`);
     } else {
       console.log(`[${role}] Repo ${name} already cloned at ${clonePath}`);
-      const statusResult = await Bun.$`cd ${clonePath} && git status --porcelain`.quiet();
-      const statusOutput = statusResult.text().trim();
-
-      if (statusOutput === "") {
-        console.log(`[${role}] Pulling ${name} (${defaultBranch})...`);
-        await Bun.$`cd ${clonePath} && git pull origin ${defaultBranch} --ff-only`.quiet();
-        console.log(`[${role}] Pulled ${name}`);
-      } else {
-        console.warn(`[${role}] Repo ${name} has uncommitted changes, skipping pull`);
-        warning = `The repo "${name}" at ${clonePath} has uncommitted changes. A git pull was skipped to avoid losing work. You may need to commit or stash changes before pulling updates.`;
-      }
+      warning = await refreshExistingRepoForTask({ name, clonePath, defaultBranch }, role);
     }
 
     const claudeMd = await readClaudeMd(clonePath, role);
-    return { clonePath, claudeMd, warning };
+    const autoStashes = await listSwarmAutostashes(clonePath, role);
+    return { clonePath, claudeMd, warning, autoStashes };
   } catch (err) {
-    const errorMsg = (err as Error).message;
+    const errorMsg = scrubSecrets((err as Error).message);
     console.warn(`[${role}] Error setting up repo ${name}: ${errorMsg}`);
     const warning = `Failed to clone/setup repo "${name}" at ${clonePath}: ${errorMsg}. The repo may not be available. You may need to clone it manually.`;
     // Only return clonePath if the directory actually exists (clone may have failed)
     const cloneExists = existsSync(clonePath);
-    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning };
+    const autoStashes = cloneExists ? await listSwarmAutostashes(clonePath, role) : [];
+    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning, autoStashes };
   }
 }
 
@@ -1692,6 +1758,31 @@ async function cleanupActiveSessions(config: ApiConfig): Promise<void> {
   }
 }
 
+/** Reset orphaned in-progress tasks for this agent back to pending dispatch. */
+async function recoverOrphanedInProgressTasks(config: ApiConfig): Promise<number> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-Agent-ID": config.agentId,
+  };
+  if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+  try {
+    const response = await fetch(`${config.apiUrl}/api/active-sessions/recover-orphaned-tasks`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ agentId: config.agentId, minAgeSeconds: 60 }),
+    });
+    if (!response.ok) {
+      console.warn(`[runner] Failed to recover orphaned tasks: ${response.status}`);
+      return 0;
+    }
+    const data = (await response.json()) as { recovered?: number };
+    return data.recovered ?? 0;
+  } catch (error) {
+    console.warn(`[runner] Error recovering orphaned tasks: ${error}`);
+    return 0;
+  }
+}
+
 /** Trigger a heartbeat sweep via the API (lead startup self-check) */
 async function triggerHeartbeatSweep(config: ApiConfig): Promise<boolean> {
   try {
@@ -1743,7 +1834,7 @@ interface Trigger {
     text?: string;
   }>;
   cursorUpdates?: Array<{ channelId: string; ts: string }>; // Deferred cursor commits for channel_activity
-  requestedBy?: { name: string; email?: string };
+  requestedBy?: { name: string; email?: string; role?: string; notes?: string };
   // Phase 4 — budget_refused fields. The server emits this envelope from
   // /api/poll and MCP task-action accept when an admission gate refuses to
   // let the agent claim a task. Worker reads cause + reset/spend/budget for
@@ -1766,6 +1857,26 @@ interface PollOptions {
   since?: string; // Optional: for filtering finished tasks
 }
 
+type RequesterProfile = NonNullable<Trigger["requestedBy"]>;
+
+export async function buildRequesterProfilePrompt(
+  requestedBy: RequesterProfile | undefined,
+): Promise<string> {
+  if (!requestedBy?.role && !requestedBy?.notes) return "";
+
+  const notes = requestedBy.notes?.trim();
+  const notesSection = notes
+    ? `\nTheir stated notes for how you should respond and act:\n${notes}`
+    : "";
+  const result = await resolveTemplateAsync("task.requester.profile", {
+    requester_name: requestedBy.name,
+    requester_role_suffix: requestedBy.role ? ` (${requestedBy.role})` : "",
+    requester_notes_section: notesSection,
+  });
+
+  return result.skipped ? "" : result.text.trim();
+}
+
 /** Register agent via HTTP API */
 async function registerAgent(opts: {
   apiUrl: string;
@@ -3295,6 +3406,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       swarmUrl,
       capabilities,
       traits,
+      provider: adapter.name as ProviderName,
       name: agentProfileName,
       description: agentDescription,
       ...(traits.hasLocalEnvironment && {
@@ -3607,6 +3719,12 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   // Clean up any stale active sessions from previous runs (crash recovery)
   await cleanupActiveSessions(apiConfig);
   console.log(`[${role}] Cleaned up stale active sessions`);
+  const startupRecoveredOrphans = await recoverOrphanedInProgressTasks(apiConfig);
+  if (startupRecoveredOrphans > 0) {
+    console.log(
+      `[${role}] Recovered ${startupRecoveredOrphans} orphaned in-progress task(s) to pending`,
+    );
+  }
 
   // Fetch full agent profile to get soul/identity content
   try {
@@ -4083,7 +4201,10 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   // state persists across iterations.
   let consecutiveBudgetRefusals = 0;
 
-  // Track last finished task check for leads (to avoid re-processing)
+  // Throttle orphan recovery so it runs periodically while the worker is idle or under capacity.
+  let lastOrphanRecoveryAt = 0;
+  const ORPHAN_RECOVERY_INTERVAL_MS = 60_000;
+
   while (true) {
     // Ping server on each iteration to keep status updated
     await pingServer(apiConfig, role);
@@ -4179,6 +4300,16 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
 
     // Only poll if we have capacity
     if (state.activeTasks.size < state.maxConcurrent) {
+      if (Date.now() - lastOrphanRecoveryAt > ORPHAN_RECOVERY_INTERVAL_MS) {
+        lastOrphanRecoveryAt = Date.now();
+        const recoveredOrphans = await recoverOrphanedInProgressTasks(apiConfig);
+        if (recoveredOrphans > 0) {
+          console.log(
+            `[${role}] Recovered ${recoveredOrphans} orphaned in-progress task(s) to pending`,
+          );
+        }
+      }
+
       console.log(
         `[${role}] Polling for triggers (${state.activeTasks.size}/${state.maxConcurrent} active)...`,
       );
@@ -4418,10 +4549,11 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
 
         // Rebuild system prompt with per-task repo context
         const taskBasePrompt = await buildSystemPrompt();
-        const taskSystemPrompt =
-          (additionalSystemPrompt
-            ? `${taskBasePrompt}\n\n${additionalSystemPrompt}`
-            : taskBasePrompt) + cwdWarning;
+        const requesterProfilePrompt = await buildRequesterProfilePrompt(trigger.requestedBy);
+        const taskPromptParts = [taskBasePrompt, requesterProfilePrompt, additionalSystemPrompt]
+          .filter((part): part is string => Boolean(part))
+          .join("\n\n");
+        const taskSystemPrompt = taskPromptParts + cwdWarning;
 
         iteration++;
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");

package/src/commands/x.ts

@@ -0,0 +1,118 @@
+import { scrubSecrets } from "../utils/secret-scrubber";
+import {
+  DEFAULT_COMPOSIO_BASE_URL,
+  executeComposioRequest,
+  formatComposioResultForCli,
+  parseComposioArgs,
+} from "../x/composio";
+
+interface XCommandDeps {
+  env?: Record<string, string | undefined>;
+  error?: (message: string) => void;
+  exit?: (code: number) => void;
+  fetch?: typeof fetch;
+  log?: (message: string) => void;
+}
+
+export { parseComposioArgs } from "../x/composio";
+
+export async function runXCommand(argv: string[], deps: XCommandDeps = {}): Promise<void> {
+  const [target, ...rest] = argv;
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const exit = deps.exit ?? process.exit;
+
+  if (!target || target === "help" || target === "-h" || target === "--help") {
+    printXHelp(log);
+    return;
+  }
+
+  switch (target) {
+    case "composio":
+      await runComposioCommand(rest, deps);
+      return;
+    default:
+      error(`Unknown x target: ${target}`);
+      printXHelp(error);
+      exit(1);
+  }
+}
+
+export async function runComposioCommand(argv: string[], deps: XCommandDeps = {}): Promise<void> {
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const exit = deps.exit ?? process.exit;
+  const env = deps.env ?? process.env;
+
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "-h" || argv[0] === "--help") {
+    printComposioHelp(log);
+    return;
+  }
+
+  let parsed: ReturnType<typeof parseComposioArgs>;
+  try {
+    parsed = parseComposioArgs(argv, env);
+  } catch (err) {
+    error(`composio: ${scrubSecrets(errorMessage(err))}`);
+    printComposioHelp(error);
+    exit(1);
+    return;
+  }
+
+  const result = await executeComposioRequest(parsed, { env, fetch: deps.fetch });
+
+  if (!result.ok) {
+    if (result.status > 0) error(`composio: HTTP ${result.status} ${result.statusText}`.trim());
+    else error(`composio: ${result.error ?? result.statusText}`);
+    if (result.formattedBody) error(result.formattedBody);
+    exit(1);
+    return;
+  }
+
+  log(formatComposioResultForCli(result));
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+function printXHelp(log: (message: string) => void): void {
+  log(`Usage: agent-swarm x <target> [args]
+
+Targets:
+  composio    Route a request to the Composio REST API
+
+Examples:
+  agent-swarm x composio GET /tools
+  agent-swarm x composio POST /tools/execute/GITHUB_CREATE_AN_ISSUE --body '{"arguments":{}}'`);
+}
+
+function printComposioHelp(log: (message: string) => void): void {
+  log(`Usage: agent-swarm x composio <method> <path> [options]
+
+Routes an HTTP request to the Composio REST API.
+
+Arguments:
+  <method>              GET, POST, PUT, PATCH, DELETE, or HEAD
+  <path>                API path relative to ${DEFAULT_COMPOSIO_BASE_URL}
+
+Options:
+  --body, --data <json> JSON request body
+  -q, --query k=v       Append a query parameter (repeatable)
+  -H, --header k=v      Add a header (repeatable)
+  --base-url <url>      Override base URL (default: COMPOSIO_BASE_URL or v3.1 API)
+  --org                 Use COMPOSIO_ORG_API_KEY and x-org-api-key
+  --raw                 Print response text without JSON pretty formatting
+  -h, --help            Show this help
+
+Environment:
+  COMPOSIO_API_KEY      Project API key for x-api-key auth
+  COMPOSIO_ORG_API_KEY  Optional organization key for --org
+  COMPOSIO_BASE_URL     Optional API base URL override
+
+Examples:
+  agent-swarm x composio GET /tools
+  agent-swarm x composio GET /tools --query limit=10
+  agent-swarm x composio POST /tool_router/session --body '{"user_id":"swarm"}'
+  agent-swarm x composio POST /tools/execute/GITHUB_CREATE_AN_ISSUE --body '{"arguments":{}}'`);
+}