@project-ajax/sdk 0.0.28

package/src/cli/commands/auth.impl.ts

@@ -0,0 +1,92 @@
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { baseUrl } from "../api/client.js";
+import type { Environment } from "../config.js";
+import { buildHandler, type HandlerContext } from "../handler.js";
+
+interface LoginFlags {
+	env?: Environment;
+	"base-url"?: string;
+}
+
+/**
+ * Open a URL in the user's default browser or Notion app (if app available)
+ */
+async function openUrl(env: Environment, url: string): Promise<void> {
+	const platform = process.platform;
+
+	try {
+		if (platform === "darwin") {
+			// Check if we should try to open Notion app on macOS
+			let notionAppName: string | null = null;
+
+			if (env === "prod" && existsSync("/Applications/Notion.app")) {
+				notionAppName = "Notion";
+			} else if (env === "dev" && existsSync("/Applications/Notion Dev.app")) {
+				notionAppName = "Notion Dev";
+			}
+
+			if (notionAppName) {
+				// Open the app first, then the URL (which will open in the app)
+				exec(`open -a "${notionAppName}" "${url}"`);
+			} else {
+				// Fall back to opening in default browser
+				exec(`open "${url}"`);
+			}
+		} else if (platform === "win32") {
+			exec(`start "" "${url}"`);
+		} else {
+			// Linux and other Unix-like systems
+			exec(`xdg-open "${url}"`);
+		}
+	} catch (error) {
+		throw new Error(`Failed to open browser: ${error}`);
+	}
+}
+
+export const login = buildHandler(async function (
+	this: HandlerContext,
+	flags: LoginFlags,
+	token?: string,
+) {
+	const environment = flags.env ?? "prod";
+
+	if (flags["base-url"]) {
+		await this.config.setBaseUrl(flags["base-url"]);
+	}
+
+	// If no token provided, open the browser to get one
+	if (!token) {
+		const url = `${baseUrl({
+			environment,
+			override: this.config.baseUrl,
+		})}/__workers__?createToken=true`;
+
+		this.writer.writeErr(`Opening browser to create a token...\n${url}\n`);
+		this.writer.writeErr("After creating a token, run:");
+		this.writer.writeErr("\tnpx workers auth login <token>");
+
+		try {
+			await openUrl(environment, url);
+		} catch (_error) {
+			this.writer.writeErr(
+				`Failed to open browser automatically. Please visit:\n  ${url}`,
+			);
+		}
+
+		return;
+	}
+
+	await this.config.setEnvironment(environment);
+	await this.config.setToken(token);
+
+	this.writer.writeErr("Successfully logged in!");
+});
+
+export const show = buildHandler(function (this: HandlerContext) {
+	this.writer.writeOut(`${this.config.token ?? ""}`);
+});
+
+export const logout = buildHandler(async function (this: HandlerContext) {
+	await this.config.setToken(null);
+});

package/src/cli/commands/auth.ts

