@project-ajax/sdk 0.0.60 → 0.0.62

package/src/capabilities/slashCommand.ts

@@ -1,71 +0,0 @@
-import type { Block } from "../block.js";
-import { ExecutionError } from "../error.js";
-
-export type SlashCommandConfiguration = {
-	menuTitle: string;
-	menuDescription: string;
-	search: {
-		placeholder: string;
-		debounce: number;
-	};
-
-	/**
-	 * A function that returns a list of items to display in the search results
-	 * as well as the corresponding blocks to insert for each item should it be selected.
-	 */
-	executeSearch: (searchQuery: string) => Promise<{
-		items: { title: string; description: string; id: string }[];
-	}>;
-	executeSelect: (selectedItemId: string) => Promise<Block[]>;
-};
-
-export type SlashCommandHandlerResult = {
-	menuTitle: string;
-	menuDescription: string;
-	search: {
-		placeholder: string;
-		debounce: number;
-	};
-};
-
-/**
- * Creates a special handler for handling slash commands.
- *
- * @param slashCommandConfiguration - The configuration for the slash command.
- * @returns A handler function that executes the slash command function, and passes data
- * needed to complete the operation back to the platform.
- */
-export function slashCommand(
-	slashCommandConfiguration: SlashCommandConfiguration,
-) {
-	return {
-		_tag: "slashCommand",
-		config: {
-			menuTitle: slashCommandConfiguration.menuTitle,
-			menuDescription: slashCommandConfiguration.menuDescription,
-			search: slashCommandConfiguration.search,
-		},
-		async handleSearch(searchQuery: string) {
-			const result = await slashCommandConfiguration
-				.executeSearch(searchQuery)
-				.catch((err) => {
-					throw new ExecutionError(err);
-				});
-
-			process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
-
-			return result;
-		},
-		async handleSelect(selectedItemId: string) {
-			const result = await slashCommandConfiguration
-				.executeSelect(selectedItemId)
-				.catch((err) => {
-					throw new ExecutionError(err);
-				});
-
-			process.stdout.write(`\n<output>${JSON.stringify(result)}</output>\n`);
-
-			return result;
-		},
-	};
-}

package/src/cli/api/client.ts

