@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/db-queries-oauth.test.ts

@@ -40,7 +40,7 @@ describe("OAuth Apps CRUD", () => {
   test("upsertOAuthApp creates a new app", async () => {
     await upsertOAuthApp("test-provider", {
       clientId: "client-123",
-      clientSecret: "secret-456",
+      clientSecret: "example-secret-456",
       authorizeUrl: "https://example.com/authorize",
       tokenUrl: "https://example.com/token",
       redirectUri: "https://example.com/callback",
@@ -51,7 +51,7 @@ describe("OAuth Apps CRUD", () => {
     expect(app).not.toBeNull();
     expect(app!.provider).toBe("test-provider");
     expect(app!.clientId).toBe("client-123");
-    expect(app!.clientSecret).toBe("secret-456");
+    expect(app!.clientSecret).toBe("example-secret-456");
     expect(app!.authorizeUrl).toBe("https://example.com/authorize");
     expect(app!.tokenUrl).toBe("https://example.com/token");
     expect(app!.redirectUri).toBe("https://example.com/callback");
@@ -62,7 +62,7 @@ describe("OAuth Apps CRUD", () => {
   test("upsertOAuthApp updates existing app on conflict", async () => {
     await upsertOAuthApp("test-provider", {
       clientId: "client-updated",
-      clientSecret: "secret-updated",
+      clientSecret: "example-secret-updated",
       authorizeUrl: "https://example.com/authorize-v2",
       tokenUrl: "https://example.com/token-v2",
       redirectUri: "https://example.com/callback-v2",
@@ -80,7 +80,7 @@ describe("OAuth Apps CRUD", () => {
   test("multiple providers can coexist", async () => {
     await upsertOAuthApp("provider-a", {
       clientId: "a-client",
-      clientSecret: "a-secret",
+      clientSecret: "example-a-secret",
       authorizeUrl: "https://a.com/authorize",
       tokenUrl: "https://a.com/token",
       redirectUri: "https://a.com/callback",
@@ -88,7 +88,7 @@ describe("OAuth Apps CRUD", () => {
     });
     await upsertOAuthApp("provider-b", {
       clientId: "b-client",
-      clientSecret: "b-secret",
+      clientSecret: "example-b-secret",
       authorizeUrl: "https://b.com/authorize",
       tokenUrl: "https://b.com/token",
       redirectUri: "https://b.com/callback",
@@ -162,8 +162,8 @@ describe("OAuth Tokens CRUD", () => {
 
     const futureDate = new Date(Date.now() + 3600000).toISOString();
     await storeOAuthTokens("token-test", {
-      accessToken: "access-abc",
-      refreshToken: "refresh-xyz",
+      accessToken: "example-access-abc",
+      refreshToken: "example-refresh-xyz",
       expiresAt: futureDate,
       scope: "read,write",
     });
@@ -171,94 +171,94 @@ describe("OAuth Tokens CRUD", () => {
     const tokens = await getOAuthTokens("token-test");
     expect(tokens).not.toBeNull();
     expect(tokens!.provider).toBe("token-test");
-    expect(tokens!.accessToken).toBe("access-abc");
-    expect(tokens!.refreshToken).toBe("refresh-xyz");
+    expect(tokens!.accessToken).toBe("example-access-abc");
+    expect(tokens!.refreshToken).toBe("example-refresh-xyz");
     expect(tokens!.scope).toBe("read,write");
   });
 
   test("storeOAuthTokens updates existing tokens (upsert)", async () => {
     const futureDate = new Date(Date.now() + 7200000).toISOString();
     await storeOAuthTokens("token-test", {
-      accessToken: "access-updated",
+      accessToken: "example-access-updated",
       expiresAt: futureDate,
     });
 
     const tokens = await getOAuthTokens("token-test");
-    expect(tokens!.accessToken).toBe("access-updated");
+    expect(tokens!.accessToken).toBe("example-access-updated");
     // refreshToken should be preserved (COALESCE)
-    expect(tokens!.refreshToken).toBe("refresh-xyz");
+    expect(tokens!.refreshToken).toBe("example-refresh-xyz");
   });
 
   test("updateOAuthTokensAfterRefresh replaces the rotated refresh token atomically", async () => {
     const futureDate = new Date(Date.now() + 7200000).toISOString();
     await storeOAuthTokens("token-test", {
-      accessToken: "access-before-refresh",
-      refreshToken: "refresh-before-refresh",
+      accessToken: "example-access-before-refresh",
+      refreshToken: "example-refresh-before-refresh",
       expiresAt: new Date(Date.now() + 60000).toISOString(),
     });
     const observed = (await getOAuthTokens("token-test"))!;
 
-    await updateOAuthTokensAfterRefresh("token-test", "refresh-before-refresh", {
-      accessToken: "access-after-refresh",
-      refreshToken: "refresh-after-refresh",
+    await updateOAuthTokensAfterRefresh("token-test", "example-refresh-before-refresh", {
+      accessToken: "example-access-after-refresh",
+      refreshToken: "example-refresh-after-refresh",
       expiresAt: futureDate,
       scope: "read,write",
       expectedTokenVersion: observed.tokenVersion,
     });
 
     const tokens = await getOAuthTokens("token-test");
-    expect(tokens!.accessToken).toBe("access-after-refresh");
-    expect(tokens!.refreshToken).toBe("refresh-after-refresh");
+    expect(tokens!.accessToken).toBe("example-access-after-refresh");
+    expect(tokens!.refreshToken).toBe("example-refresh-after-refresh");
     expect(tokens!.expiresAt).toBe(futureDate);
     expect(tokens!.scope).toBe("read,write");
   });
 
   test("updateOAuthTokensAfterRefresh refuses to overwrite a concurrently rotated token", async () => {
     await storeOAuthTokens("token-test", {
-      accessToken: "access-current",
-      refreshToken: "refresh-current",
+      accessToken: "example-access-current",
+      refreshToken: "example-refresh-current",
       expiresAt: new Date(Date.now() + 60000).toISOString(),
     });
 
     await expect(
       updateOAuthTokensAfterRefresh("token-test", "refresh-stale", {
-        accessToken: "access-stale-result",
-        refreshToken: "refresh-stale-result",
+        accessToken: "example-access-stale-result",
+        refreshToken: "example-refresh-stale-result",
         expiresAt: new Date(Date.now() + 7200000).toISOString(),
       }),
     ).rejects.toThrow(/stored refresh token changed during refresh/);
 
     const tokens = await getOAuthTokens("token-test");
-    expect(tokens!.accessToken).toBe("access-current");
-    expect(tokens!.refreshToken).toBe("refresh-current");
+    expect(tokens!.accessToken).toBe("example-access-current");
+    expect(tokens!.refreshToken).toBe("example-refresh-current");
   });
 
   test("updateOAuthTokensAfterRefresh rejects a stale version even when the refresh token is unchanged", async () => {
     await storeOAuthTokens("token-test", {
-      accessToken: "access-observed",
-      refreshToken: "refresh-stable",
+      accessToken: "example-access-observed",
+      refreshToken: "example-refresh-stable",
       expiresAt: new Date(Date.now() + 60000).toISOString(),
     });
     const observed = (await getOAuthTokens("token-test"))!;
 
     await storeOAuthTokens("token-test", {
-      accessToken: "access-concurrent-winner",
-      refreshToken: "refresh-stable",
+      accessToken: "example-access-concurrent-winner",
+      refreshToken: "example-refresh-stable",
       expiresAt: new Date(Date.now() + 3600000).toISOString(),
     });
 
     await expect(
-      updateOAuthTokensAfterRefresh("token-test", "refresh-stable", {
-        accessToken: "access-stale-result",
-        refreshToken: "refresh-stale-result",
+      updateOAuthTokensAfterRefresh("token-test", "example-refresh-stable", {
+        accessToken: "example-access-stale-result",
+        refreshToken: "example-refresh-stale-result",
         expiresAt: new Date(Date.now() + 7200000).toISOString(),
         expectedTokenVersion: observed.tokenVersion,
       }),
     ).rejects.toThrow(/no rows updated/);
 
     const tokens = await getOAuthTokens("token-test");
-    expect(tokens?.accessToken).toBe("access-concurrent-winner");
-    expect(tokens?.refreshToken).toBe("refresh-stable");
+    expect(tokens?.accessToken).toBe("example-access-concurrent-winner");
+    expect(tokens?.refreshToken).toBe("example-refresh-stable");
   });
 
   test("listAuthorizationSweepRows normalizes legacy bare expiresAt values", async () => {
@@ -282,15 +282,15 @@ describe("OAuth Tokens CRUD", () => {
   test("deleteOAuthTokens revokes in place and reconnect reuses the authorization id", async () => {
     await upsertOAuthApp("disconnect-continuity", {
       clientId: "client-dc",
-      clientSecret: "secret-dc",
+      clientSecret: "example-secret-dc",
       authorizeUrl: "https://example.com/authorize",
       tokenUrl: "https://example.com/token",
       redirectUri: "https://example.com/callback",
       scopes: "read",
     });
     await storeOAuthTokens("disconnect-continuity", {
-      accessToken: "access-original",
-      refreshToken: "refresh-original",
+      accessToken: "example-access-original",
+      refreshToken: "example-refresh-original",
       expiresAt: new Date(Date.now() + 3600000).toISOString(),
     });
     const originalId = await getDefaultAuthorizationIdForProvider("disconnect-continuity");
@@ -303,15 +303,15 @@ describe("OAuth Tokens CRUD", () => {
     expect(await getDefaultAuthorizationIdForProvider("disconnect-continuity")).toBe(originalId);
 
     await storeOAuthTokens("disconnect-continuity", {
-      accessToken: "access-reconnected",
-      refreshToken: "refresh-reconnected",
+      accessToken: "example-access-reconnected",
+      refreshToken: "example-refresh-reconnected",
       expiresAt: new Date(Date.now() + 3600000).toISOString(),
     });
     // Reconnect reuses the same authorization id.
     expect(await getDefaultAuthorizationIdForProvider("disconnect-continuity")).toBe(originalId);
     const reconnected = await getOAuthTokens("disconnect-continuity");
     expect(reconnected?.id).toBe(originalId);
-    expect(reconnected?.accessToken).toBe("access-reconnected");
+    expect(reconnected?.accessToken).toBe("example-access-reconnected");
   });
 });
 

package/src/tests/defer-task.test.ts

@@ -19,6 +19,7 @@ import {
   completeTask,
   createAgent,
   createTaskExtended,
+  createUser,
   createWorkflow,
   createWorkflowRun,
   createWorkflowRunStep,
@@ -183,14 +184,30 @@ describe("defer-task handler", () => {
 
     const stored = await getTaskById(task.id);
     expect(stored?.status).toBe("completed");
-    // Summary first, then the deferral status line, then the checks.
-    expect(stored?.output).toBe(
+    // Human-facing output: one line, `Deferred until {date} {time} ({link}) -> {desc}`.
+    // No requestedByUserId is set on this task, so it falls back to UTC and
+    // labels it explicitly.
+    const shortId = schedule.id.slice(0, 8);
+    expect(stored?.output).toMatch(
+      /^Deferred until (today|tomorrow|\d{2}-\d{2}) \d{2}:\d{2}:\d{2} UTC \(/,
+    );
+    expect(stored?.output).toContain(
+      `([${shortId}](https://app.agent-swarm.dev/schedules/${schedule.id})) -> deploy 42 is still running`,
+    );
+    expect(stored?.output).not.toContain(schedule.nextRunAt!);
+    expect(stored?.output).not.toContain("Checks:");
+    expect(stored?.output).not.toContain("- smoke tests pass");
+    expect(stored?.output).not.toContain("Pending:");
+    expect(stored?.output).not.toContain(SUMMARY);
+
+    // Full detail (ISO timestamp, schedule id, checks) lands in the task log.
+    const logs = (await getLogsByTaskId(task.id)).filter(
+      (log) => log.eventType === "task_progress",
+    );
+    expect(logs).toHaveLength(1);
+    expect(logs[0]!.newValue).toBe(
       `${SUMMARY}\n\nDeferred until ${schedule.nextRunAt} (schedule ${schedule.id}). Pending: deploy 42 is still running\n\nChecks:\n- deploy 42 status is green\n- smoke tests pass`,
     );
-    expect(stored?.output).toContain("Pending: deploy 42 is still running");
-    expect(stored?.output).toContain(schedule.nextRunAt!);
-    expect(stored?.output).toContain(schedule.id);
-    expect(stored?.output).toContain("- smoke tests pass");
   });
 
   test("runAt path is honoured verbatim", async () => {
@@ -423,8 +440,56 @@ describe("defer-task handler", () => {
       meta(),
     )) as DeferTaskResult;
     expect(result.structuredContent.success).toBe(true);
-    expect((await getTaskById(task.id))?.output).toBe(
-      `${SUMMARY}\n\nDeferred until ${result.structuredContent.nextRunAt} (schedule ${result.structuredContent.scheduleId}). Pending: pending`,
+    const stored = await getTaskById(task.id);
+    const shortId = result.structuredContent.scheduleId!.slice(0, 8);
+    expect(stored?.output).toMatch(
+      /^Deferred until (today|tomorrow|\d{2}-\d{2}) \d{2}:\d{2}:\d{2} UTC \(/,
+    );
+    expect(stored?.output).toContain(`([${shortId}](`);
+    expect(stored?.output).toContain(") -> pending");
+    expect(stored?.output).not.toContain(SUMMARY);
+  });
+
+  test("human-facing output strips a repeated Pending: prefix and caps a long note", async () => {
+    const task = await startedTask("verbose note");
+    const longNote = `Pending: ${"x".repeat(300)}\nsecond line is dropped`;
+    const result = (await buildTool().handler(
+      { taskId: task.id, delayMs: 60_000, summary: SUMMARY, note: longNote },
+      meta(),
+    )) as DeferTaskResult;
+
+    expect(result.structuredContent.success).toBe(true);
+    const stored = await getTaskById(task.id);
+    // No doubled "Pending: Pending:", no second line, capped with an ellipsis.
+    expect(stored?.output).not.toContain("Pending: Pending:");
+    expect(stored?.output).not.toContain("second line is dropped");
+    expect(stored?.output).toContain(`-> ${"x".repeat(99)}…`);
+
+    // The full untrimmed note still reaches the task log and the wake-up task.
+    const logs = (await getLogsByTaskId(task.id)).filter(
+      (log) => log.eventType === "task_progress",
+    );
+    expect(logs[0]!.newValue).toContain(`Pending: ${longNote}`);
+    const schedules = await schedulesForTask(task.id);
+    expect(schedules[0]!.taskTemplate).toContain(longNote);
+  });
+
+  test("human-facing time renders in the requester's timezone, unlabelled, when one is on file", async () => {
+    const user = await createUser({ name: "Requester", timezone: "America/New_York" });
+    const task = await startedTask("waiting on requester", agentId, {
+      requestedByUserId: user.id,
+    });
+
+    const result = (await buildTool().handler(
+      { taskId: task.id, delayMs: 60_000, summary: SUMMARY, note: "pending" },
+      meta(),
+    )) as DeferTaskResult;
+
+    expect(result.structuredContent.success).toBe(true);
+    const stored = await getTaskById(task.id);
+    // A real timezone is on file: no explicit "UTC" label on the time.
+    expect(stored?.output).toMatch(
+      /^Deferred until (today|tomorrow|\d{2}-\d{2}) \d{2}:\d{2}:\d{2} \(/,
     );
   });
 

package/src/tests/deferred-task-wait-migration.test.ts

@@ -0,0 +1,64 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+
+test("multi-task wait migration preserves legacy claims, audit fields, and current watched IDs", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec("PRAGMA foreign_keys = ON; CREATE TABLE scheduled_tasks (id TEXT PRIMARY KEY)");
+    db.exec(
+      await Bun.file(
+        new URL("../be/migrations/150_deferred_task_waits.sql", import.meta.url),
+      ).text(),
+    );
+    for (const status of ["pending", "fired"]) {
+      db.run("INSERT INTO scheduled_tasks VALUES (?)", [status]);
+      db.run(
+        `INSERT INTO deferred_task_waits
+         (scheduleId, taskId, eventName, status, firedBy, childTaskId, resolvedAt,
+          created_at, updated_at, created_by, updated_by)
+         VALUES (?, ?, 'settled', ?, ?, ?, ?, 'created', 'updated', 'creator', 'updater')`,
+        [
+          status,
+          `resumed-${status}`,
+          status,
+          status === "fired" ? "ceiling" : null,
+          status === "fired" ? "child" : null,
+          status === "fired" ? "resolved" : null,
+        ],
+      );
+    }
+    const before = db
+      .query("SELECT * FROM deferred_task_waits ORDER BY scheduleId")
+      .all() as Record<string, unknown>[];
+    const sql = await Bun.file(
+      new URL("../be/migrations/153_deferred_task_wait_members.sql", import.meta.url),
+    ).text();
+    db.transaction(() => db.exec(sql))();
+    for (const { taskId, ...wait } of before) {
+      expect(
+        db
+          .query("SELECT * FROM deferred_task_waits WHERE scheduleId = ?")
+          .get(wait.scheduleId as string),
+      ).toEqual({ ...wait, mode: "all" });
+      expect(
+        db
+          .query("SELECT * FROM deferred_task_wait_members WHERE scheduleId = ?")
+          .get(wait.scheduleId as string),
+      ).toEqual({
+        scheduleId: wait.scheduleId,
+        taskId,
+        created_at: "created",
+        updated_at: "updated",
+        created_by: "creator",
+        updated_by: "updater",
+      });
+    }
+    db.run("DELETE FROM scheduled_tasks WHERE id = 'pending'");
+    expect(
+      db.query("SELECT * FROM deferred_task_wait_members WHERE scheduleId = 'pending'").all(),
+    ).toEqual([]);
+    expect(db.query("PRAGMA foreign_key_check").all()).toEqual([]);
+  } finally {
+    db.close();
+  }
+});