@getjack/jack 0.1.26 → 0.1.27

package/src/lib/services/storage-create.ts

@@ -0,0 +1,152 @@
+/**
+ * Storage (R2 bucket) creation logic for jack services storage create
+ *
+ * Handles both managed (control plane) and BYO (wrangler r2 bucket create) modes.
+ */
+
+import { join } from "node:path";
+import { $ } from "bun";
+import { createProjectResource } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { getProjectNameFromDir } from "../storage/index.ts";
+import {
+	addR2Binding,
+	generateBucketName,
+	getExistingR2Bindings,
+	toStorageBindingName,
+} from "./storage-config.ts";
+
+export interface CreateStorageBucketOptions {
+	name?: string;
+	interactive?: boolean; // Whether to prompt for deploy
+}
+
+export interface CreateStorageBucketResult {
+	bucketName: string;
+	bindingName: string;
+	created: boolean; // false if reused existing
+}
+
+interface ExistingBucket {
+	name: string;
+	creation_date?: string;
+}
+
+/**
+ * List all R2 buckets in the Cloudflare account via wrangler
+ */
+async function listBucketsViaWrangler(): Promise<ExistingBucket[]> {
+	const result = await $`wrangler r2 bucket list --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		// If wrangler fails, return empty list (might not be logged in)
+		return [];
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+		// wrangler r2 bucket list --json returns array: [{ "name": "...", "creation_date": "..." }]
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Find an existing R2 bucket by name
+ */
+async function findExistingBucket(bucketName: string): Promise<ExistingBucket | null> {
+	const buckets = await listBucketsViaWrangler();
+	return buckets.find((b) => b.name === bucketName) ?? null;
+}
+
+/**
+ * Create an R2 bucket via wrangler (for BYO mode)
+ */
+async function createBucketViaWrangler(bucketName: string): Promise<{ created: boolean }> {
+	// Check if bucket already exists
+	const existing = await findExistingBucket(bucketName);
+	if (existing) {
+		return { created: false };
+	}
+
+	const result = await $`wrangler r2 bucket create ${bucketName}`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to create bucket ${bucketName}`);
+	}
+
+	return { created: true };
+}
+
+/**
+ * Create an R2 storage bucket for the current project.
+ *
+ * For managed projects: calls control plane POST /v1/projects/:id/resources/r2
+ * For BYO projects: uses wrangler r2 bucket create
+ *
+ * In both cases, updates wrangler.jsonc with the new binding.
+ */
+export async function createStorageBucket(
+	projectDir: string,
+	options: CreateStorageBucketOptions = {},
+): Promise<CreateStorageBucketResult> {
+	// Read project link to determine deploy mode
+	const link = await readProjectLink(projectDir);
+	if (!link) {
+		throw new Error("Not in a jack project. Run 'jack new' to create a project.");
+	}
+
+	// Get project name from wrangler config
+	const projectName = await getProjectNameFromDir(projectDir);
+
+	// Get existing R2 bindings to determine naming
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const existingBindings = await getExistingR2Bindings(wranglerPath);
+	const existingCount = existingBindings.length;
+
+	// Determine bucket name
+	const bucketName = options.name ?? generateBucketName(projectName, existingCount);
+
+	// Determine binding name
+	const isFirst = existingCount === 0;
+	const bindingName = toStorageBindingName(bucketName, isFirst);
+
+	// Check if binding name already exists
+	const bindingExists = existingBindings.some((b) => b.binding === bindingName);
+	if (bindingExists) {
+		throw new Error(`Binding "${bindingName}" already exists. Choose a different bucket name.`);
+	}
+
+	let created = true;
+	let actualBucketName = bucketName;
+
+	if (link.deploy_mode === "managed") {
+		// Managed mode: call control plane
+		// Note: Control plane will reuse existing bucket if name matches
+		const resource = await createProjectResource(link.project_id, "r2", {
+			name: bucketName,
+			bindingName,
+		});
+		// Use the actual name from control plane (may differ from CLI-generated name)
+		actualBucketName = resource.resource_name;
+	} else {
+		// BYO mode: use wrangler r2 bucket create (checks for existing first)
+		const result = await createBucketViaWrangler(bucketName);
+		created = result.created;
+	}
+
+	// Update wrangler.jsonc with the new binding
+	await addR2Binding(wranglerPath, {
+		binding: bindingName,
+		bucket_name: actualBucketName,
+	});
+
+	return {
+		bucketName: actualBucketName,
+		bindingName,
+		created,
+	};
+}

