spectrum-ts 0.0.1 → 0.1.2

package/dist/chunk-3TBRO2J7.js

@@ -0,0 +1,58 @@
+// src/utils/stream.ts
+import { Repeater } from "@repeaterjs/repeater";
+function stream(setup) {
+  const repeater = new Repeater(async (push, stop) => {
+    const emit = (value) => {
+      Promise.resolve(push(value)).catch((error) => {
+        stop(error);
+        return void 0;
+      });
+    };
+    const end = (error) => {
+      stop(error);
+    };
+    const cleanup = await setup(emit, end);
+    try {
+      await stop;
+    } finally {
+      await cleanup?.();
+    }
+  });
+  return Object.assign(repeater, {
+    close: async () => {
+      await repeater.return(void 0);
+    }
+  });
+}
+function mergeStreams(streams) {
+  return stream((emit, end) => {
+    if (streams.length === 0) {
+      end();
+      return;
+    }
+    let openStreams = streams.length;
+    const workers = streams.map(async (source) => {
+      try {
+        for await (const value of source) {
+          emit(value);
+        }
+      } catch (error) {
+        end(error);
+      } finally {
+        openStreams -= 1;
+        if (openStreams === 0) {
+          end();
+        }
+      }
+    });
+    return async () => {
+      await Promise.allSettled(streams.map((source) => source.close()));
+      await Promise.allSettled(workers);
+    };
+  });
+}
+
+export {
+  stream,
+  mergeStreams
+};

package/dist/chunk-UZ2CXPOD.js

