@getjack/jack 0.1.4 → 0.1.6

package/src/commands/tag.ts

@@ -0,0 +1,282 @@
+/**
+ * jack tag - Manage project tags
+ *
+ * Usage:
+ *   jack tag add <tags...>              Add tags to current project
+ *   jack tag add <project> <tags...>    Add tags to named project
+ *   jack tag remove <tags...>           Remove tags from current project
+ *   jack tag remove <project> <tags...> Remove tags from named project
+ *   jack tag list                       List all tags across projects
+ *   jack tag list [project]             List tags for a specific project
+ */
+
+import { error, info, item, success } from "../lib/output.ts";
+import { readProjectLink } from "../lib/project-link.ts";
+import {
+	addTags,
+	findProjectPathByName,
+	getAllTagsWithCounts,
+	getProjectTags,
+	removeTags,
+	validateTags,
+} from "../lib/tags.ts";
+
+export default async function tag(subcommand?: string, args: string[] = []): Promise<void> {
+	if (!subcommand) {
+		showHelp();
+		return;
+	}
+
+	switch (subcommand) {
+		case "add":
+			return await addTagsCommand(args);
+		case "remove":
+			return await removeTagsCommand(args);
+		case "list":
+			return await listTagsCommand(args);
+		case "--help":
+		case "-h":
+		case "help":
+			showHelp();
+			return;
+		default:
+			error(`Unknown subcommand: ${subcommand}`);
+			info("Available: add, remove, list");
+			process.exit(1);
+	}
+}
+
+/**
+ * Show help for the tag command
+ */
+function showHelp(): void {
+	console.error(`
+  jack tag - Manage project tags
+
+  Usage
+    $ jack tag add <tags...>              Add tags to current project
+    $ jack tag add <project> <tags...>    Add tags to named project
+    $ jack tag remove <tags...>           Remove tags from current project
+    $ jack tag remove <project> <tags...> Remove tags from named project
+    $ jack tag list                       List all tags across projects
+    $ jack tag list [project]             List tags for a specific project
+
+  Tag Format
+    Tags must be lowercase alphanumeric with optional colons and hyphens.
+    Examples: backend, api:v2, my-service, prod
+
+  Examples
+    $ jack tag add backend api          Add tags in project directory
+    $ jack tag add my-app backend       Add tag to my-app project
+    $ jack tag remove deprecated        Remove tag from current project
+    $ jack tag list                     Show all tags with counts
+    $ jack tag list my-app              Show tags for my-app
+`);
+}
+
+/**
+ * Resolve project path from arguments
+ * Returns [projectPath, remainingArgs]
+ *
+ * Logic:
+ * 1. If in a linked project directory, use cwd and all args are tags
+ * 2. If not in project directory, first arg might be project name
+ */
+async function resolveProjectAndTags(args: string[]): Promise<[string | null, string[]]> {
+	const cwd = process.cwd();
+
+	// Check if we're in a linked project directory
+	const link = await readProjectLink(cwd);
+
+	if (link) {
+		// In a project directory - all args are tags
+		return [cwd, args];
+	}
+
+	// Not in a project directory - first arg might be project name
+	if (args.length === 0) {
+		return [null, []];
+	}
+
+	const firstArg = args[0] as string; // Safe: we checked args.length > 0 above
+	const rest = args.slice(1);
+
+	// Try to find project by name
+	const projectPath = await findProjectPathByName(firstArg);
+
+	if (projectPath) {
+		// First arg was a project name
+		return [projectPath, rest];
+	}
+
+	// First arg wasn't a project name - we're not in a project directory
+	// and couldn't find a matching project
+	return [null, args];
+}
+
+/**
+ * Add tags to a project
+ */
+async function addTagsCommand(args: string[]): Promise<void> {
+	const [projectPath, tagArgs] = await resolveProjectAndTags(args);
+
+	if (!projectPath) {
+		error("Not in a project directory and no valid project name provided");
+		info("Run from a project directory or specify project name: jack tag add <project> <tags...>");
+		process.exit(1);
+	}
+
+	if (tagArgs.length === 0) {
+		error("No tags specified");
+		info("Usage: jack tag add <tags...>");
+		process.exit(1);
+	}
+
+	// Validate tags first
+	const validation = validateTags(tagArgs);
+	if (!validation.valid) {
+		error("Invalid tags:");
+		for (const { tag, reason } of validation.invalidTags) {
+			item(`"${tag}": ${reason}`);
+		}
+		process.exit(1);
+	}
+
+	const result = await addTags(projectPath, tagArgs);
+
+	if (!result.success) {
+		error(result.error || "Failed to add tags");
+		process.exit(1);
+	}
+
+	if (result.added && result.added.length > 0) {
+		success(`Added tags: ${result.added.join(", ")}`);
+	}
+
+	if (result.skipped && result.skipped.length > 0) {
+		info(`Already present: ${result.skipped.join(", ")}`);
+	}
+
+	if (result.tags.length > 0) {
+		info(`Current tags: ${result.tags.join(", ")}`);
+	}
+}
+
+/**
+ * Remove tags from a project
+ */
+async function removeTagsCommand(args: string[]): Promise<void> {
+	const [projectPath, tagArgs] = await resolveProjectAndTags(args);
+
+	if (!projectPath) {
+		error("Not in a project directory and no valid project name provided");
+		info(
+			"Run from a project directory or specify project name: jack tag remove <project> <tags...>",
+		);
+		process.exit(1);
+	}
+
+	if (tagArgs.length === 0) {
+		error("No tags specified");
+		info("Usage: jack tag remove <tags...>");
+		process.exit(1);
+	}
+
+	const result = await removeTags(projectPath, tagArgs);
+
+	if (!result.success) {
+		error(result.error || "Failed to remove tags");
+		process.exit(1);
+	}
+
+	if (result.removed && result.removed.length > 0) {
+		success(`Removed tags: ${result.removed.join(", ")}`);
+	}
+
+	if (result.skipped && result.skipped.length > 0) {
+		info(`Not found: ${result.skipped.join(", ")}`);
+	}
+
+	if (result.tags.length > 0) {
+		info(`Remaining tags: ${result.tags.join(", ")}`);
+	} else {
+		info("No tags remaining");
+	}
+}
+
+/**
+ * List tags for a project or all tags across projects
+ */
+async function listTagsCommand(args: string[]): Promise<void> {
+	const [projectArg] = args;
+
+	if (projectArg) {
+		// List tags for a specific project
+		await listProjectTags(projectArg);
+	} else {
+		// Check if we're in a project directory
+		const cwd = process.cwd();
+		const link = await readProjectLink(cwd);
+
+		if (link) {
+			// In a project directory - show tags for this project
+			await listProjectTagsForPath(cwd);
+		} else {
+			// Not in project directory - show all tags
+			await listAllTags();
+		}
+	}
+}
+
+/**
+ * List tags for a specific project by name
+ */
+async function listProjectTags(projectName: string): Promise<void> {
+	const projectPath = await findProjectPathByName(projectName);
+
+	if (!projectPath) {
+		error(`Project not found: ${projectName}`);
+		process.exit(1);
+	}
+
+	await listProjectTagsForPath(projectPath);
+}
+
+/**
+ * List tags for a project at a specific path
+ */
+async function listProjectTagsForPath(projectPath: string): Promise<void> {
+	const tags = await getProjectTags(projectPath);
+
+	console.error("");
+	if (tags.length === 0) {
+		info("No tags for this project");
+		info("Add tags with: jack tag add <tags...>");
+	} else {
+		info(`Tags (${tags.length}):`);
+		for (const tag of tags) {
+			item(tag);
+		}
+	}
+	console.error("");
+}
+
+/**
+ * List all tags across all projects with counts
+ */
+async function listAllTags(): Promise<void> {
+	const tagCounts = await getAllTagsWithCounts();
+
+	console.error("");
+	if (tagCounts.length === 0) {
+		info("No tags found across any projects");
+		info("Add tags with: jack tag add <tags...>");
+	} else {
+		info(`All tags (${tagCounts.length}):`);
+		for (const { tag, count } of tagCounts) {
+			const projectLabel = count === 1 ? "project" : "projects";
+			item(`${tag} (${count} ${projectLabel})`);
+		}
+	}
+	console.error("");
+}