package/src/lib/services/storage-delete.ts

@@ -0,0 +1,89 @@
+/**
+ * Storage (R2 bucket) deletion logic for jack services storage delete
+ *
+ * Handles both managed (control plane) and BYO (wrangler r2 bucket delete) modes.
+ */
+
+import { join } from "node:path";
+import { $ } from "bun";
+import { deleteProjectResource, fetchProjectResources } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { getExistingR2Bindings, removeR2Binding } from "./storage-config.ts";
+
+export interface DeleteStorageBucketResult {
+	bucketName: string;
+	deleted: boolean;
+	bindingRemoved: boolean;
+}
+
+/**
+ * Delete an R2 bucket via wrangler (for BYO mode)
+ */
+async function deleteBucketViaWrangler(bucketName: string): Promise<void> {
+	const result = await $`wrangler r2 bucket delete ${bucketName}`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		// Ignore "not found" errors - bucket may already be deleted
+		if (!stderr.includes("not found") && !stderr.includes("does not exist")) {
+			throw new Error(stderr || `Failed to delete bucket ${bucketName}`);
+		}
+	}
+}
+
+/**
+ * Delete an R2 storage bucket for the current project.
+ *
+ * For managed projects: calls control plane DELETE /v1/projects/:id/resources/:id
+ * For BYO projects: uses wrangler r2 bucket delete
+ *
+ * In both cases, removes the binding from wrangler.jsonc.
+ */
+export async function deleteStorageBucket(
+	projectDir: string,
+	bucketName: string,
+): Promise<DeleteStorageBucketResult> {
+	// Read project link to determine deploy mode
+	const link = await readProjectLink(projectDir);
+	if (!link) {
+		throw new Error("Not in a jack project. Run 'jack new' to create a project.");
+	}
+
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Verify bucket exists in wrangler.jsonc
+	const bindings = await getExistingR2Bindings(wranglerPath);
+	const binding = bindings.find((b) => b.bucket_name === bucketName);
+
+	if (!binding) {
+		throw new Error(`Bucket "${bucketName}" not found in this project.`);
+	}
+
+	let deleted = true;
+
+	if (link.deploy_mode === "managed") {
+		// Managed mode: delete via control plane (don't call wrangler - user may not have CF auth)
+		const resources = await fetchProjectResources(link.project_id);
+		const r2Resource = resources.find(
+			(r) => r.resource_type === "r2" && r.resource_name === bucketName,
+		);
+
+		if (r2Resource) {
+			await deleteProjectResource(link.project_id, r2Resource.id);
+		}
+		// If resource not in control plane, just remove the local binding
+		// Don't attempt wrangler delete - managed mode users don't have CF credentials
+	} else {
+		// BYO mode: delete via wrangler directly
+		await deleteBucketViaWrangler(bucketName);
+	}
+
+	// Remove binding from wrangler.jsonc (both modes)
+	const bindingRemoved = await removeR2Binding(wranglerPath, bucketName);
+
+	return {
+		bucketName,
+		deleted,
+		bindingRemoved,
+	};
+}

package/src/lib/services/storage-info.ts

