@1kbirds/chidori-mock-gmail 0.1.0

package/dist/ui/styles.css

@@ -0,0 +1,340 @@
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #202124;
+  background: #f6f8fc;
+}
+
+button,
+input,
+textarea {
+  font: inherit;
+}
+
+.gmail-shell {
+  min-height: 100vh;
+  display: grid;
+  grid-template-columns: 248px 1fr;
+}
+
+.gmail-sidebar {
+  padding: 18px 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+
+.gmail-brand {
+  font-size: 23px;
+  font-weight: 600;
+  padding-left: 8px;
+}
+
+.gmail-compose {
+  width: fit-content;
+  border: 0;
+  border-radius: 8px;
+  padding: 13px 20px;
+  background: #c2e7ff;
+  color: #001d35;
+  box-shadow: 0 1px 2px rgb(60 64 67 / 30%);
+  cursor: pointer;
+}
+
+.gmail-sidebar nav,
+.gmail-labels {
+  display: grid;
+  gap: 3px;
+}
+
+.gmail-sidebar nav button,
+.gmail-labels button {
+  border: 0;
+  border-radius: 0 18px 18px 0;
+  padding: 8px 12px;
+  background: transparent;
+  display: flex;
+  justify-content: space-between;
+  cursor: pointer;
+  text-align: left;
+}
+
+.gmail-sidebar nav button.active,
+.gmail-labels button.active {
+  background: #d3e3fd;
+  font-weight: 700;
+}
+
+.gmail-labels h2 {
+  margin: 0;
+  padding: 0 12px;
+  color: #5f6368;
+  font-size: 13px;
+}
+
+.gmail-account {
+  margin-top: auto;
+  display: grid;
+  gap: 5px;
+  padding: 10px;
+  color: #5f6368;
+  font-size: 13px;
+}
+
+.gmail-account strong {
+  color: #202124;
+}
+
+.gmail-account button,
+.gmail-actions button,
+.gmail-composer button {
+  border: 1px solid #dadce0;
+  background: #fff;
+  border-radius: 6px;
+  padding: 7px 10px;
+  cursor: pointer;
+}
+
+.gmail-main {
+  min-width: 0;
+  display: grid;
+  grid-template-rows: auto 1fr;
+}
+
+.gmail-toolbar {
+  min-height: 66px;
+  display: grid;
+  grid-template-columns: minmax(260px, 680px) auto;
+  align-items: center;
+  gap: 18px;
+  padding: 12px 20px;
+}
+
+.gmail-toolbar input {
+  border: 0;
+  border-radius: 8px;
+  background: #eaf1fb;
+  padding: 13px 16px;
+  outline: 0;
+}
+
+.gmail-toolbar div {
+  display: grid;
+  gap: 2px;
+  justify-self: end;
+  text-align: right;
+}
+
+.gmail-toolbar span {
+  color: #5f6368;
+  font-size: 12px;
+}
+
+.gmail-workspace {
+  min-height: 0;
+  display: grid;
+  grid-template-columns: minmax(280px, 420px) 1fr;
+  gap: 16px;
+  padding: 0 20px 20px 0;
+}
+
+.gmail-list,
+.gmail-reader {
+  background: #fff;
+  border-radius: 8px;
+  border: 1px solid #e0e0e0;
+  overflow: hidden;
+}
+
+.gmail-list {
+  display: grid;
+  align-content: start;
+}
+
+.gmail-list button {
+  border: 0;
+  border-bottom: 1px solid #f1f3f4;
+  background: #fff;
+  padding: 12px 14px;
+  text-align: left;
+  display: grid;
+  grid-template-columns: 1fr auto;
+  gap: 3px 10px;
+  cursor: pointer;
+}
+
+.gmail-list button.selected {
+  background: #eef4ff;
+}
+
+.gmail-list button.unread strong,
+.gmail-list button.unread span {
+  font-weight: 800;
+}
+
+.gmail-list strong,
+.gmail-list small {
+  grid-column: 1 / -1;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.gmail-list small,
+.gmail-list time {
+  color: #5f6368;
+  font-size: 12px;
+}
+
+.gmail-reader {
+  padding: 22px;
+  overflow: auto;
+}
+
+.gmail-reader-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 18px;
+  border-bottom: 1px solid #f1f3f4;
+  padding-bottom: 16px;
+}
+
+.gmail-reader h1 {
+  margin: 0;
+  font-size: 24px;
+  font-weight: 500;
+}
+
+.gmail-reader p {
+  color: #5f6368;
+}
+
+.gmail-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-content: start;
+  gap: 8px;
+}
+
+.gmail-thread {
+  display: grid;
+  gap: 12px;
+  margin-top: 16px;
+}
+
+.gmail-thread-message {
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 14px;
+}
+
+.gmail-thread-message header {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.gmail-thread-message header div {
+  display: grid;
+  gap: 2px;
+}
+
+.gmail-thread-message span,
+.gmail-thread-message time {
+  color: #5f6368;
+  font-size: 12px;
+}
+
+.gmail-thread-message p {
+  color: #202124;
+  white-space: pre-wrap;
+}
+
+.gmail-attachments {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.gmail-attachments span {
+  border: 1px solid #dadce0;
+  border-radius: 6px;
+  padding: 7px 9px;
+}
+
+.gmail-empty {
+  display: grid;
+  min-height: 300px;
+  place-items: center;
+  color: #5f6368;
+}
+
+.gmail-composer {
+  position: fixed;
+  right: 24px;
+  bottom: 0;
+  width: min(560px, calc(100vw - 32px));
+  background: #fff;
+  border-radius: 8px 8px 0 0;
+  box-shadow: 0 8px 28px rgb(60 64 67 / 32%);
+  overflow: hidden;
+  display: grid;
+}
+
+.gmail-composer header {
+  background: #f2f6fc;
+  padding: 10px 12px;
+  display: flex;
+  justify-content: space-between;
+}
+
+.gmail-composer header button {
+  border: 0;
+  background: transparent;
+}
+
+.gmail-composer input,
+.gmail-composer textarea {
+  border: 0;
+  border-bottom: 1px solid #f1f3f4;
+  padding: 10px 12px;
+  outline: 0;
+}
+
+.gmail-composer textarea {
+  min-height: 220px;
+  resize: vertical;
+}
+
+.gmail-composer footer {
+  padding: 10px 12px;
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.gmail-composer .gmail-send {
+  background: #0b57d0;
+  color: #fff;
+  border-color: #0b57d0;
+}
+
+@media (max-width: 860px) {
+  .gmail-shell,
+  .gmail-workspace {
+    grid-template-columns: 1fr;
+  }
+
+  .gmail-toolbar {
+    grid-template-columns: 1fr;
+  }
+
+  .gmail-toolbar div {
+    justify-self: start;
+    text-align: left;
+  }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@1kbirds/chidori-mock-gmail",
+  "version": "0.1.0",
+  "description": "Gmail mock app and tools for Chidori TypeScript agents.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./dist/ui/index.d.ts",
+      "import": "./dist/ui/index.js"
+    },
+    "./ui/styles.css": "./dist/ui/styles.css"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && cp src/ui/styles.css dist/ui/styles.css",
+    "test": "vitest run",
+    "dev": "vite --host 127.0.0.1 --port 5175"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@vitejs/plugin-react": "^5.0.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "typescript": "^5.8.0",
+    "vite": "^7.0.0",
+    "vitest": "^3.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ThousandBirdsInc/chidori-mock.git",
+    "directory": "packages/gmail"
+  },
+  "homepage": "https://github.com/ThousandBirdsInc/chidori-mock/tree/main/packages/gmail",
+  "bugs": {
+    "url": "https://github.com/ThousandBirdsInc/chidori-mock/issues"
+  }
+}

package/src/__tests__/service.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { createGmailClient, createGmailMock, demoSeed, handleGmailApiRequest } from "../index";
+import { GmailMockError } from "../errors";
+
+describe("GmailMock service", () => {
+  it("creates isolated seeded mock instances", () => {
+    const first = createGmailMock({ now: "2026-06-01T16:30:00.000Z", seed: demoSeed });
+    const second = createGmailMock({ now: "2026-06-01T16:30:00.000Z", seed: demoSeed });
+
+    first.send({ to: ["new@example.com"], subject: "Only first", body: "Hello" });
+
+    expect(first.listMessages({ labelIds: ["SENT"] }).resultSizeEstimate).toBe(2);
+    expect(second.listMessages({ labelIds: ["SENT"] }).resultSizeEstimate).toBe(1);
+  });
+
+  it("lists, searches, reads, modifies, trashes, untrashes, and deletes messages", () => {
+    const mock = createGmailMock({ now: "2026-06-01T16:30:00.000Z", seed: demoSeed });
+
+    const inbox = mock.listMessages({ labelIds: ["INBOX"] });
+    expect(inbox.resultSizeEstimate).toBe(3);
+
+    const search = mock.listMessages({ q: "from:morgan@example.com is:unread" });
+    expect(search.messages?.[0].id).toBe("msg_schedule_request");
+
+    const read = mock.modifyMessage("msg_schedule_request", { removeLabelIds: ["UNREAD"] });
+    expect(read.labelIds).not.toContain("UNREAD");
+
+    const archived = mock.modifyMessage("msg_schedule_request", { removeLabelIds: ["INBOX"] });
+    expect(archived.labelIds).not.toContain("INBOX");
+
+    const trashed = mock.trashMessage("msg_schedule_request");
+    expect(trashed.labelIds).toContain("TRASH");
+
+    const untrashed = mock.untrashMessage("msg_schedule_request");
+    expect(untrashed.labelIds).toContain("INBOX");
+
+    mock.deleteMessage("msg_schedule_request");
+    expect(() => mock.getMessage("msg_schedule_request")).toThrow(GmailMockError);
+  });
+
+  it("supports labels", () => {
+    const mock = createGmailMock({ seed: demoSeed });
+
+    const label = mock.createLabel({ name: "Follow Up" });
+    expect(label.type).toBe("user");
+
+    mock.modifyMessage("msg_launch_brief", { addLabelIds: [label.id] });
+    expect(mock.listMessages({ labelIds: [label.id] }).messages?.[0].id).toBe("msg_launch_brief");
+
+    mock.updateLabel(label.id, { name: "Follow-up" });
+    expect(mock.getLabel(label.id).name).toBe("Follow-up");
+
+    mock.deleteLabel(label.id);
+    expect(() => mock.getLabel(label.id)).toThrow(GmailMockError);
+  });
+
+  it("groups threads and modifies a full thread", () => {
+    const mock = createGmailMock({ seed: demoSeed });
+
+    const thread = mock.getThread("thread_customer");
+    expect(thread.messages).toHaveLength(2);
+
+    mock.modifyThread("thread_customer", { addLabelIds: ["STARRED"] });
+    expect(mock.getThread("thread_customer").messages.every((message) => message.labelIds.includes("STARRED"))).toBe(true);
+  });
+
+  it("supports drafts and send", () => {
+    const mock = createGmailMock({ now: "2026-06-01T16:30:00.000Z", seed: demoSeed });
+
+    const draft = mock.createDraft({ to: ["morgan@example.com"], subject: "Meeting", body: "Tuesday works." });
+    expect(mock.getDraft(draft.id).message.labelIds).toContain("DRAFT");
+
+    const updated = mock.updateDraft(draft.id, { to: ["morgan@example.com"], subject: "Meeting", body: "Wednesday works." });
+    expect(updated.message.snippet).toBe("Wednesday works.");
+
+    const sent = mock.sendDraft(draft.id);
+    expect(sent.labelIds).toEqual(["SENT"]);
+    expect(() => mock.getDraft(draft.id)).toThrow(GmailMockError);
+
+    const direct = mock.send({ to: ["grace@example.com"], subject: "Direct", body: "Sent directly." });
+    expect(direct.labelIds).toEqual(["SENT"]);
+  });
+});
+
+describe("Gmail client facade", () => {
+  it("returns googleapis-like response wrappers", async () => {
+    const mock = createGmailMock({ seed: demoSeed });
+    const client = createGmailClient(mock);
+
+    const profile = await client.users.getProfile();
+    expect(profile.status).toBe(200);
+    expect(profile.data.emailAddress).toBe("ada@example.com");
+
+    const sent = await client.users.messages.send({ requestBody: { to: ["x@example.com"], subject: "Hi", body: "Hello" } });
+    expect(sent.data.labelIds).toEqual(["SENT"]);
+
+    const deleted = await client.users.messages.delete({ id: sent.data.id });
+    expect(deleted.status).toBe(204);
+  });
+});
+
+describe("Gmail REST-style adapter", () => {
+  it("routes common Gmail endpoints", () => {
+    const mock = createGmailMock({ seed: demoSeed });
+
+    const sent = handleGmailApiRequest(mock, {
+      method: "POST",
+      path: "/gmail/v1/users/me/messages/send",
+      body: { to: ["api@example.com"], subject: "API", body: "Created through API" },
+    });
+    expect(sent.status).toBe(200);
+
+    const listed = handleGmailApiRequest(mock, {
+      method: "GET",
+      path: "/gmail/v1/users/me/messages",
+      query: { q: "subject:API", labelIds: ["SENT"] },
+    });
+    expect((listed.body as { resultSizeEstimate: number }).resultSizeEstimate).toBe(1);
+  });
+});

package/src/api.ts

@@ -0,0 +1,157 @@
+import { GmailMockError } from "./errors";
+import type { GmailMock } from "./service";
+import type { GmailLabel, GmailMessage, GmailModifyRequest, GmailSearchOptions, GmailSendRequest } from "./types";
+
+export interface GmailApiRequest {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: string;
+  query?: Record<string, string | number | boolean | string[] | undefined>;
+  body?: unknown;
+}
+
+export interface GmailApiResponse<T = unknown> {
+  status: number;
+  headers: Record<string, string>;
+  body?: T;
+}
+
+export function handleGmailApiRequest(mock: GmailMock, request: GmailApiRequest): GmailApiResponse {
+  try {
+    return route(mock, request);
+  } catch (error) {
+    if (error instanceof GmailMockError) {
+      return json(error.status, error.toJSON());
+    }
+    throw error;
+  }
+}
+
+function route(mock: GmailMock, request: GmailApiRequest): GmailApiResponse {
+  const url = new URL(request.path, "https://gmail.googleapis.com");
+  const path = url.pathname.replace(/\/+$/, "");
+  const query = request.query ?? {};
+
+  if (request.method === "GET" && path === "/gmail/v1/users/me/profile") {
+    return json(200, mock.getProfile());
+  }
+
+  if (path === "/gmail/v1/users/me/labels") {
+    if (request.method === "GET") return json(200, mock.listLabels());
+    if (request.method === "POST") return json(200, mock.createLabel(request.body as Partial<GmailLabel>));
+  }
+
+  const labelMatch = path.match(/^\/gmail\/v1\/users\/me\/labels\/([^/]+)$/);
+  if (labelMatch) {
+    const id = decodeURIComponent(labelMatch[1]);
+    if (request.method === "GET") return json(200, mock.getLabel(id));
+    if (request.method === "PUT" || request.method === "PATCH") return json(200, mock.updateLabel(id, request.body as Partial<GmailLabel>));
+    if (request.method === "DELETE") {
+      mock.deleteLabel(id);
+      return { status: 204, headers: {} };
+    }
+  }
+
+  if (path === "/gmail/v1/users/me/messages") {
+    if (request.method === "GET") return json(200, mock.listMessages(searchOptions(query)));
+    if (request.method === "POST") return json(200, mock.insertMessage(request.body as Partial<GmailMessage> | GmailSendRequest));
+  }
+
+  if (request.method === "POST" && path === "/gmail/v1/users/me/messages/send") {
+    return json(200, mock.send(request.body as GmailSendRequest));
+  }
+
+  const messageActionMatch = path.match(/^\/gmail\/v1\/users\/me\/messages\/([^/]+)\/(modify|trash|untrash)$/);
+  if (messageActionMatch && request.method === "POST") {
+    const id = decodeURIComponent(messageActionMatch[1]);
+    const action = messageActionMatch[2];
+    if (action === "modify") return json(200, mock.modifyMessage(id, request.body as GmailModifyRequest));
+    if (action === "trash") return json(200, mock.trashMessage(id));
+    return json(200, mock.untrashMessage(id));
+  }
+
+  const messageMatch = path.match(/^\/gmail\/v1\/users\/me\/messages\/([^/]+)$/);
+  if (messageMatch) {
+    const id = decodeURIComponent(messageMatch[1]);
+    if (request.method === "GET") return json(200, mock.getMessage(id));
+    if (request.method === "DELETE") {
+      mock.deleteMessage(id);
+      return { status: 204, headers: {} };
+    }
+  }
+
+  if (path === "/gmail/v1/users/me/threads" && request.method === "GET") {
+    return json(200, mock.listThreads(searchOptions(query)));
+  }
+
+  const threadActionMatch = path.match(/^\/gmail\/v1\/users\/me\/threads\/([^/]+)\/(modify|trash)$/);
+  if (threadActionMatch && request.method === "POST") {
+    const id = decodeURIComponent(threadActionMatch[1]);
+    return json(200, threadActionMatch[2] === "modify" ? mock.modifyThread(id, request.body as GmailModifyRequest) : mock.trashThread(id));
+  }
+
+  const threadMatch = path.match(/^\/gmail\/v1\/users\/me\/threads\/([^/]+)$/);
+  if (threadMatch && request.method === "GET") {
+    return json(200, mock.getThread(decodeURIComponent(threadMatch[1])));
+  }
+
+  if (path === "/gmail/v1/users/me/drafts") {
+    if (request.method === "GET") return json(200, mock.listDrafts());
+    if (request.method === "POST") return json(200, mock.createDraft(request.body as GmailSendRequest));
+  }
+
+  const draftSendMatch = path.match(/^\/gmail\/v1\/users\/me\/drafts\/([^/]+)\/send$/);
+  if (draftSendMatch && request.method === "POST") return json(200, mock.sendDraft(decodeURIComponent(draftSendMatch[1])));
+
+  const draftMatch = path.match(/^\/gmail\/v1\/users\/me\/drafts\/([^/]+)$/);
+  if (draftMatch) {
+    const id = decodeURIComponent(draftMatch[1]);
+    if (request.method === "GET") return json(200, mock.getDraft(id));
+    if (request.method === "PUT") return json(200, mock.updateDraft(id, request.body as GmailSendRequest));
+    if (request.method === "DELETE") {
+      mock.deleteDraft(id);
+      return { status: 204, headers: {} };
+    }
+  }
+
+  return json(404, {
+    error: {
+      code: 404,
+      message: `Unsupported mock endpoint: ${request.method} ${request.path}`,
+      errors: [{ domain: "global", reason: "notFound", message: "Unsupported mock endpoint" }],
+    },
+  });
+}
+
+function json<T>(status: number, body: T): GmailApiResponse<T> {
+  return { status, headers: { "content-type": "application/json" }, body };
+}
+
+function searchOptions(query: GmailApiRequest["query"]): GmailSearchOptions {
+  return {
+    q: stringQuery(query?.q),
+    labelIds: arrayQuery(query?.labelIds),
+    includeSpamTrash: boolQuery(query?.includeSpamTrash),
+    maxResults: numberQuery(query?.maxResults),
+  };
+}
+
+function stringQuery(value: string | number | boolean | string[] | undefined): string | undefined {
+  return Array.isArray(value) ? value[0] : value === undefined ? undefined : String(value);
+}
+
+function arrayQuery(value: string | number | boolean | string[] | undefined): string[] | undefined {
+  if (Array.isArray(value)) return value.map(String);
+  if (typeof value === "string") return value.split(",").filter(Boolean);
+  return undefined;
+}
+
+function boolQuery(value: string | number | boolean | string[] | undefined): boolean | undefined {
+  if (value === undefined) return undefined;
+  return value === true || value === "true";
+}
+
+function numberQuery(value: string | number | boolean | string[] | undefined): number | undefined {
+  if (value === undefined || Array.isArray(value)) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}