@keystrokehq/cli 0.0.1

package/dist/dist-CUK7yBM0.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+import * as fs$1 from "node:fs/promises";
+import * as os from "node:os";
+import * as path$1 from "node:path";
+import { z } from "zod";
+//#region ../../packages/local-memory/dist/index.mjs
+const KEYSTROKE_CREDENTIALS_DIR = ".keystroke";
+const KEYSTROKE_CREDENTIALS_FILE = "credentials.json";
+const credentialUserSchema = z.object({
+	id: z.string().min(1),
+	email: z.email(),
+	name: z.string().optional()
+});
+const storedCredentialsSchemaV1 = z.object({
+	version: z.literal(1),
+	apiKey: z.string().min(1),
+	apiKeyId: z.uuid().optional(),
+	serverUrl: z.url(),
+	webUrl: z.url(),
+	createdAt: z.string().min(1),
+	organizationId: z.uuid().optional(),
+	organizationName: z.string().optional(),
+	user: credentialUserSchema.optional()
+});
+const orgEntrySchema = z.object({
+	organizationId: z.uuid(),
+	organizationName: z.string().min(1),
+	apiKey: z.string().min(1),
+	apiKeyId: z.uuid().optional(),
+	createdAt: z.string().min(1)
+});
+const storedCredentialsSchema = z.object({
+	version: z.literal(2),
+	serverUrl: z.url(),
+	webUrl: z.url(),
+	user: credentialUserSchema.optional(),
+	activeOrgId: z.uuid().optional(),
+	orgs: z.array(orgEntrySchema)
+});
+function getCredentialsDirPath(homeDir = os.homedir()) {
+	return path$1.join(homeDir, KEYSTROKE_CREDENTIALS_DIR);
+}
+function getCredentialsFilePath(homeDir = os.homedir()) {
+	return path$1.join(getCredentialsDirPath(homeDir), KEYSTROKE_CREDENTIALS_FILE);
+}
+function migrateV1ToV2(v1) {
+	const orgs = [];
+	if (v1.organizationId && v1.apiKey) orgs.push({
+		organizationId: v1.organizationId,
+		organizationName: v1.organizationName ?? "Unknown",
+		apiKey: v1.apiKey,
+		apiKeyId: v1.apiKeyId,
+		createdAt: v1.createdAt
+	});
+	return {
+		version: 2,
+		serverUrl: v1.serverUrl,
+		webUrl: v1.webUrl,
+		user: v1.user,
+		activeOrgId: v1.organizationId,
+		orgs
+	};
+}
+async function readStoredCredentials(filePath = getCredentialsFilePath()) {
+	try {
+		const raw = await fs$1.readFile(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const v2 = storedCredentialsSchema.safeParse(parsed);
+		if (v2.success) return v2.data;
+		const v1 = storedCredentialsSchemaV1.safeParse(parsed);
+		if (v1.success) return migrateV1ToV2(v1.data);
+		throw new Error(`Invalid credentials file: ${filePath}`);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function deleteStoredCredentials(filePath = getCredentialsFilePath()) {
+	try {
+		await fs$1.unlink(filePath);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function writeStoredCredentials(credentials, filePath = getCredentialsFilePath()) {
+	const parsed = storedCredentialsSchema.parse(credentials);
+	await fs$1.mkdir(path$1.dirname(filePath), { recursive: true });
+	await fs$1.writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 384 });
+	try {
+		await fs$1.chmod(filePath, 384);
+	} catch {}
+}
+/**
+* Adds or replaces an org entry in stored credentials. Sets it as the active org.
+* Creates the credentials file if it doesn't exist (requires shared fields).
+*/
+async function upsertOrgCredentials(params, filePath = getCredentialsFilePath()) {
+	const existing = await readStoredCredentials(filePath);
+	if (existing) {
+		const orgs = existing.orgs.filter((o) => o.organizationId !== params.orgEntry.organizationId);
+		orgs.push(params.orgEntry);
+		await writeStoredCredentials({
+			...existing,
+			serverUrl: params.serverUrl,
+			webUrl: params.webUrl,
+			user: params.user ?? existing.user,
+			activeOrgId: params.orgEntry.organizationId,
+			orgs
+		}, filePath);
+	} else await writeStoredCredentials({
+		version: 2,
+		serverUrl: params.serverUrl,
+		webUrl: params.webUrl,
+		user: params.user,
+		activeOrgId: params.orgEntry.organizationId,
+		orgs: [params.orgEntry]
+	}, filePath);
+}
+/**
+* Sets the active org. Validates the org exists in the stored orgs array.
+* @throws Error if no stored credentials or org not found
+*/
+async function setActiveOrg(orgId, filePath = getCredentialsFilePath()) {
+	const existing = await readStoredCredentials(filePath);
+	if (!existing) throw new Error("No stored credentials found. Run `keystroke auth` first.");
+	if (!existing.orgs.find((o) => o.organizationId === orgId)) throw new Error(`No stored API key for organization ${orgId}. Run \`keystroke auth\` to add credentials for this org.`);
+	await writeStoredCredentials({
+		...existing,
+		activeOrgId: orgId
+	}, filePath);
+}
+/**
+* Removes a single org entry from stored credentials.
+* If it was the active org, clears activeOrgId (falls back to first remaining org).
+* Returns the removed entry (for key revocation), or null if not found.
+*/
+async function removeOrgCredentials(orgId, filePath = getCredentialsFilePath()) {
+	const existing = await readStoredCredentials(filePath);
+	if (!existing) return null;
+	const removed = existing.orgs.find((o) => o.organizationId === orgId);
+	if (!removed) return null;
+	const remainingOrgs = existing.orgs.filter((o) => o.organizationId !== orgId);
+	if (remainingOrgs.length === 0) {
+		await deleteStoredCredentials(filePath);
+		return removed;
+	}
+	const newActiveId = existing.activeOrgId === orgId ? remainingOrgs[0]?.organizationId : existing.activeOrgId;
+	await writeStoredCredentials({
+		...existing,
+		orgs: remainingOrgs,
+		activeOrgId: newActiveId
+	}, filePath);
+	return removed;
+}
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function findActiveOrg(creds) {
+	if (!creds.activeOrgId) return creds.orgs[0];
+	return creds.orgs.find((o) => o.organizationId === creds.activeOrgId) ?? creds.orgs[0];
+}
+/**
+* Resolves API auth options using explicit overrides first, then ~/.keystroke credentials.
+* When a logger is provided, it emits consistent fallback/read diagnostics.
+*/
+async function resolveAuthOptions(input) {
+	const credentialsPath = input.credentialsPath ?? getCredentialsFilePath();
+	let storedCredentials = null;
+	try {
+		storedCredentials = await readStoredCredentials(credentialsPath);
+	} catch (error) {
+		input.logger?.warn(`Could not read saved credentials from ${credentialsPath}: ${toErrorMessage(error)}`);
+	}
+	const activeOrg = storedCredentials ? findActiveOrg(storedCredentials) : void 0;
+	const apiKey = input.apiKey ?? activeOrg?.apiKey;
+	const baseUrl = input.baseUrl ?? storedCredentials?.serverUrl;
+	if (!input.apiKey && activeOrg?.apiKey) input.logger?.info(`Using saved API key from ${credentialsPath}`);
+	if (!input.baseUrl && storedCredentials?.serverUrl) input.logger?.info(`Using saved API URL from ${credentialsPath}`);
+	return {
+		apiKey,
+		baseUrl,
+		credentialsPath,
+		storedCredentials,
+		activeOrg
+	};
+}
+const KEYSTROKE_LOGS_DIR = "logs";
+const KEYSTROKE_LOG_FILE = "cli.jsonl";
+function getLogFilePath(homeDir = os.homedir()) {
+	return path$1.join(homeDir, KEYSTROKE_CREDENTIALS_DIR, KEYSTROKE_LOGS_DIR, KEYSTROKE_LOG_FILE);
+}
+/**
+* Reads the last `count` lines from the log file as raw strings.
+* Returns an empty array if the file does not exist.
+*/
+async function readLogFile(count = 100, homeDir = os.homedir()) {
+	const filePath = getLogFilePath(homeDir);
+	let content;
+	try {
+		content = await fs$1.readFile(filePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const lines = content.split("\n");
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines.slice(-count);
+}
+/**
+* Deletes the log file. Returns true if the file existed and was deleted,
+* false if it did not exist.
+*/
+async function clearLogFile(homeDir = os.homedir()) {
+	const filePath = getLogFilePath(homeDir);
+	try {
+		await fs$1.unlink(filePath);
+		return true;
+	} catch (err) {
+		if (err.code === "ENOENT") return false;
+		throw err;
+	}
+}
+const KEYSTROKE_PROJECTS_FILE = "projects.json";
+const projectEntrySchema = z.object({
+	lastAccessed: z.string().min(1),
+	name: z.string().min(1).optional()
+});
+const storedProjectsSchema = z.object({
+	version: z.literal(1),
+	projects: z.record(z.string(), projectEntrySchema),
+	lastProject: z.string().optional()
+});
+function getProjectsFilePath(homeDir = os.homedir()) {
+	return path$1.join(homeDir, KEYSTROKE_CREDENTIALS_DIR, KEYSTROKE_PROJECTS_FILE);
+}
+async function readStoredProjects(filePath = getProjectsFilePath()) {
+	try {
+		const raw = await fs$1.readFile(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const result = storedProjectsSchema.safeParse(parsed);
+		if (!result.success) return null;
+		return result.data;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		if (error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+async function writeStoredProjects(projects, filePath = getProjectsFilePath()) {
+	const parsed = storedProjectsSchema.parse(projects);
+	await fs$1.mkdir(path$1.dirname(filePath), { recursive: true });
+	await fs$1.writeFile(filePath, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+/**
+* Upsert a project entry. Fire-and-forget safe — catches all errors internally.
+* Never throws. Call without `await` if you don't need to wait.
+*/
+async function trackProject(projectPath, options) {
+	const filePath = options?.filePath ?? getProjectsFilePath();
+	const absolutePath = path$1.resolve(projectPath);
+	try {
+		const data = await readStoredProjects(filePath) ?? {
+			version: 1,
+			projects: {}
+		};
+		const previousEntry = data.projects[absolutePath];
+		const entry = {
+			lastAccessed: (/* @__PURE__ */ new Date()).toISOString(),
+			...options?.name ? { name: options.name } : previousEntry?.name ? { name: previousEntry.name } : {}
+		};
+		data.projects[absolutePath] = entry;
+		data.lastProject = absolutePath;
+		await writeStoredProjects(data, filePath);
+	} catch {}
+}
+/**
+* Clears the stored projects file (projects.json). Returns true if the file
+* existed and was deleted, false if it did not exist.
+*/
+async function clearStoredProjects(filePath = getProjectsFilePath()) {
+	try {
+		await fs$1.unlink(filePath);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+/** Base directory name for all Keystroke local storage (user and project-local). */
+const KEYSTROKE_DIR = KEYSTROKE_CREDENTIALS_DIR;
+/**
+* Returns the Keystroke temp directory path.
+*
+* - `getKeystrokeTmpDir({ projectRoot })` → `projectRoot/.keystroke/tmp` — for build
+*   artifacts that require module resolution from the project (workflow-builder).
+* - `getKeystrokeTmpDir()` → `~/.keystroke/tmp` — for general temporary storage.
+*
+* Callers must create the directory (e.g. `mkdir(path, { recursive: true })`)
+* before use.
+*/
+function getKeystrokeTmpDir(options) {
+	const baseDir = options?.projectRoot ? path$1.resolve(options.projectRoot) : os.homedir();
+	return path$1.join(baseDir, KEYSTROKE_DIR, "tmp");
+}
+//#endregion
+export { getKeystrokeTmpDir as a, removeOrgCredentials as c, trackProject as d, upsertOrgCredentials as f, getCredentialsFilePath as i, resolveAuthOptions as l, clearStoredProjects as n, readLogFile as o, deleteStoredCredentials as r, readStoredProjects as s, clearLogFile as t, setActiveOrg as u };

package/dist/env-91KwMKov.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { config } from "dotenv";
+//#region ../../packages/env-utils/dist/index.mjs
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function findMonorepoRoot() {
+	let currentDir = __dirname;
+	while (currentDir !== "/") {
+		const turboPath = path.join(currentDir, "turbo.json");
+		const pnpmWorkspacePath = path.join(currentDir, "pnpm-workspace.yaml");
+		if (existsSync(turboPath) && existsSync(pnpmWorkspacePath)) return currentDir;
+		currentDir = path.dirname(currentDir);
+	}
+	throw new Error("Could not find monorepo root (turbo.json + pnpm-workspace.yaml)");
+}
+function ensureRootEnvFile(rootEnvPath) {
+	try {
+		writeFileSync(rootEnvPath, "# Temporary root env file generated by @keystroke/env-utils\n", { flag: "wx" });
+	} catch (error) {
+		const fsError = error;
+		if (fsError.code === "EEXIST") return;
+		throw new Error(`Could not create temporary root env file at ${rootEnvPath}: ${fsError.message ?? "unknown error"}`);
+	}
+}
+function resolveEnvPath(options = {}) {
+	const fallbackToDefault = options.fallbackToDefault ?? true;
+	if (options.absolutePath) {
+		if (existsSync(options.absolutePath)) return options.absolutePath;
+		if (!fallbackToDefault) throw new Error(`Could not find env file at explicit path: ${options.absolutePath}`);
+	}
+	const fileName = options.fileName ?? ".env";
+	let rootDir = null;
+	try {
+		rootDir = findMonorepoRoot();
+	} catch {}
+	if (rootDir) {
+		const rootEnvPath = path.join(rootDir, fileName);
+		if (existsSync(rootEnvPath)) return rootEnvPath;
+		if (fileName === ".env") {
+			ensureRootEnvFile(rootEnvPath);
+			return rootEnvPath;
+		}
+	}
+	if (!fallbackToDefault) throw new Error(`Could not find env file in monorepo root: ${fileName}`);
+	return path.join(process.cwd(), fileName);
+}
+/**
+* Load environment variables from a file in the monorepo root.
+*
+* This function finds the monorepo root by looking for turbo.json and pnpm-workspace.yaml,
+* then loads the requested env file from that location. For the default `.env`, this utility
+* creates a temporary root `.env` file if one does not exist. Other file names can fall back
+* to the current working directory when allowed.
+*
+* All dotenv logs are suppressed to keep output clean.
+*
+* @example
+* ```ts
+* import { loadRootEnv } from '@keystroke/env-utils';
+*
+* // Load env vars before accessing process.env
+* loadRootEnv();
+*
+* // Explicit integration env file (use `fallbackToDefault: false` only when a missing file must hard-fail):
+* loadRootEnv({ fileName: '.env.test', fallbackToDefault: true });
+* ```
+*/
+function loadRootEnv(options) {
+	config({
+		path: resolveEnvPath(options),
+		quiet: true,
+		debug: false
+	});
+}
+const EnvironmentSchema = z.enum([
+	"development",
+	"staging",
+	"production"
+]);
+z.enum([
+	"development",
+	"production",
+	"test"
+]);
+z.enum([
+	"cli",
+	"server",
+	"worker"
+]);
+z.enum([
+	"development",
+	"test",
+	"staging",
+	"production"
+]);
+//#endregion
+//#region src/lib/env.ts
+loadRootEnv();
+const cliEnvSchema = z.object({
+	WEB_URL: z.url().optional(),
+	SERVER_URL: z.url().optional(),
+	KEYSTROKE_API_KEY: z.string().min(1).optional(),
+	KEYSTROKE_ORG_ID: z.string().min(1).optional(),
+	ENVIRONMENT: EnvironmentSchema.optional().default("production")
+});
+let cachedEnv;
+/**
+* Returns the process environment for credential resolution.
+* Used by credentials upload and other features that need KEYSTROKE_* vars.
+*/
+function getProcessEnv() {
+	return process.env;
+}
+function getEnv() {
+	if (cachedEnv) return cachedEnv;
+	cachedEnv = cliEnvSchema.parse(process.env);
+	return cachedEnv;
+}
+function resolveCliWebUrl(override) {
+	if (override) return override;
+	const env = getEnv();
+	if (!env.WEB_URL) throw new Error("WEB_URL is required (set WEB_URL env or pass --web-url)");
+	return env.WEB_URL;
+}
+function isLocalMode() {
+	return getEnv().ENVIRONMENT === "development";
+}
+function resolveCliServerUrl(override) {
+	if (override) return override;
+	const env = getEnv();
+	if (!env.SERVER_URL) throw new Error("SERVER_URL is required (set SERVER_URL env or pass --server-url)");
+	return env.SERVER_URL;
+}
+//#endregion
+export { resolveCliWebUrl as a, resolveCliServerUrl as i, getProcessEnv as n, isLocalMode as r, getEnv as t };