@cursor/july 0.1.20 → 0.1.21

package/src/internal/prompt-context.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildIdentitySection,
+  buildSessionContextBlock,
+  channelPresenceLine,
+} from "./prompt-context.js";
+
+describe("buildIdentitySection", () => {
+  it("renders name and description in one section", () => {
+    const section = buildIdentitySection({
+      name: "pr-approver",
+      description: "Reviews GitHub pull requests.",
+    });
+    expect(section).toBe(
+      [
+        "## About you",
+        "",
+        'You are "pr-approver" — Reviews GitHub pull requests. You run as a persistent service: messages reach you through channels (such as Slack, GitHub, webhooks, or a web playground), and each conversation is a session that can continue across multiple turns.',
+      ].join("\n")
+    );
+  });
+
+  it("omits the description clause when absent", () => {
+    const section = buildIdentitySection({ name: "solo" });
+    expect(section).toContain(
+      'You are "solo". You run as a persistent service'
+    );
+    expect(section).not.toContain("—");
+  });
+
+  it("keeps names containing quotes verbatim", () => {
+    const section = buildIdentitySection({ name: 'the "best" bot' });
+    expect(section).toContain('You are "the "best" bot".');
+  });
+});
+
+describe("channelPresenceLine", () => {
+  it("marks http and mcp as live user channels", () => {
+    const live =
+      "A user is interacting with you live and sees your replies as they stream.";
+    expect(channelPresenceLine({ channelId: "http" })).toBe(live);
+    expect(channelPresenceLine({ channelId: "mcp" })).toBe(live);
+  });
+
+  it("resolves slack from the channel pack kind, whatever the file stem", () => {
+    const slack =
+      "You are replying in a Slack thread; participants will read your messages.";
+    expect(
+      channelPresenceLine({ channelId: "slack", channelKind: "slack" })
+    ).toBe(slack);
+    expect(
+      channelPresenceLine({ channelId: "slack-app", channelKind: "slack" })
+    ).toBe(slack);
+  });
+
+  it("resolves github from the channel pack kind", () => {
+    expect(
+      channelPresenceLine({ channelId: "pr-events", channelKind: "github" })
+    ).toContain("triggered by a GitHub event");
+  });
+
+  it("marks any schedule:* channel as unattended", () => {
+    expect(
+      channelPresenceLine({ channelId: "schedule:nightly-report" })
+    ).toContain("No user is watching");
+  });
+
+  it("returns undefined for unknown channels and kinds", () => {
+    expect(channelPresenceLine({ channelId: "discord" })).toBeUndefined();
+    expect(channelPresenceLine({ channelId: "schedules" })).toBeUndefined();
+    expect(
+      channelPresenceLine({ channelId: "custom", channelKind: "discord" })
+    ).toBeUndefined();
+  });
+
+  it("does not infer slack/github semantics from the file stem alone", () => {
+    expect(
+      channelPresenceLine({ channelId: "slack", channelKind: undefined })
+    ).toBeUndefined();
+  });
+});
+
+describe("buildSessionContextBlock", () => {
+  const now = new Date("2026-07-16T12:34:56.000Z");
+
+  it("renders the tagged block with a presence line", () => {
+    const block = buildSessionContextBlock({
+      sessionId: "ses_abc",
+      channelId: "http",
+      environment: "local dev server",
+      now,
+    });
+    expect(block).toBe(
+      [
+        "<agentkit_context>",
+        "session: ses_abc",
+        "channel: http",
+        "environment: local dev server",
+        "time: 2026-07-16T12:34:56.000Z",
+        "</agentkit_context>",
+        "A user is interacting with you live and sees your replies as they stream.",
+      ].join("\n")
+    );
+  });
+
+  it("omits the presence line for unknown channels", () => {
+    const block = buildSessionContextBlock({
+      sessionId: "ses_abc",
+      channelId: "custom-webhook",
+      environment: "hosted deployment",
+      now,
+    });
+    expect(block.endsWith("</agentkit_context>")).toBe(true);
+    expect(block).toContain("environment: hosted deployment");
+  });
+
+  it("stamps the current time in ISO 8601 UTC when no clock is given", () => {
+    const block = buildSessionContextBlock({
+      sessionId: "ses_abc",
+      channelId: "http",
+      environment: "local dev server",
+    });
+    const time = /time: (.+)\n/.exec(block)?.[1] ?? "";
+    expect(time).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+    expect(Math.abs(Date.parse(time) - Date.now())).toBeLessThan(5_000);
+  });
+});

