@keystrokehq/cli 0.0.1

package/dist/chunk-CH6r78ws.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/clear-cache.handler-B9tqSoSM.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { t as ui } from "./keystroke.mjs";
+import { n as clearStoredProjects } from "./dist-CUK7yBM0.mjs";
+//#region src/commands/projects/clear-cache.handler.ts
+async function handleProjectsClearCache(_options, _ctx) {
+	if (await clearStoredProjects()) ui.success("Projects cache cleared.");
+	else ui.text("No projects cache found. Nothing to clear.");
+}
+//#endregion
+export { handleProjectsClearCache };

package/dist/clear.handler-BTIXXPTJ.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import { h as toErrorMessage, i as logger, l as AUTH_HINT, t as ui } from "./keystroke.mjs";
+import { c as removeOrgCredentials, r as deleteStoredCredentials } from "./dist-CUK7yBM0.mjs";
+import { createClient } from "./src-eHwu-Gfw.mjs";
+//#region src/commands/auth/clear.handler.ts
+async function tryRevokeKey(apiKey, apiKeyId, baseUrl, organizationId) {
+	try {
+		await createClient({
+			apiKey,
+			baseUrl,
+			organizationId
+		}).public.auth.revoke({ apiKeyId });
+		logger.info("API key revoked on server", { apiKeyId });
+	} catch (error) {
+		logger.error("Failed to revoke API key on server", { error: toErrorMessage(error) });
+		ui.warn(`Could not revoke API key on server: ${toErrorMessage(error)}`);
+	}
+}
+async function handleAuthClear(_options, ctx) {
+	const creds = ctx.storedCredentials;
+	if (!creds || creds.orgs.length === 0) {
+		if (await deleteStoredCredentials()) ui.success("Local credentials removed.");
+		else ui.text(`No credentials found. ${AUTH_HINT}`);
+		return;
+	}
+	if (ctx.organizationId && ctx.orgSource === "flag") {
+		const removed = await removeOrgCredentials(ctx.organizationId);
+		if (!removed) {
+			ui.warn(`No stored credentials for organization ${ctx.organizationId}.`);
+			return;
+		}
+		if (removed.apiKeyId && creds.serverUrl) await tryRevokeKey(removed.apiKey, removed.apiKeyId, creds.serverUrl, removed.organizationId);
+		ui.success(`Credentials removed for ${removed.organizationName}.`);
+		return;
+	}
+	for (const org of creds.orgs) if (org.apiKeyId && creds.serverUrl) await tryRevokeKey(org.apiKey, org.apiKeyId, creds.serverUrl, org.organizationId);
+	await deleteStoredCredentials();
+	ui.success("All local credentials removed.");
+}
+//#endregion
+export { handleAuthClear };

package/dist/clear.handler-BydlX-zE.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { t as clearLogFile } from "./dist-CUK7yBM0.mjs";
+import { log } from "@clack/prompts";
+//#region src/commands/logs/clear.handler.ts
+async function handleLogsClear(_options, _ctx) {
+	if (await clearLogFile()) log.success("Log file cleared.");
+	else log.message("No log file found. Nothing to clear.");
+}
+//#endregion
+export { handleLogsClear };

