@keystrokehq/cli 0.0.1

package/dist/inspect.handler-DT_cD036.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { i as resolveTypeHint } from "./schema-display-CgmeKigW.mjs";
+import { i as requireClient, t as assertProjectConfigMatchesAuthenticatedOrg } from "./context-T7HZuB97.mjs";
+import { n as resolveLocalWorkflowManifest, r as resolveProjectContext, t as lookupCurrentDeploymentWorkflow } from "./current-deployment-workflow-poHt27i3.mjs";
+import dayjs from "dayjs";
+//#region src/commands/workflows/inspect/inspect-display.ts
+function formatBuildTimestamp(iso) {
+	if (!iso) return "unknown";
+	const d = dayjs(iso);
+	return d.isValid() ? d.format("MMM D, YYYY [at] h:mm A") : iso;
+}
+function renderManifestInspect(manifest, source, version) {
+	if (source === "deployed" && version !== void 0) {
+		ui.text(style(`  Deployed v${version}`, ANSI.dim));
+		ui.br();
+	}
+	ui.text(style(`  ${manifest.name}`, `${ANSI.bold}${ANSI.cyan}`));
+	if (manifest.description) ui.text(style(`  ${manifest.description}`, ANSI.dim));
+	ui.br();
+	ui.text(style("  Input", ANSI.bold));
+	const inputFields = formatSchemaFields(manifest.workflowSchemas?.input);
+	if (inputFields) ui.text(inputFields);
+	else ui.text(style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Output", ANSI.bold));
+	const outputFields = formatSchemaFields(manifest.workflowSchemas?.output);
+	if (outputFields) ui.text(outputFields);
+	else ui.text(style("    (none)", ANSI.dim));
+	ui.br();
+	ui.text(style("  Steps", ANSI.bold));
+	const stepsText = formatSteps(manifest.steps ?? {});
+	if (stepsText) ui.text(stepsText);
+	else ui.text(style("    (none)", ANSI.dim));
+	ui.br();
+	const credentialsText = formatCredentials(manifest.credentials);
+	if (credentialsText) {
+		ui.text(style("  Integrations Required", ANSI.bold));
+		ui.text(credentialsText);
+		ui.br();
+	}
+	if (source === "local" && manifest.buildInfo) {
+		const builtAt = formatBuildTimestamp(manifest.buildInfo.timestamp);
+		const versionStr = `local-build v${manifest.buildInfo.builderVersion ?? "unknown"}`;
+		ui.text(style(`  Built ${builtAt} · ${versionStr}`, ANSI.dim));
+	}
+}
+function formatSchemaFields(schema) {
+	if (!schema || typeof schema !== "object") return "";
+	const props = schema.properties;
+	if (!props || Object.keys(props).length === 0) return "";
+	const required = schema.required ?? [];
+	const requiredSet = new Set(required);
+	const lines = [];
+	for (const [name, fieldSchema] of Object.entries(props)) {
+		const typeHint = resolveTypeHint(fieldSchema);
+		const req = requiredSet.has(name) ? style("  required", ANSI.dim) : "";
+		const desc = typeof fieldSchema.description === "string" ? `\n      ${style(fieldSchema.description, ANSI.dim)}` : "";
+		lines.push(`    ${name}  ${style(typeHint, ANSI.dim)}${req}${desc}`);
+	}
+	return lines.join("\n");
+}
+function formatCredentials(credentials) {
+	if (!credentials) return "";
+	const lines = [];
+	if (credentials.required?.length) for (const id of credentials.required) lines.push(`    ${id}`);
+	if (credentials.byStep && Object.keys(credentials.byStep).length > 0) {
+		lines.push("");
+		for (const [stepNodeId, stepCreds] of Object.entries(credentials.byStep)) {
+			const entries = Array.isArray(stepCreds) ? stepCreds : [];
+			for (const e of entries) {
+				const scope = e.scope ? ` (${e.scope})` : "";
+				lines.push(`    ${stepNodeId} → ${e.credentialSetId}${scope}`);
+			}
+		}
+	}
+	return lines.join("\n");
+}
+function formatSteps(steps) {
+	const workflowSteps = Object.values(steps).filter((s) => s.callKind === "workflow-step");
+	if (workflowSteps.length === 0) return "";
+	const lines = [];
+	workflowSteps.forEach((step, i) => {
+		lines.push(`    ${i + 1}. ${step.label ?? step.stepName}`);
+		lines.push(`       ${style(step.stepName, ANSI.dim)} (${step.callKind})`);
+		if (step.credentialSets && step.credentialSets.length > 0) for (const credentialSet of step.credentialSets) {
+			const scope = credentialSet.scope ? ` (${credentialSet.scope})` : "";
+			lines.push(`       ${style(`→ ${credentialSet.resolvedId}${scope}`, ANSI.dim)}`);
+		}
+	});
+	const otherCount = Object.values(steps).length - workflowSteps.length;
+	if (otherCount > 0) lines.push(`    ${style(`+ ${otherCount} other node type(s)`, ANSI.dim)}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/commands/workflows/inspect/inspect.handler.ts
+async function handleWorkflowsInspect(options, ctx) {
+	if (options.deployed) return handleInspectDeployed(options, ctx);
+	return handleInspectLocal(options, ctx);
+}
+async function handleInspectLocal(options, ctx) {
+	const resolved = await resolveLocalWorkflowManifest(options.workflow, options.path, { jsonMode: ctx.jsonMode });
+	const workflowsDir = resolved.workflowsDir;
+	trackProject(workflowsDir);
+	if (ctx.jsonMode) {
+		writeJson(resolved.manifest);
+		return;
+	}
+	renderManifestInspect(resolved.manifest, "local");
+}
+async function handleInspectDeployed(options, ctx) {
+	const resolved = await resolveProjectContext(options.workflow, options.path, { jsonMode: ctx.jsonMode });
+	trackProject(resolved.workflowsDir);
+	const client = requireClient(ctx);
+	await assertProjectConfigMatchesAuthenticatedOrg(client, { organizationId: resolved.organizationId });
+	let deploymentLookup;
+	try {
+		deploymentLookup = await lookupCurrentDeploymentWorkflow(client, {
+			projectId: resolved.projectId,
+			authoredWorkflowId: resolved.authoredWorkflowId
+		});
+	} catch (error) {
+		ui.error(`Failed to inspect current deployment workflow: ${toErrorMessage(error)}`);
+		throwReportedCliExit(`Failed to inspect current deployment workflow: ${toErrorMessage(error)}`, { cause: error });
+	}
+	if (deploymentLookup.status === "missingCurrentDeployment") {
+		ui.error("This project has no current deployment.");
+		ui.hint("Run `keystroke deploy` to create the current deployment, then try again.");
+		throwReportedCliExit("This project has no current deployment.");
+	}
+	if (deploymentLookup.status === "missingWorkflow") {
+		ui.error(`Workflow "${options.workflow}" is not part of the current deployment.`);
+		ui.hint("Run `keystroke deploy` to include it in the current deployment, then try again.");
+		throwReportedCliExit(`Workflow "${options.workflow}" is not part of the current deployment.`);
+	}
+	if (ctx.jsonMode) {
+		writeJson(deploymentLookup.workflow.manifest);
+		return;
+	}
+	renderManifestInspect(deploymentLookup.workflow.manifest, "deployed");
+}
+//#endregion
+export { handleWorkflowsInspect };

package/dist/integration-catalog-Bt-L3GjF.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { C as CliExitError, D as throwReportedCliExit, h as toErrorMessage, m as isNetworkError, p as isAuthError, t as ui, u as REAUTH_HINT } from "./keystroke.mjs";
+import { a as writeJsonError } from "./output-DM4b7KgY.mjs";
+import { i as requireClient } from "./context-T7HZuB97.mjs";
+//#region src/lib/integration-catalog.ts
+const catalogCache = /* @__PURE__ */ new WeakMap();
+function buildView(entries) {
+	const byPublicId = /* @__PURE__ */ new Map();
+	const byResolvedCredentialSetId = /* @__PURE__ */ new Map();
+	const oauthPublicIds = [];
+	for (const entry of entries) {
+		for (const alias of entry.aliases) byPublicId.set(alias.toLowerCase(), entry);
+		byPublicId.set(entry.publicId.toLowerCase(), entry);
+		byResolvedCredentialSetId.set(entry.credentialSet.resolvedCredentialSetId, {
+			label: entry.name,
+			integrationPublicId: entry.publicId,
+			role: "connection",
+			connectionKind: entry.connectionKind
+		});
+		for (const internal of entry.internalCredentialSets) byResolvedCredentialSetId.set(internal.resolvedCredentialSetId, {
+			label: internal.displayName,
+			integrationPublicId: entry.publicId,
+			role: internal.role
+		});
+		if (entry.connectionKind === "oauth") oauthPublicIds.push(entry.publicId);
+	}
+	function lookupByPublicId(id) {
+		if (!id) return void 0;
+		return byPublicId.get(id.trim().toLowerCase());
+	}
+	return {
+		integrations: entries,
+		byPublicId,
+		byResolvedCredentialSetId,
+		oauthPublicIds,
+		lookupByPublicId
+	};
+}
+/**
+* Maps an SDK error from the catalog fetch into a reported `CliExitError` so
+* the caller can simply `throw` it through the existing CLI error-handling
+* machinery. Preserves the familiar error messages for auth and network
+* failure paths and preserves the underlying `cause` on the thrown error
+* chain regardless of `jsonMode`.
+*/
+function reportCatalogFetchFailure(ctx, error) {
+	if (error instanceof CliExitError) throw error;
+	if (isAuthError(error)) {
+		const message = `Not authenticated. ${REAUTH_HINT}`;
+		if (ctx.jsonMode) writeJsonError(message, {
+			code: "AUTH_ERROR",
+			hint: REAUTH_HINT,
+			cause: error
+		});
+		ui.error(message);
+		throwReportedCliExit(message, { cause: error });
+	}
+	if (isNetworkError(error)) {
+		const url = ctx.baseUrl ?? "the Keystroke server";
+		const message = `Could not reach ${url} to load the integration catalog.`;
+		const hint = `Check that your local services are running and that the CLI is pointed at ${url}.`;
+		if (ctx.jsonMode) writeJsonError(message, {
+			code: "NETWORK_ERROR",
+			hint,
+			cause: error
+		});
+		ui.error(message);
+		ui.hint(hint);
+		throwReportedCliExit(message, { cause: error });
+	}
+	const message = `Failed to load the integration catalog: ${toErrorMessage(error)}`;
+	if (ctx.jsonMode) writeJsonError(message, {
+		code: "CATALOG_ERROR",
+		cause: error
+	});
+	ui.error(message);
+	throwReportedCliExit(message, { cause: error });
+}
+/**
+* Returns the integration catalog view for the current invocation.
+*
+* Memoized per `CliContext`: repeated calls in the same invocation share a
+* single in-flight HTTP request and then a single resolved view. Cross-
+* invocation caching is deliberately out of scope — a new process gets a
+* fresh catalog so CLI behavior cannot lag a server-side integration change.
+*/
+function getIntegrationCatalog(ctx) {
+	const cached = catalogCache.get(ctx);
+	if (cached) return cached;
+	const promise = (async () => {
+		const client = requireClient(ctx);
+		try {
+			return buildView((await client.integrations.list({ includeInternal: true })).integrations);
+		} catch (error) {
+			catalogCache.delete(ctx);
+			reportCatalogFetchFailure(ctx, error);
+		}
+	})();
+	catalogCache.set(ctx, promise);
+	return promise;
+}
+//#endregion
+export { getIntegrationCatalog as t };

package/dist/integrations-DlatPK4W.mjs

@@ -0,0 +1,79 @@
+#!/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/integrations/integrations.command.ts
+const IntegrationsListOptionsSchema = JsonOptionSchema.extend({
+	kind: z.enum(["oauth", "manual"]).optional(),
+	search: z.string().optional(),
+	connected: z.boolean().optional()
+});
+const INTEGRATIONS_LIST_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	kind: {
+		flag: "--kind <kind>",
+		description: "Filter by connection kind: oauth or manual"
+	},
+	search: {
+		flag: "--search <query>",
+		description: "Case-insensitive substring match against publicId, name, and aliases"
+	},
+	connected: {
+		flag: "--connected",
+		description: "Only show integrations with at least one configured connection in the current org"
+	}
+};
+const IntegrationsRegisterOptionsSchema = JsonOptionSchema.extend({
+	integrationId: z.string().optional(),
+	clientApp: z.string().optional().describe("Internal credential set id holding clientId + clientSecret"),
+	displayName: z.string().optional().describe("Human-readable display name for the workspace integration")
+});
+const INTEGRATIONS_REGISTER_OPTIONS_CONFIG = {
+	...JSON_OPTION_CONFIG,
+	clientApp: {
+		flag: "--client-app <credentialSetId>",
+		description: "Internal credential set id holding clientId + clientSecret (required)"
+	},
+	displayName: {
+		flag: "--display-name <name>",
+		description: "Human-readable display name for the workspace integration"
+	}
+};
+function createIntegrationsCommand() {
+	return createTypedCommand({
+		name: "integrations",
+		description: "List Keystroke integrations available to your organization",
+		schema: IntegrationsListOptionsSchema,
+		optionsConfig: INTEGRATIONS_LIST_OPTIONS_CONFIG,
+		loadHandler: async () => (await import("./list.handler-lq3ZGAn4.mjs")).handleIntegrationsList,
+		subcommands: [createTypedCommand({
+			name: "list",
+			description: "List Keystroke integrations available to your organization",
+			schema: IntegrationsListOptionsSchema,
+			optionsConfig: INTEGRATIONS_LIST_OPTIONS_CONFIG,
+			loadHandler: async () => (await import("./list.handler-lq3ZGAn4.mjs")).handleIntegrationsList
+		}), createTypedCommand({
+			name: "register",
+			description: "Register a workspace provider app for future workspace-authored OAuth support",
+			schema: IntegrationsRegisterOptionsSchema,
+			optionsConfig: INTEGRATIONS_REGISTER_OPTIONS_CONFIG,
+			handler: async (opts, ctx) => {
+				const { handleIntegrationsRegister } = await import("./register.handler-BPCdor1_.mjs");
+				await handleIntegrationsRegister({
+					integrationId: opts.integrationId,
+					clientAppCredentialSetId: opts.clientApp,
+					displayName: opts.displayName,
+					json: opts.json
+				}, ctx);
+			},
+			argument: {
+				name: "integrationId",
+				description: "Workspace integration id to register (e.g., acmeCrm)",
+				key: "integrationId"
+			}
+		})]
+	});
+}
+//#endregion
+export { createIntegrationsCommand };

package/dist/keystroke.d.mts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+export { };