package/src/internal/reminder-runner.test.ts

@@ -0,0 +1,390 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { defineStorage } from "../storage.js";
+import type { JsonValue } from "../types.js";
+import { ReminderRunner, ReminderValidationError } from "./reminder-runner.js";
+import type { SessionEngine } from "./session-engine.js";
+import { StorageCoordinator } from "./storage-coordinator.js";
+
+function mockEngine(
+  stateRoot: string,
+  storage?: StorageCoordinator
+): SessionEngine {
+  const send = vi.fn(async () => ({
+    id: "ses_1",
+    continuationToken: "tok",
+    isNew: false,
+    info: {
+      id: "ses_1",
+      channelId: "drive",
+      mode: "chat" as const,
+      auth: null,
+    },
+    getEventStream: () => ({}) as never,
+    waitForCompletion: async () => ({ status: "completed" as const }),
+  }));
+  return {
+    stateRoot,
+    storage,
+    host: {
+      mcp: {} as never,
+      github: {} as never,
+      slack: {} as never,
+    },
+    sessions: {
+      findByContinuation: vi.fn(async () => ({
+        sessionId: "ses_1",
+        channelId: "drive",
+        mode: "chat" as const,
+        auth: null,
+        continuationKey: "tok",
+        turnCount: 1,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      })),
+    },
+    send,
+    waitForCompletion: async () => ({ status: "completed" as const }),
+    trackBackground: () => {},
+    getChannelSession: async () => null,
+    isTurnRunning: () => false,
+  } as unknown as SessionEngine;
+}
+
+function memoryStorage(): {
+  coordinator: StorageCoordinator;
+  store: Map<string, JsonValue>;
+} {
+  const store = new Map<string, JsonValue>();
+  const definition = defineStorage({
+    put: (key, value) => {
+      store.set(key, value);
+    },
+    get: (key) => store.get(key),
+    delete: (key) => {
+      store.delete(key);
+    },
+    list: (prefix) =>
+      [...store.entries()]
+        .filter(([key]) => key.startsWith(prefix))
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .map(([key, value]) => ({ key, value })),
+  });
+  return {
+    coordinator: new StorageCoordinator({
+      definition,
+      agentName: "test-agent",
+      projectRoot: "/tmp/test-agent",
+      logger: () => {},
+    }),
+    store,
+  };
+}
+
+describe("ReminderRunner", () => {
+  let dir: string;
+
+  afterEach(async () => {
+    if (dir !== undefined) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("validates prompt XOR run and schedule shape", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const runner = new ReminderRunner(mockEngine(dir));
+    await expect(
+      runner.create({
+        purpose: "x",
+        channelId: "drive",
+        continuationToken: "tok",
+        prompt: "hi",
+        run: async () => ({ action: "skip" }),
+        delay: "1s",
+      })
+    ).rejects.toBeInstanceOf(ReminderValidationError);
+
+    await expect(
+      runner.create({
+        purpose: "x",
+        channelId: "drive",
+        continuationToken: "tok",
+        prompt: "hi",
+        every: "1m",
+        delay: "1s",
+      })
+    ).rejects.toBeInstanceOf(ReminderValidationError);
+  });
+
+  it("creates one-shot, dispatches, and completes", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    const created = await runner.create({
+      purpose: "ci_recheck",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      prompt: "check ci",
+    });
+    expect(created.status).toBe("armed");
+    expect(created.hasRunHandler).toBe(false);
+
+    await runner.dispatch(created.id);
+    const listed = await runner.list();
+    const done = listed.find((r) => r.id === created.id);
+    expect(done?.status).toBe("completed");
+    expect(engine.send).toHaveBeenCalled();
+    const message = (engine.send as ReturnType<typeof vi.fn>).mock
+      .calls[0]?.[1];
+    expect(message).toContain(`id=${created.id}`);
+    expect(message).toContain("check ci");
+  });
+
+  it("disarms prompt reminders when the bound session is gone", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    (
+      engine.sessions.findByContinuation as ReturnType<typeof vi.fn>
+    ).mockResolvedValue(undefined);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    const created = await runner.create({
+      purpose: "orphan",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      prompt: "should not wake",
+    });
+    const result = await runner.dispatch(created.id);
+    expect(result.outcome).toBe("fired");
+    expect(result.reason).toBe("session_gone");
+    const listed = await runner.list();
+    expect(listed.find((r) => r.id === created.id)?.status).toBe("disarmed");
+    expect(listed.find((r) => r.id === created.id)?.disarmReason).toBe(
+      "session_gone"
+    );
+    expect(engine.send).not.toHaveBeenCalled();
+  });
+
+  it("reports noop when dispatching a cancelled reminder", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+    const created = await runner.create({
+      purpose: "x",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      prompt: "hi",
+    });
+    await runner.cancel(created.id);
+    const result = await runner.dispatch(created.id);
+    expect(result).toEqual({
+      reminderId: created.id,
+      outcome: "noop",
+      reason: "not_armed",
+    });
+    expect(engine.send).not.toHaveBeenCalled();
+  });
+
+  it("rejects invalid reschedule.at instead of NaN-looping", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+    const created = await runner.create({
+      purpose: "watch",
+      channelId: "drive",
+      continuationToken: "tok",
+      every: "30m",
+      async run() {
+        return { action: "skip", reschedule: { at: "not-a-date" } };
+      },
+    });
+    await expect(runner.dispatch(created.id)).rejects.toBeInstanceOf(
+      ReminderValidationError
+    );
+    await runner.cancel(created.id);
+  });
+
+  it("includes reminder id and cancel guidance only for recurring until prompts", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    const oneshot = await runner.create({
+      purpose: "once",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      prompt: "one shot body",
+      until: "Stop when done.",
+    });
+    await runner.dispatch(oneshot.id);
+    const oneshotMsg = (engine.send as ReturnType<typeof vi.fn>).mock
+      .calls[0]?.[1] as string;
+    expect(oneshotMsg).toContain(`id=${oneshot.id}`);
+    expect(oneshotMsg).toContain("one-shot reminder");
+    expect(oneshotMsg).not.toContain("reminders_cancel");
+
+    (engine.send as ReturnType<typeof vi.fn>).mockClear();
+    const recurring = await runner.create({
+      purpose: "loop",
+      channelId: "drive",
+      continuationToken: "tok2",
+      every: "30m",
+      prompt: "loop body",
+      until: "Cancel when green.",
+    });
+    await runner.dispatch(recurring.id);
+    const loopMsg = (engine.send as ReturnType<typeof vi.fn>).mock
+      .calls[0]?.[1] as string;
+    expect(loopMsg).toContain(`id=${recurring.id}`);
+    expect(loopMsg).toContain(`reminders_cancel with id=${recurring.id}`);
+    await runner.cancel(recurring.id);
+  });
+
+  it("disarms when until function returns true", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    const created = await runner.create({
+      purpose: "watch",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      until: async () => true,
+      async run() {
+        return { action: "delivered" };
+      },
+    });
+    await runner.dispatch(created.id);
+    const listed = await runner.list();
+    expect(listed.find((r) => r.id === created.id)?.status).toBe("disarmed");
+    expect(engine.send).not.toHaveBeenCalled();
+  });
+
+  it("run handler can skip without waking the session", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    const created = await runner.create({
+      purpose: "watch",
+      channelId: "drive",
+      continuationToken: "tok",
+      every: "30m",
+      async run() {
+        return { action: "skip" };
+      },
+    });
+    await runner.dispatch(created.id);
+    const listed = await runner.list({ status: "armed" });
+    expect(listed.some((r) => r.id === created.id)).toBe(true);
+    expect(engine.send).not.toHaveBeenCalled();
+    await runner.cancel(created.id);
+  });
+
+  it("mirrors prompt reminders into defineStorage and hydrates a fresh host", async () => {
+    const { coordinator, store } = memoryStorage();
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engineA = mockEngine(dir, coordinator);
+    const runnerA = new ReminderRunner(engineA);
+    await runnerA.start();
+    const created = await runnerA.create({
+      purpose: "ci_recheck",
+      channelId: "drive",
+      continuationToken: "tok",
+      delay: "1h",
+      prompt: "check ci",
+    });
+    await coordinator.whenIdle();
+    expect(store.size).toBeGreaterThan(0);
+    runnerA.stop();
+
+    // Fresh state root (replacement host) + same sink.
+    const dirB = await mkdtemp(join(tmpdir(), "rem-runner-b-"));
+    try {
+      const engineB = mockEngine(dirB, coordinator);
+      const runnerB = new ReminderRunner(engineB);
+      await runnerB.start();
+      const listed = await runnerB.list({ status: "armed" });
+      const rem = listed.find((r) => r.id === created.id);
+      expect(rem?.purpose).toBe("ci_recheck");
+      expect(rem?.prompt).toBe("check ci");
+      expect(rem?.status).toBe("armed");
+      runnerB.stop();
+    } finally {
+      await rm(dirB, { recursive: true, force: true });
+    }
+  });
+
+  it("disarms run-handler reminders on restart when handlers are gone", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+    const created = await runner.create({
+      purpose: "watch",
+      channelId: "drive",
+      continuationToken: "tok",
+      every: "30m",
+      async run() {
+        return { action: "skip" };
+      },
+    });
+    runner.stop();
+
+    const restored = new ReminderRunner(engine);
+    await restored.start();
+    const listed = await restored.list();
+    const rem = listed.find((r) => r.id === created.id);
+    expect(rem?.status).toBe("disarmed");
+    expect(rem?.disarmReason).toBe("handler_lost_on_restart");
+    expect(engine.send).not.toHaveBeenCalled();
+  });
+
+  it("does not re-arm after cancel during an in-flight fire", async () => {
+    dir = await mkdtemp(join(tmpdir(), "rem-runner-"));
+    const engine = mockEngine(dir);
+    const runner = new ReminderRunner(engine);
+    await runner.start();
+
+    let releaseRun: (() => void) | undefined;
+    const runGate = new Promise<void>((resolve) => {
+      releaseRun = resolve;
+    });
+
+    const created = await runner.create({
+      purpose: "watch",
+      channelId: "drive",
+      continuationToken: "tok",
+      every: "30m",
+      async run() {
+        await runGate;
+        return { action: "delivered" };
+      },
+    });
+
+    const firePromise = runner.dispatch(created.id);
+    // Let fire() enter the run handler before cancel.
+    await new Promise((r) => setTimeout(r, 10));
+    await runner.cancel(created.id, "pr_closed");
+    releaseRun?.();
+    await firePromise;
+
+    const listed = await runner.list();
+    expect(listed.find((r) => r.id === created.id)?.status).toBe("cancelled");
+  });
+});