package/src/commands/unlink.ts

@@ -0,0 +1,30 @@
+/**
+ * jack unlink - Remove .jack/ directory from current project
+ *
+ * Removes the local project link but does NOT delete the project from cloud.
+ * You can re-link anytime with: jack link
+ */
+
+import { error, info, success } from "../lib/output.ts";
+import { unregisterPath } from "../lib/paths-index.ts";
+import { readProjectLink, unlinkProject } from "../lib/project-link.ts";
+
+export default async function unlink(): Promise<void> {
+	// Check if linked
+	const link = await readProjectLink(process.cwd());
+
+	if (!link) {
+		error("This directory is not linked");
+		info("Nothing to unlink");
+		process.exit(1);
+	}
+
+	// Remove from paths index
+	await unregisterPath(link.project_id, process.cwd());
+
+	// Remove .jack/ directory
+	await unlinkProject(process.cwd());
+
+	success("Project unlinked");
+	info("You can re-link with: jack link");
+}

package/src/index.ts

@@ -4,7 +4,7 @@ import pkg from "../package.json";
 import { enableDebug } from "./lib/debug.ts";
 import { isJackError } from "./lib/errors.ts";
 import { info, error as printError } from "./lib/output.ts";
-import { identify, shutdown, withTelemetry } from "./lib/telemetry.ts";
+import { getEnvironmentProps, identify, shutdown, withTelemetry } from "./lib/telemetry.ts";
 
 const cli = meow(
 	`
@@ -35,6 +35,11 @@ const cli = meow(
     logout              Sign out
     whoami              Show current user
 
+  Project Management
+    link [name]         Link directory to a project
+    unlink              Remove project link
+    tag                 Manage project tags
+
   Advanced
     agents              Manage AI agent configs
     secrets             Manage project secrets
@@ -105,6 +110,18 @@ const cli = meow(
 				type: "boolean",
 				default: false,
 			},
+			all: {
+				type: "boolean",
+				shortFlag: "a",
+				default: false,
+			},
+			status: {
+				type: "string",
+			},
+			json: {
+				type: "boolean",
+				default: false,
+			},
 			project: {
 				type: "string",
 				shortFlag: "p",
@@ -125,6 +142,10 @@ const cli = meow(
 				type: "boolean",
 				default: false,
 			},
+			tag: {
+				type: "string",
+				isMultiple: true,
+			},
 		},
 	},
 );
@@ -143,6 +164,7 @@ identify({
 	arch: process.arch,
 	node_version: process.version,
 	is_ci: !!process.env.CI,
+	...getEnvironmentProps(),
 });
 
 try {
@@ -200,6 +222,11 @@ try {
 			});
 			break;
 		}
+		case "tag": {
+			const { default: tag } = await import("./commands/tag.ts");
+			await withTelemetry("tag", tag)(args[0], args.slice(1));
+			break;
+		}
 		case "sync": {
 			const { default: sync } = await import("./commands/sync.ts");
 			await withTelemetry(
@@ -279,6 +306,14 @@ try {
 			if (cli.flags.local) lsArgs.push("--local");
 			if (cli.flags.deployed) lsArgs.push("--deployed");
 			if (cli.flags.cloud) lsArgs.push("--cloud");
+			if (cli.flags.all) lsArgs.push("--all");
+			if (cli.flags.json) lsArgs.push("--json");
+			if (cli.flags.status) lsArgs.push("--status", cli.flags.status);
+			if (cli.flags.tag) {
+				for (const t of cli.flags.tag) {
+					lsArgs.push("--tag", t);
+				}
+			}
 			await withTelemetry("projects", projects)("list", lsArgs);
 			break;
 		}
@@ -307,6 +342,16 @@ try {
 			await withTelemetry("feedback", feedback)();
 			break;
 		}
+		case "link": {
+			const { default: link } = await import("./commands/link.ts");
+			await withTelemetry("link", link)(args[0], { byo: cli.flags.byo });
+			break;
+		}
+		case "unlink": {
+			const { default: unlink } = await import("./commands/unlink.ts");
+			await withTelemetry("unlink", unlink)();
+			break;
+		}
 		default:
 			cli.showHelp(command ? 1 : 0);
 	}

package/src/lib/auth/index.ts

@@ -9,10 +9,12 @@ export {
 export { requireAuth, requireAuthOrLogin, getCurrentUser } from "./guard.ts";
 export {
 	deleteCredentials,
+	getAuthState,
 	getCredentials,
 	isLoggedIn,
 	isTokenExpired,
 	saveCredentials,
 	type AuthCredentials,
+	type AuthState,
 	type AuthUser,
 } from "./store.ts";

package/src/lib/auth/store.ts

@@ -42,9 +42,33 @@ export async function deleteCredentials(): Promise<void> {
 	}
 }
 
-export async function isLoggedIn(): Promise<boolean> {
+export type AuthState = "logged-in" | "not-logged-in" | "session-expired";
+
+/**
+ * Get detailed auth state
+ * - "logged-in": valid token (or successfully refreshed)
+ * - "not-logged-in": no credentials stored
+ * - "session-expired": had credentials but refresh failed
+ */
+export async function getAuthState(): Promise<AuthState> {
 	const creds = await getCredentials();
-	return creds !== null;
+	if (!creds) return "not-logged-in";
+
+	// If token is not expired, we're logged in
+	if (!isTokenExpired(creds)) return "logged-in";
+
+	// If expired, try to refresh (dynamic import to avoid circular dep)
+	try {
+		const { getValidAccessToken } = await import("./client.ts");
+		const token = await getValidAccessToken();
+		return token !== null ? "logged-in" : "session-expired";
+	} catch {
+		return "session-expired";
+	}
+}
+
+export async function isLoggedIn(): Promise<boolean> {
+	return (await getAuthState()) === "logged-in";
 }
 
 export function isTokenExpired(creds: AuthCredentials): boolean {

package/src/lib/binding-validator.ts

@@ -12,7 +12,7 @@ import type { WranglerConfig } from "./build-helper.ts";
 /**
  * Bindings supported by jack cloud managed deployments.
  */
-export const SUPPORTED_BINDINGS = ["d1_databases", "ai", "assets", "vars"] as const;
+export const SUPPORTED_BINDINGS = ["d1_databases", "ai", "assets", "vars", "r2_buckets"] as const;
 
 /**
  * Bindings not yet supported by jack cloud.
@@ -23,7 +23,6 @@ export const UNSUPPORTED_BINDINGS = [
 	"durable_objects",
 	"queues",
 	"services",
-	"r2_buckets",
 	"hyperdrive",
 	"vectorize",
 	"browser",
@@ -38,7 +37,6 @@ const BINDING_DISPLAY_NAMES: Record<string, string> = {
 	durable_objects: "Durable Objects",
 	queues: "Queues",
 	services: "Service Bindings",
-	r2_buckets: "R2 Buckets",
 	hyperdrive: "Hyperdrive",
 	vectorize: "Vectorize",
 	browser: "Browser Rendering",
@@ -68,16 +66,9 @@ export function validateBindings(
 		const value = config[binding as keyof WranglerConfig];
 		if (value !== undefined && value !== null) {
 			const displayName = BINDING_DISPLAY_NAMES[binding] || binding;
-			// Special message for R2 - suggest using Workers Assets instead
-			if (binding === "r2_buckets") {
-				errors.push(
-					`✗ R2 buckets not supported in managed deploy.\n  For static files, use Workers Assets instead (assets.directory in wrangler.jsonc).\n  Fix: Replace r2_buckets with assets config, or use 'wrangler deploy' for full control.`,
-				);
-			} else {
-				errors.push(
-					`✗ ${displayName} not supported in managed deploy.\n  Managed deploy supports: D1, AI, Assets, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
-				);
-			}
+			errors.push(
+				`✗ ${displayName} not supported in managed deploy.\n  Managed deploy supports: D1, AI, Assets, R2, vars.\n  Fix: Remove ${binding} from wrangler.jsonc, or use 'wrangler deploy' for full control.`,
+			);
 		}
 	}
 

