@hitch42/applet 0.1.0-beta.2 → 0.1.0-beta.9

package/dist/{deploy-DKB-Tef7.js → deploy-D_OFJ6-Q.js}

@@ -1,6 +1,8 @@
-import { t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
-import { t as buildApplet } from "./build-BRkmrUcj.js";
+import { i as readWorkspaceConfig, n as fetchWithOrgAuth } from "./workspace-XVtM12ZC.js";
+import { a as loadGitHubActionsSources, n as githubActionsContext, r as hitchResponseError, t as fetchWithGitHubActions } from "./ci-5qWl7lT3.js";
+import { n as buildPreparedApplet, r as prepareWorkspaceBuild, t as buildApplet } from "./build-CAb26kMY.js";
 import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { relative, resolve, sep } from "node:path";
 import { execFile } from "node:child_process";
@@ -2311,6 +2313,12 @@ var import_tar_stream = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin((
 	exports.pack = require_pack();
 })))(), 1);
 const execFileAsync = promisify(execFile);
+var WorkspaceDeployError = class extends Error {
+	constructor(failedApplets) {
+		super(`Failed to deploy: ${failedApplets.join(", ")}. See the applet logs above.`);
+		this.name = "WorkspaceDeployError";
+	}
+};
 function isErrno(error, code) {
 	return error instanceof Error && "code" in error && error.code === code;
 }
@@ -2355,14 +2363,17 @@ async function createBundle(distDir) {
 	body.set(bundle);
 	return body;
 }
