@elizaos/plugin-elizacloud 2.0.0-alpha.8 → 2.0.11-beta.7

package/src/cloud/index.ts

@@ -0,0 +1,38 @@
+export {
+  type CloudLoginOptions,
+  type CloudLoginResult,
+  cloudLogin,
+} from "./auth.js";
+export { BackupScheduler } from "./backup.js";
+export {
+  isCloudAuthApiKeyService,
+  normalizeCloudApiKey,
+  type CloudAuthApiKeyService,
+} from "./auth-service-types.js";
+export {
+  normalizeCloudSiteUrl,
+  resolveCloudApiBaseUrl,
+} from "./base-url.js";
+export * from "./duffel-client.js";
+export * from "./lifeops-schedule-sync-client.js";
+export * from "./lifeops-schedule-sync-contracts.js";
+export {
+  type BackupInfo,
+  type CloudAgent,
+  type CloudAgentCreateParams,
+  ElizaCloudClient,
+  type ProvisionInfo,
+} from "./bridge-client.js";
+export {
+  type CloudConnectionStatus,
+  CloudManager,
+  type CloudManagerCallbacks,
+} from "./cloud-manager.js";
+export { CloudRuntimeProxy } from "./cloud-proxy.js";
+export * from "./managed-payment-clients.js";
+export * from "./x402-payment-handler.js";
+export {
+  ConnectionMonitor,
+  type ConnectionMonitorCallbacks,
+} from "./reconnect.js";
+export { validateCloudBaseUrl } from "./validate-url.js";

package/src/cloud/lifeops-schedule-sync-client.ts

