@project-ajax/sdk 0.0.60 → 0.0.62

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

@@ -1,254 +0,0 @@
-import {
-	afterEach,
-	beforeEach,
-	describe,
-	expect,
-	it,
-	type Mock,
-	vi,
-} from "vitest";
-import { Result } from "../api/result.js";
-import { Config } from "../config.js";
-import {
-	baseFlags,
-	cleanupTmpDirectories,
-	createAndLoadConfig,
-	createBaseContext,
-} from "./utils/testing.js";
-
-// Mock external dependencies
-vi.mock("../deploy.js", () => ({
-	deployWorker: vi.fn(),
-}));
-
-import { deployWorker } from "../deploy.js";
-import { deploy } from "./deploy.impl.js";
-
-afterEach(cleanupTmpDirectories);
-
-describe("deploy", () => {
-	let stderrSpy: Mock<typeof process.stderr.write>;
-
-	beforeEach(() => {
-		stderrSpy = vi
-			.spyOn(process.stderr, "write")
-			.mockImplementation(() => true);
-	});
-
-	it("deploys existing worker when workerId is set", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: "worker-123",
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-		vi.mocked(deployWorker).mockResolvedValue(
-			Result.success({ workerId: "worker-123" }),
-		);
-
-		const updateSpy = vi.spyOn(mockConfig, "update");
-		const context = createBaseContext();
-
-		await deploy.call(context, baseFlags);
-
-		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
-			workerPath: process.cwd(),
-			workerId: "worker-123",
-			token:
-				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-			environment: "local",
-		});
-
-		expect(updateSpy).toHaveBeenCalledWith({
-			workerId: "worker-123",
-		});
-
-		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
-		expect(allCalls).toContain("Deploying worker...");
-		expect(allCalls).toContain("✓ Successfully deployed worker");
-	});
-
-	it("deploys new worker with name flag", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: null,
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-		vi.mocked(deployWorker).mockResolvedValue(
-			Result.success({ workerId: "worker-456" }),
-		);
-
-		const updateSpy = vi.spyOn(mockConfig, "update");
-		const context = createBaseContext();
-		vi.spyOn(context.io, "input").mockResolvedValue("my-worker");
-
-		await deploy.call(context, { ...baseFlags, name: "my-worker" });
-
-		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
-			name: "my-worker",
-			workerPath: process.cwd(),
-			token:
-				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-			environment: "local",
-		});
-
-		expect(updateSpy).toHaveBeenCalledWith({
-			workerId: "worker-456",
-		});
-		expect(context.io.input).not.toHaveBeenCalled();
-
-		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
-		expect(allCalls).toContain("✓ Successfully deployed worker");
-	});
-
-	it("prompts for name when deploying new worker without name flag", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: null,
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-		vi.mocked(deployWorker).mockResolvedValue(
-			Result.success({ workerId: "worker-789" }),
-		);
-
-		const updateSpy = vi.spyOn(mockConfig, "update");
-		const context = createBaseContext();
-		vi.spyOn(context.io, "input").mockResolvedValue("prompted-worker");
-
-		await deploy.call(context, baseFlags);
-
-		expect(context.io.input).toHaveBeenCalledWith({
-			message: "Enter a name for the worker",
-			required: true,
-			noTTY: "Provide a name for the worker with --name",
-		});
-
-		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
-			name: "prompted-worker",
-			workerPath: process.cwd(),
-			token:
-				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-			environment: "local",
-		});
-
-		expect(updateSpy).toHaveBeenCalledWith({
-			workerId: "worker-789",
-		});
-	});
-
-	it("throws error when name is not provided", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: null,
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-
-		const context = createBaseContext();
-		vi.spyOn(context.io, "input").mockResolvedValue("");
-
-		await expect(deploy.call(context, baseFlags)).rejects.toThrow(
-			"Name is required",
-		);
-	});
-
-	it("throws error when both workerId and name are provided", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: "worker-123",
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-
-		const context = createBaseContext();
-
-		await expect(
-			deploy.call(context, { ...baseFlags, name: "my-worker" }),
-		).rejects.toThrow("Cannot specify a name when updating an existing worker");
-	});
-
-	it("handles deployment failure", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: "worker-123",
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-		vi.mocked(deployWorker).mockResolvedValue(
-			Result.fail({
-				status: 500,
-				statusText: "Internal Server Error",
-				message: "Deployment failed",
-			}),
-		);
-
-		const context = createBaseContext();
-
-		await deploy.call(context, baseFlags);
-
-		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
-		expect(allCalls).toContain("✗ Failed to deploy worker");
-		expect(allCalls).toContain("Deployment failed");
-	});
-
-	it("trims whitespace from prompted name", async () => {
-		const [mockConfig] = await createAndLoadConfig({
-			configFile: {
-				token:
-					"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
-				workerId: null,
-				environment: "local",
-				baseUrl: "http://localhost:3000",
-			},
-		});
-
-		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
-		vi.mocked(deployWorker).mockResolvedValue(
-			Result.success({ workerId: "worker-999" }),
-		);
-
-		const context = createBaseContext();
-		vi.spyOn(context.io, "input").mockResolvedValue("  worker-name  ");
-
-		await deploy.call(context, baseFlags);
-
-		expect(deployWorker).toHaveBeenCalledWith(
-			expect.anything(),
-			expect.objectContaining({
-				name: "worker-name",
-			}),
-		);
-	});
-});

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

