@hitch42/applet 0.1.1-beta.1

package/dist/index.js

@@ -0,0 +1,136 @@
+import { i as registerHitchContract, t as uploadFile } from "./upload-DRbVhuDm.js";
+import { n as appletManifestSchema, r as appletSourceDefinitionSchema, t as appletDefinitionSchema } from "./manifest-DyoJ1MIL.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/me.ts
+const personSchema = z.object({
+	id: z.uuid(),
+	firstName: z.string(),
+	lastName: z.string(),
+	email: z.email()
+});
+const membershipSchema = z.object({
+	orgId: z.uuid(),
+	code: z.string(),
+	name: z.string(),
+	iconFileId: z.uuid().nullable(),
+	role: z.enum(["member", "owner"]),
+	capabilities: z.array(z.string())
+});
+const meSchema = z.object({
+	person: personSchema,
+	memberships: z.array(membershipSchema),
+	organization: z.object({
+		id: z.uuid(),
+		code: z.string()
+	}).nullable(),
+	multiOrg: z.boolean()
+});
+const meContract = { get: oc.route({
+	method: "GET",
+	path: "/v1/me"
+}).input(z.void()).output(meSchema) };
+//#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, createFileOutputSchema, fileSchema, filesContract, getFileOutputSchema, meContract, meSchema, pruneContract, registerHitchContract, teamMemberSchema, teamSchema, teamsContract, uploadFile };

package/dist/init-BS1Y-eNL.js

@@ -0,0 +1,240 @@
+import { a as ORG_CODE_PATTERN, i as APPLET_CODE_PATTERN } from "./manifest-DyoJ1MIL.js";
+import { i as resolveInstanceUrl, r as resolveAuthForOrg } from "./auth-DaVK0k5R.js";
+import { n as runGenerate } from "./generate-CH0VQmUi.js";
+import { n as loadAppletSourceDefinition, r as readWorkspaceConfig } from "./load-config-BnxocLAQ.js";
+import { a as writeWorkspaceSupport, i as writeAppletSupport, n as loadCliManifest, t as assertWorkspaceCli } from "./project-CxN-Dtc7.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 [entry] = await readdir(path);
+	if (entry !== void 0) 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"
+		});
+		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 };

package/dist/lazy-client-x0DCI98S.js

@@ -0,0 +1,64 @@
+import { isContractProcedure } from "@orpc/contract";
+//#region src/hitch/batch.ts
+const BATCH_VERBS = [
+	"create",
+	"update",
+	"delete",
+	"updateWhere"
+];
+function withBatchRecorder(target, contract) {
+	if (isContractProcedure(contract)) return target;
+	const batchContract = Reflect.get(contract, "batch");
+	if (!isContractProcedure(batchContract)) return target;
+	return new Proxy(target, { get(inner, property, receiver) {
+		const value = Reflect.get(inner, property, receiver);
+		if (property !== "batch") return value;
+		return (...args) => {
+			const [input, options] = args;
+			if (typeof input !== "function") return Reflect.apply(value, receiver, args);
+			return (async () => {
+				const requests = [];
+				let active = true;
+				const records = Reflect.get(contract, "records");
+				const tx = Object.fromEntries(Object.entries(records).map(([code, procedures]) => [code, Object.fromEntries(BATCH_VERBS.filter((verb) => typeof procedures === "object" && procedures !== null && isContractProcedure(Reflect.get(procedures, verb))).map((verb) => [verb, (procedureInput) => {
+					if (!active) throw new Error("The batch was already sent.");
+					const body = Reflect.get(procedureInput, "body");
+					const id = verb === "update" || verb === "delete" ? Reflect.get(Reflect.get(procedureInput, "params"), "id") : void 0;
+					requests.push({
+						method: verb === "create" || verb === "updateWhere" ? "POST" : verb === "update" ? "PATCH" : "DELETE",
+						path: verb === "create" ? `/v1/${code}` : verb === "updateWhere" ? `/v1/${code}/update` : `/v1/${code}/${String(id)}`,
+						...verb === "delete" ? {} : { body }
+					});
+				}]))]));
+				try {
+					await Reflect.apply(input, void 0, [tx]);
+				} finally {
+					active = false;
+				}
+				const recorderOptions = options;
+				return Reflect.apply(value, receiver, [{
+					body: {
+						requests,
+						...recorderOptions?.dryRun ? { dry_run: true } : {}
+					},
+					...recorderOptions?.idempotencyKey ? { headers: { "Idempotency-Key": recorderOptions.idempotencyKey } } : {}
+				}]);
+			})();
+		};
+	} });
+}
+//#endregion
+//#region src/lazy-client.ts
+function createLazyClientProxy(build) {
+	let client;
+	const at = (path) => new Proxy(() => void 0, {
+		get: (_target, property) => at([...path, property]),
+		apply: (_target, _thisArg, args) => {
+			client ??= build();
+			return path.reduce((value, property) => value[property], client)(...args);
+		}
+	});
+	return at([]);
+}
+//#endregion
+export { withBatchRecorder as n, createLazyClientProxy as t };