package/dist/commander-DfTVqQ-3.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { C as CliExitError, h as toErrorMessage, i as logger, l as AUTH_HINT, n as createHiddenGlobalOptions, p as isAuthError, r as captureCliTelemetryResolvedContext, t as ui, w as InputValidationError } from "./keystroke.mjs";
+import { a as writeJsonError, r as isJsonMode } from "./output-DM4b7KgY.mjs";
+import { Command } from "commander";
+//#region src/lib/commander.ts
+/**
+* Applies typed options to a Commander command from a schema and configuration
+* Type-safe: ensures all schema keys have corresponding option configurations
+*
+* @param command - Commander command to apply options to
+* @param schema - Zod schema for option validation
+* @param optionsConfig - Configuration mapping schema keys to Commander flags/descriptions
+* @returns The command with options applied
+*/
+function applyTypedOptionsToCommand(command, schema, optionsConfig, skipKeys) {
+	const schemaKeys = Object.keys(schema.shape);
+	for (const key of schemaKeys) {
+		if (skipKeys?.has(String(key))) continue;
+		const config = optionsConfig[key];
+		if (!config) throw new Error(`Missing option configuration for key: ${String(key)}`);
+		if (config.collect) {
+			command.option(config.flag, config.description, (value, previous) => [...previous ?? [], value], []);
+			continue;
+		}
+		command.option(config.flag, config.description);
+	}
+	return command;
+}
+/**
+* Creates a fully type-safe Commander command from a schema and configuration.
+* Combines option application and action handler creation into a single function.
+*
+* Every handler receives a `CliContext` (with nullable client) by default.
+* Global options (`--api-key`, `--base-url`) defined on the root program are
+* automatically picked up and passed to `resolveBaseContext`.
+*
+* Provide a `resolve` function to narrow/extend the context for specialized needs.
+* The handler's `ctx` type is **inferred** from `resolve`'s return type.
+*
+* @param params - Command parameters
+* @param params.resolve - Optional context resolver; narrows or extends the base CliContext
+* @param params.subcommands - Optional array of subcommands to register under this command
+* @returns Fully configured Commander command
+*/
+function createTypedCommand(params) {
+	const { name, description, schema, optionsConfig, resolve, subcommands } = params;
+	const command = new Command(name).description(description);
+	for (const opt of createHiddenGlobalOptions()) command.addOption(opt);
+	if (params.argument) {
+		const bracket = params.argument.required === false ? ["[", "]"] : ["<", ">"];
+		command.argument(`${bracket[0]}${params.argument.name}${bracket[1]}`, params.argument.description);
+	}
+	applyTypedOptionsToCommand(command, schema, optionsConfig, params.argument ? new Set([params.argument.key]) : void 0);
+	command.action(async (...args) => {
+		let jsonMode = false;
+		try {
+			let rawOptions;
+			let cmd;
+			if (params.argument) {
+				const argValue = args[0];
+				rawOptions = args[1];
+				cmd = args[2];
+				rawOptions[params.argument.key] = argValue;
+			} else {
+				rawOptions = args[0];
+				cmd = args[1];
+			}
+			const parseResult = schema.safeParse(rawOptions);
+			if (!parseResult.success) {
+				ui.error("Invalid options provided:");
+				for (const issue of parseResult.error.issues) ui.hint(`${issue.path.join(".")}: ${issue.message}`);
+				throw new InputValidationError("Invalid options provided", { reported: true });
+			}
+			const parsed = parseResult.data;
+			if ("json" in parsed) jsonMode = isJsonMode(parsed);
+			const globalOpts = cmd.optsWithGlobals();
+			if (globalOpts.debug) logger.setDebug(true);
+			const contextMode = params.contextMode ?? "full";
+			const contextModule = await import("./context-T7HZuB97.mjs").then((n) => n.n);
+			const base = contextMode === "auth" ? await contextModule.resolveAuthContext({
+				apiKey: globalOpts.apiKey,
+				baseUrl: globalOpts.baseUrl,
+				org: globalOpts.org
+			}) : await contextModule.resolveBaseContext({
+				apiKey: globalOpts.apiKey,
+				baseUrl: globalOpts.baseUrl,
+				org: globalOpts.org
+			});
+			captureCliTelemetryResolvedContext(base);
+			base.jsonMode = jsonMode;
+			const typedBase = base;
+			const ctx = resolve ? await resolve(parseResult.data, typedBase) : typedBase;
+			const handler = params.handler ?? await params.loadHandler?.();
+			if (!handler) throw new CliExitError(`Command "${name}" has no handler configured.`);
+			await handler(parseResult.data, ctx);
+		} catch (error) {
+			if (error instanceof CliExitError) {
+				if (!error.reported) {
+					const message = toErrorMessage(error);
+					const authError = isAuthError(error);
+					if (jsonMode) writeJsonError(message, {
+						code: authError ? "AUTH_ERROR" : "UNHANDLED_ERROR",
+						hint: authError ? AUTH_HINT : void 0
+					});
+					if (authError) {
+						ui.error(`Authentication failed: ${message}`);
+						ui.hint(AUTH_HINT);
+					} else ui.error(`Uncaught error in command handler: ${message}`);
+				}
+				throw error.markReported();
+			}
+			const message = toErrorMessage(error);
+			const authError = isAuthError(error);
+			if (jsonMode) writeJsonError(message, {
+				code: authError ? "AUTH_ERROR" : "UNHANDLED_ERROR",
+				hint: authError ? AUTH_HINT : void 0
+			});
+			if (authError) {
+				ui.error(`Authentication failed: ${message}`);
+				ui.hint(AUTH_HINT);
+			} else ui.error(`Uncaught error in command handler: ${message}`);
+			throw new CliExitError(message, {
+				cause: error,
+				reported: true
+			});
+		}
+	});
+	for (const sub of subcommands ?? []) command.addCommand(sub);
+	return command;
+}
+//#endregion
+export { createTypedCommand as t };