@@ -0,0 +1,245 @@
+import {
+  normalizeCloudSiteUrl,
+  resolveCloudApiBaseUrl,
+} from "./base-url.js";
+import type {
+  GetLifeOpsScheduleMergedStateResponse,
+  SyncLifeOpsScheduleObservationsRequest,
+  SyncLifeOpsScheduleObservationsResponse,
+} from "./lifeops-schedule-sync-contracts.js";
+
+const LIFEOPS_SCHEDULE_REQUEST_TIMEOUT_MS = 20_000;
+
+export class LifeOpsScheduleSyncClientError extends Error {
+  constructor(
+    public readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "LifeOpsScheduleSyncClientError";
+  }
+}
+
+export type ResolvedLifeOpsScheduleSyncConfig =
+  | {
+      configured: false;
+      mode: "none";
+    }
+  | {
+      configured: true;
+      mode: "remote";
+      baseUrl: string;
+      accessToken: string | null;
+    }
+  | {
+      configured: true;
+      mode: "cloud";
+      apiBaseUrl: string;
+      apiKey: string;
+      agentId: string;
+    };
+
+export interface LifeOpsScheduleSyncConfigInput {
+  remoteApiBase?: string | null;
+  remoteAccessToken?: string | null;
+  apiKey?: string | null;
+  baseUrl?: string | null;
+  agentId?: string | null;
+}
+
+function normalizeOptionalString(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+
+export function normalizeLifeOpsScheduleSyncSecret(
+  value: string | null | undefined,
+): string | null {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.toUpperCase() === "[REDACTED]" ? null : trimmed;
+}
+
+export function resolveLifeOpsScheduleSyncConfig(
+  config: LifeOpsScheduleSyncConfigInput = {},
+): ResolvedLifeOpsScheduleSyncConfig {
+  const remoteApiBase = normalizeOptionalString(config.remoteApiBase);
+  if (remoteApiBase) {
+    return {
+      configured: true,
+      mode: "remote",
+      baseUrl: remoteApiBase.replace(/\/+$/, ""),
+      accessToken:
+        normalizeLifeOpsScheduleSyncSecret(config.remoteAccessToken) ??
+        normalizeLifeOpsScheduleSyncSecret(process.env.ELIZA_REMOTE_ACCESS_TOKEN),
+    };
+  }
+
+  const apiKey =
+    normalizeLifeOpsScheduleSyncSecret(config.apiKey) ??
+    normalizeLifeOpsScheduleSyncSecret(process.env.ELIZAOS_CLOUD_API_KEY);
+  const agentId =
+    normalizeLifeOpsScheduleSyncSecret(config.agentId) ??
+    normalizeLifeOpsScheduleSyncSecret(process.env.ELIZAOS_CLOUD_AGENT_ID);
+  if (!apiKey || !agentId) {
+    return {
+      configured: false,
+      mode: "none",
+    };
+  }
+
+  return {
+    configured: true,
+    mode: "cloud",
+    apiBaseUrl: resolveCloudApiBaseUrl(
+      normalizeOptionalString(config.baseUrl) ?? process.env.ELIZAOS_CLOUD_BASE_URL,
+    ),
+    apiKey,
+    agentId,
+  };
+}
+
+function buildTimeoutSignal(): AbortSignal {
+  return AbortSignal.timeout(LIFEOPS_SCHEDULE_REQUEST_TIMEOUT_MS);
+}
+
+async function readJsonResponse<T>(response: Response): Promise<T> {
+  if (!response.ok) {
+    let detail = `${response.status} ${response.statusText}`.trim();
+    const text = await response.text();
+    const trimmed = text.trim();
+    if (trimmed.length > 0) {
+      try {
+        const parsed = JSON.parse(trimmed) as {
+          error?: string;
+          message?: string;
+        };
+        detail = parsed.message ?? parsed.error ?? trimmed;
+      } catch {
+        detail = trimmed.slice(0, 200);
+      }
+    }
+    throw new LifeOpsScheduleSyncClientError(response.status, detail);
+  }
+  return (await response.json()) as T;
+}
+
+export function resolveLifeOpsScheduleSyncSiteUrl(rawUrl?: string): string {
+  return normalizeCloudSiteUrl(rawUrl);
+}
+
+export class LifeOpsScheduleSyncClient {
+  constructor(
+    private readonly configSource:
+      | ResolvedLifeOpsScheduleSyncConfig
+      | (() => ResolvedLifeOpsScheduleSyncConfig) =
+      resolveLifeOpsScheduleSyncConfig,
+  ) {}
+
+  private getConfig(): ResolvedLifeOpsScheduleSyncConfig {
+    return typeof this.configSource === "function"
+      ? this.configSource()
+      : this.configSource;
+  }
+
+  get configured(): boolean {
+    return this.getConfig().configured;
+  }
+
+  private requireConfig(): Exclude<
+    ResolvedLifeOpsScheduleSyncConfig,
+    { configured: false }
+  > {
+    const config = this.getConfig();
+    if (!config.configured) {
+      throw new LifeOpsScheduleSyncClientError(
+        409,
+        "LifeOps schedule sync is not configured.",
+      );
+    }
+    return config;
+  }
+
+  private resolvePath(pathname: string): string {
+    const config = this.requireConfig();
+    const normalizedPath = pathname.replace(/^\/+/, "");
+    if (config.mode === "remote") {
+      return new URL(
+        `api/lifeops/schedule/${normalizedPath}`,
+        `${config.baseUrl.replace(/\/+$/, "")}/`,
+      ).toString();
+    }
+    return new URL(
+      `eliza/agents/${encodeURIComponent(config.agentId)}/lifeops/schedule/${normalizedPath}`,
+      `${config.apiBaseUrl.replace(/\/+$/, "")}/`,
+    ).toString();
+  }
+
+  private requestHeaders(
+    initHeaders: HeadersInit | undefined,
+  ): Record<string, string> {
+    const config = this.requireConfig();
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    };
+    if (config.mode === "cloud") {
+      headers["X-API-Key"] = config.apiKey;
+    }
+    if (config.mode === "remote" && config.accessToken) {
+      headers.Authorization = `Bearer ${config.accessToken}`;
+    }
+    if (initHeaders instanceof Headers) {
+      for (const [key, value] of initHeaders.entries()) {
+        headers[key] = value;
+      }
+      return headers;
+    }
+    if (Array.isArray(initHeaders)) {
+      for (const [key, value] of initHeaders) {
+        headers[key] = value;
+      }
+      return headers;
+    }
+    return {
+      ...headers,
+      ...(initHeaders ?? {}),
+    };
+  }
+
+  private async request<T>(pathname: string, init: RequestInit): Promise<T> {
+    const response = await fetch(this.resolvePath(pathname), {
+      ...init,
+      headers: this.requestHeaders(init.headers),
+      signal: init.signal ?? buildTimeoutSignal(),
+    });
+    return readJsonResponse<T>(response);
+  }
+
+  async syncObservations(
+    request: SyncLifeOpsScheduleObservationsRequest,
+  ): Promise<SyncLifeOpsScheduleObservationsResponse> {
+    return this.request<SyncLifeOpsScheduleObservationsResponse>(
+      "observations",
+      {
+        method: "POST",
+        body: JSON.stringify(request),
+      },
+    );
+  }
+
+  async getMergedState(
+    timezone: string,
+    scope: "local" | "cloud" | "effective" = "cloud",
+  ): Promise<GetLifeOpsScheduleMergedStateResponse> {
+    const query = new URLSearchParams({ timezone, scope });
+    return this.request<GetLifeOpsScheduleMergedStateResponse>(
+      `merged-state?${query.toString()}`,
+      {
+        method: "GET",
+      },
+    );
+  }
+}

