@project-ajax/sdk 0.0.60 → 0.0.61

package/src/cli/commands/utils/testing.ts

@@ -1,66 +0,0 @@
-import * as fs from "node:fs";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import * as os from "node:os";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { Config, type ConfigMap } from "../../config.js";
-import type { LocalContext } from "../../context.js";
-import type { GlobalFlags } from "../../flags.js";
-import { IO } from "../../io.js";
-
-export const tmpDirectories: string[] = [];
-
-export const baseFlags: GlobalFlags = {
-	debug: false,
-};
-
-export async function createAndLoadConfig({
-	configFile,
-	env,
-	flags,
-}: {
-	configFile: Partial<ConfigMap>;
-	env?: Partial<NodeJS.ProcessEnv>;
-	flags?: Partial<GlobalFlags>;
-}): Promise<[config: Config, path: string]> {
-	const configFilePath = await createConfigFile(configFile);
-
-	const map = await Config.load({
-		configFilePath,
-		processEnv: env ?? {},
-		flags: {
-			...baseFlags,
-			...(flags ?? {}),
-		},
-	});
-
-	return [map, configFilePath];
-}
-
-export function createBaseContext(): LocalContext {
-	return {
-		fs,
-		io: new IO({ debugEnabled: false }),
-		os,
-		path,
-		process,
-	};
-}
-
-export async function cleanupTmpDirectories() {
-	while (tmpDirectories.length > 0) {
-		const dir = tmpDirectories.pop();
-		if (dir) {
-			await rm(dir, { recursive: true, force: true });
-		}
-	}
-}
-
-async function createConfigFile(contents: Partial<ConfigMap>) {
-	const dir = await mkdtemp(path.join(tmpdir(), "cmd-test-"));
-	tmpDirectories.push(dir);
-	const configFilePath = path.join(dir, "config.json");
-
-	await writeFile(configFilePath, JSON.stringify(contents, null, 2), "utf-8");
-	return configFilePath;
-}

package/src/cli/config.test.ts

@@ -1,108 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	cleanupTmpDirectories,
-	createAndLoadConfig,
-} from "./commands/utils/testing.js";
-import { Config, type ConfigMap } from "./config.js";
-
-const baseConfigMap: ConfigMap = {
-	token: "file-token",
-	workerId: "file-worker",
-	environment: "local",
-	baseUrl: "https://config.example.com",
-};
-
-afterEach(cleanupTmpDirectories);
-
-describe("Config.load precedence", () => {
-	it("uses values from the config file when no overrides are present", async () => {
-		const [config] = await createAndLoadConfig({
-			configFile: baseConfigMap,
-		});
-
-		expect(config.token).toBe(baseConfigMap.token);
-		expect(config.workerId).toBe(baseConfigMap.workerId);
-		expect(config.environment).toBe(baseConfigMap.environment);
-		expect(config.baseUrl).toBe(baseConfigMap.baseUrl);
-	});
-
-	it("prefers environment variables over the config file", async () => {
-		const envVars = {
-			WORKERS_TOKEN: "env-token",
-			WORKERS_WORKER_ID: "env-worker",
-			WORKERS_ENVIRONMENT: "staging",
-		};
-		const [config] = await createAndLoadConfig({
-			configFile: baseConfigMap,
-			env: envVars,
-		});
-
-		expect(config.token).toBe(envVars.WORKERS_TOKEN);
-		expect(config.workerId).toBe(envVars.WORKERS_WORKER_ID);
-		expect(config.environment).toBe(envVars.WORKERS_ENVIRONMENT);
-		expect(config.baseUrl).toBe(baseConfigMap.baseUrl);
-	});
-
-	it("prefers flags over environment variables and config file values", async () => {
-		const envVars = {
-			WORKERS_WORKER_ID: "env-worker",
-			WORKERS_ENVIRONMENT: "staging",
-			WORKERS_BASE_URL: "https://env.example.com",
-		};
-
-		const flags = {
-			env: "dev" as const,
-			"base-url": "https://flag.example.com",
-		};
-
-		const [config] = await createAndLoadConfig({
-			configFile: baseConfigMap,
-			env: envVars,
-			flags,
-		});
-
-		expect(config.token).toBe(baseConfigMap.token);
-		expect(config.workerId).toBe(envVars.WORKERS_WORKER_ID);
-		expect(config.environment).toBe(flags.env);
-		expect(config.baseUrl).toBe(flags["base-url"]);
-	});
-});
-
-describe("Config.update", () => {
-	it("persists only provided keys to disk", async () => {
-		const [, configFilePath] = await createAndLoadConfig({
-			configFile: {
-				token: "file-token",
-				workerId: "file-worker",
-				environment: "prod",
-				baseUrl: "https://config.example.com",
-			},
-		});
-
-		const config = await Config.load({
-			configFilePath,
-			processEnv: {
-				WORKERS_BASE_URL: "https://env.example.com",
-			} as NodeJS.ProcessEnv,
-			flags: { debug: false },
-		});
-
-		expect(config.baseUrl).toBe("https://env.example.com");
-
-		await config.update({
-			token: "updated-token",
-		});
-
-		expect(config.token).toBe("updated-token");
-
-		const persisted = JSON.parse(await readFile(configFilePath, "utf-8"));
-
-		expect(persisted).toEqual({
-			token: "updated-token",
-			workerId: "file-worker",
-			environment: "prod",
-			baseUrl: "https://config.example.com",
-		});
-	});
-});

