@project-ajax/sdk 0.0.28

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

@@ -0,0 +1,124 @@
+import { Result } from "../api/result.js";
+import type { FormatFlags, GlobalFlags } from "../flags.js";
+import { buildAuthedHandler } from "../handler.js";
+import { chunkEvery } from "../utils/array.js";
+import { pluralize } from "../utils/string.js";
+
+export const setSecrets = buildAuthedHandler(async function (
+	_flags: GlobalFlags,
+	...args: string[]
+) {
+	const secrets = parseSecretArgs(args);
+	const { workerId } = this.config;
+
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	this.writer.writeErr(`Setting ${pluralize(secrets.length, "secret")}...`);
+
+	const result = await this.apiClient.upsertSecrets(workerId, secrets);
+
+	if (Result.isSuccess(result)) {
+		for (const secret of Result.unwrap(result).secrets) {
+			this.writer.writeErr(`Set secret "${secret.key}"`);
+		}
+	} else {
+		this.writer.writeErr(`✗ Failed to set secrets`);
+		this.writer.writeErr(`✗ ${result.error.message}`);
+		throw new Error(result.error.message);
+	}
+});
+
+export const listSecrets = 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 secrets...`);
+
+	const result = await this.apiClient.listSecrets(workerId);
+
+	if (Result.isSuccess(result)) {
+		this.process.stderr.write("OK\n\n");
+
+		const data = Result.unwrap(result);
+		if (data.secrets.length === 0) {
+			this.writer.writeErr("No secrets for this worker.");
+		} else {
+			this.writer.writeTableOut({
+				headers: ["Key", "Created At"],
+				rows: data.secrets.map((secret) => [secret.key, secret.createdAt]),
+				plain: flags.plain,
+			});
+		}
+	} else {
+		this.process.stderr.write("ERROR\n\n");
+
+		this.writer.writeErr(`✗ Failed to list secrets`);
+		this.writer.writeErr(`✗ ${result.error.message}`);
+		throw new Error(result.error.message);
+	}
+});
+
+export const removeSecret = buildAuthedHandler(async function (
+	_flags: GlobalFlags,
+	key: string,
+) {
+	const { workerId } = this.config;
+	if (!workerId) {
+		throw new Error(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+	}
+
+	this.process.stderr.write(`Removing secret "${key}"...`);
+
+	const result = await this.apiClient.deleteSecret(workerId, key);
+
+	if (Result.isSuccess(result)) {
+		this.process.stderr.write("OK\n\n");
+	} else {
+		this.process.stderr.write("ERROR\n\n");
+
+		this.writer.writeErr(`✗ Failed to remove secret "${key}"`);
+		this.writer.writeErr(`✗ ${result.error.message}`);
+		throw new Error(result.error.message);
+	}
+});
+
+function usageError() {
+	return new Error(
+		"Invalid secrets provided. Usage: workers secrets set <key> <value> [<key2> <value2>...] or <key>=<value> [<key2>=<value2>...]",
+	);
+}
+
+/**
+ * Parse secret arguments from CLI, supporting "key value", "key=value", and "key:value" formats.
+ */
+function parseSecretArgs(
+	args: readonly string[],
+): Array<{ key: string; value: string }> {
+	if (args.length === 0) {
+		throw usageError();
+	}
+
+	// Split each arg by = or : to flatten everything into tokens
+	const tokens = args.flatMap((arg) => arg.split(/[=:]/));
+
+	const secrets = chunkEvery(tokens, 2).map(([key, value]) => {
+		if (!key || !value) {
+			throw usageError();
+		}
+
+		return { key, value };
+	});
+	return secrets;
+}

package/src/cli/commands/secrets.ts

@@ -0,0 +1,73 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+
+export const secretsCommands = buildRouteMap({
+	docs: {
+		brief: "Commands for managing worker secrets",
+	},
+	routes: {
+		set: buildCommand({
+			docs: {
+				brief:
+					"Set one or more secrets for a worker. Supports 'key value' or 'key=value' format.",
+			},
+
+			parameters: {
+				positional: {
+					kind: "array",
+					parameter: {
+						brief: "Secret key-value pairs (key value or key=value)",
+						parse: String,
+						placeholder: "secrets...",
+					},
+				},
+
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./secrets.impl.js").then((m) => m.setSecrets),
+		}),
+
+		list: buildCommand({
+			docs: {
+				brief: "List all secrets for a worker (keys only)",
+			},
+
+			parameters: {
+				flags: {
+					...globalFlags,
+					...formatFlags,
+				},
+			},
+
+			loader: () => import("./secrets.impl.js").then((m) => m.listSecrets),
+		}),
+
+		rm: buildCommand({
+			docs: {
+				brief: "Remove a secret from a worker",
+			},
+
+			parameters: {
+				positional: {
+					kind: "tuple",
+					parameters: [
+						{
+							brief: "The secret key name to remove",
+							parse: String,
+							placeholder: "key",
+						},
+					],
+				},
+
+				flags: {
+					...globalFlags,
+				},
+			},
+
+			loader: () => import("./secrets.impl.js").then((m) => m.removeSecret),
+		}),
+	},
+});

package/src/cli/config.ts

@@ -0,0 +1,175 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export const Environments = ["local", "staging", "dev", "prod"] as const;
+export type Environment = (typeof Environments)[number];
+
+interface ConfigFile {
+	environment?: Environment;
+	baseUrl?: string;
+	token: string | null;
+	workerId: string | null;
+}
+
+export function parseEnvironment(name: string): Environment {
+	if (["local", "staging", "dev", "prod"].includes(name)) {
+		return name as Environment;
+	}
+
+	throw new Error(`Invalid environment name: ${name}`);
+}
+
+export class TokenNotSetError extends Error {
+	constructor(
+		message: string = "Not authenticated. Run 'workers auth login' first.",
+	) {
+		super(message);
+		this.name = "TokenNotSetError";
+	}
+}
+
+export function parseEnvironmentName(name: string): Environment {
+	if (["local", "staging", "dev", "prod"].includes(name)) {
+		return name as Environment;
+	}
+
+	throw new Error(`Invalid environment name: ${name}`);
+}
+
+export class Config {
+	readonly #configFile: ConfigFile;
+	readonly #configFilePath: string;
+
+	constructor(configFilePath: string, configFile: ConfigFile) {
+		this.#configFilePath = configFilePath;
+		this.#configFile = configFile;
+	}
+
+	async setEnvironment(environment: Environment) {
+		this.#configFile.environment = environment;
+		await this.#writeConfigFile();
+	}
+
+	async setBaseUrl(baseUrl: string) {
+		this.#configFile.baseUrl = baseUrl;
+		await this.#writeConfigFile();
+	}
+
+	get baseUrl() {
+		return this.#configFile.baseUrl;
+	}
+
+	get token() {
+		return this.#configFile.token;
+	}
+
+	get tokenInfo(): { token: string; spaceId: string; cellId: string } {
+		const token = this.#configFile.token;
+		if (!token) {
+			throw new TokenNotSetError();
+		}
+
+		const { spaceId, cellId } = extractPayloadFromToken(token);
+		return { token, spaceId, cellId };
+	}
+
+	get environment() {
+		return this.#configFile.environment;
+	}
+
+	get workerId() {
+		return this.#configFile.workerId;
+	}
+
+	async setToken(token: string | null) {
+		this.#configFile.token = token;
+		await this.#writeConfigFile();
+	}
+
+	async setWorkerId(workerId: string | null) {
+		this.#configFile.workerId = workerId;
+		await this.#writeConfigFile();
+	}
+
+	async #writeConfigFile() {
+		await fs.promises.writeFile(
+			this.#configFilePath,
+			JSON.stringify(this.#configFile, null, 2),
+			"utf-8",
+		);
+	}
+
+	static async load(configFilePath: string) {
+		const absConfigFilePath = path.resolve(process.cwd(), configFilePath);
+		const configFile = await Config.#readConfigFile(absConfigFilePath);
+		return new Config(absConfigFilePath, configFile);
+	}
+
+	static async #readConfigFile(configFilePath: string) {
+		let configFile: ConfigFile;
+		try {
+			const configContents = await fs.promises.readFile(
+				configFilePath,
+				"utf-8",
+			);
+
+			configFile = JSON.parse(configContents) as ConfigFile;
+		} catch (error) {
+			if (isENOENT(error)) {
+				configFile = { token: null, workerId: null };
+			} else {
+				throw error;
+			}
+		}
+
+		return configFile;
+	}
+}
+
+function isENOENT(
+	error: unknown,
+): error is NodeJS.ErrnoException & { code: "ENOENT" } {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+export function extractPayloadFromToken(token: string): {
+	spaceId: string;
+	userId: string;
+	cellId: string;
+} {
+	try {
+		// Token format: <version>.<type>.<encoded-payload-json>.<encoded-signature>
+		const parts = token.split(".");
+		if (parts.length !== 4 || !parts[2]) {
+			throw new Error("Invalid token format.");
+		}
+
+		// Decode the payload (third part)
+		const payloadBase64 = parts[2];
+		const payloadJson = Buffer.from(payloadBase64, "base64url").toString(
+			"utf-8",
+		);
+		const payload = JSON.parse(payloadJson) as {
+			spaceId?: string;
+			userId?: string;
+			cellId?: string;
+		};
+
+		if (!payload.spaceId || !payload.userId || !payload.cellId) {
+			throw new Error(
+				"Token payload missing required fields (spaceId, userId, cellId).",
+			);
+		}
+
+		return {
+			spaceId: payload.spaceId,
+			userId: payload.userId,
+			cellId: payload.cellId,
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("Token")) {
+			throw error;
+		}
+		throw new Error("Failed to parse token payload.");
+	}
+}

package/src/cli/context.ts

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { StricliAutoCompleteContext } from "@stricli/auto-complete";
+import type { CommandContext } from "@stricli/core";
+import { Writer } from "./writer.js";
+
+export interface LocalContext
+	extends CommandContext,
+		StricliAutoCompleteContext {
+	readonly fs: typeof fs;
+	readonly os: typeof os;
+	readonly path: typeof path;
+	readonly process: NodeJS.Process;
+	readonly writer: Writer;
+}
+
+export function buildContext(process: NodeJS.Process): LocalContext {
+	return {
+		fs,
+		os,
+		path,
+		process,
+		writer: new Writer({ debugEnabled: false }),
+	};
+}

package/src/cli/deploy.ts

@@ -0,0 +1,175 @@
+// AI-Generated: Significantly generated by model: Claude Sonnet 4.5; agent: AI Agents.
+
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as esbuild from "esbuild";
+import type { ApiError, Environment } from "./api/client.js";
+import { Result } from "./api/result.js";
+import type { LocalContext } from "./context.js";
+import type { AuthedContext } from "./handler.js";
+
+export interface DeployOptions {
+	/**
+	 * Path to the worker directory to deploy
+	 */
+	workerPath: string;
+
+	/**
+	 * API token for authentication
+	 */
+	token: string;
+
+	/**
+	 * Environment to deploy to
+	 */
+	environment: Environment;
+
+	workerId?: string | null;
+}
+
+/**
+ * Deploy a worker to the specified environment
+ */
+export async function deployWorker(
+	context: AuthedContext,
+	options: DeployOptions,
+): Promise<Result<{ workerId: string }, ApiError>> {
+	const { workerPath, workerId: workerIdForUpdate } = options;
+
+	// Resolve absolute path
+	const absPath = path.resolve(process.cwd(), workerPath);
+	context.writer.debug(`Deploying worker from: ${absPath}`);
+
+	// Create API client
+	const client = context.apiClient;
+
+	let uploadUrl: string;
+	let uploadFields: Record<string, string>;
+	let workerId: string;
+
+	context.writer.writeErr(
+		workerIdForUpdate ? `Updating worker...` : `Creating worker...`,
+	);
+
+	if (workerIdForUpdate) {
+		workerId = workerIdForUpdate;
+		const updateResult = await client.updateWorkerBundle(workerIdForUpdate);
+		if (Result.isSuccess(updateResult)) {
+			const res = Result.unwrap(updateResult);
+			uploadUrl = res.url;
+			uploadFields = res.fields;
+		} else {
+			context.writer.writeErr(
+				"Failed to generate pre-signed upload URL for worker bundle:",
+			);
+			throw new Error(updateResult.error.message);
+		}
+	} else {
+		const createResult = await client.createWorker("tmp-give-me-a-good-name");
+		if (Result.isSuccess(createResult)) {
+			const res = Result.unwrap(createResult);
+			uploadUrl = res.url;
+			uploadFields = res.fields;
+			workerId = res.worker.workerId;
+		} else {
+			console.error("Failed to create worker:");
+			throw new Error(createResult.error.message);
+		}
+	}
+
+	context.writer.debug(`Generated upload URL: ${uploadUrl}`);
+
+	// Build the worker bundle
+	context.writer.writeErr("Building worker bundle...");
+	const archivePath = await buildWorkerBundle(context, absPath);
+	context.writer.debug(`Created bundle at: ${archivePath}`);
+
+	// Upload the bundle
+	context.writer.writeErr("Uploading bundle...");
+	await uploadBundle(uploadUrl, uploadFields, archivePath);
+	context.writer.debug("Upload complete");
+
+	// Fetch and save capabilities
+	context.writer.writeErr("Fetching and saving worker capabilities...");
+	const capabilitiesResult = await client.fetchAndSaveCapabilities(workerId);
+
+	if (Result.isSuccess(capabilitiesResult)) {
+		return Result.success({ workerId });
+	} else {
+		return capabilitiesResult;
+	}
+}
+
+/**
+ * Build the worker bundle using esbuild and create a tar.gz archive
+ */
+async function buildWorkerBundle(
+	context: LocalContext,
+	workerPath: string,
+): Promise<string> {
+	const entrypoint = "src/index.ts";
+
+	if (!fs.existsSync(path.join(workerPath, entrypoint))) {
+		throw new Error(`Entrypoint not found: ${entrypoint}`);
+	}
+
+	// Create temporary output directory
+	const outdir = fs.mkdtempSync("/tmp/workers-build-");
+
+	// Build with esbuild
+	esbuild.buildSync({
+		entryPoints: [entrypoint],
+		absWorkingDir: workerPath,
+		bundle: true,
+		outdir,
+		platform: "node",
+	});
+
+	context.writer.debug(`Built bundle to: ${outdir}`);
+
+	// Create tar.gz archive
+	const archiveDir = fs.mkdtempSync("/tmp/workers-archive-");
+	const archivePath = path.join(archiveDir, "archive.tar.gz");
+
+	childProcess.execSync(`tar -czf ${archivePath} -C ${outdir} .`);
+
+	return archivePath;
+}
+
+/**
+ * Upload the worker bundle to the pre-signed URL
+ */
+async function uploadBundle(
+	url: string,
+	fields: Record<string, string>,
+	archivePath: string,
+): Promise<void> {
+	const formData = new FormData();
+
+	// Add all the pre-signed fields
+	for (const [key, value] of Object.entries(fields)) {
+		formData.append(key, value);
+	}
+
+	// Add the file
+	const fileBuffer = fs.readFileSync(archivePath);
+	formData.append(
+		"file",
+		new Blob([new Uint8Array(fileBuffer)]),
+		"archive.tar.gz",
+	);
+
+	// Upload
+	const response = await fetch(url, {
+		method: "POST",
+		body: formData,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(
+			`Failed to upload bundle: ${response.status} ${response.statusText}\n${errorText}`,
+		);
+	}
+}

package/src/cli/flags.ts

@@ -0,0 +1,43 @@
+import type { TypedFlagParameter } from "@stricli/core";
+import type { LocalContext } from "./context.js";
+
+export interface GlobalFlags {
+	config?: string;
+	debug: boolean;
+}
+
+export const globalFlags: {
+	[K in keyof Required<GlobalFlags>]: TypedFlagParameter<
+		GlobalFlags[K],
+		LocalContext
+	>;
+} = {
+	config: {
+		kind: "parsed",
+		parse: String,
+		brief: "The path to the config file to use",
+		optional: true,
+	},
+	debug: {
+		kind: "boolean",
+		brief: "Enable debug logging",
+		default: false,
+	},
+};
+
+export interface FormatFlags {
+	plain: boolean;
+}
+
+export const formatFlags: {
+	[K in keyof Required<FormatFlags>]: TypedFlagParameter<
+		FormatFlags[K],
+		LocalContext
+	>;
+} = {
+	plain: {
+		kind: "boolean",
+		brief: "Output the results in plain text format",
+		default: false,
+	},
+};

package/src/cli/handler.ts

@@ -0,0 +1,62 @@
+import type { BaseArgs } from "@stricli/core";
+import { ApiClient } from "./api/client.js";
+import { Config } from "./config.js";
+import type { LocalContext } from "./context.js";
+import type { GlobalFlags } from "./flags.js";
+
+export interface HandlerContext extends LocalContext {
+	config: Config;
+}
+
+export interface AuthedContext extends HandlerContext {
+	apiClient: ApiClient;
+}
+
+export function buildHandler<const FLAGS, const ARGS extends BaseArgs = []>(
+	handler: (
+		this: HandlerContext,
+		flags: FLAGS,
+		...args: ARGS
+	) => Promise<void> | void,
+) {
+	return async function (
+		this: LocalContext,
+		flags: GlobalFlags & FLAGS,
+		...args: ARGS
+	) {
+		const config = await Config.load(flags.config ?? "./workers.json");
+
+		this.writer.debugEnabled = flags.debug;
+
+		await handler.call({ ...this, config }, flags, ...args);
+	};
+}
+
+export function buildAuthedHandler<
+	const FLAGS,
+	const ARGS extends BaseArgs = [],
+>(
+	handler: (
+		this: AuthedContext,
+		flags: FLAGS,
+		...args: ARGS
+	) => Promise<void> | void,
+) {
+	return buildHandler(function (flags: FLAGS, ...args: ARGS) {
+		const environment = this.config.environment;
+		if (!environment) {
+			// Unexpected to get here when token is set
+			throw new Error("Unexpected error: Environment not set");
+		}
+
+		const { token, cellId } = this.config.tokenInfo;
+		const client = new ApiClient({
+			token,
+			environment,
+			baseUrl: this.config.baseUrl,
+			cellId,
+			writer: this.writer,
+		});
+		return handler.call({ ...this, apiClient: client }, flags, ...args);
+	});
+}