package/src/cloud/lifeops-schedule-sync-contracts.ts

@@ -0,0 +1,124 @@
+import type {
+  LifeOpsAwakeProbability,
+  LifeOpsCircadianState,
+  LifeOpsPersonalBaseline,
+  LifeOpsRelativeTime,
+  LifeOpsScheduleInsight,
+  LifeOpsScheduleMealLabel,
+  LifeOpsScheduleRegularity,
+  LifeOpsScheduleSleepStatus,
+  LifeOpsUnclearReason,
+} from "@elizaos/shared";
+
+export const LIFEOPS_SCHEDULE_DEVICE_KINDS = [
+  "iphone",
+  "ipad",
+  "mac",
+  "watch",
+  "cloud",
+  "unknown",
+] as const;
+
+export type LifeOpsScheduleDeviceKind =
+  (typeof LIFEOPS_SCHEDULE_DEVICE_KINDS)[number];
+
+export const LIFEOPS_SCHEDULE_OBSERVATION_ORIGINS = [
+  "local_inference",
+  "device_sync",
+] as const;
+
+export type LifeOpsScheduleObservationOrigin =
+  (typeof LIFEOPS_SCHEDULE_OBSERVATION_ORIGINS)[number];
+
+export const LIFEOPS_SCHEDULE_STATE_SCOPES = ["local", "cloud"] as const;
+
+export type LifeOpsScheduleStateScope =
+  (typeof LIFEOPS_SCHEDULE_STATE_SCOPES)[number];
+
+export interface LifeOpsScheduleObservationSnapshot {
+  effectiveDayKey: string;
+  localDate: string;
+  phase: LifeOpsCircadianState;
+  circadianState: LifeOpsCircadianState;
+  stateConfidence: number;
+  uncertaintyReason: LifeOpsUnclearReason | null;
+  relativeTime: LifeOpsRelativeTime;
+  awakeProbability: LifeOpsAwakeProbability;
+  regularity: LifeOpsScheduleRegularity;
+  baseline: LifeOpsPersonalBaseline | null;
+  sleepStatus: LifeOpsScheduleSleepStatus;
+  isProbablySleeping: boolean;
+  sleepConfidence: number;
+  currentSleepStartedAt: string | null;
+  lastSleepStartedAt: string | null;
+  lastSleepEndedAt: string | null;
+  lastSleepDurationMinutes: number | null;
+  wakeAt: string | null;
+  firstActiveAt: string | null;
+  lastActiveAt: string | null;
+  lastMealAt: string | null;
+  nextMealLabel: LifeOpsScheduleMealLabel | null;
+  nextMealWindowStartAt: string | null;
+  nextMealWindowEndAt: string | null;
+  nextMealConfidence: number;
+}
+
+export interface LifeOpsScheduleObservation {
+  id: string;
+  agentId: string;
+  origin: LifeOpsScheduleObservationOrigin;
+  deviceId: string;
+  deviceKind: LifeOpsScheduleDeviceKind;
+  timezone: string;
+  observedAt: string;
+  windowStartAt: string;
+  windowEndAt: string | null;
+  circadianState: LifeOpsCircadianState;
+  stateConfidence: number;
+  uncertaintyReason: LifeOpsUnclearReason | null;
+  mealLabel: LifeOpsScheduleMealLabel | null;
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface LifeOpsScheduleMergedState extends LifeOpsScheduleInsight {
+  id: string;
+  agentId: string;
+  scope: LifeOpsScheduleStateScope;
+  mergedAt: string;
+  observationCount: number;
+  deviceCount: number;
+  contributingDeviceKinds: LifeOpsScheduleDeviceKind[];
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SyncLifeOpsScheduleObservationInput {
+  circadianState: LifeOpsCircadianState;
+  stateConfidence: number;
+  uncertaintyReason?: LifeOpsUnclearReason | null;
+  windowStartAt: string;
+  windowEndAt?: string | null;
+  mealLabel?: LifeOpsScheduleMealLabel | null;
+  snapshot?: Partial<LifeOpsScheduleObservationSnapshot> | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SyncLifeOpsScheduleObservationsRequest {
+  deviceId: string;
+  deviceKind: LifeOpsScheduleDeviceKind;
+  timezone: string;
+  observedAt?: string;
+  observations: SyncLifeOpsScheduleObservationInput[];
+}
+
+export interface SyncLifeOpsScheduleObservationsResponse {
+  acceptedCount: number;
+  mergedState: LifeOpsScheduleMergedState;
+}
+
+export interface GetLifeOpsScheduleMergedStateResponse {
+  mergedState: LifeOpsScheduleMergedState | null;
+}