package/src/lib/build-helper.ts

@@ -36,12 +36,15 @@ export interface WranglerConfig {
 		run_worker_first?: boolean;
 	};
 	vars?: Record<string, string>;
+	r2_buckets?: Array<{
+		binding: string;
+		bucket_name: string;
+	}>;
 	// Unsupported bindings (for validation)
 	kv_namespaces?: unknown;
 	durable_objects?: unknown;
 	queues?: unknown;
 	services?: unknown;
-	r2_buckets?: unknown;
 	hyperdrive?: unknown;
 	vectorize?: unknown;
 	browser?: unknown;
@@ -82,6 +85,18 @@ export async function needsViteBuild(projectPath: string): Promise<boolean> {
 	);
 }
 
+/**
+ * Checks if project requires OpenNext build by detecting open-next config files
+ * @param projectPath - Absolute path to project directory
+ * @returns true if open-next.config.ts or open-next.config.js exists
+ */
+export async function needsOpenNextBuild(projectPath: string): Promise<boolean> {
+	return (
+		existsSync(join(projectPath, "open-next.config.ts")) ||
+		existsSync(join(projectPath, "open-next.config.js"))
+	);
+}
+
 /**
  * Runs Vite build for the project
  * @param projectPath - Absolute path to project directory
@@ -105,6 +120,29 @@ export async function runViteBuild(projectPath: string): Promise<void> {
 	}
 }
 
+/**
+ * Runs OpenNext build for Next.js projects targeting Cloudflare
+ * @param projectPath - Absolute path to project directory
+ * @throws JackError if build fails
+ */
+export async function runOpenNextBuild(projectPath: string): Promise<void> {
+	// OpenNext builds Next.js for Cloudflare Workers
+	// Outputs to .open-next/worker.js and .open-next/assets/
+	const buildResult = await $`bunx opennextjs-cloudflare build`.cwd(projectPath).nothrow().quiet();
+
+	if (buildResult.exitCode !== 0) {
+		throw new JackError(
+			JackErrorCode.BUILD_FAILED,
+			"OpenNext build failed",
+			"Check your next.config and source files for errors",
+			{
+				exitCode: buildResult.exitCode,
+				stderr: buildResult.stderr.toString(),
+			},
+		);
+	}
+}
+
 /**
  * Builds a Cloudflare Worker project using wrangler dry-run
  * @param options - Build options with project path and optional reporter
@@ -117,13 +155,22 @@ export async function buildProject(options: BuildOptions): Promise<BuildOutput>
 	// Parse wrangler config first
 	const config = await parseWranglerConfig(projectPath);
 
-	// Check if Vite build is needed and run it
+	// Check if OpenNext build is needed (Next.js + Cloudflare)
+	const hasOpenNext = await needsOpenNextBuild(projectPath);
+	if (hasOpenNext) {
+		reporter?.start("Building...");
+		await runOpenNextBuild(projectPath);
+		reporter?.stop();
+		reporter?.success("Built");
+	}
+
+	// Check if Vite build is needed and run it (skip if OpenNext already built)
 	const hasVite = await needsViteBuild(projectPath);
-	if (hasVite) {
-		reporter?.start("Building with Vite...");
+	if (hasVite && !hasOpenNext) {
+		reporter?.start("Building...");
 		await runViteBuild(projectPath);
 		reporter?.stop();
-		reporter?.success("Built with Vite");
+		reporter?.success("Built");
 	}
 
 	// Create unique temp directory for build output
@@ -209,3 +256,44 @@ async function resolveEntrypoint(outDir: string, main?: string): Promise<string>
 		"Ensure wrangler outputs a single entry file (index.js or worker.js)",
 	);
 }
+
+/**
+ * Ensures R2 buckets exist for BYO deploy.
+ * Creates buckets via wrangler if they don't exist.
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of bucket names that were created or already existed
+ */
+export async function ensureR2Buckets(projectPath: string): Promise<string[]> {
+	const config = await parseWranglerConfig(projectPath);
+
+	if (!config.r2_buckets || config.r2_buckets.length === 0) {
+		return [];
+	}
+
+	const results: string[] = [];
+
+	for (const bucket of config.r2_buckets) {
+		const bucketName = bucket.bucket_name;
+
+		// Try to create the bucket (wrangler handles "already exists" gracefully)
+		const result = await $`wrangler r2 bucket create ${bucketName}`
+			.cwd(projectPath)
+			.nothrow()
+			.quiet();
+
+		// Exit code 0 = created, non-zero with "already exists" = fine
+		const stderr = result.stderr.toString();
+		if (result.exitCode === 0 || stderr.includes("already exists")) {
+			results.push(bucketName);
+		} else {
+			throw new JackError(
+				JackErrorCode.RESOURCE_ERROR,
+				`Failed to create R2 bucket: ${bucketName}`,
+				"Check your Cloudflare account has R2 enabled",
+				{ stderr },
+			);
+		}
+	}
+
+	return results;
+}