@@ -0,0 +1,175 @@
+// src/platform/define.ts
+function createPlatformInstance(def, runtime) {
+  const isPlatformUser = (value) => {
+    return typeof value === "object" && value !== null && "__platform" in value && value.__platform === def.name;
+  };
+  const normalizeSpaceArgs = (args) => {
+    if (args.length === 0) {
+      return { users: [], params: void 0 };
+    }
+    const [first, ...rest] = args;
+    if (Array.isArray(first)) {
+      return {
+        users: first,
+        params: rest[0]
+      };
+    }
+    if (!isPlatformUser(first)) {
+      return {
+        users: [],
+        params: first
+      };
+    }
+    const last = args.at(-1);
+    if (last !== void 0 && !isPlatformUser(last)) {
+      return {
+        users: args.slice(0, -1),
+        params: last
+      };
+    }
+    return {
+      users: args,
+      params: void 0
+    };
+  };
+  const base = {
+    async user(userID) {
+      const resolved = await def.user.resolve({
+        input: { userID },
+        client: runtime.client,
+        config: runtime.config
+      });
+      return {
+        ...resolved,
+        __platform: def.name
+      };
+    },
+    async space(...args) {
+      const { users, params } = normalizeSpaceArgs(args);
+      let parsedParams = params;
+      if (params !== void 0 && def.space.params) {
+        parsedParams = def.space.params.parse(params);
+      }
+      const resolved = await def.space.resolve({
+        input: { users, params: parsedParams },
+        client: runtime.client,
+        config: runtime.config
+      });
+      const parsedSpace = def.space.schema ? def.space.schema.parse(resolved) : resolved;
+      const spaceRef = {
+        id: parsedSpace.id,
+        __platform: def.name
+      };
+      const typingCtx = {
+        space: spaceRef,
+        client: runtime.client,
+        config: runtime.config
+      };
+      return {
+        ...parsedSpace,
+        ...spaceRef,
+        send: async (...content) => {
+          const built = await Promise.all(content.map((c) => c.build()));
+          await def.actions.send({
+            ...typingCtx,
+            content: built
+          });
+        },
+        startTyping: async () => {
+          await def.actions.startTyping?.(typingCtx);
+        },
+        stopTyping: async () => {
+          await def.actions.stopTyping?.(typingCtx);
+        },
+        responding: async (fn) => {
+          await def.actions.startTyping?.(typingCtx);
+          try {
+            return await fn();
+          } finally {
+            await def.actions.stopTyping?.(typingCtx).catch(() => {
+            });
+          }
+        }
+      };
+    }
+  };
+  const eventProperties = {};
+  for (const eventName of Object.keys(def.events)) {
+    if (eventName === "messages") {
+      continue;
+    }
+    const producer = def.events[eventName];
+    if (producer) {
+      eventProperties[eventName] = producer({
+        client: runtime.client,
+        config: runtime.config
+      });
+    }
+  }
+  return Object.assign(base, eventProperties);
+}
+function definePlatform(name, def) {
+  const fullDef = { name, ...def };
+  const platformCache = /* @__PURE__ */ new WeakMap();
+  const narrowSpectrum = (spectrum) => {
+    const cached = platformCache.get(spectrum);
+    if (cached) {
+      return cached;
+    }
+    const runtime = spectrum.__internal.platforms.get(name);
+    if (!runtime) {
+      throw new Error(`Platform "${name}" is not registered`);
+    }
+    const instance = createPlatformInstance(
+      fullDef,
+      runtime
+    );
+    platformCache.set(spectrum, instance);
+    return instance;
+  };
+  const narrowSpace = (input) => {
+    if (input.__platform !== name) {
+      throw new Error(
+        `Expected space from "${name}", got "${input.__platform}"`
+      );
+    }
+    return input;
+  };
+  const narrowMessage = (input) => {
+    if (input.platform !== name) {
+      throw new Error(
+        `Expected message from "${name}", got "${input.platform}"`
+      );
+    }
+    return input;
+  };
+  const narrower = ((input) => {
+    if ("__providers" in input && "__internal" in input) {
+      return narrowSpectrum(input);
+    }
+    if ("__platform" in input && "send" in input) {
+      return narrowSpace(input);
+    }
+    if ("platform" in input && "sender" in input && "space" in input) {
+      return narrowMessage(input);
+    }
+    throw new Error("Invalid input to platform narrowing function");
+  });
+  narrower.config = (config = {}) => {
+    return {
+      __tag: "PlatformProviderConfig",
+      __def: void 0,
+      __name: name,
+      config,
+      __definition: fullDef
+    };
+  };
+  if (def.static) {
+    Object.assign(narrower, def.static);
+  }
+  return narrower;
+}
+
+export {
+  definePlatform
+};

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import z__default from 'zod';
+import { P as ProviderMessage, a as PlatformDef, b as Platform, c as PlatformProviderConfig, S as SpectrumLike, C as CustomEventStreams, d as Space, M as Message, e as ContentBuilder } from './types-eXHZpal1.js';
+export { A as AnyPlatformDef, f as Content, E as EventProducer, g as PlatformInstance, h as PlatformMessage, i as PlatformSpace, j as PlatformUser, k as SchemaMessage, U as User, l as attachment, m as custom, t as text } from './types-eXHZpal1.js';
+export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-DGy4geUK.js';
+import 'hotscript';
+import 'type-fest';
+
+declare function definePlatform<_Name extends string, _ConfigSchema extends z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined, _SpaceSchema extends z__default.ZodType<object> | undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined, _Client, _ResolvedUser extends {
+    id: string;
+}, _ResolvedSpace extends {
+    id: string;
+}, _MessageSchema extends z__default.ZodType<object> | undefined = undefined, _MessageType extends ProviderMessage<_ResolvedUser, _ResolvedSpace, _MessageSchema extends z__default.ZodType<object> ? z__default.infer<_MessageSchema> : Record<never, never>> = ProviderMessage<_ResolvedUser, _ResolvedSpace, _MessageSchema extends z__default.ZodType<object> ? z__default.infer<_MessageSchema> : Record<never, never>>, _Events extends {
+    messages: (ctx: {
+        client: _Client;
+        config: z__default.infer<_ConfigSchema>;
+    }) => AsyncIterable<_MessageType>;
+} = {
+    messages: (ctx: {
+        client: _Client;
+        config: z__default.infer<_ConfigSchema>;
+    }) => AsyncIterable<_MessageType>;
+}, _Static extends Record<string, unknown> = Record<never, never>>(name: _Name, def: Omit<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events>, "name"> & {
+    static?: _Static;
+}): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events>> & Readonly<_Static>;
+
+type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
+    readonly messages: AsyncIterable<[Space, Message]>;
+    stop(): Promise<void>;
+    send(space: Space, ...content: [ContentBuilder, ...ContentBuilder[]]): Promise<void>;
+    responding<T>(space: Space, fn: () => T | Promise<T>): Promise<T>;
+};
+declare function Spectrum<const Providers extends PlatformProviderConfig[]>(options: {
+    projectId: string;
+    projectSecret: string;
+    providers: [...Providers];
+} | {
+    projectId?: never;
+    projectSecret?: never;
+    providers: [...Providers];
+}): Promise<SpectrumInstance<Providers>>;
+
+export { ContentBuilder, Message, Platform, PlatformDef, PlatformProviderConfig, Space, Spectrum, type SpectrumInstance, definePlatform };