package/src/internal/reminder-store.test.ts

@@ -0,0 +1,53 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  isReminderRecord,
+  type ReminderRecord,
+  ReminderStore,
+} from "./reminder-store.js";
+
+describe("ReminderStore", () => {
+  let dir: string;
+
+  afterEach(async () => {
+    if (dir !== undefined) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("saves, lists, and loads armed reminders", async () => {
+    dir = await mkdtemp(join(tmpdir(), "agent-serve-reminders-"));
+    const store = new ReminderStore(dir);
+    const now = new Date().toISOString();
+    const record: ReminderRecord = {
+      version: 1,
+      id: "rem_test",
+      purpose: "merge_conflict_watch",
+      channelId: "drive",
+      continuationToken: "pr-owner-repo-1",
+      target: { prUrl: "https://github.com/owner/repo/pull/1" },
+      scheduleKind: "every",
+      scheduleValue: "30m",
+      intervalMs: 30 * 60_000,
+      hasRunHandler: true,
+      hasUntilFn: true,
+      busyPolicy: "skipIfBusy",
+      status: "armed",
+      fireCount: 0,
+      nextFireAtMs: Date.now() + 60_000,
+      createdAt: now,
+      updatedAt: now,
+    };
+    await store.save(record);
+    const loaded = await store.get("rem_test");
+    expect(loaded?.purpose).toBe("merge_conflict_watch");
+    const armed = await store.listArmed();
+    expect(armed).toHaveLength(1);
+    await store.delete("rem_test");
+    expect(await store.get("rem_test")).toBeUndefined();
+    expect(isReminderRecord(record)).toBe(true);
+    expect(isReminderRecord({ not: "a reminder" })).toBe(false);
+  });
+});

package/src/internal/request-headers.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { mergeRequestHeaders } from "./request-headers.js";
+
+describe("mergeRequestHeaders", () => {
+  it("returns empty object when unset", () => {
+    expect(mergeRequestHeaders(undefined)).toEqual({});
+    expect(mergeRequestHeaders({})).toEqual({});
+  });
+
+  it("adds Authorization bearer", () => {
+    expect(mergeRequestHeaders({ bearerToken: "secret" })).toEqual({
+      authorization: "Bearer secret",
+    });
+  });
+
+  it("merges engineAccess headers with bearer", () => {
+    expect(
+      mergeRequestHeaders({
+        bearerToken: "secret",
+        headers: { "x-anyrun-port-token": "pt" },
+      })
+    ).toEqual({
+      "x-anyrun-port-token": "pt",
+      authorization: "Bearer secret",
+    });
+  });
+});