@@ -1,628 +0,0 @@
-/**
- * API client for making authenticated requests to the Workers API
- */
-
-import type { IO } from "../io.js";
-import { Result } from "./result.js";
-
-export type Environment = "local" | "staging" | "dev" | "prod";
-
-interface ApiClientConfig {
-	token: string;
-	environment: Environment;
-	baseUrl?: string | undefined;
-	cellId: string;
-	writer: IO;
-}
-
-type Endpoint = `/${string}`;
-
-export interface ApiError {
-	status: number;
-	statusText: string;
-	message: string;
-	validationError?: {
-		errorId: string;
-		name: string;
-		debugMessage: string;
-		message: string;
-	};
-}
-
-/**
- * API client for making authenticated requests to Workers endpoints
- */
-export class ApiClient {
-	readonly #token: string;
-	readonly #baseUrl: string | undefined;
-	readonly #cellId: string;
-	readonly #writer: IO;
-
-	constructor(config: ApiClientConfig) {
-		this.#token = config.token;
-		this.#baseUrl = config.baseUrl;
-		this.#cellId = config.cellId;
-		this.#writer = config.writer;
-	}
-
-	#baseApiUrl() {
-		return `${this.#baseUrl}/api/v3`;
-	}
-
-	/**
-	 * Make an authenticated fetch request to the Workers API
-	 */
-	private async fetch(
-		endpoint: Endpoint,
-		requestOptions: Omit<RequestInit, "body"> & { body?: unknown },
-		options: { stream: true },
-	): Promise<Result<ReadableStream<Uint8Array<ArrayBufferLike>>, ApiError>>;
-	private async fetch<TResponse>(
-		endpoint: Endpoint,
-		requestOptions?: Omit<RequestInit, "body"> & { body?: unknown },
-	): Promise<Result<TResponse, ApiError>>;
-	private async fetch<TResponse>(
-		endpoint: Endpoint,
-		requestOptions: Omit<RequestInit, "body"> & { body?: unknown } = {},
-		options?: { stream: true },
-	): Promise<
-		Result<TResponse | ReadableStream<Uint8Array<ArrayBufferLike>>, ApiError>
-	> {
-		if (!endpoint.startsWith("/")) {
-			throw new Error("Endpoint must start with a slash (/)");
-		}
-
-		const url = `${this.#baseApiUrl()}${endpoint}`;
-
-		this.#writer.debug(`Fetching ${url}`);
-		this.#writer.debug(
-			`Options: ${JSON.stringify(requestOptions, null, "\t")}`,
-		);
-
-		const headers = new Headers({
-			Authorization: `Bearer ${this.#token}`,
-			"Content-Type": "application/json",
-			"X-Notion-Cell": this.#cellId,
-		});
-
-		const addlHeaders = headersInitToEntries(requestOptions.headers);
-
-		for (const [key, value] of addlHeaders) {
-			headers.append(key, value);
-		}
-
-		const response = await fetch(url, {
-			method: requestOptions.method ?? "GET",
-			headers,
-			body: requestOptions.body ? JSON.stringify(requestOptions.body) : null,
-		});
-
-		this.#writer.debug(`Response: ${response.status} ${response.statusText}`);
-
-		if (!response.ok) {
-			const error = await parseApiError(response);
-			return Result.fail(error);
-		}
-
-		if (options?.stream) {
-			if (!response.body) {
-				return Result.fail({
-					status: response.status,
-					statusText: response.statusText,
-					message: "No body in response",
-				});
-			}
-
-			return Result.success(response.body);
-		} else {
-			const data = (await response.json()) as TResponse;
-			return Result.success(data);
-		}
-	}
-
-	/**
-	 * Create a new worker
-	 */
-	async createWorker(name: string): Promise<
-		Result<
-			{
-				worker: {
-					workerId: string;
-					name: string;
-					spaceId: string;
-					createdAt: string;
-					updatedAt: string;
-					state: unknown;
-				};
-				url: string;
-				fields: Record<string, string>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersCreateWorker", {
-			method: "POST",
-			body: {
-				name,
-			},
-		});
-	}
-
-	/**
-	 * Update an existing worker's bundle
-	 */
-	async updateWorkerBundle(workerId: string): Promise<
-		Result<
-			{
-				url: string;
-				fields: Record<string, string>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersUpdateWorker", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * Get a worker by ID
-	 */
-	async getWorker(workerId: string): Promise<
-		Result<
-			{
-				worker: {
-					workerId: string;
-					name: string;
-					spaceId: string;
-					state: unknown;
-					tools: unknown[];
-					createdAt: string;
-					updatedAt: string;
-				};
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersGetWorker", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * List all workers in the space
-	 */
-	async listWorkers(): Promise<
-		Result<
-			{
-				workers: Array<{
-					workerId: string;
-					name: string;
-					spaceId: string;
-					state: unknown;
-					createdAt: string;
-					updatedAt: string;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersListWorkers", {
-			method: "POST",
-			body: {},
-		});
-	}
-
-	/**
-	 * Delete a worker
-	 */
-	async deleteWorker(
-		workerId: string,
-	): Promise<Result<Record<string, never>, ApiError>> {
-		return this.fetch("/workersDeleteWorker", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * Fetch and save worker capabilities
-	 */
-	async fetchAndSaveCapabilities(workerId: string): Promise<
-		Result<
-			{
-				capabilities: ReadonlyArray<{
-					_tag: "sync" | "slashCommand";
-					spaceId: string;
-					workerId: string;
-					key: string;
-					config: unknown;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersFetchAndSaveCapabilities", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * Upsert secrets (create or update multiple secrets)
-	 */
-	async upsertSecrets(
-		workerId: string,
-		secrets: Array<{ key: string; value: string }>,
-	): Promise<
-		Result<
-			{
-				secrets: Array<{
-					spaceId: string;
-					workerId: string;
-					key: string;
-					createdAt: string;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersUpsertSecrets", {
-			method: "POST",
-			body: {
-				workerId,
-				secrets,
-			},
-		});
-	}
-
-	/**
-	 * List all secrets for a worker (keys only, not values)
-	 */
-	async listSecrets(
-		workerId: string,
-		options?: { secretKinds?: Array<"keyValue" | "oauth"> },
-	): Promise<
-		Result<
-			{
-				secrets: Array<{
-					spaceId: string;
-					workerId: string;
-					key: string;
-					createdAt: string;
-					kind: "keyValue" | "oauth";
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersListSecrets", {
-			method: "POST",
-			body: {
-				workerId,
-				secretKinds: options?.secretKinds,
-			},
-		});
-	}
-
-	/**
-	 * Pull decrypted env vars for a worker
-	 */
-	async pullEnv(workerId: string): Promise<
-		Result<
-			{
-				env: Array<{
-					key: string;
-					value: string;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersPullEnv", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	async listOauthProviders(): Promise<
-		Result<
-			{
-				providers: Array<{
-					key: string;
-					displayName: string;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersListOauthProviders", {
-			method: "POST",
-			body: {},
-		});
-	}
-
-	/**
-	 * Start the OAuth flow for a provider
-	 */
-	async startOauth(args: { workerId: string; provider: string }): Promise<
-		Result<
-			{
-				authorizationUrl: string;
-				state: string;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersStartOauth", {
-			method: "POST",
-			body: {
-				workerId: args.workerId,
-				provider: args.provider,
-			},
-		});
-	}
-
-	/**
-	 * Remove an OAuth connection for a worker
-	 */
-	async deleteOauthConnection(args: {
-		workerId: string;
-		provider: string;
-	}): Promise<Result<Record<string, never>, ApiError>> {
-		return this.fetch("/workersDeleteOauthConnection", {
-			method: "POST",
-			body: {
-				workerId: args.workerId,
-				provider: args.provider,
-			},
-		});
-	}
-
-	/**
-	 * Delete a secret
-	 */
-	async deleteSecret(
-		workerId: string,
-		key: string,
-	): Promise<Result<Record<string, never>, ApiError>> {
-		return this.fetch("/workersDeleteSecret", {
-			method: "POST",
-			body: {
-				workerId,
-				key,
-			},
-		});
-	}
-
-	/**
-	 * List all capabilities for a worker
-	 */
-	async listCapabilities(workerId: string): Promise<
-		Result<
-			{
-				capabilities: Array<{
-					_tag: "sync" | "slashCommand";
-					key: string;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersListCapabilities", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * Run a capability
-	 */
-	async runCapability(
-		workerId: string,
-		capabilityKey: string,
-		functionName: string | null,
-		args: Array<{ name: string; value: string }>,
-		stream: true,
-	): Promise<Result<ReadableStream<Uint8Array<ArrayBufferLike>>, ApiError>>;
-	async runCapability(
-		workerId: string,
-		capabilityKey: string,
-		functionName: string | null,
-		args: Array<{ name: string; value: string }>,
-		stream?: false | undefined,
-	): Promise<Result<{ result: unknown }, ApiError>>;
-	async runCapability(
-		workerId: string,
-		capabilityKey: string,
-		functionName: string | null,
-		args: Array<{ name: string; value: string }>,
-		stream?: boolean | undefined,
-	): Promise<
-		Result<
-			{ result: unknown } | ReadableStream<Uint8Array<ArrayBufferLike>>,
-			ApiError
-		>
-	> {
-		if (stream) {
-			return this.fetch(
-				"/workersRunCapability",
-				{
-					method: "POST",
-					body: {
-						workerId,
-						capabilityKey,
-						functionName,
-						args,
-						stream,
-					},
-				},
-				{ stream },
-			);
-		} else {
-			return this.fetch("/workersRunCapability", {
-				method: "POST",
-				body: {
-					workerId,
-					capabilityKey,
-					functionName,
-					args,
-					stream,
-				},
-			});
-		}
-	}
-
-	/**
-	 * Download the bundle for a worker
-	 */
-	async downloadWorkerBundle(
-		workerId: string,
-	): Promise<Result<ReadableStream<Uint8Array<ArrayBufferLike>>, ApiError>> {
-		return this.fetch(
-			"/workersGetBundle",
-			{
-				method: "POST",
-				body: {
-					workerId,
-				},
-			},
-			{ stream: true },
-		);
-	}
-
-	/**
-	 * List all runs for a worker
-	 */
-	async listRunsForWorker(workerId: string): Promise<
-		Result<
-			{
-				runs: Array<{
-					workerId: string;
-					spaceId: string;
-					runId: string;
-					name: string;
-					exitCode: number | null;
-					startedAt: string;
-					endedAt: string | null;
-				}>;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersListRunsForWorker", {
-			method: "POST",
-			body: {
-				workerId,
-			},
-		});
-	}
-
-	/**
-	 * Get logs for a specific run
-	 */
-	async getRunLogs(
-		workerId: string,
-		runId: string,
-	): Promise<
-		Result<
-			{
-				logs: string;
-			},
-			ApiError
-		>
-	> {
-		return this.fetch("/workersGetRunLogs", {
-			method: "POST",
-			body: {
-				workerId,
-				runId,
-			},
-		});
-	}
-}
-
-function headersInitToEntries(
-	headersInit: RequestInit["headers"],
-): [string, string][] {
-	if (headersInit instanceof Headers) {
-		return Array.from(headersInit.entries());
-	}
-
-	if (Array.isArray(headersInit)) {
-		return headersInit;
-	}
-
-	if (headersInit === undefined) {
-		return [];
-	}
-
-	const entries: [string, string][] = [];
-	for (const [key, value] of Object.entries(headersInit)) {
-		if (value === undefined) {
-			continue;
-		}
-		entries.push([key, value]);
-	}
-
-	return entries;
-}
-
-async function parseApiError(response: Response): Promise<ApiError> {
-	const errorText = await response.text();
-	const message = `[${response.status}] ${response.statusText}: ${errorText}`;
-	const error: ApiError = {
-		status: response.status,
-		statusText: response.statusText,
-		message,
-	};
-
-	if (response.status === 400) {
-		const validationError = parseValidationError(errorText);
-		if (validationError) {
-			error.validationError = validationError;
-		}
-	}
-
-	return error;
-}
-
-/**
- * Try to parse a ValidationError from error response text
- */
-function parseValidationError(
-	errorText: string,
-): ApiError["validationError"] | undefined {
-	try {
-		const errorJson = JSON.parse(errorText);
-		if (
-			errorJson.name === "ValidationError" &&
-			errorJson.debugMessage &&
-			errorJson.errorId
-		) {
-			return {
-				errorId: errorJson.errorId,
-				name: errorJson.name,
-				debugMessage: errorJson.debugMessage,
-				message: errorJson.message,
-			};
-		}
-	} catch {
-		// If parsing fails, return undefined
-	}
-	return undefined;
-}