@hitch42/applet 0.1.0-beta.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hitch42 Pty Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_internal/client.d.ts

@@ -0,0 +1,7 @@
+import { PersistQueryClientOptions } from "@tanstack/react-query-persist-client";
+import { AnyRouter } from "@tanstack/react-router";
+//#region src/internal/client.d.ts
+declare function appletQueryPersistence(appletCode: string): Promise<Omit<PersistQueryClientOptions, "queryClient"> | undefined>;
+declare function mountApplet(router: AnyRouter, appletCode: string): void;
+//#endregion
+export { appletQueryPersistence, mountApplet };

package/dist/_internal/client.js

@@ -0,0 +1,169 @@
+import { i as openCacheDatabase, n as clearAppletQueryCaches, o as sweepExpiredQueryCaches, r as indexedDbPersister, t as cacheTabId } from "../query-cache-CXmAyLv3.js";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
+import { RouterProvider } from "@tanstack/react-router";
+import { createElement, useEffect } from "react";
+import { createRoot } from "react-dom/client";
+import { RotateCcw } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/internal/error-page.tsx
+const STYLES = `
+.hitch-error {
+  position: relative;
+  display: flex;
+  min-height: 100dvh;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  padding: 3rem 1.5rem;
+  background:
+    radial-gradient(ellipse 80% 50% at 50% -20%, color-mix(in oklch, var(--primary) 12%, transparent), transparent),
+    var(--background);
+  color: var(--foreground);
+  font-family: "Inter Variable", Inter, ui-sans-serif, system-ui, sans-serif;
+}
+.hitch-error__content { width: 100%; max-width: 28rem; text-align: center; }
+.hitch-error__title { margin: 0 0 0.75rem; font-size: 1.875rem; font-weight: 600; letter-spacing: -0.025em; }
+.hitch-error__text { margin: 0 0 2rem; color: var(--muted-foreground); line-height: 1.625; text-wrap: balance; }
+.hitch-error__button {
+  display: inline-flex;
+  width: 100%;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  border: 0;
+  border-radius: calc(var(--radius, 0.625rem) + 4px);
+  padding: 0.75rem 1.5rem;
+  background: var(--primary);
+  color: var(--primary-foreground);
+  font: inherit;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 150ms;
+}
+.hitch-error__button:hover { background: color-mix(in oklch, var(--primary) 90%, transparent); }
+.hitch-error__button:focus-visible { outline: 2px solid var(--ring, var(--primary)); outline-offset: 2px; }
+.hitch-error__hint { margin: 1rem 0 0; color: var(--muted-foreground); font-size: 0.875rem; }
+.hitch-error__details { margin-top: 1.5rem; color: var(--muted-foreground); font-size: 0.875rem; text-align: left; }
+.hitch-error__details summary { cursor: pointer; text-align: center; }
+.hitch-error__details pre {
+  max-height: 12rem;
+  margin: 0.75rem 0 0;
+  padding: 1rem;
+  overflow: auto;
+  border: 1px solid var(--border);
+  border-radius: var(--radius, 0.625rem);
+  font: 0.75rem/1.5 ui-monospace, monospace;
+  white-space: pre;
+}
+`;
+function AppletErrorPage({ error, onReload }) {
+	useEffect(() => {
+		console.error("The applet failed to render.", error);
+	}, [error]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "hitch-error",
+		role: "alert",
+		children: [/* @__PURE__ */ jsx("style", { children: STYLES }), /* @__PURE__ */ jsxs("div", {
+			className: "hitch-error__content",
+			children: [
+				/* @__PURE__ */ jsx("h1", {
+					className: "hitch-error__title",
+					children: "We hit a snag"
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "hitch-error__text",
+					children: "This applet ran into an unexpected error. Reload to try again."
+				}),
+				/* @__PURE__ */ jsxs("button", {
+					type: "button",
+					className: "hitch-error__button",
+					onClick: onReload,
+					children: [/* @__PURE__ */ jsx(RotateCcw, {
+						size: 16,
+						"aria-hidden": true
+					}), "Reload applet"]
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "hitch-error__hint",
+					children: "If this keeps happening, let your admin know."
+				}),
+				import.meta.env.DEV && /* @__PURE__ */ jsxs("details", {
+					className: "hitch-error__details",
+					children: [/* @__PURE__ */ jsx("summary", { children: "Error details" }), /* @__PURE__ */ jsx("pre", { children: error instanceof Error ? error.stack ?? error.message : String(error) })]
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/internal/client.ts
+const CACHE_MAX_AGE = 3e5;
+const CACHE_SCOPE_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function appletQueryPersistence(appletCode) {
+	const contextPromise = window.__hitchCacheContext;
+	if (!contextPromise) return void 0;
+	const databaseReady = openCacheDatabase().then(() => true, (error) => {
+		console.error("Could not open the applet query cache.", error);
+		return false;
+	});
+	let context;
+	try {
+		context = await contextPromise;
+	} catch (error) {
+		console.error("Could not load the applet cache context.", error);
+		return;
+	}
+	const cacheScope = typeof context === "object" && context !== null && "cacheScope" in context && typeof context.cacheScope === "string" ? context.cacheScope.trim() : void 0;
+	const cacheBuster = typeof context === "object" && context !== null && "cacheBuster" in context && typeof context.cacheBuster === "string" ? context.cacheBuster.trim() : void 0;
+	if (!cacheScope || !CACHE_SCOPE_PATTERN.test(cacheScope) || !cacheBuster || !CACHE_SCOPE_PATTERN.test(cacheBuster)) return;
+	if (!await databaseReady) return void 0;
+	try {
+		return {
+			persister: indexedDbPersister(`${appletCode}:${cacheScope}:${cacheTabId()}`),
+			maxAge: CACHE_MAX_AGE,
+			buster: cacheBuster,
+			dehydrateOptions: { shouldDehydrateMutation: () => false }
+		};
+	} catch (error) {
+		console.error("Could not access applet query cache storage.", error);
+		return;
+	}
+}
+function mountApplet(router, appletCode) {
+	const queryClient = router.options.context.queryClient;
+	if (!queryClient) throw new Error("getRouter must provide a QueryClient via createRouter({ context: { queryClient } }).");
+	const root = document.getElementById("root");
+	if (root === null) throw new Error("Missing #root element in index.html.");
+	router.options.defaultErrorComponent ??= ({ error }) => createElement(AppletErrorPage, {
+		error,
+		onReload: () => {
+			queryClient.clear();
+			clearAppletQueryCaches(appletCode).catch((error) => console.error("Could not clear the applet query cache.", error)).finally(() => window.location.reload());
+		}
+	});
+	const applet = createElement(RouterProvider, { router });
+	const sweepWhenIdle = () => {
+		const sweep = () => {
+			sweepExpiredQueryCaches(CACHE_MAX_AGE).catch((error) => console.error("Could not clear expired applet query caches.", error));
+		};
+		if ("requestIdleCallback" in window) requestIdleCallback(sweep);
+		else setTimeout(sweep, 1e3);
+	};
+	appletQueryPersistence(appletCode).then((persistence) => {
+		createRoot(root).render(persistence ? createElement(PersistQueryClientProvider, {
+			client: queryClient,
+			persistOptions: persistence,
+			onSuccess: sweepWhenIdle,
+			onError: () => {
+				console.error("Could not restore the applet query cache.");
+				sweepWhenIdle();
+			}
+		}, applet) : createElement(QueryClientProvider, { client: queryClient }, applet));
+	}).catch((error) => {
+		console.error("Could not initialize the applet query cache.", error);
+		createRoot(root).render(createElement(QueryClientProvider, { client: queryClient }, applet));
+	});
+}
+//#endregion
+export { appletQueryPersistence, mountApplet };

package/dist/_internal/server.d.ts

@@ -0,0 +1,92 @@
+import { t as AnyWorkflowDefinition } from "../workflow-DurM6Fwx.js";
+import { d as listEmailTrackersInputSchema, i as createEmailPixelInputSchema, p as markEmailTrackerSentBodySchema, t as TelephonyMessageReceivedEvent } from "../telephony-protocol-D-nf3Gca.js";
+import { z } from "zod";
+//#region src/server/entry.d.ts
+declare function createWorkerEntry(server: {
+  router: object;
+  workflows?: Record<string, AnyWorkflowDefinition>;
+  telephony?: {
+    onMessageReceived?: (event: TelephonyMessageReceivedEvent) => void | Promise<void>;
+  };
+}, options: {
+  code: string;
+}): {
+  fetch(request: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+};
+//#endregion
+//#region src/server/workflow-protocol.d.ts
+type StepJournalEntry = {
+  kind: "step";
+  id: string;
+  name: string;
+  result: unknown;
+};
+type SleepJournalEntry = {
+  kind: "sleep";
+  id: string;
+  name: string;
+  until: number;
+};
+type AttemptJournalEntry = {
+  kind: "attempt";
+  id: string;
+  name: string;
+  error: string;
+};
+type FailedJournalEntry = {
+  kind: "failed";
+  id: string;
+  name: string;
+  error: string;
+};
+declare const journalEntrySchema: z.ZodType<StepJournalEntry | SleepJournalEntry | AttemptJournalEntry | FailedJournalEntry>;
+type JournalEntry = z.infer<typeof journalEntrySchema>;
+declare const workflowInvocationRequestSchema: z.ZodType<{
+  payload: unknown;
+  journal: JournalEntry[];
+}>;
+type WorkflowInvocationRequest = z.infer<typeof workflowInvocationRequestSchema>;
+type StepOutcome = {
+  kind: "step";
+  id: string;
+  name: string;
+  result: unknown;
+};
+type SleepOutcome = {
+  kind: "sleep";
+  id: string;
+  name: string;
+  until: number;
+};
+type StepErrorOutcome = {
+  kind: "step_error";
+  id: string;
+  name: string;
+  message: string;
+  retries: {
+    limit: number;
+    delayMs: number;
+    backoff: "constant" | "linear" | "exponential";
+  };
+};
+type DoneOutcome = {
+  kind: "done";
+  result: unknown;
+};
+type ErrorOutcome = {
+  kind: "error";
+  message: string;
+};
+declare const workflowOutcomeSchema: z.ZodType<StepOutcome | SleepOutcome | StepErrorOutcome | DoneOutcome | ErrorOutcome>;
+type WorkflowOutcome = z.infer<typeof workflowOutcomeSchema>;
+//#endregion
+//#region src/server/workflow-engine.d.ts
+type Engine = {
+  invoke<T>(name: string, fn: () => Promise<T>): Promise<T>;
+  sleepUntil(name: string, until: Date): Promise<void>;
+  sleep(name: string, milliseconds: number): Promise<void>;
+};
+declare class WorkflowFailedError extends Error {}
+declare function runWorkflowJournal(engine: Engine, invoke: (journal: JournalEntry[]) => Promise<WorkflowOutcome>): Promise<unknown>;
+//#endregion
+export { type Engine, type JournalEntry, WorkflowFailedError, type WorkflowInvocationRequest, type WorkflowOutcome, createEmailPixelInputSchema, createWorkerEntry, journalEntrySchema, listEmailTrackersInputSchema, markEmailTrackerSentBodySchema, runWorkflowJournal, workflowInvocationRequestSchema, workflowOutcomeSchema };

package/dist/_internal/server.js

@@ -0,0 +1,181 @@
+import { c as listEmailTrackersInputSchema, t as createEmailPixelInputSchema, u as markEmailTrackerSentBodySchema } from "../email-DBTVhNB_.js";
+import { a as workflowOutcomeSchema, c as HITCH_SESSION_HEADER, i as workflowInvocationRequestSchema, l as HITCH_USER_HEADER, n as runWorkflowJournal, o as HITCH_APPLET_HEADER, r as journalEntrySchema, s as HITCH_APPLET_TOKEN_HEADER, t as WorkflowFailedError } from "../workflow-engine-MogejNfF.js";
+import { o as runWithRequestContext, r as toMilliseconds, t as MAX_DURATION_MS } from "../workflow-CTo2kZF1.js";
+import { z } from "zod";
+import { RPCHandler } from "@orpc/server/fetch";
+//#region src/server/telephony-protocol.ts
+const telephonyMessageReceivedEventSchema = z.object({
+	eventId: z.string(),
+	type: z.literal("message.received"),
+	messageId: z.string(),
+	numberId: z.string(),
+	occurredAt: z.iso.datetime()
+});
+//#endregion
+//#region src/server/workflow-run.ts
+const MAX_RESULT_SIZE = 1048576;
+function errorMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).slice(0, 2048);
+}
+function outcomeTooLarge(outcome) {
+	return new TextEncoder().encode(JSON.stringify(outcome)).byteLength > MAX_RESULT_SIZE;
+}
+async function runWorkflowInvocation(definition, request) {
+	const occurrences = /* @__PURE__ */ new Map();
+	const never = new Promise(() => void 0);
+	let claimed = false;
+	let resolveRecorded = () => void 0;
+	const recordedPromise = new Promise((resolve) => {
+		resolveRecorded = resolve;
+	});
+	const nextId = (name) => {
+		const occurrence = (occurrences.get(name) ?? 0) + 1;
+		occurrences.set(name, occurrence);
+		return `${name}#${occurrence}`;
+	};
+	const record = (outcome) => {
+		resolveRecorded(outcome);
+		return never;
+	};
+	const runPromise = definition.run({
+		async do(name, optionsOrFn, possibleFn) {
+			const id = nextId(name);
+			const journaled = request.journal.find((entry) => entry.kind === "step" && entry.id === id);
+			if (journaled?.kind === "step") return journaled.result;
+			const failed = request.journal.find((entry) => entry.kind === "failed" && entry.id === id);
+			if (failed?.kind === "failed") throw new Error(failed.error);
+			if (claimed) return never;
+			claimed = true;
+			const options = typeof optionsOrFn === "function" ? void 0 : optionsOrFn;
+			const fn = typeof optionsOrFn === "function" ? optionsOrFn : possibleFn;
+			const retries = options?.retries ? {
+				limit: options.retries.limit,
+				delayMs: toMilliseconds(options.retries.delay),
+				backoff: options.retries.backoff ?? "constant"
+			} : {
+				limit: 0,
+				delayMs: 0,
+				backoff: "constant"
+			};
+			if (retries.delayMs * (retries.backoff === "exponential" ? 2 ** (retries.limit - 1) : retries.backoff === "linear" ? retries.limit : 1) > MAX_DURATION_MS) throw new Error("Retry delay grows beyond 365 days.");
+			try {
+				const outcome = {
+					kind: "step",
+					id,
+					name,
+					result: await fn()
+				};
+				return record(outcomeTooLarge(outcome) ? {
+					kind: "error",
+					message: `Step "${name}" result exceeds 1 MiB.`
+				} : outcome);
+			} catch (error) {
+				return record({
+					kind: "step_error",
+					id,
+					name,
+					message: errorMessage(error),
+					retries
+				});
+			}
+		},
+		async sleep(name, duration) {
+			const id = nextId(name);
+			if (request.journal.find((entry) => entry.kind === "sleep" && entry.id === id) !== void 0) return;
+			if (claimed) return never;
+			claimed = true;
+			return record({
+				kind: "sleep",
+				id,
+				name,
+				until: Date.now() + toMilliseconds(duration)
+			});
+		}
+	}, request.payload).then((result) => {
+		const outcome = {
+			kind: "done",
+			result
+		};
+		return outcomeTooLarge(outcome) ? {
+			kind: "error",
+			message: "Workflow result exceeds 1 MiB."
+		} : outcome;
+	}, (error) => ({
+		kind: "error",
+		message: errorMessage(error)
+	}));
+	return Promise.race([runPromise, recordedPromise]);
+}
+//#endregion
+//#region src/server/entry.ts
+const WORKFLOW_PATH_PREFIX = "/api/__hitch/workflows/";
+const SERVER_EXPORT_ERROR = "src/server/main.ts must default-export { router, workflows } — change \"export default router\" to \"export default { router }\".";
+function jsonError(status, error) {
+	return Response.json({ error }, { status });
+}
+function createWorkerEntry(server, options) {
+	const candidate = server;
+	if (typeof candidate !== "object" || candidate === null || !("router" in candidate)) throw new Error(SERVER_EXPORT_ERROR);
+	const handler = new RPCHandler(server.router);
+	return { async fetch(request, env) {
+		const userId = request.headers.get(HITCH_USER_HEADER);
+		const sessionToken = request.headers.get(HITCH_SESSION_HEADER);
+		const appletId = request.headers.get(HITCH_APPLET_HEADER);
+		const token = request.headers.get(HITCH_APPLET_TOKEN_HEADER);
+		const identity = userId !== null && sessionToken !== null ? {
+			kind: "user",
+			userId,
+			sessionToken
+		} : appletId !== null && token !== null ? {
+			kind: "applet",
+			appletId,
+			token
+		} : void 0;
+		if (identity === void 0) return jsonError(401, "missing_identity");
+		const bindings = typeof env === "object" && env !== null ? env : {};
+		if (typeof bindings.HITCH_API_URL !== "string") return jsonError(500, "missing_api_binding");
+		const service = typeof bindings.HITCH === "object" && bindings.HITCH !== null ? bindings.HITCH : void 0;
+		const apiFetch = typeof service?.fetch === "function" ? service.fetch.bind(bindings.HITCH) : globalThis.fetch.bind(globalThis);
+		return runWithRequestContext({
+			identity,
+			appletCode: options.code,
+			api: {
+				baseUrl: bindings.HITCH_API_URL,
+				fetch: apiFetch
+			}
+		}, async () => {
+			const pathname = new URL(request.url).pathname;
+			if (pathname === "/api/__hitch/telephony/message-received" && request.method === "POST") {
+				if (identity.kind !== "applet") return jsonError(403, "applet_identity_required");
+				const parsed = await request.json().then((body) => telephonyMessageReceivedEventSchema.safeParse(body)).catch(() => void 0);
+				if (!parsed?.success) return jsonError(400, "malformed_request");
+				const onMessageReceived = server.telephony?.onMessageReceived;
+				if (!onMessageReceived) return jsonError(404, "no_telephony_handler");
+				try {
+					await onMessageReceived(parsed.data);
+					return Response.json({ ok: true });
+				} catch (error) {
+					return jsonError(500, error instanceof Error ? error.message : String(error));
+				}
+			}
+			if (pathname.startsWith(WORKFLOW_PATH_PREFIX)) {
+				const parsed = await request.json().then((body) => workflowInvocationRequestSchema.safeParse(body)).catch(() => void 0);
+				if (parsed === void 0 || !parsed.success) return jsonError(400, "malformed_request");
+				const code = decodeURIComponent(pathname.slice(23));
+				const workflows = server.workflows ?? {};
+				const definition = Object.hasOwn(workflows, code) ? workflows[code] : void 0;
+				return Response.json(definition === void 0 ? {
+					kind: "error",
+					message: `Unknown workflow "${code}".`
+				} : await runWorkflowInvocation(definition, parsed.data));
+			}
+			const result = await handler.handle(request, {
+				context: {},
+				prefix: "/api"
+			});
+			return result.matched ? result.response : new Response(null, { status: 404 });
+		});
+	} };
+}
+//#endregion
+export { WorkflowFailedError, createEmailPixelInputSchema, createWorkerEntry, journalEntrySchema, listEmailTrackersInputSchema, markEmailTrackerSentBodySchema, runWorkflowJournal, workflowInvocationRequestSchema, workflowOutcomeSchema };

package/dist/applet.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/applet.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+//#region bin/applet.ts
+const usage = `Usage:
+  applet login [--no-browser]
+  applet init <org> [--no-commit | --no-git] [--no-install]
+  applet bootstrap [--no-install]
+  applet new <code> [--client-only | --server-only] [--no-install]
+  applet generate
+  applet build
+  applet deploy
+  applet logs [code] [--since <duration>] [--limit <count>]
+                     [--search <text>] [--level <level>] [--filter <json>] [--run <id>] [--live]
+  applet variables set <KEY> [value] [--secret] [-y | --yes]
+  applet variables list
+  applet variables delete <KEY> [-y | --yes]
+  applet schedules run <code> [-y | --yes]
+
+Login options:
+  --no-browser      Print the sign-in URL without opening a browser.
+
+Init options:
+  --no-commit        Do not create the initial commit
+  --no-git           Do not create a git repository
+  --no-install       Do not run pnpm install
+
+New options:
+  --client-only      Create only client source
+  --server-only      Create only server source
+  --no-install       Do not run pnpm install
+
+Bootstrap options:
+  --no-install       Do not run pnpm install
+
+Schema changesets:
+  Set requiresChangeset in applet.manifest.ts to generate, build, and deploy
+  against a pending changeset. The release goes live when the changeset
+  applies in Hitch. After it applies, the field uses the live schema.
+
+Run applet deploy in the workspace root to deploy every applet. In GitHub
+Actions it skips an applet when neither its folder nor any file outside
+applets/ changed since its current CI release.
+
+Logs options:
+  --since <duration>  Show logs from this period. Default: 1h. Maximum: 7d.
+  --limit <count>     Return up to this many logs. Default: 100. Maximum: 100.
+  --search <text>     Search log text.
+  --level <level>     Show this level and higher levels.
+                      Valid levels: debug, log, info, warn, error.
+                      The log level is an alias for info.
+  --run <id>          Show workflow logs for one run.
+  --filter <json>     Filter log fields with a Hitch JSON filter object.
+  --live              Poll for new logs every two seconds.
+
+Variables options:
+  --secret            Store the value as a secret.
+  -y, --yes           Skip the live applet confirmation.
+
+Schedules options:
+  -y, --yes           Skip the schedule confirmation.
+
+Login: applet login selects the organization from hitch.config.ts and shares
+credentials with hitch login.
+CI: set HITCH_API_KEY (and HITCH_API_URL for a non-default instance).
+GitHub Actions: generate, build, and deploy use the job's OIDC token instead of
+a key. Grant the job id-token: write.`;
+async function main() {
+	const { positionals, values } = parseArgs({
+		allowPositionals: true,
+		options: {
+			"client-only": { type: "boolean" },
+			filter: { type: "string" },
+			run: { type: "string" },
+			level: { type: "string" },
+			limit: { type: "string" },
+			live: { type: "boolean" },
+			"no-browser": { type: "boolean" },
+			"no-commit": { type: "boolean" },
+			"no-git": { type: "boolean" },
+			"no-install": { type: "boolean" },
+			secret: { type: "boolean" },
+			search: { type: "string" },
+			"server-only": { type: "boolean" },
+			since: { type: "string" },
+			yes: {
+				type: "boolean",
+				short: "y"
+			}
+		},
+		strict: true
+	});
+	if (positionals.length === 1 && positionals[0] === "login" && Object.keys(values).every((key) => key === "no-browser")) {
+		await (await import("./login-BBO74hPC.js")).runLogin({ noBrowser: values["no-browser"] });
+		return;
+	}
+	if (values["no-browser"] !== void 0) throw new Error(usage);
+	const noGitFlags = values["no-commit"] === void 0 && values["no-git"] === void 0;
+	const noVariableFlags = values.secret === void 0 && values.yes === void 0;
+	const noLogFlags = values.run === void 0 && values.filter === void 0 && values.level === void 0 && values.limit === void 0 && values.live === void 0 && values.search === void 0 && values.since === void 0;
+	const noModeFlags = values["client-only"] === void 0 && values["server-only"] === void 0;
+	if (positionals.length === 1 && positionals[0] === "bootstrap" && noModeFlags && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./init-DwsXRUk-.js")).runBootstrap({ install: values["no-install"] !== true });
+		return;
+	}
+	if (positionals.length === 1 && positionals[0] === "generate" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./generate-wIN3IYqL.js")).runGenerate({});
+		return;
+	}
+	if (positionals.length === 1 && positionals[0] === "build" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./build-CcT-wNN9.js")).runBuild();
+		return;
+	}
+	if (positionals.length === 1 && positionals[0] === "deploy" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./deploy-BbL3GObV.js")).runDeploy({});
+		return;
+	}
+	if (positionals.length === 2 && positionals[0] === "init" && noModeFlags && noVariableFlags && noLogFlags) {
+		await (await import("./init-DwsXRUk-.js")).runInit(positionals[1], {
+			commit: values["no-commit"] !== true,
+			git: values["no-git"] !== true,
+			install: values["no-install"] !== true
+		});
+		return;
+	}
+	if (positionals.length === 2 && positionals[0] === "new" && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./init-DwsXRUk-.js")).runNew({
+			code: positionals[1],
+			clientOnly: values["client-only"],
+			install: values["no-install"] !== true,
+			serverOnly: values["server-only"]
+		});
+		return;
+	}
+	if ((positionals.length === 1 || positionals.length === 2) && positionals[0] === "logs" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noVariableFlags) {
+		await (await import("./logs-XvK6Zs5Y.js")).runLogs({
+			code: positionals[1],
+			filter: values.filter,
+			run: values.run,
+			level: values.level,
+			limit: values.limit,
+			live: values.live,
+			search: values.search,
+			since: values.since
+		});
+		return;
+	}
+	if (positionals.length === 3 && positionals[0] === "schedules" && positionals[1] === "run" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noLogFlags && values.secret === void 0) {
+		await (await import("./schedules-BkWZsbSs.js")).runSchedule({
+			code: positionals[2],
+			yes: values.yes
+		});
+		return;
+	}
+	if ((positionals.length === 3 || positionals.length === 4) && positionals[0] === "variables" && positionals[1] === "set" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noLogFlags) {
+		await (await import("./variables-0tjnAeut.js")).runVariablesSet({
+			key: positionals[2],
+			secret: values.secret,
+			value: positionals[3],
+			yes: values.yes
+		});
+		return;
+	}
+	if (positionals.length === 2 && positionals[0] === "variables" && positionals[1] === "list" && values["no-install"] === void 0 && noModeFlags && noGitFlags && noVariableFlags && noLogFlags) {
+		await (await import("./variables-0tjnAeut.js")).runVariablesList({});
+		return;
+	}
+	if (positionals.length === 3 && positionals[0] === "variables" && positionals[1] === "delete" && values["no-install"] === void 0 && noModeFlags && noGitFlags && values.secret === void 0 && noLogFlags) {
+		await (await import("./variables-0tjnAeut.js")).runVariablesDelete({
+			key: positionals[2],
+			yes: values.yes
+		});
+		return;
+	}
+	throw new Error(usage);
+}
+try {
+	await main();
+} catch (error) {
+	console.error(error instanceof Error ? error.message : error);
+	if (!(error instanceof Error) || error.message !== usage) console.error(`\n${usage}`);
+	process.exitCode = 1;
+}
+//#endregion
+export {};