spectrum-ts 0.2.1 → 0.3.0

package/src/platform/types.ts

@@ -1,442 +0,0 @@
-import type { Fn, Pipe, Tuples } from "hotscript";
-import type z from "zod";
-import type { Content } from "../types/content";
-import type { Message } from "../types/message";
-import type { Space } from "../types/space";
-import type { User } from "../types/user";
-
-type ResolvedSpace = Pick<Space, "id">;
-type SpaceRef = Pick<Space, "id" | "__platform">;
-type ResolvedUser = Pick<User, "id">;
-type AwaitedReturn<T> = T extends (...args: never[]) => Promise<infer R>
-  ? R
-  : never;
-type SchemaInfer<T> = T extends { schema?: infer S extends z.ZodType<object> }
-  ? z.infer<S>
-  : Record<never, never>;
-type InferSchema<TSchema> =
-  TSchema extends z.ZodType<object> ? z.infer<TSchema> : Record<never, never>;
-type InferOptionalSchema<TSchema> =
-  TSchema extends z.ZodType<object> ? z.infer<TSchema> : never;
-
-type InputSchema<TSchema> =
-  TSchema extends z.ZodType<object> ? z.input<TSchema> : never;
-
-// ---------------------------------------------------------------------------
-// Event system types
-// ---------------------------------------------------------------------------
-
-export type EventProducer<
-  TPayload = unknown,
-  TClient = unknown,
-  TConfig = unknown,
-> = (ctx: { client: TClient; config: TConfig }) => AsyncIterable<TPayload>;
-
-export type ProviderMessage<
-  TSender extends ResolvedUser = ResolvedUser,
-  TSpace extends ResolvedSpace = ResolvedSpace,
-  TExtra extends object = Record<never, never>,
-> = {
-  id: string;
-  content: Content[];
-  sender: TSender;
-  space: TSpace;
-  timestamp?: Date;
-} & TExtra;
-
-type MergeSchema<
-  TSchema extends z.ZodType | undefined,
-  TBase extends object,
-> = TSchema extends z.ZodType
-  ? string extends keyof z.infer<TSchema>
-    ? TBase
-    : Omit<z.infer<TSchema>, keyof TBase> & TBase
-  : TBase;
-
-export type SchemaMessage<
-  TUserSchema extends z.ZodType | undefined = undefined,
-  TSpaceSchema extends z.ZodType | undefined = undefined,
-> = ProviderMessage<
-  MergeSchema<TUserSchema, ResolvedUser>,
-  MergeSchema<TSpaceSchema, ResolvedSpace>
->;
-
-type InferEventPayload<T> = T extends (ctx: never) => AsyncIterable<infer P>
-  ? P
-  : never;
-
-// ---------------------------------------------------------------------------
-// Reserved names — event names that would collide with SpectrumInstance methods
-// ---------------------------------------------------------------------------
-
-type ReservedNames = "stop" | "send" | "__internal" | "__providers";
-
-// ---------------------------------------------------------------------------
-// PlatformDef — the full definition of a platform adapter
-// ---------------------------------------------------------------------------
-
-export interface PlatformDef<
-  _Name extends string = string,
-  _ConfigSchema extends z.ZodType<object> = z.ZodType<object>,
-  _UserSchema extends z.ZodType<object> | undefined = undefined,
-  _SpaceSchema extends z.ZodType<object> | undefined = undefined,
-  _SpaceParamsSchema extends z.ZodType<object> | undefined = undefined,
-  _Client = unknown,
-  _ResolvedUser extends ResolvedUser = ResolvedUser,
-  _ResolvedSpace extends ResolvedSpace = ResolvedSpace,
-  _MessageSchema extends z.ZodType<object> | undefined = undefined,
-  _MessageType extends ProviderMessage<
-    _ResolvedUser,
-    _ResolvedSpace,
-    InferSchema<_MessageSchema>
-  > = ProviderMessage<
-    _ResolvedUser,
-    _ResolvedSpace,
-    InferSchema<_MessageSchema>
-  >,
-  _Events extends {
-    messages: EventProducer<_MessageType, _Client, z.infer<_ConfigSchema>>;
-  } = {
-    messages: EventProducer<_MessageType, _Client, z.infer<_ConfigSchema>>;
-  },
-> {
-  actions: {
-    send: (_: {
-      space: _ResolvedSpace & SpaceRef;
-      content: Content[];
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<void>;
-    startTyping?: (_: {
-      space: _ResolvedSpace & SpaceRef;
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<void>;
-    stopTyping?: (_: {
-      space: _ResolvedSpace & SpaceRef;
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<void>;
-    reactToMessage?: (_: {
-      space: _ResolvedSpace & SpaceRef;
-      messageId: string;
-      reaction: string;
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<void>;
-    replyToMessage?: (_: {
-      space: _ResolvedSpace & SpaceRef;
-      messageId: string;
-      content: Content[];
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<void>;
-  };
-
-  config: _ConfigSchema;
-
-  events: _Events;
-
-  lifecycle: {
-    createClient: (ctx: {
-      config: z.infer<_ConfigSchema>;
-      projectId: string | undefined;
-      projectSecret: string | undefined;
-    }) => Promise<_Client>;
-    destroyClient: (ctx: { client: _Client }) => Promise<void>;
-  };
-
-  message?: {
-    schema?: _MessageSchema;
-  };
-  name: _Name;
-
-  space: {
-    schema?: _SpaceSchema;
-    params?: _SpaceParamsSchema;
-    resolve: (_: {
-      input: {
-        users: (_ResolvedUser & { __platform: _Name })[];
-        params?: _SpaceParamsSchema extends z.ZodType<object>
-          ? z.infer<_SpaceParamsSchema>
-          : undefined;
-      };
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<_ResolvedSpace>;
-  };
-
-  user: {
-    schema?: _UserSchema;
-    resolve: (_: {
-      input: { userID: string };
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => Promise<_ResolvedUser>;
-  };
-}
-
-// ---------------------------------------------------------------------------
-// AnyPlatformDef — structural wildcard for erasure contexts
-// ---------------------------------------------------------------------------
-
-export interface AnyPlatformDef {
-  actions: {
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard action
-    send: (_: any) => Promise<void>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard action
-    startTyping?: (_: any) => Promise<void>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard action
-    stopTyping?: (_: any) => Promise<void>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard action
-    reactToMessage?: (_: any) => Promise<void>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard action
-    replyToMessage?: (_: any) => Promise<void>;
-  };
-  config: z.ZodType<object>;
-  events: {
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard event
-    messages: (ctx: any) => AsyncIterable<any>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard event
-    [key: string]: (ctx: any) => AsyncIterable<any>;
-  };
-  lifecycle: {
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard lifecycle
-    createClient: (ctx: any) => Promise<any>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard lifecycle
-    destroyClient: (ctx: any) => Promise<void>;
-  };
-  message?: { schema?: z.ZodType<object> };
-  name: string;
-  space: {
-    schema?: z.ZodType<object>;
-    params?: z.ZodType<object>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard resolver
-    resolve: (_: any) => Promise<any>;
-  };
-  user: {
-    schema?: z.ZodType<object>;
-    // biome-ignore lint/suspicious/noExplicitAny: wildcard resolver
-    resolve: (_: any) => Promise<any>;
-  };
-}
-
-// ---------------------------------------------------------------------------
-// PlatformProviderConfig — carries platform def type through providers array
-// ---------------------------------------------------------------------------
-
-export interface PlatformProviderConfig<
-  Def extends AnyPlatformDef = AnyPlatformDef,
-> {
-  readonly __def: Def;
-  readonly __definition: AnyPlatformDef;
-  readonly __name: Def["name"];
-  readonly __tag: "PlatformProviderConfig";
-  readonly config: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// HotScript Fn's for type-level provider operations
-// ---------------------------------------------------------------------------
-
-interface MatchesPlatformName<Name extends string> extends Fn {
-  return: this["arg0"] extends PlatformProviderConfig<infer Def>
-    ? Def["name"] extends Name
-      ? true
-      : false
-    : false;
-}
-
-interface ExtractDef extends Fn {
-  return: this["arg0"] extends PlatformProviderConfig<infer Def> ? Def : never;
-}
-
-interface ExtractDefByName<Name extends string> extends Fn {
-  return: this["arg0"] extends { name: Name } ? true : false;
-}
-
-// ---------------------------------------------------------------------------
-// HotScript Fn's for custom event operations
-// ---------------------------------------------------------------------------
-
-interface ExtractCustomEventNames extends Fn {
-  return: this["arg0"] extends AnyPlatformDef
-    ? Exclude<keyof this["arg0"]["events"], "messages" | symbol | number>
-    : never;
-}
-
-interface ToCustomEventVariant<EventName extends string> extends Fn {
-  return: this["arg0"] extends PlatformProviderConfig<infer Def>
-    ? EventName extends keyof Def["events"]
-      ? InferEventPayload<Def["events"][EventName]> & { platform: Def["name"] }
-      : never
-    : never;
-}
-
-// ---------------------------------------------------------------------------
-// HasProvider — check if a platform name exists in providers tuple
-// ---------------------------------------------------------------------------
-
-export type HasProvider<
-  Providers extends PlatformProviderConfig[],
-  Name extends string,
-> = Pipe<Providers, [Tuples.Some<MatchesPlatformName<Name>>]>;
-
-// ---------------------------------------------------------------------------
-// ExtractProviderDef — pull a platform's def from the providers tuple
-// ---------------------------------------------------------------------------
-
-export type ExtractProviderDef<
-  Providers extends PlatformProviderConfig[],
-  Name extends string,
-> = Pipe<
-  Providers,
-  [Tuples.Map<ExtractDef>, Tuples.Find<ExtractDefByName<Name>>]
->;
-
-// ---------------------------------------------------------------------------
-// AllCustomEventNames — union of all non-messages event names across providers
-// ---------------------------------------------------------------------------
-
-type AllCustomEventNames<Providers extends PlatformProviderConfig[]> = Pipe<
-  Providers,
-  [Tuples.Map<ExtractDef>, Tuples.Map<ExtractCustomEventNames>, Tuples.ToUnion]
->;
-
-// ---------------------------------------------------------------------------
-// UnifiedCustomEvent — for a given event name, union of payloads across providers
-// ---------------------------------------------------------------------------
-
-type UnifiedCustomEvent<
-  Providers extends PlatformProviderConfig[],
-  EventName extends string,
-> = Pipe<
-  Providers,
-  [Tuples.Map<ToCustomEventVariant<EventName>>, Tuples.ToUnion]
->;
-
-// ---------------------------------------------------------------------------
-// CustomEventStreams — mapped type producing async iterables for each custom event
-// ---------------------------------------------------------------------------
-
-export type CustomEventStreams<Providers extends PlatformProviderConfig[]> = {
-  [K in Exclude<AllCustomEventNames<Providers>, ReservedNames> &
-    string]: AsyncIterable<UnifiedCustomEvent<Providers, K>>;
-};
-
-// ---------------------------------------------------------------------------
-// Platform-specific Space, Message, and User types
-// ---------------------------------------------------------------------------
-
-type ResolvedSpaceOf<Def extends AnyPlatformDef> = AwaitedReturn<
-  Def["space"]["resolve"]
->;
-type SchemaSpaceOf<Def extends AnyPlatformDef> = InferOptionalSchema<
-  Def["space"]["schema"]
->;
-
-type ResolvedUserOf<Def extends AnyPlatformDef> = AwaitedReturn<
-  Def["user"]["resolve"]
->;
-
-type SpaceShapeOf<Def extends AnyPlatformDef> = [SchemaSpaceOf<Def>] extends [
-  never,
-]
-  ? ResolvedSpaceOf<Def>
-  : SchemaSpaceOf<Def>;
-
-type SpaceParamsInputOf<Def extends AnyPlatformDef> = InputSchema<
-  Def["space"]["params"]
->;
-
-type SpaceArrayArgs<Def extends AnyPlatformDef> = [
-  SpaceParamsInputOf<Def>,
-] extends [never]
-  ? [users: PlatformUser<Def>[]]
-  :
-      | [users: PlatformUser<Def>[]]
-      | [users: PlatformUser<Def>[], params: SpaceParamsInputOf<Def>]
-      | [params: SpaceParamsInputOf<Def>];
-
-type SpaceVarargArgs<Def extends AnyPlatformDef> = [
-  SpaceParamsInputOf<Def>,
-] extends [never]
-  ? PlatformUser<Def>[]
-  : PlatformUser<Def>[] | [...PlatformUser<Def>[], SpaceParamsInputOf<Def>];
-
-type SpaceArgs<Def extends AnyPlatformDef> =
-  | SpaceArrayArgs<Def>
-  | SpaceVarargArgs<Def>;
-
-export type PlatformSpace<Def extends AnyPlatformDef> = Omit<
-  SpaceShapeOf<Def>,
-  keyof Space
-> &
-  Space;
-
-export type PlatformMessage<Def extends AnyPlatformDef> = Omit<
-  SchemaInfer<Def["message"]>,
-  keyof Message
-> &
-  Message<Def["name"], PlatformUser<Def>, PlatformSpace<Def>>;
-
-export type PlatformUser<Def extends AnyPlatformDef> = Omit<
-  ResolvedUserOf<Def>,
-  keyof User
-> &
-  User;
-
-// ---------------------------------------------------------------------------
-// PlatformInstance — returned from imessage(spectrum)
-// ---------------------------------------------------------------------------
-
-export type PlatformInstance<Def extends AnyPlatformDef> = {
-  space(...args: SpaceArgs<Def>): Promise<PlatformSpace<Def>>;
-  user(userID: string): Promise<PlatformUser<Def>>;
-} & {
-  [K in Exclude<
-    keyof Def["events"],
-    "messages" | symbol | number
-  > as K extends ReservedNames ? never : K]: AsyncIterable<
-    InferEventPayload<Def["events"][K]>
-  >;
-};
-
-// ---------------------------------------------------------------------------
-// SpectrumLike — minimal interface for platform narrowing
-// ---------------------------------------------------------------------------
-
-export interface SpectrumLike<
-  Providers extends PlatformProviderConfig[] = PlatformProviderConfig[],
-> {
-  readonly __internal: {
-    platforms: Map<
-      string,
-      { client: unknown; config: unknown; definition: AnyPlatformDef }
-    >;
-  };
-  readonly __providers: Providers;
-}
-
-// ---------------------------------------------------------------------------
-// Platform — the callable returned by definePlatform()
-// ---------------------------------------------------------------------------
-
-export interface Platform<Def extends AnyPlatformDef> {
-  config(
-    ...args: Record<string, never> extends z.input<Def["config"]>
-      ? [config?: z.input<Def["config"]>]
-      : [config: z.input<Def["config"]>]
-  ): PlatformProviderConfig<Def>;
-  <Providers extends PlatformProviderConfig[]>(
-    spectrum: SpectrumLike<Providers>
-  ): HasProvider<Providers, Def["name"]> extends true
-    ? PlatformInstance<Def>
-    : never;
-
-  (space: Space): PlatformSpace<Def>;
-
-  (message: Message): PlatformMessage<Def>;
-}
-
-export type { Message } from "../types/message";

package/src/providers/imessage/auth.ts

@@ -1,115 +0,0 @@
-import {
-  type AdvancedIMessage,
-  createClient,
-} from "@photon-ai/advanced-imessage";
-import {
-  cloud,
-  type DedicatedTokenData,
-  type SharedTokenData,
-} from "../../utils/cloud";
-
-const RENEWAL_RATIO = 0.8;
-const EXPIRY_BUFFER_MS = 30_000;
-const RETRY_DELAY_MS = 30_000;
-
-interface CloudAuth {
-  dispose: () => void;
-}
-
-const cloudAuthState = new WeakMap<AdvancedIMessage[], CloudAuth>();
-
-export async function createCloudClients(
-  projectId: string,
-  projectSecret: string
-): Promise<AdvancedIMessage[]> {
-  let tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
-  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1000;
-  let disposed = false;
-  let renewalTimer: ReturnType<typeof setTimeout> | undefined;
-
-  const scheduleRenewal = () => {
-    if (disposed) {
-      return;
-    }
-    const ttlMs = tokenData.expiresIn * 1000;
-    const renewInMs = Math.max(ttlMs * RENEWAL_RATIO, 5000);
-
-    renewalTimer = setTimeout(async () => {
-      try {
-        tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
-        tokenExpiresAt = Date.now() + tokenData.expiresIn * 1000;
-        scheduleRenewal();
-      } catch {
-        renewalTimer = setTimeout(() => scheduleRenewal(), RETRY_DELAY_MS);
-        renewalTimer?.unref?.();
-      }
-    }, renewInMs);
-    renewalTimer?.unref?.();
-  };
-
-  scheduleRenewal();
-
-  const refreshIfNeeded = async (): Promise<void> => {
-    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
-      return;
-    }
-    tokenData = await cloud.issueImessageTokens(projectId, projectSecret);
-    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1000;
-    scheduleRenewal();
-  };
-
-  const buildClients = (): AdvancedIMessage[] => {
-    if (tokenData.type === "shared") {
-      const address =
-        process.env.SPECTRUM_IMESSAGE_ADDRESS ??
-        "imessage.spectrum.photon.codes:443";
-
-      return [
-        createClient({
-          address,
-          tls: true,
-          token: async () => {
-            await refreshIfNeeded();
-            return (tokenData as SharedTokenData).token;
-          },
-        }),
-      ];
-    }
-
-    return Object.entries(tokenData.auth).map(([instanceId, token]) =>
-      createClient({
-        address: `${instanceId}.imsg.photon.codes:443`,
-        tls: true,
-        token: async () => {
-          await refreshIfNeeded();
-          const data = tokenData as DedicatedTokenData;
-          return data.auth[instanceId] ?? token;
-        },
-      })
-    );
-  };
-
-  const clients = buildClients();
-
-  cloudAuthState.set(clients, {
-    dispose: () => {
-      disposed = true;
-      if (renewalTimer !== undefined) {
-        clearTimeout(renewalTimer);
-        renewalTimer = undefined;
-      }
-    },
-  });
-
-  return clients;
-}
-
-export async function disposeCloudAuth(
-  clients: AdvancedIMessage[]
-): Promise<void> {
-  const auth = cloudAuthState.get(clients);
-  if (auth) {
-    auth.dispose();
-    cloudAuthState.delete(clients);
-  }
-}

package/src/providers/imessage/index.ts

@@ -1,153 +0,0 @@
-import { createClient, directChat } from "@photon-ai/advanced-imessage";
-import { IMessageSDK } from "@photon-ai/imessage-kit";
-import { definePlatform } from "../../platform/define";
-import { createCloudClients, disposeCloudAuth } from "./auth";
-import { messages as localMessages, send as localSend } from "./local";
-import {
-  messages as remoteMessages,
-  reactToMessage as remoteReactToMessage,
-  replyToMessage as remoteReplyToMessage,
-  send as remoteSend,
-  startTyping as remoteStartTyping,
-  stopTyping as remoteStopTyping,
-} from "./remote";
-import {
-  configSchema,
-  type IMessageClient,
-  isLocal,
-  spaceSchema,
-} from "./types";
-
-export const imessage = definePlatform("iMessage", {
-  config: configSchema,
-
-  static: {
-    tapbacks: {
-      love: "love",
-      like: "like",
-      dislike: "dislike",
-      laugh: "laugh",
-      emphasize: "emphasize",
-      question: "question",
-    } as const,
-  },
-
-  user: {
-    resolve: async ({ input }) => ({ id: input.userID }),
-  },
-
-  space: {
-    schema: spaceSchema,
-    resolve: async ({ input, client }) => {
-      if (isLocal(client)) {
-        throw new Error(
-          "Space creation is not supported in local mode. Local mode only supports replying to messages."
-        );
-      }
-
-      if (input.users.length === 0) {
-        throw new Error("iMessage space creation requires at least one user");
-      }
-
-      const addresses = input.users.map((u) => u.id);
-
-      if (input.users.length === 1) {
-        return {
-          id: directChat(addresses[0] ?? "") as string,
-          type: "dm" as const,
-        };
-      }
-
-      const remote = client[0];
-      if (!remote) {
-        throw new Error("No remote iMessage client available");
-      }
-
-      const { chat } = await remote.chats.create(addresses);
-      return { id: chat.guid as string, type: "group" as const };
-    },
-  },
-
-  lifecycle: {
-    createClient: async ({
-      config,
-      projectId,
-      projectSecret,
-    }): Promise<IMessageClient> => {
-      if (config.local) {
-        return new IMessageSDK();
-      }
-
-      if (config.clients) {
-        const entries = Array.isArray(config.clients)
-          ? config.clients
-          : [config.clients];
-        return entries.map((e) =>
-          createClient({ address: e.address, tls: true, token: e.token })
-        );
-      }
-
-      if (!(projectId && projectSecret)) {
-        throw new Error(
-          "iMessage requires projectId and projectSecret. " +
-            "Either pass credentials to Spectrum(), use local mode: imessage.config({ local: true }), " +
-            "or provide explicit client config: imessage.config({ clients: [...] })"
-        );
-      }
-
-      return await createCloudClients(projectId, projectSecret);
-    },
-
-    destroyClient: async ({ client }: { client: IMessageClient }) => {
-      if (isLocal(client)) {
-        await client.close();
-        return;
-      }
-      await disposeCloudAuth(client);
-      await Promise.all(client.map((c) => c.close()));
-    },
-  },
-
-  events: {
-    messages: ({ client }) =>
-      isLocal(client) ? localMessages(client) : remoteMessages(client),
-  },
-
-  actions: {
-    send: async ({ space, content, client }) => {
-      for (const item of content) {
-        if (isLocal(client)) {
-          await localSend(client, space.id, item);
-        } else {
-          await remoteSend(client, space.id, item);
-        }
-      }
-    },
-    startTyping: async ({ space, client }) => {
-      if (isLocal(client)) {
-        return;
-      }
-      await remoteStartTyping(client, space.id);
-    },
-    stopTyping: async ({ space, client }) => {
-      if (isLocal(client)) {
-        return;
-      }
-      await remoteStopTyping(client, space.id);
-    },
-    reactToMessage: async ({ space, messageId, reaction, client }) => {
-      if (isLocal(client)) {
-        return;
-      }
-      await remoteReactToMessage(client, space.id, messageId, reaction);
-    },
-    replyToMessage: async ({ space, messageId, content, client }) => {
-      if (isLocal(client)) {
-        return;
-      }
-      for (const item of content) {
-        await remoteReplyToMessage(client, space.id, messageId, item);
-      }
-    },
-  },
-});