@@ -0,0 +1,105 @@
+/**
+ * Storage (R2 bucket) info logic for jack services storage info
+ *
+ * Gets bucket information. For now, just confirms the bucket exists
+ * since R2 doesn't have a simple stats API via wrangler.
+ */
+
+import { $ } from "bun";
+import { join } from "node:path";
+import { fetchProjectResources } from "../control-plane.ts";
+import { readProjectLink } from "../project-link.ts";
+import { getExistingR2Bindings } from "./storage-config.ts";
+
+export interface StorageBucketInfo {
+	name: string;
+	binding: string;
+	source: "control-plane" | "wrangler";
+}
+
+/**
+ * Check if a bucket exists via wrangler
+ */
+async function bucketExistsViaWrangler(bucketName: string): Promise<boolean> {
+	const result = await $`wrangler r2 bucket list --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		return false;
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const buckets = JSON.parse(output) as Array<{ name: string }>;
+		return buckets.some((b) => b.name === bucketName);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get storage bucket info for a project.
+ *
+ * @param projectDir - The project directory
+ * @param bucketName - Optional specific bucket name. If not provided, returns first bucket.
+ */
+export async function getStorageBucketInfo(
+	projectDir: string,
+	bucketName?: string,
+): Promise<StorageBucketInfo | null> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Read deploy mode from .jack/project.json
+	const link = await readProjectLink(projectDir);
+
+	// Get bindings from wrangler.jsonc
+	const bindings = await getExistingR2Bindings(wranglerPath);
+
+	if (bindings.length === 0) {
+		return null;
+	}
+
+	// Find the requested bucket (or first if not specified)
+	const binding = bucketName
+		? bindings.find((b) => b.bucket_name === bucketName)
+		: bindings[0];
+
+	if (!binding) {
+		return null;
+	}
+
+	// For managed projects, verify via control plane (don't call wrangler - user may not have CF auth)
+	if (link?.deploy_mode === "managed") {
+		const resources = await fetchProjectResources(link.project_id);
+		const r2Resource = resources.find(
+			(r) => r.resource_type === "r2" && r.resource_name === binding.bucket_name,
+		);
+
+		if (r2Resource) {
+			return {
+				name: binding.bucket_name,
+				binding: binding.binding,
+				source: "control-plane",
+			};
+		}
+		// For managed mode: if not in control plane, the bucket doesn't exist on the server
+		// but we still have a binding configured, so return the binding info
+		return {
+			name: binding.bucket_name,
+			binding: binding.binding,
+			source: "control-plane",
+		};
+	}
+
+	// For BYO only, verify bucket exists via wrangler
+	const exists = await bucketExistsViaWrangler(binding.bucket_name);
+
+	if (!exists) {
+		return null;
+	}
+
+	return {
+		name: binding.bucket_name,
+		binding: binding.binding,
+		source: "wrangler",
+	};
+}

package/src/lib/services/storage-list.ts

@@ -0,0 +1,42 @@
+/**
+ * Storage (R2 bucket) listing logic for jack services storage list
+ *
+ * Lists R2 buckets configured in wrangler.jsonc.
+ * For managed projects, fetches metadata via control plane instead of wrangler.
+ */
+
+import { join } from "node:path";
+import { getExistingR2Bindings } from "./storage-config.ts";
+
+export interface StorageBucketListEntry {
+	name: string;
+	binding: string;
+}
+
+/**
+ * List all R2 storage buckets configured for a project.
+ *
+ * For managed projects: reads bindings from wrangler.jsonc.
+ * For BYO projects: reads bindings from wrangler.jsonc.
+ *
+ * Note: R2 doesn't have a simple metadata API like D1, so we just return
+ * the configured bindings. For detailed info, use storage info.
+ */
+export async function listStorageBuckets(projectDir: string): Promise<StorageBucketListEntry[]> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Get existing R2 bindings from wrangler.jsonc
+	const bindings = await getExistingR2Bindings(wranglerPath);
+
+	if (bindings.length === 0) {
+		return [];
+	}
+
+	// Convert to list entries
+	const entries: StorageBucketListEntry[] = bindings.map((binding) => ({
+		name: binding.bucket_name,
+		binding: binding.binding,
+	}));
+
+	return entries;
+}

package/src/mcp/resources/index.ts

@@ -45,7 +45,7 @@ export function registerResources(
 				version: packageJson.version,
 				services: {
 					supported: ["d1", "kv", "r2"],
-					create_supported: ["d1"],
+					create_supported: ["d1", "r2"],
 				},
 				guidance: {
 					prefer_jack_over_wrangler: true,