@@ -0,0 +1,77 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { Environments } from "../config.js";
+import { globalFlags } from "../flags.js";
+
+export const authCommands = buildRouteMap({
+	docs: {
+		brief: "Commands for managing the CLI context",
+	},
+	routes: {
+		login: buildCommand({
+			docs: {
+				brief: "Login to the Project Ajax platform using a Workers API token",
+			},
+
+			parameters: {
+				positional: {
+					kind: "tuple",
+					parameters: [
+						{
+							brief: "A Workers API token",
+							parse: String,
+							placeholder: "api-token",
+							optional: true,
+						},
+					],
+				},
+
+				flags: {
+					env: {
+						kind: "enum",
+						values: Environments,
+						brief: "The environment to use for the command",
+						optional: true,
+						hidden: true,
+					},
+					"base-url": {
+						kind: "parsed",
+						parse: String,
+						brief: "The base URL to use for all API requests",
+						optional: true,
+						hidden: true,
+					},
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./auth.impl.js").then((m) => m.login),
+		}),
+
+		show: buildCommand({
+			docs: {
+				brief: "Get the token for the CLI",
+			},
+			parameters: {
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./auth.impl.js").then((m) => m.show),
+		}),
+
+		logout: buildCommand({
+			docs: {
+				brief: "Unset the token for the CLI",
+			},
+
+			parameters: {
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./auth.impl.js").then((m) => m.logout),
+		}),
+	},
+});

package/src/cli/commands/bundle.impl.ts

@@ -0,0 +1,21 @@
+import { Readable } from "node:stream";
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+
+export const downloadBundle = buildAuthedHandler(async function () {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	const result = await this.apiClient.downloadWorkerBundle(workerId);
+	if (Result.isFail(result)) {
+		this.writer.writeErr(`✗ Failed to download bundle`);
+		this.writer.writeErr(`✗ ${result.error.message}`);
+		return;
+	}
+
+	Readable.fromWeb(result.value).pipe(this.process.stdout);
+});

package/src/cli/commands/bundle.ts

@@ -0,0 +1,23 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+
+export const bundleCommands = buildRouteMap({
+	docs: {
+		brief: "Commands for managing worker bundles",
+	},
+	routes: {
+		download: buildCommand({
+			docs: {
+				brief: "Download the bundle for the worker",
+			},
+
+			parameters: {
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./bundle.impl.js").then((m) => m.downloadBundle),
+		}),
+	},
+});

package/src/cli/commands/capabilities.impl.ts

@@ -0,0 +1,47 @@
+import { Result } from "../api/result.js";
+import type { FormatFlags } from "../flags.js";
+import { buildAuthedHandler } from "../handler.js";
+
+export const listCapabilities = buildAuthedHandler(async function (
+	flags: FormatFlags,
+) {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	this.process.stderr.write(`Fetching capabilities...`);
+
+	const result = await this.apiClient.listCapabilities(workerId);
+
+	if (Result.isSuccess(result)) {
+		this.process.stderr.write("OK\n\n");
+
+		const data = Result.unwrap(result);
+		if (data.capabilities.length === 0) {
+			this.writer.writeErr("No capabilities found for this worker.");
+		} else {
+			this.writer.writeTableOut({
+				headers: ["Key", "Tag"],
+				rows: data.capabilities.map((capability) => [
+					capability.key,
+					capability._tag,
+				]),
+				plain: flags.plain,
+			});
+		}
+	} else {
+		this.process.stderr.write("ERROR\n\n");
+
+		// If it's a validation error, show the clean debug message
+		if (result.error.validationError) {
+			this.writer.writeErr(`✗ ${result.error.validationError.debugMessage}`);
+			throw new Error(result.error.validationError.debugMessage);
+		} else {
+			this.writer.writeErr(`✗ ${result.error.message}`);
+			throw new Error(result.error.message);
+		}
+	}
+});

package/src/cli/commands/capabilities.ts

@@ -0,0 +1,25 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+
+export const capabilitiesCommands = buildRouteMap({
+	docs: {
+		brief: "Commands for managing worker capabilities",
+	},
+	routes: {
+		list: buildCommand({
+			docs: {
+				brief: "List all capabilities for a worker",
+			},
+
+			parameters: {
+				flags: {
+					...globalFlags,
+					...formatFlags,
+				},
+			},
+
+			loader: () =>
+				import("./capabilities.impl.js").then((m) => m.listCapabilities),
+		}),
+	},
+});

package/src/cli/commands/deploy.impl.ts

@@ -0,0 +1,34 @@
+import { Result } from "../api/result.js";
+import { deployWorker } from "../deploy.js";
+import { buildAuthedHandler } from "../handler.js";
+
+export const deploy = buildAuthedHandler(async function () {
+	const { token } = this.config.tokenInfo;
+	const workerId = this.config.workerId;
+
+	const environment = this.config.environment;
+	if (!environment) {
+		// Unexpected to get here when token is set
+		throw new Error("Unexpected error: Environment not set");
+	}
+	const workerPath = this.process.cwd();
+
+	this.writer.writeErr("Deploying worker...");
+
+	const result = await deployWorker(this, {
+		workerPath,
+		workerId,
+		token,
+		environment,
+	});
+
+	if (Result.isSuccess(result)) {
+		const { workerId } = Result.unwrap(result);
+		await this.config.setWorkerId(workerId);
+		this.writer.writeErr("✓ Successfully deployed worker");
+	} else {
+		this.writer.writeErr("✗ Failed to deploy worker");
+		this.writer.writeErr(result.error.message);
+		return;
+	}
+});

package/src/cli/commands/deploy.ts

@@ -0,0 +1,16 @@
+import { buildCommand } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+
+export default buildCommand({
+	docs: {
+		brief: "Deploy a worker to the Project Ajax platform",
+	},
+
+	parameters: {
+		flags: {
+			...globalFlags,
+		},
+	},
+
+	loader: () => import("./deploy.impl.js").then((m) => m.deploy),
+});

package/src/cli/commands/exec.impl.ts

@@ -0,0 +1,169 @@
+import { Result } from "../api/result.js";
+import type { GlobalFlags } from "../flags.js";
+import { buildAuthedHandler } from "../handler.js";
+import { chunkEvery } from "../utils/array.js";
+
+const usageHint = `Usage: workers exec <capabilityName> <capabilityFunction> [<argName1>=<value1> <argName2>=<value2>...]`;
+
+interface ExecFlags extends GlobalFlags {
+	stream: boolean;
+}
+
+export const exec = buildAuthedHandler(async function (
+	flags: ExecFlags,
+	...args: readonly string[]
+) {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	const capabilityName = args[0];
+	const capabilityFunction = args[1] ?? null;
+	const functionArgs = args.slice(2).flatMap((arg) => arg.split(/[=]/));
+
+	if (!capabilityName) {
+		throw usageError();
+	}
+
+	// If there's an odd number of remaining args, the first one is the function name
+	if (functionArgs.length % 2 !== 0) {
+		throw usageError();
+	}
+
+	const argsList = chunkEvery(functionArgs, 2).map(([key, value]) => {
+		if (!key || !value) {
+			throw usageError();
+		}
+		return {
+			name: key,
+			value,
+		};
+	});
+
+	// Execute the capability
+	this.writer.writeErr(`Executing capability "${capabilityName}"...`);
+
+	if (flags.stream) {
+		const result = await this.apiClient.runCapability(
+			workerId,
+			capabilityName,
+			capabilityFunction,
+			argsList,
+			true,
+		);
+
+		if (Result.isSuccess(result)) {
+			const decoder = new TextDecoder();
+			let buffer = "";
+
+			const allOutput: string[] = [];
+
+			const onBodyLine = async (jsonLine: string) => {
+				try {
+					const parsedLine = JSON.parse(jsonLine) as
+						| {
+								_tag: "log";
+								event: {
+									stream: "stdout" | "stderr";
+									data: string;
+								};
+						  }
+						| {
+								_tag: "result";
+								result: unknown;
+						  }
+						| {
+								_tag: "error";
+								error: string;
+						  };
+
+					switch (parsedLine._tag) {
+						case "log":
+							if (parsedLine.event.stream === "stdout") {
+								allOutput.push(parsedLine.event.data);
+							}
+
+							parsedLine.event.data
+								.trim()
+								.split("\n")
+								.forEach((dataLine) => {
+									this.writer.writeErr(
+										`[worker:${parsedLine.event.stream}] ${dataLine.trim()}`,
+									);
+								});
+
+							break;
+						case "result":
+							this.writer.writeOut(JSON.stringify(parsedLine.result, null, 2));
+							break;
+						case "error":
+							this.writer.writeErr(`Error: ${parsedLine.error}`);
+							break;
+					}
+				} catch (error) {
+					this.writer.writeErr(`Error parsing log line: ${jsonLine}: ${error}`);
+				}
+			};
+
+			for await (const log of result.value) {
+				const output = decoder.decode(log);
+				buffer += output;
+
+				const lines = buffer.split("\n");
+				// Keep the last element as buffer (might be empty or incomplete line)
+				buffer = lines.pop() ?? "";
+
+				// Process all complete lines
+				for (const line of lines) {
+					await onBodyLine(line);
+				}
+			}
+
+			// Process any remaining content in buffer
+			if (buffer) {
+				await onBodyLine(buffer);
+			}
+			return;
+		} else {
+			this.writer.writeErr(`\n✗ Failed to execute capability`);
+
+			// If it's a validation error, show the clean debug message
+			if (result.error.validationError) {
+				this.writer.writeErr(`\t✗ HTTP Error: ${result.error.status}`);
+				this.writer.writeErr(
+					`\t✗ ${result.error.validationError.debugMessage}`,
+				);
+				this.writer.writeErr(`\n${usageHint}`);
+				throw new Error(result.error.validationError.debugMessage);
+			} else {
+				this.writer.writeErr(`\t✗ HTTP Error: ${result.error.status}`);
+				this.writer.writeErr(`\t✗ ${result.error.message}`);
+				throw new Error(result.error.message);
+			}
+		}
+	} else {
+		const result = await this.apiClient.runCapability(
+			workerId,
+			capabilityName,
+			capabilityFunction,
+			argsList,
+			false,
+		);
+
+		if (Result.isSuccess(result)) {
+			const data = Result.unwrap(result);
+			this.writer.writeOut(JSON.stringify(data.result, null, 2));
+		} else {
+			this.writer.writeErr(`\n✗ Failed to execute capability`);
+			this.writer.writeErr(`\t✗ ${result.error.message}`);
+			throw new Error(result.error.message);
+		}
+	}
+});
+
+function usageError() {
+	return new Error(`Invalid arguments provided. ${usageHint}`);
+}

package/src/cli/commands/exec.ts

@@ -0,0 +1,32 @@
+import { buildCommand } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+
+export default buildCommand({
+	docs: {
+		brief: "Execute a worker capability with optional function and arguments",
+	},
+
+	parameters: {
+		positional: {
+			kind: "array",
+			parameter: {
+				brief:
+					"Capability name, optional function name, and arguments (key value pairs)",
+				parse: String,
+				placeholder: "capabilityName [functionName] [key value]...",
+			},
+			minimum: 1,
+		},
+
+		flags: {
+			...globalFlags,
+			stream: {
+				kind: "boolean",
+				brief: "Stream the output of the capability",
+				default: true,
+			},
+		},
+	},
+
+	loader: () => import("./exec.impl.js").then((m) => m.exec),
+});

package/src/cli/commands/runs.impl.ts

@@ -0,0 +1,87 @@
+import { Result } from "../api/result.js";
+import type { FormatFlags, GlobalFlags } from "../flags.js";
+import { buildAuthedHandler } from "../handler.js";
+
+export const listRuns = buildAuthedHandler(async function (flags: FormatFlags) {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	this.process.stderr.write("Fetching runs...");
+
+	const result = await this.apiClient.listRunsForWorker(workerId);
+
+	if (Result.isSuccess(result)) {
+		this.process.stderr.write("OK\n\n");
+
+		const data = Result.unwrap(result);
+		if (data.runs.length === 0) {
+			this.writer.writeErr("No runs found for this worker.");
+		} else {
+			this.writer.writeTableOut({
+				headers: ["Run ID", "Name", "Started At", "Ended At", "Exit Code"],
+				rows: data.runs.map((run) => [
+					run.runId,
+					run.name,
+					run.startedAt,
+					run.endedAt,
+					run.exitCode,
+				]),
+				plain: flags.plain,
+			});
+		}
+	} else {
+		this.process.stderr.write("ERROR\n\n");
+
+		// If it's a validation error, show the clean debug message
+		if (result.error.validationError) {
+			this.writer.writeErr(`✗ ${result.error.validationError.debugMessage}`);
+			throw new Error(result.error.validationError.debugMessage);
+		} else {
+			this.writer.writeErr(`✗ ${result.error.message}`);
+			throw new Error(result.error.message);
+		}
+	}
+});
+
+export const getRunLogs = buildAuthedHandler(async function (
+	_flags: GlobalFlags,
+	runId: string,
+) {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	if (!runId) {
+		throw new Error("Run ID is required");
+	}
+
+	this.process.stderr.write(`Fetching logs for run ${runId}...`);
+
+	const result = await this.apiClient.getRunLogs(workerId, runId);
+
+	if (Result.isSuccess(result)) {
+		this.process.stderr.write("OK\n\n");
+
+		const data = Result.unwrap(result);
+		// Output logs directly to stdout (primary output)
+		this.writer.writeOut(data.logs);
+	} else {
+		this.process.stderr.write("ERROR\n\n");
+
+		// If it's a validation error, show the clean debug message
+		if (result.error.validationError) {
+			this.writer.writeErr(`✗ ${result.error.validationError.debugMessage}`);
+			throw new Error(result.error.validationError.debugMessage);
+		} else {
+			this.writer.writeErr(`✗ ${result.error.message}`);
+			throw new Error(result.error.message);
+		}
+	}
+});

package/src/cli/commands/runs.ts

@@ -0,0 +1,49 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+
+export const runsCommands = buildRouteMap({
+	docs: {
+		brief: "Commands for managing worker runs",
+	},
+	routes: {
+		list: buildCommand({
+			docs: {
+				brief: "List all runs for a worker",
+			},
+
+			parameters: {
+				flags: {
+					...globalFlags,
+					...formatFlags,
+				},
+			},
+
+			loader: () => import("./runs.impl.js").then((m) => m.listRuns),
+		}),
+
+		logs: buildCommand({
+			docs: {
+				brief: "Get logs for a specific run",
+			},
+
+			parameters: {
+				positional: {
+					kind: "tuple",
+					parameters: [
+						{
+							brief: "The run ID to get logs for",
+							parse: String,
+							placeholder: "runId",
+						},
+					],
+				},
+
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./runs.impl.js").then((m) => m.getRunLogs),
+		}),
+	},
+});