exponential-sdk 1.29.0 → 1.31.0

package/dist/index.js

@@ -1325,6 +1325,238 @@ ${text}` : text;
   }
 };
 
+// src/calendar.ts
+import { randomUUID } from "crypto";
+var CALENDAR_MAX_RESULTS = 100;
+var CALENDAR_MAX_SELECTED = 10;
+function hostTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+    return void 0;
+  }
+}
+var CalendarApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Merged, start-time-sorted events from every connected account. */
+  async listEvents(options = {}) {
+    return await this.client.calendar.getEventsMultiCalendar.query({
+      timeMin: options.from,
+      timeMax: options.to,
+      maxResults: options.maxResults
+    });
+  }
+  /**
+   * Everything on today's date, in the host's local timezone — including
+   * all-day events and meetings that started before now.
+   */
+  async today(options = {}) {
+    const from = /* @__PURE__ */ new Date();
+    from.setHours(0, 0, 0, 0);
+    const to = new Date(from);
+    to.setHours(23, 59, 59, 999);
+    return this.listEvents({ from, to, maxResults: options.maxResults });
+  }
+  /** Events from now until `days` days ahead (default 7). */
+  async upcoming(options = {}) {
+    const from = /* @__PURE__ */ new Date();
+    const to = new Date(from.getTime() + (options.days ?? 7) * 24 * 60 * 60 * 1e3);
+    return this.listEvents({ from, to, maxResults: options.maxResults });
+  }
+  /** Connected accounts, each with its calendars and current selection. */
+  async accounts() {
+    const result = await this.client.calendar.getCalendarAccounts.query();
+    return result.accounts;
+  }
+  /** Per-provider connection state, including accounts needing re-auth. */
+  async connectionStatuses() {
+    return await this.client.calendar.getAllConnectionStatuses.query();
+  }
+  /** Every calendar on one account, straight from the provider (uncached). */
+  async listCalendars(selector = {}) {
+    return await this.client.calendar.listCalendars.query(selector);
+  }
+  /** One account's selected calendars plus its cached calendar list. */
+  async getPreferences(selector = {}) {
+    return await this.client.calendar.getCalendarPreferences.query(
+      selector
+    );
+  }
+  /**
+   * Replace which calendars on an account feed the merged event list.
+   * This is a replace, not a merge — pass the full set you want.
+   */
+  async selectCalendars(input) {
+    return await this.client.calendar.updateSelectedCalendars.mutate(input);
+  }
+  /** Re-fetch an account's calendar list from the provider and re-cache it. */
+  async syncCalendars(selector = {}) {
+    return await this.client.calendar.syncCalendarList.mutate(selector);
+  }
+  async createEvent(input) {
+    const timeZone = input.timeZone ?? hostTimeZone();
+    return await this.client.calendar.createEvent.mutate({
+      summary: input.summary,
+      description: input.description,
+      // RFC3339 UTC — unambiguous regardless of host offset. `timeZone` only
+      // tells the provider which zone to render the event in.
+      start: { dateTime: input.start.toISOString(), timeZone },
+      end: { dateTime: input.end.toISOString(), timeZone },
+      attendees: input.attendees?.map((email) => ({ email })),
+      conferenceData: input.meet ? {
+        createRequest: {
+          requestId: randomUUID(),
+          conferenceSolutionKey: { type: "hangoutsMeet" }
+        }
+      } : void 0,
+      calendarId: input.calendarId,
+      provider: input.provider
+    });
+  }
+  /**
+   * Remove a calendar connection. Deletes the stored tokens and calendar
+   * preferences; it never touches the user's ability to sign in with that
+   * account. Reconnecting means redoing the OAuth flow in the web app.
+   */
+  async disconnect(selector = {}) {
+    return await this.client.calendar.disconnect.mutate(selector);
+  }
+};
+
+// src/cycles.ts
+function describeCycle(c) {
+  return c.productId ? `"${c.name}" (slug ${c.slug}, product ${c.productId})` : `"${c.name}" (slug ${c.slug}, workspace-shared)`;
+}
+var CyclesApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List cycles in a workspace, newest start date first. Pass `productId` to
+   * scope to one product's timeline (plus legacy workspace-shared cycles).
+   *
+   * Note this is not a pure read: the server reconciles cycle statuses against
+   * today's date and (unless `autoCreate: false`) provisions upcoming cycles —
+   * scoped to `productId` when given.
+   */
+  async list(options) {
+    return await this.client.product.cycle.list.query({
+      workspaceId: options.workspaceId,
+      productId: options.productId,
+      status: options.status,
+      autoCreate: options.autoCreate
+    });
+  }
+  async get(id) {
+    return await this.client.product.cycle.getById.query({ id });
+  }
+  /**
+   * The current (`ACTIVE`) cycle, or `null` when none is running (e.g. a gap
+   * between cycles).
+   *
+   * Cycles are product-scoped, so a workspace can have one ACTIVE cycle per
+   * product. Pass `product` (a product CUID or slug) to get that product's
+   * current cycle — a cycle scoped to the product wins over a legacy
+   * workspace-shared one.
+   *
+   * Without `product`, this stays backward compatible for workspaces with a
+   * single timeline: if every ACTIVE cycle belongs to the same product (or all
+   * are workspace-shared), the most recently started wins. If ACTIVE cycles
+   * from different products coexist, it throws rather than silently picking
+   * an arbitrary product's cycle.
+   */
+  async current(workspaceId, product) {
+    if (product) {
+      const productId = await this.resolveProductId(workspaceId, product);
+      const active2 = await this.list({ workspaceId, productId, status: "ACTIVE", autoCreate: false });
+      return active2.find((c) => c.productId === productId) ?? active2[0] ?? null;
+    }
+    const active = await this.list({ workspaceId, status: "ACTIVE", autoCreate: false });
+    if (active.length <= 1) return active[0] ?? null;
+    const timelines = new Set(active.map((c) => c.productId ?? null));
+    if (timelines.size === 1) return active[0] ?? null;
+    throw new Error(
+      `Multiple cycles are ACTIVE in this workspace \u2014 one per product \u2014 so "current" is ambiguous. Pass a product id or slug to pick one. Active: ${active.map(describeCycle).join(", ")}.`
+    );
+  }
+  /**
+   * Resolve what a user typed to a cycle.
+   *
+   * Accepts, in order of precedence:
+   *   - `"current"` / `"active"` → the ACTIVE cycle (see `current()`)
+   *   - a cycle CUID
+   *   - a cycle slug
+   *   - a cycle name (case-insensitive)
+   *
+   * Pass `product` (a product CUID or slug) to scope the lookup to that
+   * product's timeline. Cycle auto-numbering is per-product, so two products
+   * can both have a cycle named "Cycle 9" in one workspace: with `product`
+   * set, a cycle scoped to that product beats a legacy workspace-shared one
+   * of the same name; without it, an ambiguous name throws rather than
+   * silently picking one. Ids and slugs are unique per workspace and never
+   * ambiguous.
+   *
+   * Throws rather than returning null so callers never silently file work
+   * against the wrong cycle — or against none at all.
+   */
+  async resolve(workspaceId, slugOrIdOrName, product) {
+    const candidate = slugOrIdOrName.trim();
+    const lower = candidate.toLowerCase();
+    if (lower === "current" || lower === "active") {
+      const cycle = await this.current(workspaceId, product);
+      if (!cycle) {
+        throw new Error(
+          product ? `No cycle is currently active for product "${product}". Pass an explicit cycle slug or id, or create a cycle first.` : "No cycle is currently active in this workspace. Pass an explicit cycle slug or id, or create a cycle first."
+        );
+      }
+      return cycle;
+    }
+    const productId = product ? await this.resolveProductId(workspaceId, product) : void 0;
+    const cycles = await this.list({ workspaceId, productId, autoCreate: false });
+    const exact = cycles.find((c) => c.id === candidate) ?? cycles.find((c) => c.slug === candidate);
+    if (exact) return exact;
+    const byName = cycles.filter((c) => c.name.toLowerCase() === lower);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1) {
+      if (productId) {
+        const scoped = byName.filter((c) => c.productId === productId);
+        if (scoped.length === 1) return scoped[0];
+      }
+      throw new Error(
+        `Cycle name "${candidate}" is ambiguous: ${byName.map(describeCycle).join(", ")}. Use the slug or id instead${productId ? "" : ", or pass a product to scope the lookup"}.`
+      );
+    }
+    const known = cycles.map((c) => c.slug).join(", ");
+    throw new Error(
+      `Cycle "${candidate}" not found. Available: ${known || "(none)"}`
+    );
+  }
+  async create(input) {
+    return await this.client.product.cycle.create.mutate(input);
+  }
+  async update(input) {
+    return await this.client.product.cycle.update.mutate(input);
+  }
+  async delete(id) {
+    return await this.client.product.cycle.delete.mutate({ id });
+  }
+  /**
+   * Turn a product reference (CUID or slug) into the CUID the cycle endpoints
+   * expect. CUIDs pass through without a lookup — the server validates access.
+   */
+  async resolveProductId(workspaceId, product) {
+    const ref = product.trim();
+    if (/^c[a-z0-9]{20,}$/.test(ref)) return ref;
+    const match = await this.client.product.product.getBySlug.query({
+      workspaceId,
+      slug: ref
+    });
+    return match.id;
+  }
+};
+
 // src/pages.ts
 var PagesApi = class {
   constructor(client) {
@@ -1607,6 +1839,22 @@ var SearchApi = class {
   }
 };
 
+// src/users.ts
+var UsersApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * The account this client's token signs in as. For an External agent's key
+   * the result is the agent's shadow user: `isAgent` is true and `agent`
+   * carries the agent's name and owner — the identity to grant access to when
+   * a command comes back FORBIDDEN.
+   */
+  async me() {
+    return await this.client.user.getCurrentUser.query();
+  }
+};
+
 // src/time.ts
 function startOfLocalDay(date) {
   const d = typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date) ? /* @__PURE__ */ new Date(`${date}T00:00:00`) : new Date(date);
@@ -1896,12 +2144,15 @@ var ExponentialClient = class {
     this.labels = new LabelsApi(this.client);
     this.areas = new AreasApi(this.client);
     this.meetings = new MeetingsApi(this.client);
+    this.calendar = new CalendarApi(this.client);
+    this.cycles = new CyclesApi(this.client);
     this.pages = new PagesApi(this.client);
     this.databases = new DatabasesApi(this.client);
     this.resources = new ResourcesApi(this.client);
     this.requirements = new RequirementsApi(this.client);
     this.scopes = new ScopesApi(this.client);
     this.search = new SearchApi(this.client);
+    this.users = new UsersApi(this.client);
     this.time = new TimeApi(this.client);
     this.agentRuns = new AgentRunsApi(this.client);
   }
@@ -1932,6 +2183,8 @@ var ExponentialClient = class {
   labels;
   areas;
   meetings;
+  calendar;
+  cycles;
   pages;
   /** Databases — typed tables inside pages (ADR-0078). */
   databases;
@@ -1939,6 +2192,7 @@ var ExponentialClient = class {
   requirements;
   scopes;
   search;
+  users;
   /** Time entries — the Daily worklog's write path (ADR-0061). */
   time;
   /** Agent runs — the local runner's claim/heartbeat/append/finish (ADR-0067); agent-key only. */
@@ -1946,6 +2200,8 @@ var ExponentialClient = class {
 };
 export {
   AgentRunsApi,
+  CALENDAR_MAX_RESULTS,
+  CALENDAR_MAX_SELECTED,
   CeremoniesApi,
   DEFAULT_GAP_MINUTES,
   ExponentialClient,