package/dist/load-config-BnxocLAQ.js

@@ -0,0 +1,56 @@
+import { a as ORG_CODE_PATTERN, r as appletSourceDefinitionSchema } from "./manifest-DyoJ1MIL.js";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { loadConfigFromFile } from "vite";
+//#region src/workspace.ts
+const hitchConfigSchema = z.object({
+	sdk: z.string().min(1),
+	org: z.string().regex(ORG_CODE_PATTERN)
+});
+const require = createRequire(import.meta.url);
+function readWorkspaceConfig(dir) {
+	const path = resolve(dir, "hitch.config.ts");
+	if (!existsSync(path)) return void 0;
+	let module;
+	try {
+		module = require(path);
+	} catch (error) {
+		throw new Error(`Failed to load ${path}.`, { cause: error });
+	}
+	const config = hitchConfigSchema.safeParse(module !== null && typeof module === "object" && "default" in module ? module.default : module);
+	if (!config.success) throw new Error(`Invalid Hitch config in ${path}: ${config.error.message}`);
+	return config.data;
+}
+function resolveWorkspaceOrg(appletRoot) {
+	const appletsDir = dirname(appletRoot);
+	if (basename(appletsDir) === "applets") {
+		const config = readWorkspaceConfig(dirname(appletsDir));
+		if (config !== void 0) return config.org;
+	}
+	throw new Error(`No Hitch workspace found for ${appletRoot}. An applet must live at <workspace>/applets/<code> with hitch.config.ts in the workspace root.`);
+}
+//#endregion
+//#region src/typegen/load-config.ts
+async function loadAppletSourceDefinition(root) {
+	const path = resolve(root, "applet.manifest.ts");
+	if (!existsSync(path)) throw new Error(`No applet manifest found at ${path}.`);
+	const loaded = await loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, path, root);
+	if (loaded === null) throw new Error(`No applet manifest found at ${path}.`);
+	const parsed = appletSourceDefinitionSchema.safeParse(loaded.config);
+	if (!parsed.success) throw new Error(`Invalid applet manifest at ${loaded.path}: ${parsed.error.message}`);
+	return parsed.data;
+}
+async function loadAppletConfig(root) {
+	const { dependencies: _dependencies, devDependencies: _devDependencies, ...definition } = await loadAppletSourceDefinition(root);
+	return {
+		org: resolveWorkspaceOrg(root),
+		...definition
+	};
+}
+//#endregion
+export { resolveWorkspaceOrg as i, loadAppletSourceDefinition as n, readWorkspaceConfig as r, loadAppletConfig as t };

package/dist/logs-m00pzr_O.js

