@pome-sh/cli 0.21.5 → 0.21.6

package/dist/chunk-NJ246QPJ.js

@@ -0,0 +1,683 @@
+import { z, ZodError } from 'zod';
+
+// ../packages/twin-gmail/dist/src/errors.js
+var GmailError = class extends Error {
+  status;
+  reason;
+  constructor(status, reason, message) {
+    super(message);
+    this.status = status;
+    this.reason = reason;
+    this.name = "GmailError";
+  }
+};
+function gmailErrorEnvelope(error) {
+  if (error instanceof GmailError) {
+    return {
+      status: error.status,
+      body: {
+        error: {
+          code: error.status,
+          message: error.message,
+          errors: [{ message: error.message, domain: "global", reason: error.reason }],
+          status: googleStatus(error.status)
+        }
+      }
+    };
+  }
+  if (error instanceof ZodError || error instanceof Error && error.name === "ZodError") {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: 400,
+          message: "Invalid request",
+          errors: [{ message: "Invalid request", domain: "global", reason: "invalidArgument" }],
+          status: "INVALID_ARGUMENT"
+        }
+      }
+    };
+  }
+  if (error instanceof SyntaxError) {
+    return {
+      status: 400,
+      body: {
+        error: {
+          code: 400,
+          message: "Invalid JSON",
+          errors: [{ message: "Invalid JSON", domain: "global", reason: "invalidArgument" }],
+          status: "INVALID_ARGUMENT"
+        }
+      }
+    };
+  }
+  if (error instanceof Error && (error.name === "TwinError" || error.name === "UnknownToolError")) {
+    const unknownTool = error.name === "UnknownToolError";
+    const status = unknownTool ? 404 : typeof error.status === "number" ? error.status : 400;
+    return {
+      status,
+      body: {
+        error: {
+          code: status,
+          message: error.message,
+          errors: [
+            {
+              message: error.message,
+              domain: "global",
+              reason: unknownTool ? "notFound" : "invalidArgument"
+            }
+          ],
+          status: googleStatus(status)
+        }
+      }
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      error: {
+        code: 500,
+        message: "Internal error",
+        errors: [{ message: "Internal error", domain: "global", reason: "backendError" }],
+        status: "INTERNAL"
+      }
+    }
+  };
+}
+function notFound(resource = "Requested entity") {
+  throw new GmailError(404, "notFound", `${resource} was not found.`);
+}
+function invalidArgument(message) {
+  throw new GmailError(400, "invalidArgument", message);
+}
+function unsupported(message) {
+  throw new GmailError(501, "notImplemented", message);
+}
+function googleStatus(status) {
+  if (status === 400)
+    return "INVALID_ARGUMENT";
+  if (status === 401)
+    return "UNAUTHENTICATED";
+  if (status === 403)
+    return "PERMISSION_DENIED";
+  if (status === 404)
+    return "NOT_FOUND";
+  if (status === 429)
+    return "RESOURCE_EXHAUSTED";
+  if (status === 409)
+    return "ALREADY_EXISTS";
+  if (status === 501)
+    return "UNIMPLEMENTED";
+  return "INTERNAL";
+}
+
+// ../packages/twin-gmail/dist/src/search-parse.js
+var MAX_QUERY_BYTES = 4096;
+var MAX_TOKENS = 256;
+var MAX_DEPTH = 20;
+var MAX_BRANCHES = 256;
+var SEARCH_MAILBOX_MESSAGE_BUDGET = 1e4;
+var KNOWN_FIELDS = /* @__PURE__ */ new Set([
+  "from",
+  "to",
+  "cc",
+  "bcc",
+  "deliveredto",
+  "list",
+  "subject",
+  "rfc822msgid",
+  "filename",
+  "after",
+  "newer",
+  "before",
+  "older",
+  "newer_than",
+  "older_than",
+  "size",
+  "larger",
+  "smaller",
+  "label",
+  "category",
+  "in",
+  "is",
+  "has"
+]);
+var CATEGORY_LABELS = {
+  primary: "CATEGORY_PERSONAL",
+  personal: "CATEGORY_PERSONAL",
+  social: "CATEGORY_SOCIAL",
+  promotions: "CATEGORY_PROMOTIONS",
+  updates: "CATEGORY_UPDATES",
+  forums: "CATEGORY_FORUMS"
+};
+function validateSearchQuery(query) {
+  const node = parseSearchQuery(query);
+  const walk = (current) => {
+    switch (current.type) {
+      case "and":
+      case "or":
+        for (const child of current.children)
+          walk(child);
+        return;
+      case "not":
+        walk(current.child);
+        return;
+      case "around":
+        return;
+      case "term":
+        assertSearchTerm(current.field, current.value);
+        return;
+    }
+  };
+  walk(node);
+  return node;
+}
+function assertSearchTerm(field, value) {
+  if (!field)
+    return;
+  if (!KNOWN_FIELDS.has(field)) {
+    invalidArgument(`Unsupported search operator: ${field}`);
+  }
+  if (field === "category") {
+    if (!CATEGORY_LABELS[value.toLocaleLowerCase("en-US")]) {
+      invalidArgument(`Unsupported search category: ${value}`);
+    }
+    return;
+  }
+  if (field === "after" || field === "newer" || field === "before" || field === "older") {
+    parseDate(value);
+    return;
+  }
+  if (field === "newer_than" || field === "older_than") {
+    parseDuration(value);
+    return;
+  }
+  if (field === "size" || field === "larger" || field === "smaller") {
+    parseSize(value);
+    return;
+  }
+  if (field === "has") {
+    assertHasOperator(value);
+  }
+}
+function parseSearchQuery(query) {
+  if (Buffer.byteLength(query) > MAX_QUERY_BYTES)
+    invalidArgument("Search query exceeds limit");
+  const tokens = tokenize(query);
+  if (tokens.length > MAX_TOKENS)
+    invalidArgument("Search query has too many tokens");
+  if (tokens.length === 0)
+    return { type: "and", children: [] };
+  let position = 0;
+  const parseExpression = (depth, stop) => {
+    if (depth > MAX_DEPTH)
+      invalidArgument("Search query nesting exceeds limit");
+    const alternatives = [];
+    let conjunction = [];
+    const flush = () => {
+      alternatives.push(conjunction.length === 1 ? conjunction[0] : { type: "and", children: conjunction });
+      conjunction = [];
+    };
+    while (position < tokens.length) {
+      const token = tokens[position];
+      if (stop && token.value === stop)
+        break;
+      if (token.value.toUpperCase() === "OR") {
+        position++;
+        if (!conjunction.length)
+          invalidArgument("OR requires a left expression");
+        flush();
+        continue;
+      }
+      if (token.value.toUpperCase() === "AND") {
+        position++;
+        continue;
+      }
+      conjunction.push(parsePrimary(depth + 1));
+    }
+    if (conjunction.length)
+      flush();
+    if (!alternatives.length)
+      return { type: "and", children: [] };
+    return alternatives.length === 1 ? alternatives[0] : { type: "or", children: alternatives };
+  };
+  const parsePrimary = (depth) => {
+    const token = tokens[position++];
+    if (token.value === "(" || token.value === "{") {
+      const end = token.value === "(" ? ")" : "}";
+      const child = parseExpression(depth, end);
+      if (tokens[position]?.value !== end)
+        invalidArgument(`Unclosed ${token.value}`);
+      position++;
+      return token.value === "{" ? makeImplicitOr(child) : child;
+    }
+    if (token.value === ")" || token.value === "}")
+      invalidArgument(`Unexpected ${token.value}`);
+    let value = token.value;
+    let negate = false;
+    if (value === "-") {
+      negate = true;
+      const next = tokens[position++];
+      if (!next)
+        invalidArgument("Negation requires an expression");
+      position--;
+      const child = parsePrimary(depth + 1);
+      return { type: "not", child };
+    }
+    if (value.startsWith("-") && value.length > 1) {
+      negate = true;
+      value = value.slice(1);
+    }
+    const around = tokens[position]?.value.toUpperCase() === "AROUND";
+    if (around) {
+      position++;
+      const distance = Number(tokens[position++]?.value);
+      const right = tokens[position++]?.value;
+      if (!Number.isInteger(distance) || distance < 1 || distance > 100 || !right) {
+        invalidArgument("AROUND requires a distance and right term");
+      }
+      const node2 = { type: "around", left: value, right, distance };
+      return negate ? { type: "not", child: node2 } : node2;
+    }
+    const colon = value.indexOf(":");
+    let node;
+    if (colon > 0) {
+      const field = value.slice(0, colon).toLowerCase();
+      let fieldValue = value.slice(colon + 1);
+      if (!fieldValue && (tokens[position]?.value === "(" || tokens[position]?.value === "{")) {
+        node = parseFieldGroup(field, depth + 1);
+        return negate ? { type: "not", child: node } : node;
+      }
+      if (!fieldValue && tokens[position] && !["AND", "OR", ")", "}"].includes(tokens[position].value.toUpperCase())) {
+        fieldValue = tokens[position++].value;
+      }
+      node = { type: "term", field, value: fieldValue, exact: token.quoted };
+    } else {
+      node = { type: "term", value: value.startsWith("+") ? value.slice(1) : value, exact: token.quoted || value.startsWith("+") };
+    }
+    return negate ? { type: "not", child: node } : node;
+  };
+  const parseFieldGroup = (field, depth) => {
+    if (depth > MAX_DEPTH)
+      invalidArgument("Search query nesting exceeds limit");
+    const opening = tokens[position++].value;
+    const end = opening === "(" ? ")" : "}";
+    const groups = [[]];
+    while (position < tokens.length && tokens[position].value !== end) {
+      const token = tokens[position++];
+      if (token.value.toUpperCase() === "OR") {
+        groups.push([]);
+        continue;
+      }
+      if (token.value.toUpperCase() === "AND")
+        continue;
+      if (["(", "{", ")", "}"].includes(token.value))
+        invalidArgument("Nested field groups are unsupported");
+      let value = token.value;
+      let negate = false;
+      if (value.startsWith("-")) {
+        negate = true;
+        value = value.slice(1);
+      }
+      const term = { type: "term", field, value, exact: token.quoted };
+      groups.at(-1).push(negate ? { type: "not", child: term } : term);
+    }
+    if (tokens[position]?.value !== end)
+      invalidArgument(`Unclosed ${opening}`);
+    position++;
+    const nodes = groups.map((children) => children.length === 1 ? children[0] : { type: "and", children });
+    const useOr = opening === "{" || nodes.length > 1;
+    return useOr ? { type: "or", children: nodes } : nodes[0] ?? { type: "and", children: [] };
+  };
+  const root = parseExpression(0);
+  if (position !== tokens.length)
+    invalidArgument("Unexpected search token");
+  if (countBranches(root) > MAX_BRANCHES)
+    invalidArgument("Search query has too many branches");
+  return root;
+}
+function assertHasOperator(value) {
+  const normalized = value.toLocaleLowerCase("en-US");
+  if (normalized.endsWith("-star")) {
+    invalidArgument(`Unsupported colored-star operator: has:${value}; twin maps only STARRED via is:starred`);
+  }
+}
+function parseDate(value) {
+  const normalized = /^\d{4}\/\d{1,2}\/\d{1,2}$/.test(value) ? value.replaceAll("/", "-") : value;
+  const date = Date.parse(`${normalized}${/^\d{4}-\d/.test(normalized) ? "T00:00:00Z" : ""}`);
+  if (Number.isNaN(date))
+    invalidArgument(`Invalid search date: ${value}`);
+  return date;
+}
+function parseDuration(value) {
+  const match = value.match(/^(\d+)([dmy])$/i);
+  if (!match)
+    invalidArgument(`Invalid search duration: ${value}`);
+  const units = { d: 864e5, m: 30 * 864e5, y: 365 * 864e5 };
+  return Number(match[1]) * units[match[2].toLowerCase()];
+}
+function parseSize(value) {
+  const match = value.match(/^(\d+(?:\.\d+)?)([kmg])?$/i);
+  if (!match)
+    invalidArgument(`Invalid search size: ${value}`);
+  const scale = { k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+  return Math.floor(Number(match[1]) * (match[2] ? scale[match[2].toLowerCase()] : 1));
+}
+function countBranches(node) {
+  switch (node.type) {
+    case "and":
+    case "or":
+      return node.children.reduce((sum, child) => sum + countBranches(child), 0);
+    case "not":
+      return countBranches(node.child);
+    case "around":
+    case "term":
+      return 1;
+  }
+}
+function tokenize(query) {
+  const out = [];
+  let index = 0;
+  while (index < query.length) {
+    if (/\s/.test(query[index])) {
+      index++;
+      continue;
+    }
+    const char = query[index];
+    if ("(){}".includes(char)) {
+      out.push({ value: char });
+      index++;
+      continue;
+    }
+    let value = "";
+    let quoted = false;
+    while (index < query.length && !/\s/.test(query[index]) && !"(){}".includes(query[index])) {
+      if (query[index] === '"') {
+        quoted = true;
+        index++;
+        while (index < query.length && query[index] !== '"') {
+          if (query[index] === "\\" && index + 1 < query.length)
+            index++;
+          value += query[index++];
+        }
+        if (query[index] !== '"')
+          invalidArgument("Unclosed search quote");
+        index++;
+      } else {
+        value += query[index++];
+      }
+    }
+    if (value)
+      out.push({ value, quoted });
+  }
+  return out;
+}
+function makeImplicitOr(node) {
+  return node.type === "and" ? { type: "or", children: node.children } : node;
+}
+var KNOWN_FAULT_NAMES = ["rate-limited"];
+var gmailFaultSchema = z.object({
+  name: z.enum(KNOWN_FAULT_NAMES),
+  target: z.string().min(1).max(128).default("messages.send"),
+  succeedFirst: z.number().int().nonnegative().max(1e3).default(2),
+  throttleFor: z.number().int().positive().max(1e3).default(3),
+  retryAfterSeconds: z.number().int().positive().max(3600).default(1)
+}).strict();
+function checkFault(db, operation) {
+  const fault = readFaults(db).find((f) => f.target === operation);
+  if (!fault)
+    return;
+  const calls = bumpFaultCounter(db, operation);
+  if (calls > fault.succeedFirst && calls <= fault.succeedFirst + fault.throttleFor) {
+    throw new GmailError(429, "rateLimitExceeded", `Rate limit exceeded for ${operation}. Retry after ${fault.retryAfterSeconds}s.`);
+  }
+}
+function readFaults(db) {
+  const row = db.prepare("SELECT value FROM gmail_config WHERE key = 'faults'").get();
+  if (!row)
+    return [];
+  try {
+    return JSON.parse(row.value);
+  } catch {
+    return [];
+  }
+}
+function bumpFaultCounter(db, operation) {
+  db.prepare("INSERT INTO fault_counters(operation, calls) VALUES (?, 1) ON CONFLICT(operation) DO UPDATE SET calls = calls + 1").run(operation);
+  const row = db.prepare("SELECT calls FROM fault_counters WHERE operation = ?").get(operation);
+  return row.calls;
+}
+
+// ../packages/twin-gmail/dist/src/seed.js
+var email = z.string().trim().email().transform((value) => value.toLowerCase());
+var id = z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+var attachmentSchema = z.object({
+  filename: z.string().max(512),
+  mimeType: z.string().min(1).max(255).default("application/octet-stream"),
+  disposition: z.enum(["attachment", "inline"]).default("attachment"),
+  contentId: z.string().max(998).optional(),
+  data: z.string().max(5e7)
+}).strict();
+var messageFields = {
+  id: id.optional(),
+  threadId: id.optional(),
+  raw: z.string().max(5e7).optional(),
+  from: email.optional(),
+  to: z.array(email).max(500).default([]),
+  cc: z.array(email).max(500).default([]),
+  bcc: z.array(email).max(500).default([]),
+  subject: z.string().max(998).default(""),
+  text: z.string().max(25e6).default(""),
+  html: z.string().max(25e6).default(""),
+  date: z.string().datetime({ offset: true }).optional(),
+  messageId: z.string().min(3).max(998).optional(),
+  inReplyTo: z.string().max(998).optional(),
+  references: z.array(z.string().max(998)).max(100).default([]),
+  attachments: z.array(attachmentSchema).max(100).default([])
+};
+var messageSchema = z.object({
+  ...messageFields,
+  labels: z.array(z.string().min(1).max(255)).max(100).default([])
+}).strict();
+var draftSchema = z.object(messageFields).strict();
+var labelSchema = z.object({
+  id: id.optional(),
+  name: z.string().trim().min(1).max(225),
+  color: z.object({
+    textColor: z.string().max(32).optional(),
+    backgroundColor: z.string().max(32).optional()
+  }).strict().optional()
+}).strict();
+var filterSchema = z.object({
+  id: id.optional(),
+  criteria: z.object({
+    from: z.string().max(998).optional(),
+    to: z.string().max(998).optional(),
+    subject: z.string().max(998).optional(),
+    query: z.string().max(4096).optional(),
+    negatedQuery: z.string().max(4096).optional(),
+    hasAttachment: z.boolean().optional(),
+    excludeChats: z.boolean().optional(),
+    size: z.number().int().nonnegative().optional(),
+    sizeComparison: z.enum(["larger", "smaller"]).optional()
+  }).strict().default({}),
+  action: z.object({
+    addLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    removeLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    forward: email.optional()
+  }).strict().default({ addLabelIds: [], removeLabelIds: [] })
+}).strict();
+var sendAsSchema = z.object({
+  sendAsEmail: email,
+  displayName: z.string().max(256).default(""),
+  replyToAddress: email.optional(),
+  isPrimary: z.boolean().default(false),
+  isDefault: z.boolean().default(false),
+  verificationStatus: z.enum(["accepted", "pending"]).default("accepted")
+}).strict();
+var mailboxSchema = z.object({
+  email,
+  displayName: z.string().max(256).default(""),
+  labels: z.array(labelSchema).max(5e3).default([]),
+  messages: z.array(messageSchema).max(1e4).default([]),
+  drafts: z.array(draftSchema).max(5e3).default([]),
+  filters: z.array(filterSchema).max(1e3).default([]),
+  forwardingAddresses: z.array(z.object({
+    forwardingEmail: email,
+    verificationStatus: z.enum(["accepted", "pending"]).default("pending")
+  }).strict()).max(1e3).default([]),
+  sendAs: z.array(sendAsSchema).max(1e3).default([])
+}).strict();
+var gmailSeedSchema = z.object({
+  primaryMailbox: mailboxSchema,
+  mailboxes: z.array(mailboxSchema).max(100).default([]),
+  deliveryMode: z.enum(["sender-only", "seeded-mailboxes"]).default("sender-only"),
+  clock: z.string().datetime({ offset: true }).default("2025-01-01T00:00:00.000Z"),
+  faults: z.array(gmailFaultSchema).max(50).default([])
+}).strict().superRefine((seed, ctx) => {
+  const emails = [seed.primaryMailbox.email, ...seed.mailboxes.map((mailbox) => mailbox.email)];
+  const seen = /* @__PURE__ */ new Set();
+  for (const mailboxEmail of emails) {
+    if (seen.has(mailboxEmail)) {
+      ctx.addIssue({ code: "custom", message: `Duplicate mailbox: ${mailboxEmail}` });
+    }
+    seen.add(mailboxEmail);
+  }
+  for (const mailbox of [seed.primaryMailbox, ...seed.mailboxes]) {
+    const labelNames = /* @__PURE__ */ new Set();
+    for (const label of mailbox.labels) {
+      const key = label.name.toLowerCase();
+      if (labelNames.has(key)) {
+        ctx.addIssue({ code: "custom", message: `Duplicate label in ${mailbox.email}: ${label.name}` });
+      }
+      labelNames.add(key);
+    }
+    for (const filter of mailbox.filters) {
+      if (filter.action.forward) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Filter forwarding is unsupported: ${mailbox.email}`
+        });
+      }
+      for (const key of ["query", "negatedQuery"]) {
+        const value = filter.criteria[key];
+        if (!value)
+          continue;
+        try {
+          validateSearchQuery(value);
+        } catch (error) {
+          ctx.addIssue({
+            code: "custom",
+            message: `Invalid filter ${key} in ${mailbox.email}: ${error.message}`
+          });
+        }
+      }
+    }
+  }
+});
+function parseSeed(input) {
+  return gmailSeedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (!raw)
+    return parseSeed(defaultSeedState());
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${error.message}`);
+  }
+  return parseSeed(parsed);
+}
+var DEFAULT_GMAIL_AGENT_EMAIL = "pome-agent@pome-twin.test";
+function agentPathInboxMailbox(email2 = DEFAULT_GMAIL_AGENT_EMAIL) {
+  return {
+    email: email2,
+    displayName: "Pome Agent",
+    labels: [
+      { id: "Label_follow_up", name: "Follow Up" },
+      { id: "Label_build", name: "Build" }
+    ],
+    messages: [
+      {
+        id: "msg_welcome",
+        threadId: "thread_welcome",
+        from: "welcome@pome-twin.test",
+        to: [email2],
+        subject: "Welcome to your Pome Gmail twin",
+        text: "Your deterministic inbox is ready for agent testing.",
+        html: "<p>Your deterministic inbox is ready for agent testing.</p>",
+        date: "2026-07-18T09:00:00.000Z",
+        messageId: "welcome@pome-twin.test",
+        labels: ["INBOX"]
+      },
+      {
+        id: "msg_build",
+        threadId: "thread_build",
+        from: "ci@example.com",
+        to: [email2],
+        subject: "Build failed on main",
+        text: "The nightly build failed. See the attached log.",
+        date: "2026-07-19T10:00:00.000Z",
+        messageId: "build-001@example.com",
+        labels: ["INBOX", "UNREAD", "Build"],
+        attachments: [
+          {
+            filename: "build.log",
+            mimeType: "text/plain",
+            data: Buffer.from("BUILD FAILED step=test\n", "utf8").toString("base64")
+          }
+        ]
+      },
+      {
+        id: "msg_build_reply",
+        threadId: "thread_build",
+        from: email2,
+        to: ["ci@example.com"],
+        subject: "Re: Build failed on main",
+        text: "Looking into the failure now.",
+        date: "2026-07-19T11:00:00.000Z",
+        messageId: "build-reply@pome-twin.test",
+        inReplyTo: "build-001@example.com",
+        references: ["build-001@example.com"],
+        labels: ["SENT"]
+      },
+      {
+        id: "msg_support",
+        threadId: "thread_support",
+        from: "alice@example.com",
+        to: [email2],
+        subject: "Production export is stuck",
+        text: "Our production export has been stuck for an hour. Can you investigate?",
+        date: "2026-07-19T12:00:00.000Z",
+        messageId: "support-001@example.com",
+        labels: ["INBOX", "UNREAD"]
+      }
+    ],
+    drafts: [
+      {
+        id: "draft_ack",
+        threadId: "thread_draft_ack",
+        to: ["bob@example.com"],
+        subject: "Draft acknowledgment",
+        text: "Thanks \u2014 I'll follow up shortly.",
+        date: "2026-07-19T13:00:00.000Z",
+        messageId: "draft-ack@pome-twin.test"
+      }
+    ],
+    filters: [],
+    forwardingAddresses: [],
+    sendAs: []
+  };
+}
+function defaultSeedState() {
+  return {
+    primaryMailbox: agentPathInboxMailbox(),
+    mailboxes: [],
+    deliveryMode: "sender-only",
+    clock: "2026-07-20T00:00:00.000Z"
+  };
+}
+
+export { CATEGORY_LABELS, DEFAULT_GMAIL_AGENT_EMAIL, GmailError, KNOWN_FIELDS, SEARCH_MAILBOX_MESSAGE_BUDGET, agentPathInboxMailbox, assertHasOperator, checkFault, defaultSeedState, gmailErrorEnvelope, gmailSeedSchema, invalidArgument, loadSeedFromEnv, notFound, parseDate, parseDuration, parseSearchQuery, parseSeed, parseSize, unsupported, validateSearchQuery };