@hitch42/applet 0.1.0-beta.10

package/dist/server.js

@@ -0,0 +1,104 @@
+import { n as withFilesUpload, r as getRegisteredHitchContract } from "./upload-DRbVhuDm.js";
+import { a as getRequestContext, i as getIdentityBearer, n as createWorkflow, s as tryGetRequestContext } from "./workflow-CTo2kZF1.js";
+import { n as withBatchRecorder, t as createLazyClientProxy } from "./lazy-client-x0DCI98S.js";
+import { createORPCClient } from "@orpc/client";
+import { OpenAPILink } from "@orpc/openapi-client/fetch";
+//#region src/hitch/server.ts
+const DEFAULT_API_URL = "https://app.hitch42.com";
+const resolveTransport = () => {
+	const context = tryGetRequestContext();
+	if (context !== void 0) return {
+		baseUrl: context.api.baseUrl,
+		fetch: context.api.fetch,
+		authorization: `Bearer ${getIdentityBearer(context.identity)}`
+	};
+	const apiKey = process.env.HITCH_API_KEY;
+	if (apiKey !== void 0 && apiKey !== "") {
+		const apiUrl = process.env.HITCH_API_URL;
+		return {
+			baseUrl: apiUrl !== void 0 && apiUrl !== "" ? apiUrl : DEFAULT_API_URL,
+			fetch: (request, init) => globalThis.fetch(request, init),
+			authorization: `Bearer ${apiKey}`
+		};
+	}
+	throw new Error("Hitch request context is unavailable outside a request. Set HITCH_API_KEY to call the API with an API key.");
+};
+function createHitchClient(contract) {
+	return createORPCClient(new OpenAPILink(contract, {
+		url: () => resolveTransport().baseUrl,
+		fetch: (request, init) => resolveTransport().fetch(request, init),
+		headers: () => ({ authorization: resolveTransport().authorization })
+	}));
+}
+//#endregion
+//#region src/server/workflows-client.ts
+function mapWorkflowRun(data) {
+	const { sleep_until: sleepUntil, started_at: startedAt, finished_at: finishedAt, ...run } = data;
+	return {
+		...run,
+		sleepUntil,
+		startedAt,
+		finishedAt
+	};
+}
+async function getResponseData(response, action) {
+	const body = await response.json();
+	if (!response.ok) {
+		const { code, message } = body;
+		throw new Error(`Workflow ${action} failed (${response.status}): ${code}: ${message}`);
+	}
+	return body.data;
+}
+function createWorkflowsClient() {
+	return new Proxy({}, { get: (_target, property) => {
+		const code = String(property);
+		return {
+			async start(payload) {
+				const context = getRequestContext();
+				return { id: (await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflows/${encodeURIComponent(code)}/runs`, {
+					method: "POST",
+					headers: {
+						authorization: `Bearer ${getIdentityBearer(context.identity)}`,
+						"content-type": "application/json"
+					},
+					body: JSON.stringify({ payload })
+				}), "start")).id };
+			},
+			async get(id) {
+				const context = getRequestContext();
+				return mapWorkflowRun(await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflows/${encodeURIComponent(code)}/runs/${encodeURIComponent(id)}`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${getIdentityBearer(context.identity)}` }
+				}), "get"));
+			},
+			async list(options) {
+				const context = getRequestContext();
+				const query = new URLSearchParams({ workflow: code });
+				if (options?.status !== void 0) query.set("status", options.status);
+				if (options?.limit !== void 0) query.set("limit", String(options.limit));
+				return (await getResponseData(await context.api.fetch(`${context.api.baseUrl}/v1/applets/${encodeURIComponent(context.appletCode)}/workflow-runs?${query}`, {
+					method: "GET",
+					headers: { authorization: `Bearer ${getIdentityBearer(context.identity)}` }
+				}), "list")).map(mapWorkflowRun);
+			}
+		};
+	} });
+}
+//#endregion
+//#region src/server/env.ts
+const env = process.env;
+//#endregion
+//#region src/author/server.ts
+function buildHitchClient() {
+	const contract = getRegisteredHitchContract();
+	if (contract === void 0) throw new Error("`hitch` is unavailable: run `applet generate` first. The framework imports your .hitch automatically at build; in plain node import your .hitch once before calling hitch.");
+	return withBatchRecorder(createHitchClient(contract), contract);
+}
+const hitchClient = createLazyClientProxy(buildHitchClient);
+const filesClient = withFilesUpload(hitchClient, () => hitchClient.files);
+const workflows = createWorkflowsClient();
+const hitch = new Proxy(filesClient, { get(target, property, receiver) {
+	return property === "workflows" ? workflows : Reflect.get(target, property, receiver);
+} });
+//#endregion
+export { createWorkflow, env, hitch };

package/dist/telephony-protocol-D-nf3Gca.d.ts

@@ -0,0 +1,76 @@
+import { ContractProcedure, Meta } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/email.d.ts
+type EmailTags = Record<string, string>;
+type CreateEmailPixelInput = {
+  tags?: EmailTags;
+};
+type CreateEmailPixelOutput = {
+  id: string;
+  url: string;
+};
+type GetEmailTrackerInput = {
+  id: string;
+};
+type MarkEmailTrackerSentInput = {
+  id: string;
+  sentAt?: string;
+};
+type EmailTracker = {
+  id: string;
+  url: string;
+  tags: EmailTags;
+  createdAt: string;
+  sentAt: string | null;
+  firstHitAt: string | null;
+  lastHitAt: string | null;
+};
+type ListEmailTrackersInput = {
+  filter?: EmailTags;
+  sentAt?: {
+    $gte?: string;
+    $lt?: string;
+  };
+  cursor?: string;
+  limit?: number;
+};
+type ListEmailTrackersOutput = {
+  trackers: EmailTracker[];
+  nextCursor: string | null;
+};
+declare const emailTagKeySchema: z.ZodType<string, string>;
+declare const emailTagsSchema: z.ZodType<EmailTags, EmailTags>;
+declare const createEmailPixelInputSchema: z.ZodType<CreateEmailPixelInput, CreateEmailPixelInput>;
+declare const createEmailPixelOutputSchema: z.ZodType<CreateEmailPixelOutput, CreateEmailPixelOutput>;
+declare const getEmailTrackerInputSchema: z.ZodType<GetEmailTrackerInput, GetEmailTrackerInput>;
+declare const markEmailTrackerSentInputSchema: z.ZodType<MarkEmailTrackerSentInput, MarkEmailTrackerSentInput>;
+declare const markEmailTrackerSentBodySchema: z.ZodType<{
+  sentAt?: string;
+}, {
+  sentAt?: string;
+}>;
+declare const emailTrackerSchema: z.ZodType<EmailTracker, EmailTracker>;
+declare const listEmailTrackersInputSchema: z.ZodType<ListEmailTrackersInput, ListEmailTrackersInput>;
+declare const listEmailTrackersOutputSchema: z.ZodType<ListEmailTrackersOutput, ListEmailTrackersOutput>;
+type EmailContract = {
+  tracking: {
+    createPixel: ContractProcedure<z.ZodType<CreateEmailPixelInput | undefined, CreateEmailPixelInput | undefined>, z.ZodType<CreateEmailPixelOutput, CreateEmailPixelOutput>, Record<never, never>, Meta>;
+    markSent: ContractProcedure<z.ZodType<MarkEmailTrackerSentInput, MarkEmailTrackerSentInput>, z.ZodType<EmailTracker, EmailTracker>, Record<never, never>, Meta>;
+    get: ContractProcedure<z.ZodType<GetEmailTrackerInput, GetEmailTrackerInput>, z.ZodType<EmailTracker, EmailTracker>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<ListEmailTrackersInput | undefined, ListEmailTrackersInput | undefined>, z.ZodType<ListEmailTrackersOutput, ListEmailTrackersOutput>, Record<never, never>, Meta>;
+  };
+};
+declare function emailContract(appletCode: string): EmailContract;
+//#endregion
+//#region src/server/telephony-protocol.d.ts
+/** Handle events at least once and without order. Use eventId for idempotency.
+ * Read the message with hitch.telephony.messages.get({ id: messageId }). */
+type TelephonyMessageReceivedEvent = {
+  eventId: string;
+  type: "message.received";
+  messageId: string;
+  numberId: string;
+  occurredAt: string;
+};
+//#endregion
+export { createEmailPixelOutputSchema as a, emailTagsSchema as c, listEmailTrackersInputSchema as d, listEmailTrackersOutputSchema as f, createEmailPixelInputSchema as i, emailTrackerSchema as l, markEmailTrackerSentInputSchema as m, EmailTracker as n, emailContract as o, markEmailTrackerSentBodySchema as p, ListEmailTrackersOutput as r, emailTagKeySchema as s, TelephonyMessageReceivedEvent as t, getEmailTrackerInputSchema as u };

package/dist/telephony.d.ts

@@ -0,0 +1,77 @@
+//#region src/telephony/phone.d.ts
+type PhoneState = {
+  status: "off" | "connecting" | "ready" | "error";
+  error: string | null;
+  active: null | {
+    callId: string;
+    to: string;
+    from: string;
+    state: "connecting" | "ringing" | "active" | "held" | "ended";
+    muted: boolean;
+    startedAt: number;
+    recording: boolean;
+  };
+};
+type CallInput = {
+  numberId: string;
+  to: string;
+};
+type Listener = () => void;
+type ActiveControls = {
+  hangup: () => Promise<void>;
+  mute: () => void;
+  unmute: () => void;
+  hold: () => Promise<unknown>;
+  unhold: () => Promise<unknown>;
+  dtmf: (digit: string) => void;
+};
+declare class Phone {
+  state: PhoneState;
+  private readonly listeners;
+  private readonly api;
+  private client;
+  private currentCall;
+  private connectPromise;
+  private releaseLock;
+  private lockAbortController;
+  private channel;
+  private ownsPhone;
+  private connectResolve;
+  private readonly pendingCommands;
+  private pollTimer;
+  private stopRecording;
+  private recordingPromise;
+  private audio;
+  private firstLogin;
+  private callStarting;
+  constructor(options?: {
+    baseUrl?: string;
+  });
+  subscribe: (listener: Listener) => (() => void);
+  getSnapshot: () => PhoneState;
+  private update;
+  get active(): ActiveControls | null;
+  connect: () => Promise<void>;
+  private connectInternal;
+  private connectOwned;
+  disconnect: () => void;
+  private beforeUnload;
+  call: ({ numberId, to }: CallInput) => Promise<void>;
+  private sendCommand;
+  private onChannelMessage;
+  private runCommand;
+  private pollCall;
+  private onCallUpdate;
+}
+declare const createPhone: (options?: {
+  baseUrl?: string;
+}) => Phone;
+//#endregion
+//#region src/telephony/use-phone.d.ts
+declare const usePhone: () => {
+  state: PhoneState;
+  call: Phone["call"];
+  active: Phone["active"];
+};
+//#endregion
+export { type Phone, type PhoneState, createPhone, usePhone };