spectrum-ts 0.0.1 → 0.1.2

package/dist/providers/imessage/index.js

@@ -0,0 +1,418 @@
+import {
+  mergeStreams,
+  stream
+} from "../../chunk-3TBRO2J7.js";
+import {
+  definePlatform
+} from "../../chunk-UZ2CXPOD.js";
+
+// src/providers/imessage/index.ts
+import { createClient as createClient2, directChat } from "@photon-ai/advanced-imessage";
+import { IMessageSDK as IMessageSDK2 } from "@photon-ai/imessage-kit";
+
+// src/providers/imessage/auth.ts
+import {
+  createClient
+} from "@photon-ai/advanced-imessage";
+
+// src/utils/cloud.ts
+var SPECTRUM_CLOUD_URL = `https://${process.env.SPECTRUM_CLOUD_URL ?? "spectrum-cloud.photon.codes"}`;
+
+// src/providers/imessage/auth.ts
+var RENEWAL_RATIO = 0.8;
+var EXPIRY_BUFFER_MS = 3e4;
+var RETRY_DELAY_MS = 3e4;
+var cloudAuthState = /* @__PURE__ */ new WeakMap();
+async function fetchTokens(projectId, projectSecret) {
+  const url = `${SPECTRUM_CLOUD_URL}/${projectId}/imessage/tokens`;
+  const credentials = btoa(`${projectId}:${projectSecret}`);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${credentials}`
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `Spectrum Cloud authentication failed (${response.status}): ${body || response.statusText}`
+    );
+  }
+  const json = await response.json();
+  if (!json.succeed) {
+    throw new Error(
+      "Spectrum Cloud authentication failed: server returned succeed=false"
+    );
+  }
+  return json.data;
+}
+async function createCloudClients(projectId, projectSecret) {
+  let tokenData = await fetchTokens(projectId, projectSecret);
+  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+  let disposed = false;
+  let renewalTimer;
+  const scheduleRenewal = () => {
+    if (disposed) {
+      return;
+    }
+    const ttlMs = tokenData.expiresIn * 1e3;
+    const renewInMs = Math.max(ttlMs * RENEWAL_RATIO, 5e3);
+    renewalTimer = setTimeout(async () => {
+      try {
+        tokenData = await fetchTokens(projectId, projectSecret);
+        tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+        scheduleRenewal();
+      } catch {
+        renewalTimer = setTimeout(() => scheduleRenewal(), RETRY_DELAY_MS);
+        renewalTimer?.unref?.();
+      }
+    }, renewInMs);
+    renewalTimer?.unref?.();
+  };
+  scheduleRenewal();
+  const refreshIfNeeded = async () => {
+    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
+      return;
+    }
+    tokenData = await fetchTokens(projectId, projectSecret);
+    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+    scheduleRenewal();
+  };
+  const buildClients = () => {
+    if (tokenData.type === "shared") {
+      const address = process.env.SPECTRUM_IMESSAGE_ADDRESS ?? "spectrum-imessage.photon.codes:443";
+      return [
+        createClient({
+          address,
+          tls: true,
+          token: async () => {
+            await refreshIfNeeded();
+            return tokenData.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;
+          return data.auth[instanceId] ?? token;
+        }
+      })
+    );
+  };
+  const clients = buildClients();
+  cloudAuthState.set(clients, {
+    dispose: () => {
+      disposed = true;
+      if (renewalTimer !== void 0) {
+        clearTimeout(renewalTimer);
+        renewalTimer = void 0;
+      }
+    }
+  });
+  return clients;
+}
+async function disposeCloudAuth(clients) {
+  const auth = cloudAuthState.get(clients);
+  if (auth) {
+    auth.dispose();
+    cloudAuthState.delete(clients);
+  }
+}
+
+// src/providers/imessage/local.ts
+import { unlink, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+var toSpace = (message) => ({
+  id: `${message.isGroupChat ? "any;+;" : "any;-;"}${message.chatId}`,
+  type: message.isGroupChat ? "group" : "dm"
+});
+var toMessage = (message) => ({
+  id: message.guid,
+  content: [{ type: "plain_text", text: message.text ?? "" }],
+  sender: { id: message.sender ?? "" },
+  space: toSpace(message),
+  timestamp: message.date ?? /* @__PURE__ */ new Date()
+});
+var messages = (client) => stream((emit) => {
+  client.startWatching({
+    onMessage: (message) => emit(toMessage(message))
+  });
+  return () => client.stopWatching();
+});
+var send = async (client, spaceId, content) => {
+  switch (content.type) {
+    case "plain_text":
+      await client.send(spaceId, content.text);
+      break;
+    case "attachment": {
+      const tmp = join(tmpdir(), `spectrum-${Date.now()}-${content.name}`);
+      await writeFile(tmp, content.data);
+      try {
+        await client.send(spaceId, { files: [tmp] });
+      } finally {
+        await unlink(tmp).catch(() => {
+        });
+      }
+      break;
+    }
+    default:
+      break;
+  }
+};
+
+// src/providers/imessage/remote.ts
+import {
+  chatGuid,
+  messageGuid,
+  Reaction
+} from "@photon-ai/advanced-imessage";
+var TAPBACK_NAMES = new Set(
+  Object.values(Reaction).filter((r) => r !== "emoji" && r !== "sticker")
+);
+var toMessage2 = (event) => ({
+  id: event.message.guid,
+  content: [{ type: "plain_text", text: event.message.text ?? "" }],
+  sender: { id: event.message.sender?.address ?? "" },
+  space: {
+    id: event.chatGuid,
+    type: event.chatGuid.includes(";+;") ? "group" : "dm"
+  },
+  timestamp: event.timestamp
+});
+var clientStream = (client) => {
+  const sub = client.messages.subscribe("message.received");
+  return stream((emit, end) => {
+    (async () => {
+      try {
+        for await (const event of sub) {
+          emit(toMessage2(event));
+        }
+        end();
+      } catch (e) {
+        end(e);
+      }
+    })();
+    return () => sub.close();
+  });
+};
+var messages2 = (clients) => mergeStreams(clients.map(clientStream));
+var startTyping = async (clients, spaceId) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  await remote.chats.startTyping(chatGuid(spaceId));
+};
+var stopTyping = async (clients, spaceId) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  await remote.chats.stopTyping(chatGuid(spaceId));
+};
+var send2 = async (clients, spaceId, content) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  switch (content.type) {
+    case "plain_text":
+      await remote.messages.send(chatGuid(spaceId), content.text);
+      break;
+    case "attachment": {
+      const attachment = await remote.attachments.upload({
+        data: content.data,
+        fileName: content.name,
+        mimeType: content.mimeType
+      });
+      await remote.messages.send(chatGuid(spaceId), "", {
+        attachment: attachment.guid
+      });
+      break;
+    }
+    default:
+      break;
+  }
+};
+var replyToMessage = async (clients, spaceId, msgId, content) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  const chat = chatGuid(spaceId);
+  const replyTo = messageGuid(msgId);
+  switch (content.type) {
+    case "plain_text":
+      await remote.messages.send(chat, content.text, { replyTo });
+      break;
+    case "attachment": {
+      const attachment = await remote.attachments.upload({
+        data: content.data,
+        fileName: content.name,
+        mimeType: content.mimeType
+      });
+      await remote.messages.send(chat, "", {
+        attachment: attachment.guid,
+        replyTo
+      });
+      break;
+    }
+    default:
+      break;
+  }
+};
+var reactToMessage = async (clients, spaceId, msgId, reaction) => {
+  const remote = clients[0];
+  if (!remote) {
+    return;
+  }
+  const chat = chatGuid(spaceId);
+  const msg = messageGuid(msgId);
+  if (TAPBACK_NAMES.has(reaction)) {
+    await remote.messages.react(chat, msg, reaction);
+  } else {
+    await remote.messages.reactEmoji(chat, msg, reaction);
+  }
+};
+
+// src/providers/imessage/types.ts
+import { IMessageSDK } from "@photon-ai/imessage-kit";
+import z from "zod";
+var isLocal = (client) => client instanceof IMessageSDK;
+var clientEntry = z.object({ address: z.string(), token: z.string() });
+var configSchema = z.union([
+  z.object({ local: z.literal(true) }),
+  z.object({
+    local: z.literal(false).optional().default(false),
+    clients: clientEntry.or(z.array(clientEntry)).optional()
+  })
+]);
+var userSchema = z.object({});
+var spaceSchema = z.object({
+  id: z.string(),
+  type: z.enum(["dm", "group"])
+});
+
+// src/providers/imessage/index.ts
+var imessage = definePlatform("iMessage", {
+  config: configSchema,
+  static: {
+    tapbacks: {
+      love: "love",
+      like: "like",
+      dislike: "dislike",
+      laugh: "laugh",
+      emphasize: "emphasize",
+      question: "question"
+    }
+  },
+  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] ?? ""),
+          type: "dm"
+        };
+      }
+      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, type: "group" };
+    }
+  },
+  lifecycle: {
+    createClient: async ({
+      config,
+      projectId,
+      projectSecret
+    }) => {
+      if (config.local) {
+        return new IMessageSDK2();
+      }
+      if (config.clients) {
+        const entries = Array.isArray(config.clients) ? config.clients : [config.clients];
+        return entries.map(
+          (e) => createClient2({ 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 }) => {
+      if (isLocal(client)) {
+        await client.close();
+        return;
+      }
+      await disposeCloudAuth(client);
+      await Promise.all(client.map((c) => c.close()));
+    }
+  },
+  events: {
+    messages: ({ client }) => isLocal(client) ? messages(client) : messages2(client)
+  },
+  actions: {
+    send: async ({ space, content, client }) => {
+      for (const item of content) {
+        if (isLocal(client)) {
+          await send(client, space.id, item);
+        } else {
+          await send2(client, space.id, item);
+        }
+      }
+    },
+    startTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await startTyping(client, space.id);
+    },
+    stopTyping: async ({ space, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await stopTyping(client, space.id);
+    },
+    reactToMessage: async ({ space, messageId, reaction, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      await reactToMessage(client, space.id, messageId, reaction);
+    },
+    replyToMessage: async ({ space, messageId, content, client }) => {
+      if (isLocal(client)) {
+        return;
+      }
+      for (const item of content) {
+        await replyToMessage(client, space.id, messageId, item);
+      }
+    }
+  }
+});
+export {
+  imessage
+};

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

@@ -0,0 +1,35 @@
+import { b as Platform, a as PlatformDef, P as ProviderMessage } from '../../types-eXHZpal1.js';
+import * as node_readline from 'node:readline';
+import z__default from 'zod';
+import 'hotscript';
+import 'type-fest';
+
+declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{}, z__default.core.$strip>, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, z__default.ZodType<object, unknown, z__default.core.$ZodTypeInternals<object, unknown>> | undefined, node_readline.Interface, {
+    id: string;
+}, {
+    id: string;
+}, undefined, ProviderMessage<{
+    id: string;
+}, {
+    id: string;
+}, Record<never, never>>, {
+    messages({ client }: {
+        client: node_readline.Interface;
+        config: Record<string, never>;
+    }): AsyncGenerator<{
+        id: `${string}-${string}-${string}-${string}-${string}`;
+        content: {
+            type: "plain_text";
+            text: string;
+        }[];
+        sender: {
+            id: string;
+        };
+        space: {
+            id: string;
+        };
+        timestamp: Date;
+    }, void, any>;
+}>> & Readonly<Record<never, never>>;
+
+export { terminal };

package/dist/providers/terminal/index.js

@@ -0,0 +1,61 @@
+import {
+  definePlatform
+} from "../../chunk-UZ2CXPOD.js";
+
+// src/providers/terminal/index.ts
+import { createInterface } from "readline";
+import z from "zod";
+var terminal = definePlatform("terminal", {
+  config: z.object({}),
+  user: {
+    resolve: async ({ input }) => ({
+      id: input.userID
+    })
+  },
+  space: {
+    resolve: async () => ({
+      id: "terminal"
+    })
+  },
+  lifecycle: {
+    createClient: async () => {
+      const client = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      client.on("SIGINT", () => {
+        client.close();
+        process.kill(process.pid, "SIGINT");
+      });
+      return client;
+    },
+    destroyClient: async ({ client }) => {
+      client.close();
+      process.stdin.unref();
+    }
+  },
+  events: {
+    async *messages({ client }) {
+      for await (const line of client) {
+        yield {
+          id: crypto.randomUUID(),
+          content: [{ type: "plain_text", text: line }],
+          sender: { id: "terminal-user" },
+          space: { id: "terminal" },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+  },
+  actions: {
+    send: async ({ content }) => {
+      const outputs = content.filter((c) => c.type === "plain_text").map((c) => c.text);
+      for (const output of outputs) {
+        console.log(output);
+      }
+    }
+  }
+});
+export {
+  terminal
+};

package/dist/stream-DGy4geUK.d.ts

@@ -0,0 +1,8 @@
+interface ManagedStream<T> extends AsyncIterable<T> {
+    close(): Promise<void>;
+}
+type StreamCleanup = void | (() => void | Promise<void>);
+declare function stream<T>(setup: (emit: (value: T) => void, end: (error?: unknown) => void) => StreamCleanup | Promise<StreamCleanup>): ManagedStream<T>;
+declare function mergeStreams<T>(streams: readonly ManagedStream<T>[]): ManagedStream<T>;
+
+export { type ManagedStream as M, mergeStreams as m, stream as s };