package/dist/index.js

@@ -0,0 +1,348 @@
+import {
+  mergeStreams,
+  stream
+} from "./chunk-3TBRO2J7.js";
+import {
+  definePlatform
+} from "./chunk-UZ2CXPOD.js";
+
+// src/spectrum.ts
+import z from "zod";
+var providerMessageCoreKeys = /* @__PURE__ */ new Set([
+  "content",
+  "id",
+  "sender",
+  "space",
+  "timestamp"
+]);
+var spectrumConfigSchema = z.union([
+  z.object({
+    projectId: z.string().min(1),
+    projectSecret: z.string().min(1),
+    providers: z.array(z.custom())
+  }),
+  z.object({
+    projectId: z.undefined().optional(),
+    projectSecret: z.undefined().optional(),
+    providers: z.array(z.custom())
+  })
+]);
+async function Spectrum(options) {
+  spectrumConfigSchema.parse(options);
+  const { projectId, projectSecret, providers } = options;
+  const platformStates = /* @__PURE__ */ new Map();
+  const customEventStreams = /* @__PURE__ */ new Map();
+  let stopped = false;
+  for (const provider of providers) {
+    const providerConfig = provider;
+    const def = providerConfig.__definition;
+    const userConfig = def.config.parse(providerConfig.config);
+    const client = await def.lifecycle.createClient({
+      config: userConfig,
+      projectId,
+      projectSecret
+    });
+    platformStates.set(def.name, {
+      client,
+      config: userConfig,
+      definition: def
+    });
+  }
+  const adaptIterable = (iterable) => {
+    return stream((emit, end) => {
+      const iterator = iterable[Symbol.asyncIterator]();
+      (async () => {
+        try {
+          let result = await iterator.next();
+          while (!result.done) {
+            emit(result.value);
+            result = await iterator.next();
+          }
+          end();
+        } catch (error) {
+          end(error);
+        }
+      })();
+      return async () => {
+        await iterator.return?.();
+      };
+    });
+  };
+  const createProviderMessagesStream = (state) => {
+    const { client, config, definition } = state;
+    const raw = definition.events.messages({
+      client,
+      config
+    });
+    const bindSend = async function* () {
+      for await (const msg of raw) {
+        const extraEntries = Object.entries(msg).filter(
+          ([key]) => !providerMessageCoreKeys.has(key)
+        );
+        const extra = Object.fromEntries(extraEntries);
+        const parsedExtra = definition.message?.schema ? definition.message.schema.parse(extra) : {};
+        const spaceRef = {
+          ...msg.space,
+          __platform: definition.name
+        };
+        const typingCtx = { space: spaceRef, client, config };
+        const space = {
+          ...spaceRef,
+          send: async (...content) => {
+            const resolved = await Promise.all(content.map((c) => c.build()));
+            await definition.actions.send({
+              ...typingCtx,
+              content: resolved
+            });
+          },
+          startTyping: async () => {
+            await definition.actions.startTyping?.(typingCtx);
+          },
+          stopTyping: async () => {
+            await definition.actions.stopTyping?.(typingCtx);
+          },
+          responding: async (fn) => {
+            await definition.actions.startTyping?.(typingCtx);
+            try {
+              return await fn();
+            } finally {
+              await definition.actions.stopTyping?.(typingCtx).catch(() => {
+              });
+            }
+          }
+        };
+        const normalizedMessage = {
+          ...parsedExtra,
+          id: msg.id,
+          content: msg.content,
+          platform: definition.name,
+          react: async (reaction) => {
+            if (!definition.actions.reactToMessage) {
+              return;
+            }
+            await definition.actions.reactToMessage({
+              space: spaceRef,
+              messageId: msg.id,
+              reaction,
+              client,
+              config
+            });
+          },
+          reply: async (...content) => {
+            if (!definition.actions.replyToMessage) {
+              return;
+            }
+            const resolved = await Promise.all(content.map((c) => c.build()));
+            await definition.actions.replyToMessage({
+              space: spaceRef,
+              messageId: msg.id,
+              content: resolved,
+              client,
+              config
+            });
+          },
+          sender: {
+            ...msg.sender,
+            __platform: definition.name
+          },
+          space,
+          timestamp: msg.timestamp ?? /* @__PURE__ */ new Date()
+        };
+        yield [space, normalizedMessage];
+      }
+    };
+    return adaptIterable(bindSend());
+  };
+  const createMessagesStream = () => {
+    return stream(async (emit, end) => {
+      const merged = mergeStreams(
+        Array.from(platformStates.values(), createProviderMessagesStream)
+      );
+      (async () => {
+        try {
+          for await (const value of merged) {
+            emit(value);
+          }
+          end();
+        } catch (error) {
+          end(error);
+        }
+      })();
+      return async () => {
+        await merged.close();
+      };
+    });
+  };
+  const createCustomEventStream = (eventName) => {
+    return stream(async (emit, end) => {
+      const providerStreams = Array.from(platformStates.values(), (state) => {
+        const { client, config, definition } = state;
+        const producer = definition.events[eventName];
+        if (!producer) {
+          return void 0;
+        }
+        const providerEvents = producer({ client, config });
+        const annotatePlatform = async function* () {
+          for await (const value of providerEvents) {
+            yield { ...value, platform: definition.name };
+          }
+        };
+        return adaptIterable(annotatePlatform());
+      }).filter(
+        (value) => value !== void 0
+      );
+      const merged = mergeStreams(providerStreams);
+      (async () => {
+        try {
+          for await (const value of merged) {
+            emit(value);
+          }
+          end();
+        } catch (error) {
+          end(error);
+        }
+      })();
+      return async () => {
+        await merged.close();
+      };
+    });
+  };
+  const messagesStream = createMessagesStream();
+  const stopOnce = async () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    const streamShutdowns = [
+      messagesStream.close(),
+      ...Array.from(
+        customEventStreams.values(),
+        (eventStream) => eventStream.close()
+      )
+    ];
+    process.off("SIGINT", handleSignal);
+    process.off("SIGTERM", handleSignal);
+    await Promise.allSettled(streamShutdowns);
+    const clientShutdowns = Array.from(
+      platformStates.values(),
+      (state) => state.definition.lifecycle.destroyClient({
+        client: state.client
+      })
+    );
+    await Promise.allSettled(clientShutdowns);
+    customEventStreams.clear();
+    platformStates.clear();
+  };
+  const handleSignal = () => {
+    setTimeout(() => process.exit(1), 3e3).unref();
+    stopOnce().then(() => process.exit(0)).catch(() => process.exit(1));
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  const messages = messagesStream;
+  const customEventProxy = new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        let eventStream = customEventStreams.get(prop);
+        if (!eventStream) {
+          eventStream = createCustomEventStream(prop);
+          customEventStreams.set(prop, eventStream);
+        }
+        return eventStream;
+      }
+    }
+  );
+  const base = {
+    __providers: providers,
+    __internal: { platforms: platformStates },
+    messages,
+    stop: stopOnce,
+    send: async (space, ...content) => {
+      await space.send(...content);
+    },
+    responding: async (space, fn) => {
+      return space.responding(fn);
+    }
+  };
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (typeof prop === "string") {
+        return customEventProxy[prop];
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/types/content.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+import { lookup as lookupMimeType } from "mime-types";
+import z2 from "zod";
+var DEFAULT_ATTACHMENT_NAME = "attachment";
+var contentSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("plain_text"),
+    text: z2.string().nonempty()
+  }),
+  z2.object({
+    type: z2.literal("custom"),
+    raw: z2.json()
+  }),
+  z2.object({
+    type: z2.literal("attachment"),
+    data: z2.instanceof(Buffer),
+    mimeType: z2.string().nonempty(),
+    name: z2.string().nonempty()
+  })
+]);
+function text(text2) {
+  return {
+    build: () => Promise.resolve({ type: "plain_text", text: text2 })
+  };
+}
+function custom(raw) {
+  return {
+    build: () => Promise.resolve({ type: "custom", raw })
+  };
+}
+var resolveAttachmentName = (input, name) => name || (typeof input === "string" ? basename(input) : DEFAULT_ATTACHMENT_NAME);
+var resolveAttachmentMimeType = (name, mimeType) => {
+  if (mimeType) {
+    return mimeType;
+  }
+  const resolvedMimeType = lookupMimeType(name);
+  if (!resolvedMimeType) {
+    throw new Error(
+      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
+    );
+  }
+  return resolvedMimeType;
+};
+function attachment(input, options) {
+  return {
+    build: async () => {
+      const data = typeof input === "string" ? await readFile(input) : input;
+      const name = resolveAttachmentName(input, options?.name);
+      return {
+        data,
+        mimeType: resolveAttachmentMimeType(name, options?.mimeType),
+        name,
+        type: "attachment"
+      };
+    }
+  };
+}
+export {
+  Spectrum,
+  attachment,
+  custom,
+  definePlatform,
+  mergeStreams,
+  stream,
+  text
+};