@@ -1,73 +0,0 @@
-import type { ApiError } from "../api/client.js";
-import { Result } from "../api/result.js";
-import { deployWorker } from "../deploy.js";
-import { buildAuthedHandler } from "../handler.js";
-
-interface DeployFlags {
-	name?: string;
-}
-
-export const deploy = buildAuthedHandler(async function (flags: DeployFlags) {
-	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.io.writeErr("Deploying worker...");
-
-	const name = flags.name;
-	if (workerId && name) {
-		throw new Error("Cannot specify a name when updating an existing worker");
-	}
-
-	let result: Result<{ workerId: string }, ApiError>;
-	if (workerId) {
-		result = await deployWorker(this, {
-			workerPath,
-			workerId,
-			token,
-			environment,
-		});
-	} else {
-		let validatedName: string;
-		if (name) {
-			validatedName = name;
-		} else {
-			const nameInput = await this.io.input({
-				message: "Enter a name for the worker",
-				required: true,
-				noTTY: "Provide a name for the worker with --name",
-			});
-
-			const trimmedName = nameInput?.trim();
-
-			if (!trimmedName) {
-				throw new Error("Name is required");
-			}
-
-			validatedName = trimmedName;
-		}
-
-		result = await deployWorker(this, {
-			name: validatedName,
-			workerPath,
-			token,
-			environment,
-		});
-	}
-
-	if (Result.isSuccess(result)) {
-		const { workerId } = Result.unwrap(result);
-		await this.config.update({ workerId });
-		this.io.writeErr("✓ Successfully deployed worker");
-	} else {
-		this.io.writeErr("✗ Failed to deploy worker");
-		this.io.writeErr(result.error.message);
-		return;
-	}
-});

package/src/cli/commands/deploy.ts

@@ -1,22 +0,0 @@
-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,
-			name: {
-				kind: "parsed",
-				parse: String,
-				brief: "The name of the worker (if it has not yet been created)",
-				optional: true,
-			},
-		},
-	},
-
-	loader: () => import("./deploy.impl.js").then((m) => m.deploy),
-});

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