-async function readGitInfo() {
-	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+function gitEnvironment() {
+	return Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+}
+async function readGitInfo(appletRoot) {
+	const env = gitEnvironment();
 	try {
 		const [{ stdout: status }, { stdout: sha }] = await Promise.all([execFileAsync("git", ["status", "--porcelain"], {
-			cwd: process.cwd(),
+			cwd: appletRoot,
 			env
 		}), execFileAsync("git", ["rev-parse", "HEAD"], {
-			cwd: process.cwd(),
+			cwd: appletRoot,
 			env
 		})]);
 		return {
@@ -2373,44 +2384,196 @@ async function readGitInfo() {
 		return { gitDirty: false };
 	}
 }
-async function deployError(response) {
-	let details = "";
-	try {
-		const body = await response.json();
-		if (body !== null && typeof body === "object") details = ["code" in body && typeof body.code === "string" ? body.code : void 0, "message" in body && typeof body.message === "string" ? body.message : void 0].filter((value) => value !== void 0).join(": ");
-	} catch {
-		details = "";
-	}
-	return /* @__PURE__ */ new Error(`Deploy failed (${response.status})${details ? `: ${details}` : ""}.`);
+async function repositoryDirectory(appletRoot) {
+	const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+		cwd: appletRoot,
+		env: gitEnvironment()
+	});
+	const directory = relative(stdout.trim(), appletRoot).split(sep).join("/") || ".";
+	if (directory === ".." || directory.startsWith("../")) throw new Error(`${appletRoot} is outside its git repository ${stdout.trim()}.`);
+	return directory;
 }
-async function runDeploy(options) {
-	if (options.dist === void 0) await buildApplet(options.changesetId);
-	const distDir = resolve(options.dist ?? ".hitch/dist");
-	const manifest = await readManifest(distDir);
-	const [bundle, git] = await Promise.all([createBundle(distDir), readGitInfo()]);
+function releaseForm(manifest, bundle) {
+	const body = new FormData();
+	body.set("manifest", manifest.raw);
+	body.set("bundle", new File([bundle], "bundle.tar.gz", { type: "application/gzip" }));
+	return body;
+}
+async function deployWithOrgAuth(appletRoot, distDir, manifest, options) {
 	const fetcher = options.fetch ?? globalThis.fetch;
-	const response = await fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => {
-		const body = new FormData();
-		body.set("manifest", manifest.raw);
-		body.set("bundle", new File([bundle], "bundle.tar.gz", { type: "application/gzip" }));
+	const [bundle, git] = await Promise.all([createBundle(distDir), readGitInfo(appletRoot)]);
+	return fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => {
+		const body = releaseForm(manifest, bundle);
 		body.set("gitDirty", String(git.gitDirty));
 		if (git.gitSha !== void 0) body.set("gitSha", git.gitSha);
-		if (options.changesetId !== void 0) body.set("changeset_id", options.changesetId);
 		return fetcher(`${instanceUrl}/api/v1/applets/${manifest.code}/releases`, {
 			method: "POST",
 			headers: { Authorization: `Bearer ${accessToken}` },
 			body
 		});
 	});
-	if (!response.ok) throw await deployError(response);
+}
+async function deployWithGitHubActions(context, appletRoot, distDir, manifest, options) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const [bundle, sourceDirectory] = await Promise.all([createBundle(distDir), repositoryDirectory(appletRoot)]);
+	return fetchWithGitHubActions(context, options, (instanceUrl, accessToken) => {
+		const body = releaseForm(manifest, bundle);
+		body.set("source_directory", sourceDirectory);
+		return fetcher(`${instanceUrl}/api/ci/v1/applets/${manifest.code}/releases`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${accessToken}` },
+			body
+		});
+	});
+}
+async function deployApplet(appletRoot, options, logPrefix = "") {
+	const github = githubActionsContext(options.store?.env ?? process.env);
+	if (options.dist === void 0) await buildApplet(appletRoot);
+	const distDir = resolve(appletRoot, options.dist ?? ".hitch/dist");
+	const manifest = await readManifest(distDir);
+	const response = github === void 0 ? await deployWithOrgAuth(appletRoot, distDir, manifest, options) : await deployWithGitHubActions(github, appletRoot, distDir, manifest, options);
+	if (!response.ok) throw await hitchResponseError(response, "Deploy failed");
 	const result = await response.json();
-	console.log(`Deployed release ${result.data.id} (${result.promoted ? "promoted" : "not promoted"}).`);
+	console.log(`${logPrefix}Deployed release ${result.data.id} (${result.promoted ? "promoted" : "not promoted"}).`);
+	if (result.changeset_id !== void 0) console.log(`${logPrefix}The release goes live when changeset ${result.changeset_id} applies.`);
 	if (result.warnings?.length) {
-		for (const warning of result.warnings) console.warn(`Warning: ${warning.message}`);
-		console.warn(`Changeset ${result.changeset_id} cannot apply until the applet and the schema agree.`);
+		for (const warning of result.warnings) console.warn(`${logPrefix}Warning: ${warning.message}`);
+		console.warn(`${logPrefix}Changeset ${result.changeset_id} cannot apply until the applet and the schema agree.`);
 	}
-	if (result.unset_variables?.length) console.warn(`Warning: declared variables not set: ${result.unset_variables.join(", ")}. Set them with applet variables set.`);
+	if (result.unset_variables?.length) console.warn(`${logPrefix}Warning: declared variables not set: ${result.unset_variables.join(", ")}. Set them with applet variables set.`);
 	return result;
 }
+async function workspaceAppletRoots(workspaceRoot) {
+	const appletsDir = resolve(workspaceRoot, "applets");
+	const roots = (await readdir(appletsDir, { withFileTypes: true }).catch((error) => {
+		if (isErrno(error, "ENOENT")) return [];
+		throw error;
+	})).filter((entry) => entry.isDirectory()).map((entry) => resolve(appletsDir, entry.name)).filter((root) => existsSync(resolve(root, "applet.manifest.ts"))).sort();
+	if (roots.length === 0) throw new Error(`No applets were found under ${appletsDir}.`);
+	return roots;
+}
+async function gitChanged(topLevel, base, pathspecs, env) {
+	try {
+		await execFileAsync("git", [
+			"diff",
+			"--quiet",
+			base,
+			"HEAD",
+			"--",
+			...pathspecs
+		], {
+			cwd: topLevel,
+			env
+		});
+		return false;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === 1) return true;
+		throw error;
+	}
+}
+async function hasCommit(topLevel, sha, env) {
+	const git = (args) => execFileAsync("git", args, {
+		cwd: topLevel,
+		env
+	});
+	return git([
+		"cat-file",
+		"-e",
+		`${sha}^{commit}`
+	]).catch(() => git([
+		"fetch",
+		"--depth=1",
+		"origin",
+		sha
+	])).then(() => true, () => false);
+}
+async function ciDeployDecisions(github, workspaceRoot, appletRoots, options) {
+	const env = gitEnvironment();
+	const [sources, { stdout: topLevelOutput }, directories] = await Promise.all([
+		loadGitHubActionsSources(github, options),
+		execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+			cwd: workspaceRoot,
+			env
+		}),
+		Promise.all(appletRoots.map((appletRoot) => repositoryDirectory(appletRoot)))
+	]);
+	const topLevel = topLevelOutput.trim();
+	const appletsDirectory = relative(topLevel, resolve(workspaceRoot, "applets")).split(sep).join("/");
+	const baseByDirectory = new Map(sources.map((source) => [source.sourceDirectory, source.gitSha]));
+	const bases = new Set(directories.flatMap((directory) => baseByDirectory.get(directory) ?? []));
+	const sharedChanges = /* @__PURE__ */ new Map();
+	for (const base of bases) sharedChanges.set(base, await hasCommit(topLevel, base, env) ? await gitChanged(topLevel, base, [`:(exclude)${appletsDirectory}`], env) : void 0);
+	const decisions = await Promise.all(appletRoots.map(async (appletRoot, index) => {
+		const directory = directories[index];
+		const base = baseByDirectory.get(directory) ?? null;
+		if (base === null) return [appletRoot, {
+			deploy: true,
+			reason: "no CI release to compare"
+		}];
+		const short = base.slice(0, 7);
+		const sharedChanged = sharedChanges.get(base);
+		if (sharedChanged === void 0) return [appletRoot, {
+			deploy: true,
+			reason: `commit ${short} is not in the repository`
+		}];
+		if (await gitChanged(topLevel, base, [directory], env)) return [appletRoot, {
+			deploy: true,
+			reason: `${directory} changed since ${short}`
+		}];
+		if (sharedChanged) return [appletRoot, {
+			deploy: true,
+			reason: `files outside ${appletsDirectory} changed since ${short}`
+		}];
+		return [appletRoot, {
+			deploy: false,
+			reason: `no changes since ${short}`
+		}];
+	}));
+	return new Map(decisions);
+}
+async function runDeploy(options) {
+	const root = process.cwd();
+	const github = githubActionsContext(options.store?.env ?? process.env);
+	if (existsSync(resolve(root, "applet.manifest.ts"))) {
+		await deployApplet(root, options);
+		return;
+	}
+	if (readWorkspaceConfig(root) === void 0) throw new Error("Run applet deploy in an applet folder or in the workspace root.");
+	const appletRoots = await workspaceAppletRoots(root);
+	const decisions = github === void 0 ? void 0 : await ciDeployDecisions(github, root, appletRoots, options);
+	const selectedRoots = appletRoots.filter((appletRoot) => {
+		const name = relative(root, appletRoot);
+		const decision = decisions?.get(appletRoot);
+		if (decision === void 0) console.log(`Deploying ${name}...`);
+		else if (decision.deploy) console.log(`Deploying ${name}: ${decision.reason}.`);
+		else {
+			console.log(`Skipping ${name}: ${decision.reason}.`);
+			return false;
+		}
+		return true;
+	});
+	if (selectedRoots.length === 0) return;
+	if (options.dist === void 0) await prepareWorkspaceBuild(root, appletRoots);
+	const interactive = github === void 0 && (options.stdinIsTTY ?? process.stdin.isTTY === true);
+	const deploy = async (appletRoot) => {
+		const logPrefix = `[${relative(root, appletRoot)}] `;
+		if (options.dist === void 0) await buildPreparedApplet(appletRoot, ".hitch/dist", interactive ? "" : logPrefix);
+		await deployApplet(appletRoot, {
+			...options,
+			dist: options.dist ?? ".hitch/dist"
+		}, logPrefix);
+	};
+	if (interactive) {
+		for (const appletRoot of selectedRoots) await deploy(appletRoot);
+		return;
+	}
+	const failedApplets = (await Promise.allSettled(selectedRoots.map(deploy))).flatMap((result, index) => {
+		if (result.status === "fulfilled") return [];
+		const name = relative(root, selectedRoots[index]);
+		console.error(`[${name}] ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+		return [name];
+	});
+	if (failedApplets.length > 0) throw new WorkspaceDeployError(failedApplets);
+}
 //#endregion
 export { runDeploy };

package/dist/email-DBTVhNB_.js

@@ -0,0 +1,62 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/email.ts
+const emailTagKeySchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/);
+const emailTagsSchema = z.record(emailTagKeySchema, z.string().min(1).max(200)).refine((tags) => Object.keys(tags).length <= 10);
+const createEmailPixelInputSchema = z.object({ tags: emailTagsSchema.optional() }).strict();
+const createEmailPixelOutputSchema = z.object({
+	id: z.uuid(),
+	url: z.url()
+});
+const getEmailTrackerInputSchema = z.object({ id: z.uuid() });
+const markEmailTrackerSentInputSchema = z.object({
+	id: z.uuid(),
+	sentAt: z.iso.datetime({ offset: true }).optional()
+}).strict();
+const markEmailTrackerSentBodySchema = z.object({ sentAt: z.iso.datetime({ offset: true }).optional() }).strict();
+const emailTrackerSchema = z.object({
+	id: z.uuid(),
+	url: z.url(),
+	tags: emailTagsSchema,
+	createdAt: z.iso.datetime(),
+	sentAt: z.iso.datetime().nullable(),
+	firstHitAt: z.iso.datetime().nullable(),
+	lastHitAt: z.iso.datetime().nullable()
+});
+const listEmailTrackersInputSchema = z.object({
+	filter: emailTagsSchema.optional(),
+	sentAt: z.object({
+		$gte: z.iso.datetime({ offset: true }).optional(),
+		$lt: z.iso.datetime({ offset: true }).optional()
+	}).strict().optional(),
+	cursor: z.uuid().optional(),
+	limit: z.number().int().min(1).max(200).optional()
+}).strict();
+const listEmailTrackersOutputSchema = z.object({
+	trackers: z.array(emailTrackerSchema),
+	nextCursor: z.uuid().nullable()
+});
+function emailContract(appletCode) {
+	const path = `/v1/applets/${encodeURIComponent(appletCode)}/email/tracking`;
+	return { tracking: {
+		createPixel: oc.route({
+			method: "POST",
+			path: `${path}/pixels`,
+			successStatus: 201
+		}).input(createEmailPixelInputSchema.optional()).output(createEmailPixelOutputSchema),
+		markSent: oc.route({
+			method: "POST",
+			path: `${path}/{id}/sent`
+		}).input(markEmailTrackerSentInputSchema).output(emailTrackerSchema),
+		get: oc.route({
+			method: "GET",
+			path: `${path}/{id}`
+		}).input(getEmailTrackerInputSchema).output(emailTrackerSchema),
+		list: oc.route({
+			method: "POST",
+			path: `${path}/list`
+		}).input(listEmailTrackersInputSchema.optional()).output(listEmailTrackersOutputSchema)
+	} };
+}
+//#endregion
+export { emailTagsSchema as a, listEmailTrackersInputSchema as c, markEmailTrackerSentInputSchema as d, emailTagKeySchema as i, listEmailTrackersOutputSchema as l, createEmailPixelOutputSchema as n, emailTrackerSchema as o, emailContract as r, getEmailTrackerInputSchema as s, createEmailPixelInputSchema as t, markEmailTrackerSentBodySchema as u };

package/dist/generate-BgepN4-b.js

@@ -0,0 +1,2 @@
+import { n as runGenerate } from "./generate-CBPnHoqX.js";
+export { runGenerate };

package/dist/{generate-BFmIzHaR.js → generate-CBPnHoqX.js}

@@ -1,6 +1,7 @@
-import { i as resolveInstanceUrl, n as organizationInstanceUrl, t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
-import { t as loadAppletConfig } from "./load-config-BnxocLAQ.js";
-import { r as prepareAppletProject } from "./project-CEmDnlKa.js";
+import { c as organizationInstanceUrl, d as resolveInstanceUrl, n as fetchWithOrgAuth } from "./workspace-XVtM12ZC.js";
+import { i as loadGitHubActionsBuildInputs, n as githubActionsContext } from "./ci-5qWl7lT3.js";
+import { t as loadAppletConfig } from "./load-config-BYSxDVAl.js";
+import { r as prepareAppletProject } from "./project-D6XHllmC.js";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import { access, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
@@ -54,7 +55,7 @@ export default createWorkerEntry(server, { code: ${JSON.stringify(appletCode)} }
 }
 //#endregion
 //#region src/typegen/operations.ts
-const RECORD_ROUTE = /^\/v1\/([^/]+)(?:\/(\{id\}|query|update|aggregate))?$/;
+const RECORD_ROUTE = /^\/v1\/([^/]+)(?:\/(\{id\}(?:\/history)?|query|update|aggregate))?$/;
 const COMPONENT_REF_PREFIX$1 = "#/components/schemas/";
 const BATCH_PATH = "/v1/batch";
 const BATCH_ITEM_PATH = "paths./v1/batch.post.requestBody.content.application/json.schema.properties.requests.items";
@@ -63,6 +64,7 @@ const VERBS = {
 	"get:": "list",
 	"post:": "create",
 	"get:{id}": "get",
+	"get:{id}/history": "history",
 	"patch:{id}": "update",
 	"delete:{id}": "delete",
 	"post:query": "query",
@@ -73,6 +75,7 @@ const COMPONENT_RESPONSE_STATUS = {
 	list: "200",
 	create: "201",
 	get: "200",
+	history: "200",
 	update: "200",
 	query: "200"
 };
@@ -148,10 +151,13 @@ function prepareBatchOperation(operation, manifest) {
 		if (manifest === void 0) return true;
 		const object = manifest.objects.find(({ code }) => code === objectCode);
 		if (object === void 0) return false;
-		if (verb === "create") return object.canCreate;
-		if (verb === "delete") return object.canDelete;
-		if (verb === "update" || verb === "updateWhere") return object.readWrite.length > 0;
-		return true;
+		switch (verb) {
+			case "create": return object.canCreate;
+			case "delete": return object.canDelete;
+			case "update":
+			case "updateWhere": return object.readWrite.length > 0;
+			default: return true;
+		}
 	});
 	if (entries.length === 0) return void 0;
 	items.oneOf = entries;
@@ -165,7 +171,7 @@ function prepareRecordSpec(spec, manifest) {
 	const prepared = structuredClone(spec);
 	prepared.paths = Object.fromEntries(Object.entries(prepared.paths).flatMap(([path, pathItem]) => {
 		if (path === BATCH_PATH) {
-			if (!isObject$2(pathItem) || pathItem.post === void 0) return [];
+			if (!isObject$2(pathItem)) return [];
 			const operation = prepareBatchOperation(pathItem.post, manifest);
 			return operation === void 0 ? [] : [[path, { post: operation }]];
 		}
@@ -273,7 +279,7 @@ ${Object.entries(catalog).map(([objectCode, attributeCodes]) => `  ${JSON.string
 };`;
 	return `// Generated by @hitch42/applet — do not edit.
 import type manifest from "./manifest.gen.ts";
-${options.hasServer ? "import type server from \"../src/server/main.ts\";\nimport type * as serverModule from \"../src/server/main.ts\";\n" : ""}${options.hasClient ? "import type { Route as indexRoute } from \"../src/client/routes/index.tsx\";\n" : ""}${options.hasServer ? "import type { AnyRouter } from \"@orpc/server\";\n" : ""}${options.hasClient ? "import type { AnyRoute } from \"@tanstack/react-router\";\n" : ""}${options.hasServer ? "import type { WorkflowDefinition } from \"@hitch42/applet/server\";\n" : ""}
+${options.hasServer ? "import type server from \"../src/server/main.ts\";\nimport type * as serverModule from \"../src/server/main.ts\";\n" : ""}${options.hasClient ? "import type { Route as indexRoute } from \"../src/client/routes/index.tsx\";\n" : ""}${options.hasServer ? "import type { AnyRouter } from \"@orpc/server\";\n" : ""}${options.hasClient ? "import type { AnyRoute } from \"@tanstack/react-router\";\n" : ""}${options.hasServer ? "import type { WorkflowDefinition } from \"@hitch42/applet/server\";\nimport type { TelephonyMessageReceivedEvent } from \"@hitch42/applet\";\n" : ""}
 ${catalogType}
 
 type Expect<T extends true> = T;
@@ -286,6 +292,7 @@ type _SrcServerMainMustDefaultExportRouterAndValidWorkflows = Expect<
   typeof server extends {
     router: AnyRouter;
     workflows?: Record<string, WorkflowDefinition<any, any>>;
+    telephony?: { onMessageReceived?: (event: TelephonyMessageReceivedEvent) => void | Promise<void> };
   }
     ? true
     : false
@@ -351,9 +358,11 @@ async function responseJson(response) {
 		throw new Error("Failed to parse the organization's OpenAPI spec.", { cause: error });
 	}
 }
-async function loadAuthenticatedSpec(orgCode, options) {
+async function loadAuthenticatedSpec(manifest, options) {
+	const github = githubActionsContext(options.store?.env ?? process.env);
+	if (github !== void 0) return (await loadGitHubActionsBuildInputs(github, options, manifest.requiresChangeset)).openapi;
 	const fetcher = options.fetch ?? globalThis.fetch;
-	const response = await fetchWithOrgAuth(orgCode, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/v1/openapi.json${options.changesetId === void 0 ? "" : `?changeset_id=${encodeURIComponent(options.changesetId)}`}`, { headers: { Authorization: `Bearer ${accessToken}` } }));
+	const response = await fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/v1/openapi.json${manifest.requiresChangeset === void 0 ? "" : `?changeset_id=${encodeURIComponent(manifest.requiresChangeset)}`}`, { headers: { Authorization: `Bearer ${accessToken}` } }));
 	if (!response.ok) throw new Error(`Failed to load the organization's OpenAPI spec (${response.status}).`);
 	return responseJson(response);
 }
@@ -364,6 +373,20 @@ async function loadThemeStylesheet(orgCode, options) {
 	if (!response.ok) throw new Error(`Failed to load the organization's theme (${response.status}).`);
 	return response.text();
 }
+async function loadBuildInputs(manifest, options) {
+	const github = githubActionsContext(options.store?.env ?? process.env);
+	if (github !== void 0) {
+		const inputs = await loadGitHubActionsBuildInputs(github, options, manifest.requiresChangeset);
+		return {
+			spec: inputs.openapi,
+			theme: inputs.theme
+		};
+	}
+	return {
+		spec: await loadAuthenticatedSpec(manifest, options),
+		theme: await loadThemeStylesheet(manifest.org, options)
+	};
+}
 async function generateContract(spec, outDir) {
 	await mkdir(outDir, { recursive: true });
 	const paths = spec !== null && typeof spec === "object" && "paths" in spec ? spec.paths : void 0;
@@ -403,16 +426,16 @@ async function writeContractFiles(outDir, manifest, spec) {
 	await writeManifestGen(outDir, manifest);
 	await writeRegisterDeclaration(outDir, catalog);
 	await writeFile(resolve(outDir, "index.ts"), `// Generated by applet generate — do not edit.
-import { filesContract as files, meContract as me, pruneContract, registerHitchContract, teamsContract as teams } from "@hitch42/applet";
+import { emailContract, filesContract as files, meContract as me, pruneContract, registerHitchContract, teamsContract as teams, telephonyContract as telephony } from "@hitch42/applet";
 import manifest from "./manifest.gen.ts";
 
 ${Object.hasOwn(preparedSpec.paths, "/v1/batch") ? `import { contract as generated } from "./orpc.gen.ts";
 
 const { batch, ...records } = generated;
 
-export const contract = { records, batch, files, me, teams } as const;` : `import { contract as records } from "./orpc.gen.ts";
+export const contract = { records, batch, email: emailContract(manifest.code), files, me, teams, telephony } as const;` : `import { contract as records } from "./orpc.gen.ts";
 
-export const contract = { records, files, me, teams } as const;`}
+export const contract = { records, email: emailContract(manifest.code), files, me, teams, telephony } as const;`}
 registerHitchContract(pruneContract(contract, manifest));
 
 declare module "@hitch42/applet" {
@@ -425,15 +448,14 @@ export type * from "./zod.gen.ts";
 `);
 }
 async function syncContract(outDir, manifest, options = {}) {
-	await writeContractFiles(outDir, manifest, await loadAuthenticatedSpec(manifest.org, options));
+	await writeContractFiles(outDir, manifest, await loadAuthenticatedSpec(manifest, options));
 }
 async function runGenerate(options) {
 	await prepareAppletProject();
 	const root = process.cwd();
 	const outDir = resolve("./.hitch");
 	const manifest = await loadAppletConfig(process.cwd());
-	const spec = await loadAuthenticatedSpec(manifest.org, options);
-	const themeStylesheet = await loadThemeStylesheet(manifest.org, options);
+	const { spec, theme: themeStylesheet } = await loadBuildInputs(manifest, options);
 	const stagedDir = await mkdtemp(resolve("./.hitch.tmp-"));
 	const backupDir = `${stagedDir}.backup`;
 	let staged = true;

package/dist/index.d.ts

@@ -1,12 +1,14 @@
-import { _ as RegisteredWorkflows, a as AppletSourceDefinition, c as appletManifestSchema, d as RegisteredCatalog, f as RegisteredContract, g as RegisteredVariables, h as RegisteredVariableKeys, i as AppletPackages, l as appletSourceDefinitionSchema, m as RegisteredRouter, n as AppletManifest, o as RegisteredAppletSourceDefinition, p as RegisteredManifest, r as AppletManifestObject, s as appletDefinitionSchema, t as AppletDefinition, u as HitchRegister, v as registerHitchContract } from "./manifest-BQCAxATS.js";
-import { n as pruneContract, t as NarrowContract } from "./contract-DMrpbaLJ.js";
-import { a as UploadedHitchFile, c as createFileOutputSchema, d as getFileOutputSchema, i as UploadProgress, l as fileSchema, n as FilesUpload, r as UploadFileOptions, s as uploadFile, t as FilesClient, u as filesContract } from "./upload-YbRKEqR6.js";
+import { _ as RegisteredWorkflows, a as AppletSourceDefinition, c as appletManifestSchema, d as RegisteredCatalog, f as RegisteredContract, g as RegisteredVariables, h as RegisteredVariableKeys, i as AppletPackages, l as appletSourceDefinitionSchema, m as RegisteredRouter, n as AppletManifest, o as RegisteredAppletSourceDefinition, p as RegisteredManifest, r as AppletManifestObject, s as appletDefinitionSchema, t as AppletDefinition, u as HitchRegister, v as registerHitchContract } from "./manifest-DD_SGkS6.js";
+import { n as pruneContract, t as NarrowContract } from "./contract-rP_eV9PK.js";
+import { a as UploadedHitchFile, c as createFileOutputSchema, d as getFileOutputSchema, i as UploadProgress, l as fileSchema, n as FilesUpload, r as UploadFileOptions, s as uploadFile, t as FilesClient, u as filesContract } from "./upload-DKZzz5kW.js";
+import { a as createEmailPixelOutputSchema, c as emailTagsSchema, d as listEmailTrackersInputSchema, f as listEmailTrackersOutputSchema, i as createEmailPixelInputSchema, l as emailTrackerSchema, m as markEmailTrackerSentInputSchema, n as EmailTracker, o as emailContract, r as ListEmailTrackersOutput, s as emailTagKeySchema, t as TelephonyMessageReceivedEvent, u as getEmailTrackerInputSchema } from "./telephony-protocol-D-nf3Gca.js";
 import { ContractProcedure, Meta } from "@orpc/contract";
 import { z } from "zod";
-//#region src/workspace.d.ts
+//#region ../shared/auth/src/workspace.d.mts
 interface HitchConfig {
   sdk: string;
   org: string;
+  githubWorkflow?: boolean;
 }
 //#endregion
 //#region src/hitch/me.d.ts
@@ -33,12 +35,121 @@ type HitchMe = {
   } | null;
   multiOrg: boolean;
 };
-declare const meSchema: z.ZodType<HitchMe>;
+declare const meSchema: z.ZodType<HitchMe, HitchMe>;
 type MeContract = {
-  get: ContractProcedure<z.ZodType<void>, z.ZodType<HitchMe>, Record<never, never>, Meta>;
+  get: ContractProcedure<z.ZodType<void, void>, z.ZodType<HitchMe, HitchMe>, Record<never, never>, Meta>;
 };
 declare const meContract: MeContract;
 //#endregion
+//#region src/hitch/telephony.d.ts
+type HitchPhoneNumber = {
+  id: string;
+  e164: string;
+  label: string;
+  enabled: boolean;
+  canRead: boolean;
+  canSend: boolean;
+  canCall: boolean;
+  voiceEnabled: boolean;
+};
+type HitchCall = {
+  id: string;
+  numberId: string;
+  direction: "inbound" | "outbound";
+  status: "starting" | "ringing" | "active" | "ended" | "missed" | "failed";
+  from: string;
+  to: string;
+  userId: string | null;
+  answeredAt: string | null;
+  endedAt: string | null;
+  durationSeconds: number | null;
+  voicemailSeconds: number | null;
+  hangupCause: string | null;
+  record: boolean;
+  hasRecording: boolean;
+  transcriptStatus: "pending" | "done" | "failed" | null;
+  transcript: {
+    segments: {
+      side: "member" | "customer";
+      speaker: number;
+      start: number;
+      end: number;
+      text: string;
+    }[];
+  } | null;
+  createdAt: string;
+};
+type ListHitchCallsInput = ListHitchMessagesInput & {
+  status?: HitchCall["status"];
+};
+type HitchMessage = {
+  id: string;
+  numberId: string;
+  direction: "inbound" | "outbound";
+  status: "pending" | "unknown" | "accepted" | "sent" | "delivered" | "unconfirmed" | "failed" | "received";
+  from: string;
+  to: string;
+  body: string | null;
+  redacted: boolean;
+  userId: string | null;
+  appletId: string | null;
+  requestId: string | null;
+  errorCode: string | null;
+  errorDetail: string | null;
+  statusAt: string | null;
+  createdAt: string;
+};
+type ListHitchMessagesInput = {
+  numberId?: string;
+  userId?: string;
+  direction?: "inbound" | "outbound";
+  since?: string;
+  until?: string;
+  cursor?: string;
+  limit?: number;
+};
+type SendHitchMessageInput = {
+  numberId: string;
+  to: string;
+  body: string;
+  requestId?: string;
+};
+type MessageIdInput = {
+  id: string;
+};
+type NumbersOutput = {
+  data: HitchPhoneNumber[];
+};
+type MessagesOutput = {
+  data: HitchMessage[];
+  nextCursor: string | null;
+};
+type CallsOutput = {
+  data: HitchCall[];
+  nextCursor: string | null;
+};
+declare const hitchPhoneNumberSchema: z.ZodType<HitchPhoneNumber, HitchPhoneNumber>;
+declare const hitchMessageSchema: z.ZodType<HitchMessage, HitchMessage>;
+declare const listHitchNumbersOutputSchema: z.ZodType<NumbersOutput, NumbersOutput>;
+declare const listHitchMessagesOutputSchema: z.ZodType<MessagesOutput, MessagesOutput>;
+declare const listHitchMessagesInputSchema: z.ZodType<ListHitchMessagesInput, ListHitchMessagesInput>;
+declare const sendHitchMessageInputSchema: z.ZodType<SendHitchMessageInput, SendHitchMessageInput>;
+type TelephonyContract = {
+  calls: {
+    get: ContractProcedure<z.ZodType<MessageIdInput, MessageIdInput>, z.ZodType<HitchCall, HitchCall>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<ListHitchCallsInput, ListHitchCallsInput>, z.ZodType<CallsOutput, CallsOutput>, Record<never, never>, Meta>;
+  };
+  numbers: {
+    list: ContractProcedure<z.ZodType<void, void>, z.ZodType<NumbersOutput, NumbersOutput>, Record<never, never>, Meta>;
+  };
+  messages: {
+    get: ContractProcedure<z.ZodType<MessageIdInput, MessageIdInput>, z.ZodType<HitchMessage, HitchMessage>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<ListHitchMessagesInput, ListHitchMessagesInput>, z.ZodType<MessagesOutput, MessagesOutput>, Record<never, never>, Meta>;
+    send: ContractProcedure<z.ZodType<SendHitchMessageInput, SendHitchMessageInput>, z.ZodType<HitchMessage, HitchMessage>, Record<never, never>, Meta>;
+  };
+};
+declare const telephonyContract: TelephonyContract;
+//#endregion
 //#region src/hitch/teams.d.ts
 type HitchTeam = {
   id: string;
@@ -61,14 +172,14 @@ type TeamsOutput = {
 type TeamMembersOutput = {
   data: HitchTeamMember[];
 };
-declare const teamSchema: z.ZodType<HitchTeam>;
-declare const teamMemberSchema: z.ZodType<HitchTeamMember>;
+declare const teamSchema: z.ZodType<HitchTeam, HitchTeam>;
+declare const teamMemberSchema: z.ZodType<HitchTeamMember, HitchTeamMember>;
 type TeamsContract = {
-  list: ContractProcedure<z.ZodType<void>, z.ZodType<TeamsOutput>, Record<never, never>, Meta>;
+  list: ContractProcedure<z.ZodType<void, void>, z.ZodType<TeamsOutput, TeamsOutput>, Record<never, never>, Meta>;
   members: {
-    list: ContractProcedure<z.ZodType<TeamIdInput>, z.ZodType<TeamMembersOutput>, Record<never, never>, Meta>;
+    list: ContractProcedure<z.ZodType<TeamIdInput, TeamIdInput>, z.ZodType<TeamMembersOutput, TeamMembersOutput>, Record<never, never>, Meta>;
   };
 };
 declare const teamsContract: TeamsContract;
 //#endregion
-export { type AppletDefinition, type AppletManifest, type AppletManifestObject, type AppletPackages, type AppletSourceDefinition, type FilesClient, type FilesUpload, type HitchConfig, type HitchMe, type HitchRegister, type HitchTeam, type HitchTeamMember, type NarrowContract, type RegisteredAppletSourceDefinition, type RegisteredCatalog, type RegisteredContract, type RegisteredManifest, type RegisteredRouter, type RegisteredVariableKeys, type RegisteredVariables, type RegisteredWorkflows, type UploadFileOptions, type UploadProgress, type UploadedHitchFile, appletDefinitionSchema, appletManifestSchema, appletSourceDefinitionSchema, createFileOutputSchema, fileSchema, filesContract, getFileOutputSchema, meContract, meSchema, pruneContract, registerHitchContract, teamMemberSchema, teamSchema, teamsContract, uploadFile };
+export { type AppletDefinition, type AppletManifest, type AppletManifestObject, type AppletPackages, type AppletSourceDefinition, type EmailTracker, type FilesClient, type FilesUpload, type HitchConfig, type HitchMe, type HitchMessage, type HitchPhoneNumber, type HitchRegister, type HitchTeam, type HitchTeamMember, type ListEmailTrackersOutput, type ListHitchMessagesInput, type NarrowContract, type RegisteredAppletSourceDefinition, type RegisteredCatalog, type RegisteredContract, type RegisteredManifest, type RegisteredRouter, type RegisteredVariableKeys, type RegisteredVariables, type RegisteredWorkflows, type SendHitchMessageInput, type TelephonyContract, type TelephonyMessageReceivedEvent, type UploadFileOptions, type UploadProgress, type UploadedHitchFile, appletDefinitionSchema, appletManifestSchema, appletSourceDefinitionSchema, createEmailPixelInputSchema, createEmailPixelOutputSchema, createFileOutputSchema, emailContract, emailTagKeySchema, emailTagsSchema, emailTrackerSchema, fileSchema, filesContract, getEmailTrackerInputSchema, getFileOutputSchema, hitchMessageSchema, hitchPhoneNumberSchema, listEmailTrackersInputSchema, listEmailTrackersOutputSchema, listHitchMessagesInputSchema, listHitchMessagesOutputSchema, listHitchNumbersOutputSchema, markEmailTrackerSentInputSchema, meContract, meSchema, pruneContract, registerHitchContract, sendHitchMessageInputSchema, teamMemberSchema, teamSchema, teamsContract, telephonyContract, uploadFile };