@hitch42/applet 0.1.1-beta.6 → 0.1.1-beta.8

package/dist/{project-mW0vsN8A.js → project-CbYPtpPq.js}

@@ -1,4 +1,5 @@
-import { n as loadAppletSourceDefinition, r as readWorkspaceConfig } from "./load-config-BnxocLAQ.js";
+import { i as readWorkspaceConfig } from "./workspace-XVtM12ZC.js";
+import { n as loadAppletSourceDefinition } from "./load-config-BYSxDVAl.js";
 import { z } from "zod";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
@@ -130,7 +131,8 @@ const GITIGNORE_END = "# END Hitch generated files";
 const SKILLS = [
 	"hitch-applets",
 	"hitch-cli",
-	"hitch-data"
+	"hitch-data",
+	"hitch-theory"
 ];
 const GITIGNORE = `${GITIGNORE_START}
 ${SKILLS.map((skill) => `/.agents/skills/${skill}/`).join("\n")}
@@ -178,7 +180,7 @@ async function writeWorkspaceSupport(root, config, cli) {
 	const agents = await readFile(new URL("../scaffold/AGENTS.md", import.meta.url), "utf8");
 	await Promise.all([
 		mkdir(resolve(root, ".agents/skills"), { recursive: true }),
-		mkdir(resolve(root, ".github/workflows"), { recursive: true }),
+		config.githubWorkflow === false ? void 0 : mkdir(resolve(root, ".github/workflows"), { recursive: true }),
 		...SKILLS.map((skill) => rm(resolve(root, ".agents/skills", skill), {
 			force: true,
 			recursive: true
@@ -188,7 +190,7 @@ async function writeWorkspaceSupport(root, config, cli) {
 		...SKILLS.map((skill) => cp(new URL(`../scaffold/.agents/skills/${skill}`, import.meta.url), resolve(root, ".agents/skills", skill), { recursive: true })),
 		writeFile(resolve(root, "package.json"), `${JSON.stringify(workspacePackage(config.org), null, 2)}\n`),
 		writeFile(resolve(root, "pnpm-workspace.yaml"), workspaceFile(resolvedCli)),
-		existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
+		config.githubWorkflow === false || existsSync(deployWorkflowTarget) ? void 0 : cp(new URL("../scaffold/.github/workflows/hitch.yml", import.meta.url), deployWorkflowTarget),
 		writeFile(resolve(root, ".node-version"), "24\n"),
 		writeGitignore(root),
 		writeFile(resolve(root, "AGENTS.md"), agents)
@@ -340,17 +342,17 @@ export default defineConfig({
 		hasClient ? writeFile(resolve(root, "components.json"), await readFile(new URL("../scaffold/applet/components.json", import.meta.url), "utf8")) : void 0
 	]);
 }
-async function prepareAppletProject(appletRoot = process.cwd()) {
-	const definition = await loadAppletSourceDefinition(appletRoot);
-	const workspaceRoot = dirname(dirname(resolve(appletRoot)));
+async function prepareAppletProjects(workspaceRoot, appletRoots) {
+	const definitions = await Promise.all(appletRoots.map((root) => loadAppletSourceDefinition(root)));
 	const workspace = readWorkspaceConfig(workspaceRoot);
-	if (workspace === void 0) throw new Error(`No Hitch workspace found for ${appletRoot}.`);
+	if (workspace === void 0) throw new Error(`No Hitch workspace found at ${workspaceRoot}.`);
 	const cli = await loadCliManifest({ allowDevelopment: true });
-	await Promise.all([cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, workspace, cli), writeAppletSupport(appletRoot, definition)]);
-	return {
-		definition,
-		workspaceRoot
-	};
+	await Promise.all([cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, workspace, cli), ...appletRoots.map((root, index) => writeAppletSupport(root, definitions[index]))]);
+}
+async function prepareAppletProject(appletRoot = process.cwd()) {
+	const workspaceRoot = dirname(dirname(resolve(appletRoot)));
+	await prepareAppletProjects(workspaceRoot, [appletRoot]);
+	return workspaceRoot;
 }
 //#endregion
-export { writeWorkspaceSupport as a, writeAppletSupport as i, loadCliManifest as n, prepareAppletProject as r, assertWorkspaceCli as t };
+export { writeAppletSupport as a, prepareAppletProjects as i, loadCliManifest as n, writeWorkspaceSupport as o, prepareAppletProject as r, assertWorkspaceCli as t };

package/dist/prompt-ChS-grYO.js

@@ -0,0 +1,29 @@
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline";
+//#region src/prompt.ts
+function question(prompt, hidden = false) {
+	return new Promise((resolveAnswer, rejectAnswer) => {
+		let muted = false;
+		const output = hidden ? new Writable({ write(chunk, encoding, callback) {
+			if (!muted) process.stdout.write(chunk, encoding);
+			callback();
+		} }) : process.stdout;
+		const readline = createInterface({
+			input: process.stdin,
+			output,
+			terminal: true
+		});
+		readline.once("error", rejectAnswer);
+		if (hidden) {
+			process.stdout.write(prompt);
+			muted = true;
+		}
+		readline.question(hidden ? "" : prompt, (answer) => {
+			readline.close();
+			if (hidden) process.stdout.write("\n");
+			resolveAnswer(answer);
+		});
+	});
+}
+//#endregion
+export { question as t };

package/dist/schedules-dhU1yyFr.js

@@ -0,0 +1,42 @@
+import { t as loadAppletConfig } from "./load-config-BYSxDVAl.js";
+import { t as question } from "./prompt-ChS-grYO.js";
+import { RPCLink } from "@orpc/client/fetch";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+//#region src/schedules.ts
+async function runSchedule(options) {
+	const manifest = await loadAppletConfig(process.cwd());
+	const schedules = manifest.schedules ?? [];
+	if (schedules.length === 0) throw new Error("This applet has no schedules.");
+	const schedule = schedules.find(({ code }) => code === options.code);
+	if (schedule === void 0) throw new Error(`Unknown schedule "${options.code}". Valid codes: ${schedules.map(({ code }) => code).join(", ")}.`);
+	const unavailable = "The dev server is not running. Start it with pnpm dev.";
+	let url;
+	try {
+		const file = JSON.parse(await readFile(resolve(process.cwd(), ".hitch/dev-server.json"), "utf8"));
+		if (file === null || typeof file !== "object" || !("url" in file) || typeof file.url !== "string" || !("pid" in file) || typeof file.pid !== "number" || !Number.isInteger(file.pid) || file.pid < 1) throw new Error(unavailable);
+		try {
+			process.kill(file.pid, 0);
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EPERM")) throw error;
+		}
+		url = new URL(file.url).origin;
+	} catch {
+		throw new Error(unavailable);
+	}
+	if (options.yes !== true) {
+		if (process.stdin.isTTY !== true) throw new Error("Pass --yes to run a schedule without a terminal.");
+		const answer = await question(`Run schedule "${options.code}" (${schedule.path}) now? It runs your local code as you in production org "${manifest.org}". [y/N] `);
+		if (!["y", "yes"].includes(answer.trim().toLowerCase())) throw new Error("Schedule run cancelled.");
+	}
+	await new RPCLink({
+		url: `${url}/${manifest.code}/api`,
+		fetch
+	}).call(schedule.path.split("/").filter(Boolean), {}, { context: {} }).catch((error) => {
+		if (error instanceof TypeError && error.message === "fetch failed") throw new Error(unavailable);
+		throw error;
+	});
+	console.log(`Schedule "${options.code}" finished.`);
+}
+//#endregion
+export { runSchedule };

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import { a as createWorkflow, i as WorkflowStep, n as WorkflowDefinition, r as WorkflowDuration } from "./workflow-DurM6Fwx.js";
-import { _ as RegisteredWorkflows, f as RegisteredContract, g as RegisteredVariables, p as RegisteredManifest } from "./manifest-BQCAxATS.js";
-import { t as NarrowContract } from "./contract-DMrpbaLJ.js";
+import { _ as RegisteredWorkflows, f as RegisteredContract, g as RegisteredVariables, p as RegisteredManifest } from "./manifest-DD_SGkS6.js";
+import { t as NarrowContract } from "./contract-rP_eV9PK.js";
 import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
 import { o as WithFilesUpload } from "./upload-YbRKEqR6.js";
 import { ContractRouterClient } from "@orpc/contract";

package/dist/telephony-protocol-DRgiYjqQ.d.ts

@@ -0,0 +1,74 @@
+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>;
+declare const emailTagsSchema: z.ZodType<EmailTags>;
+declare const createEmailPixelInputSchema: z.ZodType<CreateEmailPixelInput>;
+declare const createEmailPixelOutputSchema: z.ZodType<CreateEmailPixelOutput>;
+declare const getEmailTrackerInputSchema: z.ZodType<GetEmailTrackerInput>;
+declare const markEmailTrackerSentInputSchema: z.ZodType<MarkEmailTrackerSentInput>;
+declare const markEmailTrackerSentBodySchema: z.ZodType<{
+  sentAt?: string;
+}>;
+declare const emailTrackerSchema: z.ZodType<EmailTracker>;
+declare const listEmailTrackersInputSchema: z.ZodType<ListEmailTrackersInput>;
+declare const listEmailTrackersOutputSchema: z.ZodType<ListEmailTrackersOutput>;
+type EmailContract = {
+  tracking: {
+    createPixel: ContractProcedure<z.ZodType<CreateEmailPixelInput | undefined>, z.ZodType<CreateEmailPixelOutput>, Record<never, never>, Meta>;
+    markSent: ContractProcedure<z.ZodType<MarkEmailTrackerSentInput>, z.ZodType<EmailTracker>, Record<never, never>, Meta>;
+    get: ContractProcedure<z.ZodType<GetEmailTrackerInput>, z.ZodType<EmailTracker>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<ListEmailTrackersInput | undefined>, z.ZodType<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 };