spectrum-ts 1.2.1 → 1.4.0

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

@@ -1,7 +1,91 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-Dvp0I86h.js';
+import { e as Platform, d as PlatformDef, P as ProviderMessage, S as Store, M as Message } from '../../types-BcCLW2VO.js';
+import { ChildProcess } from 'node:child_process';
 import z__default from 'zod';
+import { Socket } from 'node:net';
 import 'hotscript';
 
+type ProtocolContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "attachment";
+    name: string;
+    mimeType: string;
+    size?: number;
+    bytes?: string;
+    path?: string;
+} | {
+    type: "voice";
+    name?: string;
+    mimeType: string;
+    size?: number;
+    bytes?: string;
+    path?: string;
+} | {
+    type: "contact";
+    name?: {
+        formatted?: string;
+        first?: string;
+        last?: string;
+    };
+    vcard?: string;
+} | {
+    type: "custom";
+    raw: unknown;
+};
+interface ProtocolMessageNotification {
+    content: ProtocolContent;
+    id: string;
+    replyTo?: {
+        messageId: string;
+    };
+    senderId: string;
+    spaceId: string;
+    timestamp: string;
+}
+interface ProtocolReactionNotification {
+    messageId: string;
+    reaction: string;
+    senderId: string;
+    spaceId: string;
+    timestamp: string;
+}
+declare class RpcSession {
+    private readonly decoder;
+    private nextId;
+    private readonly pending;
+    private onNotify;
+    private onClose;
+    private closed;
+    private readonly socket;
+    constructor(socket: Socket);
+    handleNotifications(h: (method: string, params: unknown) => void): void;
+    onClosed(h: () => void): void;
+    request<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    close(): void;
+    private handle;
+    private shutdown;
+}
+
+interface ConsoleHijack {
+    restore: () => void;
+}
+type InboundEvent = {
+    kind: "message";
+    value: ProtocolMessageNotification;
+} | {
+    kind: "reaction";
+    value: ProtocolReactionNotification;
+};
+interface TerminalClient {
+    events: AsyncIterable<InboundEvent>;
+    hijack: ConsoleHijack;
+    knownChats: Set<string>;
+    nextChatIndex: number;
+    proc: ChildProcess;
+    session: RpcSession;
+}
 declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
     commands: z__default.ZodOptional<z__default.ZodArray<z__default.ZodObject<{
         name: z__default.ZodString;
@@ -9,7 +93,7 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
     }, z__default.core.$strip>>>;
 }, 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.ZodObject<{
     id: z__default.ZodOptional<z__default.ZodString>;
-}, z__default.core.$strip>, unknown, {
+}, z__default.core.$strip>, TerminalClient, {
     id: string;
 }, {
     id: string;
@@ -26,14 +110,15 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
         messageId: string;
     } | undefined;
 }>, {
-    messages(ctx: {
-        client: unknown;
+    messages({ client }: {
+        client: TerminalClient;
         config: {
             commands?: {
                 name: string;
                 description?: string | undefined;
             }[] | undefined;
         };
+        store: Store;
     }): AsyncGenerator<{
         replyTo?: {
             messageId: string;

package/dist/providers/terminal/index.js

@@ -1,6 +1,6 @@
 import {
   asVoice
-} from "../../chunk-I7EKZS5C.js";
+} from "../../chunk-B4MHPWPZ.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -10,7 +10,7 @@ import {
   fromVCard,
   reactionSchema,
   toVCard
-} from "../../chunk-UQPIWAHH.js";
+} from "../../chunk-LH4YEBG3.js";
 
 // src/providers/terminal/index.ts
 import { spawn } from "child_process";
@@ -746,42 +746,43 @@ var terminal = definePlatform("terminal", {
       replyTo: z.object({ messageId: z.string() }).optional()
     })
   },
-  user: {
-    resolve: async ({ input }) => ({
-      id: input.userID
-    })
-  },
-  space: {
-    params: z.object({ id: z.string().optional() }),
-    resolve: async (ctx) => {
-      const client = ctx.client;
-      const id = ctx.input.params?.id ?? generateChatId(client);
-      client.knownChats.add(id);
-      await client.session.request("ensureSpace", { id });
-      return { id };
-    }
-  },
   lifecycle: {
     createClient: async ({ config }) => {
       return await spawnClient({ commands: config.commands });
     },
     destroyClient: async ({ client }) => {
-      const c = client;
-      c.hijack.restore();
+      client.hijack.restore();
       try {
-        await c.session.request("shutdown", void 0, SHUTDOWN_TIMEOUT_MS);
+        await client.session.request(
+          "shutdown",
+          void 0,
+          SHUTDOWN_TIMEOUT_MS
+        );
       } catch {
       }
-      c.session.close();
+      client.session.close();
       try {
-        c.proc.kill("SIGTERM");
+        client.proc.kill("SIGTERM");
       } catch {
       }
     }
   },
+  user: {
+    resolve: async ({ input }) => ({
+      id: input.userID
+    })
+  },
+  space: {
+    params: z.object({ id: z.string().optional() }),
+    resolve: async ({ client, input }) => {
+      const id = input.params?.id ?? generateChatId(client);
+      client.knownChats.add(id);
+      await client.session.request("ensureSpace", { id });
+      return { id };
+    }
+  },
   events: {
-    async *messages(ctx) {
-      const client = ctx.client;
+    async *messages({ client }) {
       for await (const evt of client.events) {
         if (evt.kind === "message") {
           const msg = evt.value;
@@ -812,37 +813,26 @@ var terminal = definePlatform("terminal", {
   },
   actions: {
     send: async ({ client, content, space }) => {
-      const c = client;
       const proto = await spectrumToProtocol(content);
-      const result = await c.session.request(
-        "send",
-        { spaceId: space.id, content: proto }
-      );
+      const result = await client.session.request("send", { spaceId: space.id, content: proto });
       return buildOutboundRecord(result, content, space.id);
     },
     startTyping: async ({ client, space }) => {
-      const c = client;
-      await c.session.request("startTyping", { spaceId: space.id });
+      await client.session.request("startTyping", { spaceId: space.id });
     },
     stopTyping: async ({ client, space }) => {
-      const c = client;
-      await c.session.request("stopTyping", { spaceId: space.id });
+      await client.session.request("stopTyping", { spaceId: space.id });
     },
     reactToMessage: async ({ client, space, target, reaction }) => {
-      const c = client;
-      await c.session.request("reactToMessage", {
+      await client.session.request("reactToMessage", {
         spaceId: space.id,
         messageId: target.id,
         reaction
       });
     },
     replyToMessage: async ({ client, space, messageId, content }) => {
-      const c = client;
       const proto = await spectrumToProtocol(content);
-      const result = await c.session.request(
-        "replyToMessage",
-        { spaceId: space.id, messageId, content: proto }
-      );
+      const result = await client.session.request("replyToMessage", { spaceId: space.id, messageId, content: proto });
       return buildOutboundRecord(result, content, space.id);
     }
   }

package/dist/providers/whatsapp-business/index.d.ts

@@ -1,4 +1,4 @@
-import { o as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage, i as ManagedStream } from '../../types-Dvp0I86h.js';
+import { q as SchemaMessage, e as Platform, d as PlatformDef, P as ProviderMessage, S as Store, k as ManagedStream } from '../../types-BcCLW2VO.js';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import * as z from 'zod';
 import z__default from 'zod';
@@ -34,6 +34,7 @@ declare const whatsappBusiness: Platform<PlatformDef<"WhatsApp Business", z.ZodU
             phoneNumberId: string;
             appSecret?: string | undefined;
         } | Record<string, never>;
+        store: Store;
     }) => ManagedStream<WhatsAppMessage>;
 }>> & Readonly<Record<never, never>>;
 

package/dist/providers/whatsapp-business/index.js

@@ -12,7 +12,7 @@ import {
   asReaction,
   asText,
   definePlatform
-} from "../../chunk-UQPIWAHH.js";
+} from "../../chunk-LH4YEBG3.js";
 
 // src/providers/whatsapp-business/index.ts
 import { createClient as createClient2 } from "@photon-ai/whatsapp-business";
@@ -778,29 +778,6 @@ var spaceSchema = z.object({
 // src/providers/whatsapp-business/index.ts
 var whatsappBusiness = definePlatform("WhatsApp Business", {
   config: configSchema,
-  user: {
-    resolve: async ({ input }) => ({ id: input.userID })
-  },
-  space: {
-    schema: spaceSchema,
-    resolve: async ({ input }) => {
-      if (input.users.length === 0) {
-        throw new Error("WhatsApp space creation requires at least one user");
-      }
-      if (input.users.length > 1) {
-        throw UnsupportedError.action(
-          "createSpace",
-          "WhatsApp Business",
-          "only 1:1 conversations are supported"
-        );
-      }
-      const user = input.users[0];
-      if (!user) {
-        throw new Error("WhatsApp space creation requires a user");
-      }
-      return { id: user.id };
-    }
-  },
   lifecycle: {
     createClient: async ({
       config,
@@ -828,6 +805,29 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
       await Promise.all(client.map((c) => c.close()));
     }
   },
+  user: {
+    resolve: async ({ input }) => ({ id: input.userID })
+  },
+  space: {
+    schema: spaceSchema,
+    resolve: async ({ input }) => {
+      if (input.users.length === 0) {
+        throw new Error("WhatsApp space creation requires at least one user");
+      }
+      if (input.users.length > 1) {
+        throw UnsupportedError.action(
+          "createSpace",
+          "WhatsApp Business",
+          "only 1:1 conversations are supported"
+        );
+      }
+      const user = input.users[0];
+      if (!user) {
+        throw new Error("WhatsApp space creation requires a user");
+      }
+      return { id: user.id };
+    }
+  },
   events: {
     messages: ({ client }) => messages(client)
   },
@@ -836,20 +836,10 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
       return await send(client, space.id, content);
     },
     reactToMessage: async ({ space, target, reaction, client }) => {
-      await reactToMessage(
-        client,
-        space.id,
-        target.id,
-        reaction
-      );
+      await reactToMessage(client, space.id, target.id, reaction);
     },
     replyToMessage: async ({ space, messageId, content, client }) => {
-      return await replyToMessage(
-        client,
-        space.id,
-        messageId,
-        content
-      );
+      return await replyToMessage(client, space.id, messageId, content);
     }
   }
 });

package/dist/{types-Dvp0I86h.d.ts → types-BcCLW2VO.d.ts}

@@ -180,6 +180,29 @@ interface OutboundMessage<TPlatform extends string = string, TSender extends Use
 }
 type Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> = InboundMessage<TPlatform, TSender, TSpace> | OutboundMessage<TPlatform, TSender, TSpace>;
 
+/**
+ * A small per-platform key-value bag, modeled after Swift's `UserDefaults`.
+ * Untyped writes; typed reads return `undefined` on missing key OR type
+ * mismatch (no throws). In-memory only.
+ *
+ * SDK-internal: reachable from inside `definePlatform` callbacks via the
+ * `store` field on lifecycle/action/event ctx. Not exposed on the public
+ * SpectrumInstance or platform narrower.
+ */
+interface Store {
+    array<T = unknown>(key: string): T[] | undefined;
+    bool(key: string): boolean | undefined;
+    clear(): void;
+    delete(key: string): boolean;
+    get(key: string): unknown;
+    has(key: string): boolean;
+    keys(): string[];
+    number(key: string): number | undefined;
+    object<T = Record<string, unknown>>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+    string(key: string): string | undefined;
+}
+
 interface ManagedStream<T> extends AsyncIterable<T> {
     close(): Promise<void>;
 }
@@ -195,7 +218,8 @@ declare function broadcast<T>(source: ManagedStream<T>): Broadcaster<T>;
 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 AwaitedReturn<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type NoInferClient<T> = [T][T extends unknown ? 0 : never];
 type SchemaInfer<T> = T extends {
     schema?: infer S extends z__default.ZodType<object>;
 } ? z__default.infer<S> : Record<never, never>;
@@ -203,8 +227,9 @@ type InferSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__defa
 type InferOptionalSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__default.infer<TSchema> : never;
 type InputSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__default.input<TSchema> : never;
 type EventProducer<TPayload = unknown, TClient = unknown, TConfig = unknown> = (ctx: {
-    client: TClient;
+    client: NoInferClient<TClient>;
     config: TConfig;
+    store: Store;
 }) => AsyncIterable<TPayload>;
 type ProviderMessage<TSender extends ResolvedUser = ResolvedUser, TSpace extends ResolvedSpace = ResolvedSpace, TExtra extends object = Record<never, never>> = {
     id: string;
@@ -239,6 +264,12 @@ type MergeSchema<TSchema extends z__default.ZodType | undefined, TBase extends o
 type SchemaMessage<TUserSchema extends z__default.ZodType | undefined = undefined, TSpaceSchema extends z__default.ZodType | undefined = undefined> = ProviderMessage<MergeSchema<TUserSchema, ResolvedUser>, MergeSchema<TSpaceSchema, ResolvedSpace>>;
 type InferEventPayload<T> = T extends (ctx: never) => AsyncIterable<infer P> ? P : never;
 type ReservedNames = "stop" | "send" | "__internal" | "__providers";
+interface CreateClientContext<_ConfigSchema extends z__default.ZodType<object>> {
+    config: z__default.infer<_ConfigSchema>;
+    projectId: string | undefined;
+    projectSecret: string | undefined;
+    store: Store;
+}
 interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__default.ZodType<object> = z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined = undefined, _SpaceSchema extends z__default.ZodType<object> | undefined = undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined = undefined, _Client = unknown, _ResolvedUser extends ResolvedUser = ResolvedUser, _ResolvedSpace extends ResolvedSpace = ResolvedSpace, _MessageSchema extends z__default.ZodType<object> | undefined = undefined, _MessageType extends ProviderMessage<_ResolvedUser, _ResolvedSpace, InferSchema<_MessageSchema>> = ProviderMessage<_ResolvedUser, _ResolvedSpace, InferSchema<_MessageSchema>>, _Events extends {
     messages: EventProducer<_MessageType, _Client, z__default.infer<_ConfigSchema>>;
 } = {
@@ -248,58 +279,62 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
         send: (_: {
             space: _ResolvedSpace & SpaceRef;
             content: Content;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<ProviderMessageRecord>;
         startTyping?: (_: {
             space: _ResolvedSpace & SpaceRef;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<void>;
         stopTyping?: (_: {
             space: _ResolvedSpace & SpaceRef;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<void>;
         reactToMessage?: (_: {
             space: _ResolvedSpace & SpaceRef;
             target: _MessageType;
             reaction: string;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<void>;
         replyToMessage?: (_: {
             space: _ResolvedSpace & SpaceRef;
             messageId: string;
             target: _MessageType;
             content: Content;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<ProviderMessageRecord>;
         editMessage?: (_: {
             space: _ResolvedSpace & SpaceRef;
             messageId: string;
             content: Content;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<void>;
         getMessage?: (_: {
             space: _ResolvedSpace & SpaceRef;
             messageId: string;
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<_MessageType | undefined>;
     };
     config: _ConfigSchema;
     events: _Events;
     lifecycle: {
-        createClient: (ctx: {
-            config: z__default.infer<_ConfigSchema>;
-            projectId: string | undefined;
-            projectSecret: string | undefined;
-        }) => Promise<_Client>;
-        destroyClient: (ctx: {
-            client: _Client;
+        createClient: (ctx: CreateClientContext<_ConfigSchema>) => Promise<_Client>;
+        destroyClient?: (ctx: {
+            client: NoInferClient<_Client>;
+            store: Store;
         }) => Promise<void>;
     };
     message?: {
@@ -316,8 +351,9 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
                 })[];
                 params?: _SpaceParamsSchema extends z__default.ZodType<object> ? z__default.infer<_SpaceParamsSchema> : undefined;
             };
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<_ResolvedSpace>;
     };
     user: {
@@ -326,8 +362,9 @@ interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__de
             input: {
                 userID: string;
             };
-            client: _Client;
+            client: NoInferClient<_Client>;
             config: z__default.infer<_ConfigSchema>;
+            store: Store;
         }) => Promise<_ResolvedUser>;
     };
 }
@@ -348,7 +385,7 @@ interface AnyPlatformDef {
     };
     lifecycle: {
         createClient: (ctx: any) => Promise<any>;
-        destroyClient: (ctx: any) => Promise<void>;
+        destroyClient?: (ctx: any) => Promise<void>;
     };
     message?: {
         schema?: z__default.ZodType<object>;
@@ -431,6 +468,7 @@ interface PlatformRuntime {
     client: unknown;
     config: unknown;
     definition: AnyPlatformDef;
+    store: Store;
     subscribeMessages: () => ManagedStream<[Space, InboundMessage]>;
 }
 interface SpectrumLike<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> {
@@ -449,4 +487,4 @@ interface Platform<Def extends AnyPlatformDef> {
     (message: Message): PlatformMessage<Def>;
 }
 
-export { type AnyPlatformDef as A, type Broadcaster as B, type ContentBuilder as C, type EventProducer as E, type InboundMessage as I, type Message as M, type OutboundMessage as O, type ProviderMessage as P, type SpectrumLike as S, type User as U, type ContentInput as a, type Content as b, type PlatformDef as c, type Platform as d, type PlatformProviderConfig as e, type CustomEventStreams as f, type Space as g, type InboundPlatformMessage as h, type ManagedStream as i, type PlatformInstance as j, type PlatformMessage as k, type PlatformRuntime as l, type PlatformSpace as m, type PlatformUser as n, type SchemaMessage as o, broadcast as p, mergeStreams as q, stream as s };
+export { type AnyPlatformDef as A, type Broadcaster as B, type ContentBuilder as C, type EventProducer as E, type InboundMessage as I, type Message as M, type OutboundMessage as O, type ProviderMessage as P, type Store as S, type User as U, type ContentInput as a, type Content as b, type CreateClientContext as c, type PlatformDef as d, type Platform as e, type PlatformProviderConfig as f, type SpectrumLike as g, type CustomEventStreams as h, type Space as i, type InboundPlatformMessage as j, type ManagedStream as k, type PlatformInstance as l, type PlatformMessage as m, type PlatformRuntime as n, type PlatformSpace as o, type PlatformUser as p, type SchemaMessage as q, broadcast as r, mergeStreams as s, stream as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",