package/src/cli/config.ts

@@ -1,265 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { GlobalFlags } from "./flags.js";
-
-export const Environments = ["local", "staging", "dev", "prod"] as const;
-export type Environment = (typeof Environments)[number];
-
-export interface ConfigMap {
-	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";
-	}
-}
-
-/**
- * Manages configuration for the CLI.
- *
- * Environment variables take precedence over the config file.
- *
- * | Environment Variable | Config File | Description |
- * |----------------------|-------------|-------------|
- * | WORKERS_TOKEN        | token       | The token to use for authentication |
- * | WORKERS_ENVIRONMENT  | environment | The environment to use |
- * | WORKERS_WORKER_ID    | workerId    | The worker ID to use |
- * | WORKERS_BASE_URL     | baseUrl     | The base URL to use |
- */
-export class Config {
-	readonly #configMap: ConfigMap;
-	readonly #configFilePath: string;
-
-	constructor(opts: {
-		configMap: ConfigMap;
-		configFilePath: string;
-	}) {
-		this.#configMap = opts.configMap;
-		this.#configFilePath = opts.configFilePath;
-	}
-
-	// Getters read from the environment variables, and then the config file.
-
-	get baseUrl() {
-		return this.#configMap.baseUrl;
-	}
-
-	get token() {
-		return this.#configMap.token;
-	}
-
-	get environment() {
-		return this.#configMap.environment;
-	}
-
-	get workerId() {
-		return this.#configMap.workerId;
-	}
-
-	get tokenInfo(): { token: string; spaceId: string; cellId: string } {
-		const token = this.token;
-		if (!token) {
-			throw new TokenNotSetError();
-		}
-
-		const { spaceId, cellId } = extractPayloadFromToken(token);
-		return { token, spaceId, cellId };
-	}
-
-	/**
-	 * Update the config with a partial config map.
-	 *
-	 * This will write only the updated keys in the config file on disk. Not all
-	 * keys are written, since some current keys in the Config object may have
-	 * come from e.g. environment variables, rather than the original config
-	 * file.
-	 *
-	 * @param config The config update.
-	 */
-	async update(config: Partial<ConfigMap>) {
-		Object.assign(this.#configMap, config);
-
-		const currentConfigFile = await Config.#readConfigFile(
-			this.#configFilePath,
-		);
-		Object.assign(currentConfigFile, config);
-		await fs.promises.writeFile(
-			this.#configFilePath,
-			JSON.stringify(currentConfigFile, null, 2),
-			"utf-8",
-		);
-	}
-
-	static async load(opts: {
-		configFilePath: string;
-		processEnv: NodeJS.ProcessEnv;
-		flags: GlobalFlags;
-	}) {
-		const absConfigFilePath = path.resolve(process.cwd(), opts.configFilePath);
-		const partialConfig = await Config.#readConfigFile(absConfigFilePath);
-
-		if (opts.processEnv.WORKERS_TOKEN) {
-			partialConfig.token = opts.processEnv.WORKERS_TOKEN;
-		}
-		if (opts.processEnv.WORKERS_ENVIRONMENT) {
-			partialConfig.environment = parseEnvironment(
-				opts.processEnv.WORKERS_ENVIRONMENT,
-			);
-		}
-		if (opts.processEnv.WORKERS_WORKER_ID) {
-			partialConfig.workerId = opts.processEnv.WORKERS_WORKER_ID;
-		}
-		if (opts.processEnv.WORKERS_BASE_URL) {
-			partialConfig.baseUrl = opts.processEnv.WORKERS_BASE_URL;
-		}
-
-		if (opts.flags.token) {
-			partialConfig.token = opts.flags.token;
-		}
-		if (opts.flags.env) {
-			partialConfig.environment = parseEnvironment(opts.flags.env);
-		}
-		if (opts.flags["base-url"]) {
-			partialConfig.baseUrl = opts.flags["base-url"];
-		}
-		if (opts.flags["worker-id"]) {
-			partialConfig.workerId = opts.flags["worker-id"];
-		}
-
-		partialConfig.environment ??= "prod";
-		partialConfig.baseUrl ??= baseUrlForEnvironment(partialConfig.environment);
-
-		const environment = partialConfig.environment;
-		if (!environment) {
-			throw new Error("Environment is required");
-		}
-
-		const baseUrl = partialConfig.baseUrl;
-		if (!baseUrl) {
-			throw new Error("Base URL is required");
-		}
-
-		const token = partialConfig.token;
-		if (token === undefined) {
-			throw new Error("Token is required");
-		}
-
-		const workerId = partialConfig.workerId;
-		if (workerId === undefined) {
-			throw new Error("Worker ID is required");
-		}
-
-		const configMap: ConfigMap = {
-			environment,
-			baseUrl,
-			token,
-			workerId,
-		};
-
-		return new Config({
-			configFilePath: absConfigFilePath,
-			configMap,
-		});
-	}
-
-	static async #readConfigFile(configFilePath: string) {
-		let configFile: Partial<ConfigMap>;
-		try {
-			const configContents = await fs.promises.readFile(
-				configFilePath,
-				"utf-8",
-			);
-
-			configFile = JSON.parse(configContents) as Partial<ConfigMap>;
-		} catch (error) {
-			if (isENOENT(error)) {
-				// The default, non-logged in configuration before overrides are
-				// applied from environment variables, and then flags.
-				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.");
-	}
-}
-
-function baseUrlForEnvironment(environment: Environment): string {
-	switch (environment) {
-		case "local":
-			return "http://localhost:3000";
-		case "staging":
-			return "https://staging.notion.so";
-		case "dev":
-			return "https://dev.notion.so";
-		case "prod":
-			return "https://www.notion.so";
-	}
-}

package/src/cli/context.ts

@@ -1,26 +0,0 @@
-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 { IO } from "./io.js";
-
-export interface LocalContext
-	extends CommandContext,
-		StricliAutoCompleteContext {
-	readonly fs: typeof fs;
-	readonly io: IO;
-	readonly os: typeof os;
-	readonly path: typeof path;
-	readonly process: NodeJS.Process;
-}
-
-export function buildContext(process: NodeJS.Process): LocalContext {
-	return {
-		fs,
-		io: new IO({ debugEnabled: false }),
-		os,
-		path,
-		process,
-	};
-}

package/src/cli/deploy.ts

@@ -1,190 +0,0 @@
-// 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 BaseDeployOptions {
-	/**
-	 * Path to the worker directory to deploy
-	 */
-	workerPath: string;
-
-	/**
-	 * API token for authentication
-	 */
-	token: string;
-
-	/**
-	 * Environment to deploy to
-	 */
-	environment: Environment;
-}
-
-export interface CreateDeployOptions extends BaseDeployOptions {
-	/**
-	 * Name of the worker (if it has not yet been created)
-	 */
-	name: string;
-}
-
-export interface UpdateDeployOptions extends BaseDeployOptions {
-	/**
-	 * ID of the worker to update
-	 */
-	workerId: string;
-}
-
-export type DeployOptions = CreateDeployOptions | UpdateDeployOptions;
-
-/**
- * Deploy a worker to the specified environment
- */
-export async function deployWorker(
-	context: AuthedContext,
-	options: DeployOptions,
-): Promise<Result<{ workerId: string }, ApiError>> {
-	const { workerPath } = options;
-
-	// Resolve absolute path
-	const absPath = path.resolve(process.cwd(), workerPath);
-	context.io.debug(`Deploying worker from: ${absPath}`);
-
-	// Create API client
-	const client = context.apiClient;
-
-	let uploadUrl: string;
-	let uploadFields: Record<string, string>;
-	let workerId: string;
-
-	if ("workerId" in options) {
-		context.io.writeErr(`Updating worker...`);
-
-		workerId = options.workerId;
-
-		const updateResult = await client.updateWorkerBundle(workerId);
-		if (Result.isSuccess(updateResult)) {
-			const res = Result.unwrap(updateResult);
-			uploadUrl = res.url;
-			uploadFields = res.fields;
-		} else {
-			context.io.writeErr(
-				"Failed to generate pre-signed upload URL for worker bundle:",
-			);
-			throw new Error(updateResult.error.message);
-		}
-	} else {
-		context.io.writeErr(`Creating worker...`);
-
-		const createResult = await client.createWorker(options.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.io.debug(`Generated upload URL: ${uploadUrl}`);
-
-	// Build the worker bundle
-	context.io.writeErr("Building worker bundle...");
-	const archivePath = await buildWorkerBundle(context, absPath);
-	context.io.debug(`Created bundle at: ${archivePath}`);
-
-	// Upload the bundle
-	context.io.writeErr("Uploading bundle...");
-	await uploadBundle(uploadUrl, uploadFields, archivePath);
-	context.io.debug("Upload complete");
-
-	// Fetch and save capabilities
-	context.io.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.io.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}`,
-		);
-	}
-}