@@ -0,0 +1,183 @@
+import { i as APPLET_CODE_PATTERN } from "./manifest-DyoJ1MIL.js";
+import { t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
+import { i as resolveWorkspaceOrg, r as readWorkspaceConfig, t as loadAppletConfig } from "./load-config-BnxocLAQ.js";
+import { z } from "zod";
+//#region src/logs.ts
+const LOG_LEVELS = [
+	"debug",
+	"log",
+	"info",
+	"warn",
+	"error"
+];
+const MAX_RANGE_MS = 6048e5;
+const LIVE_OVERLAP_MS = 1e4;
+const POLL_INTERVAL_MS = 2e3;
+const MAX_SEEN_IDS = 5e3;
+const logSchema = z.object({
+	id: z.string(),
+	timestamp: z.number(),
+	level: z.string(),
+	message: z.string(),
+	releaseId: z.string(),
+	type: z.string().optional(),
+	runId: z.string().optional(),
+	workflow: z.string().optional(),
+	invocation: z.number().optional(),
+	outcome: z.string().optional(),
+	eventType: z.string().optional(),
+	statusCode: z.number().optional(),
+	cpuTimeMs: z.number().optional(),
+	wallTimeMs: z.number().optional()
+});
+const logsResponseSchema = z.object({ data: z.array(logSchema) });
+function parseSince(value = "1h") {
+	const match = /^(\d+)(s|m|h|d)$/.exec(value);
+	if (!match) throw new Error("--since must use a duration such as \"30m\", \"1h\", or \"2d\".");
+	const duration = Number(match[1]) * {
+		s: 1e3,
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	if (!Number.isSafeInteger(duration) || duration < 1e3 || duration > MAX_RANGE_MS) throw new Error("--since must be between 1s and 7d.");
+	return duration;
+}
+function parseLimit(value = "100") {
+	const limit = Number(value);
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error("--limit must be an integer from 1 to 100.");
+	return limit;
+}
+function parseLevel(value) {
+	if (value === void 0) return void 0;
+	const parsed = z.enum(LOG_LEVELS).safeParse(value);
+	if (!parsed.success) throw new Error("--level must be debug, log, info, warn, or error.");
+	return parsed.data;
+}
+function parseFilter(value) {
+	if (value === void 0) return void 0;
+	try {
+		const filter = JSON.parse(value);
+		if (filter === null || typeof filter !== "object" || Array.isArray(filter)) throw new Error();
+		return filter;
+	} catch {
+		throw new Error("--filter must be a JSON object.");
+	}
+}
+function parseSearch(value) {
+	if (value === void 0) return void 0;
+	const search = value.trim();
+	if (search.length === 0 || search.length > 1e3) throw new Error("--search must contain from 1 to 1000 characters.");
+	return search;
+}
+async function resolveTarget(code) {
+	if (code === void 0) {
+		const manifest = await loadAppletConfig(process.cwd());
+		return {
+			code: manifest.code,
+			org: manifest.org
+		};
+	}
+	if (!APPLET_CODE_PATTERN.test(code)) throw new Error(`Invalid applet code "${code}".`);
+	return {
+		code,
+		org: readWorkspaceConfig(process.cwd())?.org ?? resolveWorkspaceOrg(process.cwd())
+	};
+}
+async function readErrorDetails(response) {
+	try {
+		const body = await response.json();
+		if (body !== null && typeof body === "object") return ["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 {
+		return "";
+	}
+	return "";
+}
+function waitForPoll(signal) {
+	if (signal?.aborted === true) return Promise.resolve(false);
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve(true);
+		}, POLL_INTERVAL_MS);
+		const onAbort = () => {
+			clearTimeout(timeout);
+			resolve(false);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function printLog(log) {
+	const details = log.type === "invocation" ? [
+		log.statusCode === void 0 ? void 0 : `status=${log.statusCode}`,
+		log.outcome === void 0 ? void 0 : `outcome=${log.outcome}`,
+		log.wallTimeMs === void 0 ? void 0 : `wall=${log.wallTimeMs}ms`,
+		log.cpuTimeMs === void 0 ? void 0 : `cpu=${log.cpuTimeMs}ms`
+	].filter((value) => value !== void 0) : [];
+	console.log(`${new Date(log.timestamp).toISOString()} ${log.level.toUpperCase().padEnd(5)} ${log.type === "workflow" ? `[${log.workflow} ${log.runId?.slice(0, 8)}#${log.invocation}] ` : ""}${log.message}${details.length === 0 ? "" : ` [${details.join(" ")}]`}`);
+}
+async function runLogs(options) {
+	const [{ code, org }, since, limit, level, userFilter, search] = await Promise.all([
+		resolveTarget(options.code),
+		Promise.resolve(parseSince(options.since)),
+		Promise.resolve(parseLimit(options.limit)),
+		Promise.resolve(parseLevel(options.level)),
+		Promise.resolve(parseFilter(options.filter)),
+		Promise.resolve(parseSearch(options.search))
+	]);
+	const runFilter = options.run === void 0 ? void 0 : { runId: { $eq: options.run } };
+	const filter = runFilter === void 0 ? userFilter : userFilter === void 0 ? runFilter : { $and: [runFilter, userFilter] };
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const startedAt = Date.now();
+	const requestLogs = async (from, to) => {
+		const response = await fetchWithOrgAuth(org, options, (instanceUrl, accessToken) => {
+			const url = new URL(`/api/v1/applets/${encodeURIComponent(code)}/logs/query`, `${instanceUrl}/`);
+			const levelFilter = level === void 0 ? void 0 : { level: { $in: LOG_LEVELS.slice(LOG_LEVELS.indexOf(level)) } };
+			return fetcher(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({
+					from,
+					to,
+					limit,
+					...search === void 0 ? {} : { search },
+					...levelFilter === void 0 && filter === void 0 ? {} : { filter: levelFilter === void 0 ? filter : filter === void 0 ? levelFilter : { $and: [levelFilter, filter] } }
+				})
+			});
+		});
+		if (!response.ok) {
+			const details = await readErrorDetails(response);
+			throw new Error(`Logs request failed (${response.status})${details ? `: ${details}` : ""}.`);
+		}
+		return logsResponseSchema.parse(await response.json()).data;
+	};
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenIdQueue = [];
+	const printNewLogs = (logs) => {
+		logs.forEach((log) => {
+			if (seenIds.has(log.id)) return;
+			seenIds.add(log.id);
+			seenIdQueue.push(log.id);
+			if (seenIdQueue.length > MAX_SEEN_IDS) seenIds.delete(seenIdQueue.shift());
+			printLog(log);
+		});
+	};
+	const initialLogs = await requestLogs(startedAt - since, startedAt);
+	printNewLogs(initialLogs);
+	if (options.live !== true) {
+		if (initialLogs.length === 0) console.log(`No logs found for "${code}".`);
+		return;
+	}
+	let lastTimestamp = initialLogs.at(-1)?.timestamp ?? startedAt;
+	while (await waitForPoll(options.signal)) {
+		const to = Date.now();
+		const logs = await requestLogs(Math.max(startedAt - since, lastTimestamp - LIVE_OVERLAP_MS), to);
+		printNewLogs(logs);
+		lastTimestamp = Math.max(lastTimestamp, ...logs.map(({ timestamp }) => timestamp));
+	}
+}
+//#endregion
+export { runLogs };