package/dist/providers/imessage/index.d.ts

@@ -0,0 +1,82 @@
+import { M as ManagedStream } from '../../stream-DGy4geUK.js';
+import { AdvancedIMessage } from '@photon-ai/advanced-imessage';
+import { IMessageSDK } from '@photon-ai/imessage-kit';
+import * as z from 'zod';
+import z__default from 'zod';
+import { k as SchemaMessage, b as Platform, a as PlatformDef, P as ProviderMessage } from '../../types-eXHZpal1.js';
+import * as zod_v4_core from 'zod/v4/core';
+import 'hotscript';
+import 'type-fest';
+
+type IMessageClient = IMessageSDK | AdvancedIMessage[];
+declare const userSchema: z__default.ZodObject<{}, z__default.core.$strip>;
+declare const spaceSchema: z__default.ZodObject<{
+    id: z__default.ZodString;
+    type: z__default.ZodEnum<{
+        dm: "dm";
+        group: "group";
+    }>;
+}, z__default.core.$strip>;
+type IMessageMessage = SchemaMessage<typeof userSchema, typeof spaceSchema>;
+
+declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.ZodObject<{
+    local: z.ZodLiteral<true>;
+}, zod_v4_core.$strip>, z.ZodObject<{
+    local: z.ZodDefault<z.ZodOptional<z.ZodLiteral<false>>>;
+    clients: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        address: z.ZodString;
+        token: z.ZodString;
+    }, zod_v4_core.$strip>, z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        token: z.ZodString;
+    }, zod_v4_core.$strip>>]>>;
+}, zod_v4_core.$strip>]>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        dm: "dm";
+        group: "group";
+    }>;
+}, zod_v4_core.$strip>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, IMessageClient, {
+    id: string;
+}, {
+    id: string;
+    type: "dm";
+} | {
+    id: string;
+    type: "group";
+}, undefined, ProviderMessage<{
+    id: string;
+}, {
+    id: string;
+    type: "dm";
+} | {
+    id: string;
+    type: "group";
+}, Record<never, never>>, {
+    messages: ({ client }: {
+        client: IMessageClient;
+        config: {
+            local: true;
+        } | {
+            local: false;
+            clients?: {
+                address: string;
+                token: string;
+            } | {
+                address: string;
+                token: string;
+            }[] | undefined;
+        };
+    }) => ManagedStream<IMessageMessage>;
+}>> & Readonly<{
+    tapbacks: {
+        readonly love: "love";
+        readonly like: "like";
+        readonly dislike: "dislike";
+        readonly laugh: "laugh";
+        readonly emphasize: "emphasize";
+        readonly question: "question";
+    };
+}>;
+
+export { imessage };