package/dist/concurrency-gXn9Rw8x-DNl2YtrS.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+//#region ../../packages/workflow-builder/dist/concurrency-gXn9Rw8x.mjs
+/**
+* Runs async work over `items` with at most `concurrency` tasks in flight at once.
+*/
+async function runWithConcurrency(items, concurrency, fn) {
+	if (items.length === 0) return;
+	const queue = [...items];
+	const workerCount = Math.min(concurrency, queue.length);
+	await Promise.all(Array.from({ length: workerCount }, async () => {
+		for (;;) {
+			const next = queue.shift();
+			if (next === void 0) return;
+			await fn(next);
+		}
+	}));
+}
+//#endregion
+export { runWithConcurrency as t };

package/dist/connect-BUXkeH0F.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { n as JsonOptionSchema, t as JSON_OPTION_CONFIG } from "./output-DM4b7KgY.mjs";
+import { t as createTypedCommand } from "./commander-DfTVqQ-3.mjs";
+import { z } from "zod";
+//#region src/commands/connect/connect.command.ts
+const ConnectOptionsSchema = JsonOptionSchema.extend({
+	integrationId: z.string().optional(),
+	shop: z.string().optional().describe("Shopify store domain (required for keystroke connect shopify)"),
+	timeout: z.coerce.number().int().min(30).max(600).default(300).describe("Timeout in seconds (default: 5 minutes)"),
+	noOpen: z.boolean().optional().describe("Print the authorization URL instead of opening a browser")
+});
+const CONNECT_OPTIONS_CONFIG = {
+	shop: {
+		flag: "--shop <domain>",
+		description: "Shopify store domain, for example example.myshopify.com"
+	},
+	timeout: {
+		flag: "--timeout <seconds>",
+		description: "Timeout in seconds (default: 300)"
+	},
+	noOpen: {
+		flag: "--no-open",
+		description: "Do not open a browser automatically; print the authorization URL instead"
+	},
+	...JSON_OPTION_CONFIG
+};
+function createConnectCommand() {
+	return createTypedCommand({
+		name: "connect",
+		description: "Connect an official integration via OAuth (e.g., keystroke connect slack)",
+		schema: ConnectOptionsSchema,
+		optionsConfig: CONNECT_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./connect.handler-CYel9cy6.mjs")).handleConnect,
+		argument: {
+			name: "integrationId",
+			description: "Integration to connect (e.g., slack, linear)",
+			key: "integrationId"
+		}
+	});
+}
+//#endregion
+export { createConnectCommand };