@project-ajax/sdk 0.0.60 → 0.0.62

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}`,
-		);
-	}
-}

package/src/cli/flags.ts

@@ -1,72 +0,0 @@
-import type { TypedFlagParameter } from "@stricli/core";
-import { type Environment, Environments } from "./config.js";
-import type { LocalContext } from "./context.js";
-
-export interface GlobalFlags {
-	config?: string;
-	debug: boolean;
-	env?: Environment;
-	"base-url"?: string;
-	token?: string;
-	"worker-id"?: string;
-}
-
-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,
-	},
-	env: {
-		kind: "enum",
-		values: Environments,
-		brief: "The environment to use for the command",
-		optional: true,
-	},
-	"base-url": {
-		kind: "parsed",
-		parse: String,
-		brief: "The base URL to use for all API requests",
-		optional: true,
-	},
-	token: {
-		kind: "parsed",
-		parse: String,
-		brief: "The token to use for authentication",
-		optional: true,
-	},
-	"worker-id": {
-		kind: "parsed",
-		parse: String,
-		brief: "The ID of the worker to use for the command",
-		optional: true,
-	},
-};
-
-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

@@ -1,68 +0,0 @@
-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 configFilePath =
-			flags.config ??
-			this.process.env.WORKERS_CONFIG_FILE_PATH ??
-			"./workers.json";
-
-		const config = await Config.load({
-			configFilePath,
-			processEnv: process.env,
-			flags,
-		});
-
-		this.io.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) {
-		// Check token first - this will throw TokenNotSetError with helpful message if not authenticated
-		const { token, cellId } = this.config.tokenInfo;
-		const environment = this.config.environment;
-
-		const client = new ApiClient({
-			token,
-			environment,
-			baseUrl: this.config.baseUrl,
-			cellId,
-			writer: this.io,
-		});
-		return handler.call({ ...this, apiClient: client }, flags, ...args);
-	});
-}