@cursor/july 0.1.23 → 0.1.24

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

@@ -1,127 +0,0 @@
-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

@@ -1,390 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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",
-    });
-  });
-});