@@ -1,88 +0,0 @@
-import { Result } from "../api/result.js";
-import { buildAuthedHandler } from "../handler.js";
-import { pluralize } from "../utils/string.js";
-
-export interface PullEnvFlags {
-	yes: boolean;
-}
-
-export const DEFAULT_ENV_FILE = ".env";
-
-export const pullEnv = buildAuthedHandler(async function (
-	flags: PullEnvFlags,
-	filePath?: string,
-) {
-	const { workerId } = this.config;
-	if (!workerId) {
-		throw new Error(
-			"No worker configured. Run 'workers deploy' first to create a worker.",
-		);
-	}
-
-	const destination = filePath ?? DEFAULT_ENV_FILE;
-	const absoluteDestination = this.path.resolve(
-		this.process.cwd(),
-		destination,
-	);
-
-	if (this.fs.existsSync(absoluteDestination) && !flags.yes) {
-		const overwrite = await this.io.confirm({
-			message: `File "${destination}" already exists. Overwrite it?`,
-			noTTY: `File "${destination}" already exists.`,
-		});
-
-		if (overwrite !== true) {
-			this.io.writeErr("Aborted.");
-			return;
-		}
-	}
-
-	this.io.writeErr("Fetching environment variables...");
-	const envResult = await this.apiClient.pullEnv(workerId);
-
-	if (Result.isFail(envResult)) {
-		this.io.writeErr("✗ Failed to fetch env vars");
-		this.io.writeErr(`✗ ${envResult.error.message}`);
-		throw new Error(envResult.error.message);
-	}
-
-	const envEntries = envResult.value.env;
-	const fileContents = serializeEnvFile(envEntries);
-
-	await this.fs.promises.mkdir(this.path.dirname(absoluteDestination), {
-		recursive: true,
-	});
-	await this.fs.promises.writeFile(absoluteDestination, fileContents, "utf8");
-
-	this.io.writeErr(
-		`Wrote ${pluralize(envEntries.length, "env var")} to "${destination}"`,
-	);
-});
-
-export function serializeEnvFile(
-	envEntries: Array<{ key: string; value: string }>,
-): string {
-	if (envEntries.length === 0) {
-		return "# No env vars configured for this worker\n";
-	}
-
-	return envEntries
-		.map(({ key, value }) => `${key}=${formatEnvValue(value)}`)
-		.join("\n")
-		.concat("\n");
-}
-
-export function formatEnvValue(value: string): string {
-	if (/^[A-Za-z0-9_./:-]*$/.test(value)) {
-		return value;
-	}
-
-	const escaped = value
-		.replace(/\\/g, "\\\\")
-		.replace(/\n/g, "\\n")
-		.replace(/\r/g, "\\r")
-		.replace(/\t/g, "\\t")
-		.replace(/"/g, '\\"');
-
-	return `"${escaped}"`;
-}

package/src/cli/commands/env.ts

@@ -1,38 +0,0 @@
-import { buildCommand, buildRouteMap } from "@stricli/core";
-
-import { globalFlags } from "../flags.js";
-
-export const envCommands = buildRouteMap({
-	docs: {
-		brief: "Work with worker environment files",
-	},
-	routes: {
-		pull: buildCommand({
-			docs: {
-				brief: "Write the worker's env vars to a .env file",
-			},
-			parameters: {
-				positional: {
-					kind: "tuple",
-					parameters: [
-						{
-							brief: "Destination file path",
-							parse: String,
-							placeholder: "file",
-							optional: true,
-						},
-					],
-				},
-				flags: {
-					...globalFlags,
-					yes: {
-						kind: "boolean",
-						brief: "Overwrite the output file without prompting",
-						default: false,
-					},
-				},
-			},
-			loader: () => import("./env.impl.js").then((m) => m.pullEnv),
-		}),
-	},
-});

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

@@ -1,171 +0,0 @@
-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.io.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 (!flags.debug) {
-								break;
-							}
-
-							if (parsedLine.event.stream === "stdout") {
-								allOutput.push(parsedLine.event.data);
-							}
-
-							parsedLine.event.data
-								.trim()
-								.split("\n")
-								.forEach((dataLine) => {
-									this.io.writeErr(
-										`[worker:${parsedLine.event.stream}] ${dataLine.trim()}`,
-									);
-								});
-
-							break;
-						case "result":
-							this.io.writeOut(JSON.stringify(parsedLine.result, null, 2));
-							break;
-						case "error":
-							this.io.writeErr(`Error: ${parsedLine.error}`);
-							break;
-					}
-				} catch (error) {
-					this.io.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.io.writeErr(`\n✗ Failed to execute capability`);
-
-			// If it's a validation error, show the clean debug message
-			if (result.error.validationError) {
-				this.io.writeErr(`\t✗ HTTP Error: ${result.error.status}`);
-				this.io.writeErr(`\t✗ ${result.error.validationError.debugMessage}`);
-				this.io.writeErr(`\n${usageHint}`);
-				throw new Error(result.error.validationError.debugMessage);
-			} else {
-				this.io.writeErr(`\t✗ HTTP Error: ${result.error.status}`);
-				this.io.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.io.writeOut(JSON.stringify(data.result, null, 2));
-		} else {
-			this.io.writeErr(`\n✗ Failed to execute capability`);
-			this.io.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

@@ -1,32 +0,0 @@
-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),
-});