@hitch42/applet 0.1.0-beta.10

package/dist/index.d.ts

@@ -0,0 +1,185 @@
+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-I-9s8R36.js";
+import { n as pruneContract, t as NarrowContract } from "./contract-QUvEGiRI.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 ../shared/auth/src/workspace.d.mts
+interface HitchConfig {
+  sdk: string;
+  org: string;
+  githubWorkflow?: boolean;
+}
+//#endregion
+//#region src/hitch/me.d.ts
+type HitchPerson = {
+  id: string;
+  firstName: string;
+  lastName: string;
+  email: string;
+};
+type HitchMembership = {
+  orgId: string;
+  code: string;
+  name: string;
+  iconFileId: string | null;
+  role: "member" | "owner";
+  capabilities: string[];
+};
+type HitchMe = {
+  person: HitchPerson;
+  memberships: HitchMembership[];
+  organization: {
+    id: string;
+    code: string;
+  } | null;
+  multiOrg: boolean;
+};
+declare const meSchema: z.ZodType<HitchMe, HitchMe>;
+type MeContract = {
+  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;
+  name: string;
+};
+type HitchTeamMember = {
+  userId: string;
+  firstName: string;
+  lastName: string;
+  email: string;
+};
+type TeamIdInput = {
+  params: {
+    id: string;
+  };
+};
+type TeamsOutput = {
+  data: HitchTeam[];
+};
+type TeamMembersOutput = {
+  data: HitchTeamMember[];
+};
+declare const teamSchema: z.ZodType<HitchTeam, HitchTeam>;
+declare const teamMemberSchema: z.ZodType<HitchTeamMember, HitchTeamMember>;
+type TeamsContract = {
+  list: ContractProcedure<z.ZodType<void, void>, z.ZodType<TeamsOutput, TeamsOutput>, Record<never, never>, Meta>;
+  members: {
+    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 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 };

package/dist/index.js

@@ -0,0 +1,251 @@
+import { i as registerHitchContract, t as uploadFile } from "./upload-DRbVhuDm.js";
+import { a as emailTagsSchema, c as listEmailTrackersInputSchema, d as markEmailTrackerSentInputSchema, i as emailTagKeySchema, l as listEmailTrackersOutputSchema, n as createEmailPixelOutputSchema, o as emailTrackerSchema, r as emailContract, s as getEmailTrackerInputSchema, t as createEmailPixelInputSchema } from "./email-DBTVhNB_.js";
+import { n as meSchema, t as meContract } from "./me-BW7Paary.js";
+import { n as appletManifestSchema, r as appletSourceDefinitionSchema, t as appletDefinitionSchema } from "./manifest-4ZAc6HUk.js";
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/contract.ts
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pruneContract(contract, manifest) {
+	if (!isObject(contract) || !isObject(contract.records)) throw new Error("Hitch contract must contain a \"records\" router.");
+	const contractRecords = contract.records;
+	const records = Object.fromEntries(manifest.objects.map((manifestObject) => {
+		const procedures = contractRecords[manifestObject.code];
+		if (!isObject(procedures)) throw new Error(`Hitch contract object "${manifestObject.code}" is missing.`);
+		const pruned = { ...procedures };
+		if (!manifestObject.canCreate) delete pruned.create;
+		if (!manifestObject.canDelete) delete pruned.delete;
+		if (manifestObject.readWrite.length === 0) {
+			delete pruned.update;
+			delete pruned.updateWhere;
+		}
+		return [manifestObject.code, pruned];
+	}));
+	return Object.assign({}, contract, { records });
+}
+//#endregion
+//#region src/hitch/files.ts
+const fileFields = {
+	id: z.string(),
+	organizationId: z.string(),
+	key: z.string(),
+	filename: z.string(),
+	contentType: z.string(),
+	uploadedBy: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+};
+const fileSchema = z.object({
+	...fileFields,
+	sizeBytes: z.number(),
+	arrivedAt: z.string()
+});
+const pendingFileSchema = z.object({
+	...fileFields,
+	sizeBytes: z.null(),
+	arrivedAt: z.null()
+});
+const createFileInputSchema = z.object({ body: z.object({
+	filename: z.string().trim().min(1),
+	contentType: z.string().trim().min(1)
+}) });
+const createFileOutputSchema = z.object({
+	data: pendingFileSchema,
+	uploadUrl: z.string()
+});
+const fileIdInputSchema = z.object({ params: z.object({ id: z.uuid() }) });
+const getFileOutputSchema = z.object({
+	data: fileSchema,
+	downloadUrl: z.string()
+});
+const filesContract = {
+	create: oc.route({
+		method: "POST",
+		path: "/v1/files",
+		successStatus: 201,
+		inputStructure: "detailed"
+	}).input(createFileInputSchema).output(createFileOutputSchema),
+	confirm: oc.route({
+		method: "POST",
+		path: "/v1/files/{id}/confirm",
+		successStatus: 200,
+		inputStructure: "detailed"
+	}).input(fileIdInputSchema).output(getFileOutputSchema),
+	get: oc.route({
+		method: "GET",
+		path: "/v1/files/{id}",
+		inputStructure: "detailed"
+	}).input(fileIdInputSchema).output(getFileOutputSchema)
+};
+//#endregion
+//#region src/hitch/telephony.ts
+const hitchPhoneNumberSchema = z.object({
+	id: z.uuid(),
+	e164: z.string(),
+	label: z.string(),
+	enabled: z.boolean(),
+	canRead: z.boolean(),
+	canSend: z.boolean(),
+	canCall: z.boolean(),
+	voiceEnabled: z.boolean()
+});
+const hitchCallSchema = z.object({
+	id: z.uuid(),
+	numberId: z.uuid(),
+	direction: z.enum(["inbound", "outbound"]),
+	status: z.enum([
+		"starting",
+		"ringing",
+		"active",
+		"ended",
+		"missed",
+		"failed"
+	]),
+	from: z.string(),
+	to: z.string(),
+	userId: z.uuid().nullable(),
+	answeredAt: z.string().nullable(),
+	endedAt: z.string().nullable(),
+	durationSeconds: z.number().nullable(),
+	voicemailSeconds: z.number().nullable(),
+	hangupCause: z.string().nullable(),
+	record: z.boolean(),
+	hasRecording: z.boolean(),
+	transcriptStatus: z.enum([
+		"pending",
+		"done",
+		"failed"
+	]).nullable(),
+	transcript: z.object({ segments: z.array(z.object({
+		side: z.enum(["member", "customer"]),
+		speaker: z.number(),
+		start: z.number(),
+		end: z.number(),
+		text: z.string()
+	})) }).nullable(),
+	createdAt: z.string()
+});
+const hitchMessageSchema = z.object({
+	id: z.uuid(),
+	numberId: z.uuid(),
+	direction: z.enum(["inbound", "outbound"]),
+	status: z.enum([
+		"pending",
+		"unknown",
+		"accepted",
+		"sent",
+		"delivered",
+		"unconfirmed",
+		"failed",
+		"received"
+	]),
+	from: z.string(),
+	to: z.string(),
+	body: z.string().nullable(),
+	redacted: z.boolean(),
+	userId: z.uuid().nullable(),
+	appletId: z.uuid().nullable(),
+	requestId: z.string().nullable(),
+	errorCode: z.string().nullable(),
+	errorDetail: z.string().nullable(),
+	statusAt: z.string().nullable(),
+	createdAt: z.string()
+});
+const listHitchNumbersOutputSchema = z.object({ data: z.array(hitchPhoneNumberSchema) });
+const listHitchMessagesOutputSchema = z.object({
+	data: z.array(hitchMessageSchema),
+	nextCursor: z.string().nullable()
+});
+const listHitchCallsOutputSchema = z.object({
+	data: z.array(hitchCallSchema),
+	nextCursor: z.string().nullable()
+});
+const idInputSchema = z.object({ id: z.uuid() });
+const listInputFields = {
+	numberId: z.uuid().optional(),
+	userId: z.uuid().optional(),
+	direction: z.enum(["inbound", "outbound"]).optional(),
+	since: z.iso.datetime().optional(),
+	until: z.iso.datetime().optional(),
+	cursor: z.string().optional(),
+	limit: z.number().int().min(1).max(200).optional()
+};
+const listHitchMessagesInputSchema = z.object(listInputFields);
+const listHitchCallsInputSchema = z.object({
+	...listInputFields,
+	status: z.enum([
+		"starting",
+		"ringing",
+		"active",
+		"ended",
+		"missed",
+		"failed"
+	]).optional()
+});
+const sendHitchMessageInputSchema = z.object({
+	numberId: z.uuid(),
+	to: z.string(),
+	body: z.string().min(1).max(1600),
+	requestId: z.string().min(1).max(200).optional()
+});
+const telephonyContract = {
+	calls: {
+		get: oc.route({
+			method: "GET",
+			path: "/v1/telephony/calls/{id}"
+		}).input(idInputSchema).output(hitchCallSchema),
+		list: oc.route({
+			method: "GET",
+			path: "/v1/telephony/calls"
+		}).input(listHitchCallsInputSchema).output(listHitchCallsOutputSchema)
+	},
+	numbers: { list: oc.route({
+		method: "GET",
+		path: "/v1/telephony/numbers"
+	}).input(z.void()).output(listHitchNumbersOutputSchema) },
+	messages: {
+		get: oc.route({
+			method: "GET",
+			path: "/v1/telephony/messages/{id}"
+		}).input(idInputSchema).output(hitchMessageSchema),
+		list: oc.route({
+			method: "GET",
+			path: "/v1/telephony/messages"
+		}).input(listHitchMessagesInputSchema).output(listHitchMessagesOutputSchema),
+		send: oc.route({
+			method: "POST",
+			path: "/v1/telephony/messages",
+			successStatus: 201
+		}).input(sendHitchMessageInputSchema).output(hitchMessageSchema)
+	}
+};
+//#endregion
+//#region src/hitch/teams.ts
+const teamSchema = z.object({
+	id: z.uuid(),
+	name: z.string()
+});
+const teamMemberSchema = z.object({
+	userId: z.uuid(),
+	firstName: z.string(),
+	lastName: z.string(),
+	email: z.email()
+});
+const teamsOutputSchema = z.object({ data: z.array(teamSchema) });
+const teamIdInputSchema = z.object({ params: z.object({ id: z.uuid() }) });
+const teamMembersOutputSchema = z.object({ data: z.array(teamMemberSchema) });
+const teamsContract = {
+	list: oc.route({
+		method: "GET",
+		path: "/v1/teams"
+	}).input(z.void()).output(teamsOutputSchema),
+	members: { list: oc.route({
+		method: "GET",
+		path: "/v1/teams/{id}/members",
+		inputStructure: "detailed"
+	}).input(teamIdInputSchema).output(teamMembersOutputSchema) }
+};
+//#endregion
+export { 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 };

package/dist/init-DwsXRUk-.js

@@ -0,0 +1,244 @@
+import { a as ORG_CODE_PATTERN, i as APPLET_CODE_PATTERN } from "./manifest-4ZAc6HUk.js";
+import { d as resolveAuthForOrg, f as resolveInstanceUrl, i as readWorkspaceConfig } from "./workspace-DruAZPmV.js";
+import { n as runGenerate } from "./generate-XB-72Fzj.js";
+import { a as writeAppletSupport, n as loadCliManifest, o as writeWorkspaceSupport, t as assertWorkspaceCli } from "./project-B0qNXnFu.js";
+import { n as loadAppletSourceDefinition } from "./load-config-OKZU3UKn.js";
+import { access, cp, mkdir, readdir, writeFile } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/init.ts
+function isMissingFile(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function assertTargetIsAvailable(paths, targetType) {
+	const existingPath = (await Promise.all(paths.map(async (path) => {
+		try {
+			await access(path);
+			return path;
+		} catch (error) {
+			if (isMissingFile(error)) return void 0;
+			throw error;
+		}
+	}))).find((path) => path !== void 0);
+	if (existingPath !== void 0) throw new Error(`Refusing to initialize ${targetType}: ${existingPath} already exists.`);
+}
+async function assertDirectoryIsEmpty(path) {
+	const entries = await readdir(path);
+	if (entries.length > 0) {
+		const [entry] = entries;
+		throw new Error(`Refusing to initialize a workspace: ${path} is not empty (${entry} exists).`);
+	}
+}
+async function installDependencies(target, install) {
+	if (!install) return "skipped";
+	console.log("Installing dependencies with pnpm install...");
+	return new Promise((resolveInstall, rejectInstall) => {
+		let finished = false;
+		const child = spawn("pnpm", ["install"], {
+			cwd: target,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.once("error", (error) => {
+			finished = true;
+			if (isMissingFile(error)) {
+				console.error("pnpm was not found. Install pnpm, then run pnpm install.");
+				resolveInstall("failed");
+				return;
+			}
+			rejectInstall(error);
+		});
+		child.once("close", (code) => {
+			if (finished) return;
+			finished = true;
+			if (code === 0) {
+				resolveInstall("succeeded");
+				return;
+			}
+			console.error(`pnpm install failed${code === null ? "." : ` with exit code ${code}.`}`);
+			resolveInstall("failed");
+		});
+	});
+}
+async function runGit(cwd, args) {
+	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => ![
+		"GIT_COMMON_DIR",
+		"GIT_DIR",
+		"GIT_INDEX_FILE",
+		"GIT_WORK_TREE"
+	].includes(key)));
+	return new Promise((resolveGit, rejectGit) => {
+		let finished = false;
+		const child = spawn("git", args, {
+			cwd,
+			env,
+			stdio: [
+				"ignore",
+				"ignore",
+				"inherit"
+			]
+		});
+		child.once("error", (error) => {
+			finished = true;
+			if (isMissingFile(error)) {
+				console.error("git was not found; skipping repository setup.");
+				resolveGit(false);
+				return;
+			}
+			rejectGit(error);
+		});
+		child.once("close", (code) => {
+			if (finished) return;
+			finished = true;
+			if (code !== 0) console.error(`git ${args[0]} failed${code === null ? "." : ` with exit code ${code}.`}`);
+			resolveGit(code === 0);
+		});
+	});
+}
+async function generateAppletFiles(target, org, options, installResult) {
+	if (installResult === "failed") return false;
+	const previousCwd = process.cwd();
+	try {
+		const instanceUrl = await resolveInstanceUrl(void 0, options.store);
+		if (await resolveAuthForOrg(instanceUrl, org, options.store) === void 0) {
+			console.log("Not logged in. Run applet generate to pull the organization's generated files; it will prompt a login.");
+			return false;
+		}
+		process.chdir(target);
+		await runGenerate({
+			fetch: options.fetch,
+			login: options.login,
+			stdinIsTTY: options.stdinIsTTY,
+			store: options.store
+		});
+		return true;
+	} catch (error) {
+		console.warn(`Generation skipped: ${error instanceof Error ? error.message : String(error)}`);
+		console.warn("Run applet generate in the applet directory after you resolve this problem.");
+		return false;
+	} finally {
+		process.chdir(previousCwd);
+	}
+}
+async function runInit(org, options = {}) {
+	if (!ORG_CODE_PATTERN.test(org)) throw new Error(`Invalid organization code "${org}".`);
+	const target = process.cwd();
+	await assertDirectoryIsEmpty(target);
+	const cli = await loadCliManifest();
+	if (cli === void 0) throw new Error("The CLI package manifest is not published.");
+	const config = {
+		sdk: `${cli.name}@${cli.version}`,
+		org
+	};
+	await writeFile(resolve(target, "hitch.config.ts"), `import type { HitchConfig } from "@hitch42/applet";
+
+// After a clone, run: pnpm dlx ${config.sdk} bootstrap
+export default {
+  sdk: ${JSON.stringify(config.sdk)},
+  org: ${JSON.stringify(config.org)},
+} satisfies HitchConfig;
+`);
+	await writeWorkspaceSupport(target, config, cli);
+	const initialized = (options.git ?? true) && await runGit(target, [
+		"init",
+		"-b",
+		"main"
+	]);
+	const installResult = await installDependencies(target, options.install ?? true);
+	if (initialized) {
+		if ((options.commit ?? true) && await runGit(target, ["add", "-A"]) && await runGit(target, [
+			"commit",
+			"-m",
+			`applet init ${org}`
+		])) console.log("Created a git repository with an initial commit.");
+		else console.log("Created a git repository.");
+	}
+	const nextSteps = [...installResult === "succeeded" ? [] : ["pnpm install"], "pnpm exec applet new <code>"];
+	console.log(`Workspace created in ${target}.\n\nNext steps:\n${nextSteps.map((step) => `  ${step}`).join("\n")}`);
+}
+async function runBootstrap(options = {}) {
+	const target = process.cwd();
+	const config = readWorkspaceConfig(target);
+	if (config === void 0) throw new Error(`Not a Hitch workspace root: ${target}. Run applet bootstrap from the directory that contains hitch.config.ts.`);
+	const cli = await loadCliManifest();
+	if (cli === void 0) throw new Error("The CLI package manifest is not published.");
+	assertWorkspaceCli(config, cli);
+	const applets = await readdir(resolve(target, "applets"), { withFileTypes: true }).catch((error) => {
+		if (isMissingFile(error)) return [];
+		throw error;
+	});
+	const definitions = await Promise.all(applets.filter((entry) => entry.isDirectory()).map(async ({ name }) => {
+		const root = resolve(target, "applets", name);
+		return {
+			definition: await loadAppletSourceDefinition(root),
+			root
+		};
+	}));
+	await Promise.all([writeWorkspaceSupport(target, config, cli), ...definitions.map(({ definition, root }) => writeAppletSupport(root, definition))]);
+	const installResult = await installDependencies(target, options.install ?? true);
+	console.log(`Workspace files generated in ${target}.${installResult === "failed" ? "\n\nNext step:\n  pnpm install" : ""}`);
+}
+async function runNew(options) {
+	if (!APPLET_CODE_PATTERN.test(options.code)) throw new Error(`Invalid applet code "${options.code}".`);
+	if (options.clientOnly === true && options.serverOnly === true) throw new Error("Use only one of --client-only or --server-only.");
+	const workspaceRoot = process.cwd();
+	const name = options.code.replaceAll("_", " ").replace(/^./, (character) => character.toUpperCase());
+	const config = readWorkspaceConfig(workspaceRoot);
+	if (config === void 0) throw new Error(`Not a Hitch workspace root: ${workspaceRoot}. Run applet new from the directory that contains hitch.config.ts.`);
+	const cli = await loadCliManifest({ allowDevelopment: true });
+	if (cli !== void 0) assertWorkspaceCli(config, cli);
+	const appletTarget = resolve(workspaceRoot, "applets", options.code);
+	await assertTargetIsAvailable([resolve(appletTarget, "applet.manifest.ts"), resolve(appletTarget, "src")], "an applet");
+	const hasClient = options.serverOnly !== true;
+	const hasServer = options.clientOnly !== true;
+	if (hasClient) await cp(new URL("../scaffold/applet", import.meta.url), appletTarget, { recursive: true });
+	await Promise.all([hasClient ? mkdir(resolve(appletTarget, "src/client/routes"), { recursive: true }) : void 0, hasServer ? mkdir(resolve(appletTarget, "src/server"), { recursive: true }) : void 0]);
+	const definition = {
+		name,
+		code: options.code,
+		objects: [],
+		dependencies: {},
+		devDependencies: {}
+	};
+	await Promise.all([
+		writeFile(resolve(appletTarget, "applet.manifest.ts"), `import type { AppletSourceDefinition } from "@hitch42/applet";
+
+export default {
+  name: "${name}",
+  code: "${options.code}",
+  objects: [],
+  dependencies: {},
+  devDependencies: {},
+} as const satisfies AppletSourceDefinition;
+`),
+		hasClient ? writeFile(resolve(appletTarget, "src/client/routes/index.tsx"), `import { createFileRoute } from "@tanstack/react-router";
+
+import "@/client/styles/globals.css";
+
+export const Route = createFileRoute("/${options.code}/")({
+  component: () => <p>Hello from ${options.code}</p>,
+});
+`) : void 0,
+		hasServer ? writeFile(resolve(appletTarget, "src/server/main.ts"), `import { os, type } from "@orpc/server";
+
+// Delete this file if you do not require an API.
+const router = {
+  hello: os.input(type<{ name: string }>()).handler(({ input }) => \`Hello, \${input.name}!\`),
+};
+
+export default { router };
+`) : void 0
+	]);
+	await Promise.all([writeAppletSupport(appletTarget, definition), cli === void 0 ? void 0 : writeWorkspaceSupport(workspaceRoot, config, cli)]);
+	const installResult = await installDependencies(workspaceRoot, options.install ?? true);
+	const generateSucceeded = await generateAppletFiles(appletTarget, config.org, options, installResult);
+	const relativeTarget = relative(workspaceRoot, appletTarget);
+	const nextSteps = [
+		...installResult === "succeeded" ? [`cd ${JSON.stringify(relativeTarget)}`] : ["pnpm install", `cd ${JSON.stringify(relativeTarget)}`],
+		...generateSucceeded ? [] : ["pnpm exec applet generate"],
+		"pnpm exec vite"
+	];
+	console.log(`Applet created in ${relativeTarget}.\n\nNext steps:\n${nextSteps.map((step) => `  ${step}`).join("\n")}`);
+}
+//#endregion
+export { runBootstrap, runInit, runNew };