@getjack/jack 0.1.16 → 0.1.19

package/src/commands/update.ts

@@ -2,6 +2,7 @@
  * jack update - Self-update to the latest version
  */
 
+import { debug } from "../lib/debug.ts";
 import { error, info, success, warn } from "../lib/output.ts";
 import {
 	checkForUpdate,
@@ -13,8 +14,13 @@ import {
 export default async function update(): Promise<void> {
 	const currentVersion = getCurrentVersion();
 
+	debug("Update check started");
+	debug(`Current version: ${currentVersion}`);
+	debug(`Exec path: ${process.argv[1]}`);
+
 	// Check if running via bunx
 	if (isRunningViaBunx()) {
+		debug("Detected bunx execution");
 		info(`Running via bunx (current: v${currentVersion})`);
 		info("bunx automatically uses cached packages.");
 		info("To get the latest version, run:");
@@ -28,7 +34,9 @@ export default async function update(): Promise<void> {
 	info(`Current version: v${currentVersion}`);
 
 	// Check for updates
+	debug("Fetching latest version from npm...");
 	const latestVersion = await checkForUpdate();
+	debug(`Latest version from npm: ${latestVersion ?? "none (you're up to date)"}`);
 
 	if (!latestVersion) {
 		success("You're on the latest version!");
@@ -38,7 +46,9 @@ export default async function update(): Promise<void> {
 	info(`New version available: v${latestVersion}`);
 	info("Updating...");
 
+	debug("Running: bun add -g @getjack/jack@latest");
 	const result = await performUpdate();
+	debug(`Update result: ${JSON.stringify(result)}`);
 
 	if (result.success) {
 		success(`Updated to v${result.version ?? latestVersion}`);

package/src/index.ts

@@ -49,6 +49,7 @@ const cli = meow(
     mcp                 MCP server for AI agents
     telemetry           Usage data settings
     feedback            Share feedback or report issues
+    community           Join the jack Discord
 
   Run 'jack <command> --help' for command-specific options.
 
@@ -370,6 +371,12 @@ try {
 			await withTelemetry("feedback", feedback)();
 			break;
 		}
+		case "community":
+		case "discord": {
+			const { default: community } = await import("./commands/community.ts");
+			await withTelemetry("community", community)();
+			break;
+		}
 		case "link": {
 			const { default: link } = await import("./commands/link.ts");
 			await withTelemetry("link", link)(args[0], { byo: cli.flags.byo });

package/src/lib/control-plane.ts

@@ -371,6 +371,46 @@ export async function createProjectResource(
 	return data.resource;
 }
 
+export interface DeleteResourceResponse {
+	success: boolean;
+	resource_id: string;
+	deleted_at: string;
+}
+
+/**
+ * Delete a resource from a managed project.
+ * Uses DELETE /v1/projects/:id/resources/:id endpoint.
+ */
+export async function deleteProjectResource(
+	projectId: string,
+	resourceId: string,
+): Promise<DeleteResourceResponse> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/${projectId}/resources/${resourceId}`,
+		{ method: "DELETE" },
+	);
+
+	// Handle 404 gracefully - resource may already be deleted
+	if (response.status === 404) {
+		return {
+			success: true,
+			resource_id: resourceId,
+			deleted_at: new Date().toISOString(),
+		};
+	}
+
+	if (!response.ok) {
+		const err = (await response.json().catch(() => ({ message: "Unknown error" }))) as {
+			message?: string;
+		};
+		throw new Error(err.message || `Failed to delete resource: ${response.status}`);
+	}
+
+	return response.json() as Promise<DeleteResourceResponse>;
+}
+
 /**
  * Sync project tags to the control plane.
  * Fire-and-forget: errors are logged but not thrown.
@@ -580,3 +620,25 @@ export async function publishProject(projectId: string): Promise<PublishProjectR
 
 	return response.json() as Promise<PublishProjectResponse>;
 }
+
+/**
+ * Download the source snapshot for a project.
+ * Returns the zip file contents as a Buffer.
+ * Used by jack clone to restore managed projects.
+ */
+export async function downloadProjectSource(slug: string): Promise<Buffer> {
+	const { authFetch } = await import("./auth/index.ts");
+
+	const response = await authFetch(
+		`${getControlApiUrl()}/v1/projects/by-slug/${encodeURIComponent(slug)}/source`,
+	);
+
+	if (!response.ok) {
+		if (response.status === 404) {
+			throw new Error("Project source not found. Deploy first with 'jack ship'.");
+		}
+		throw new Error(`Failed to download source: ${response.status}`);
+	}
+
+	return Buffer.from(await response.arrayBuffer());
+}

package/src/lib/hooks.ts

@@ -478,6 +478,26 @@ const actionHandlers: {
 			if (action.successMessage) {
 				ui.success(substituteVars(action.successMessage, context));
 			}
+
+			// Redeploy if deployAfter is set and we have a valid project directory
+			if (action.deployAfter && context.projectDir) {
+				const deployMsg = action.deployMessage || "Deploying...";
+				ui.info(deployMsg);
+
+				const proc = Bun.spawn(["wrangler", "deploy"], {
+					cwd: context.projectDir,
+					stdout: "ignore",
+					stderr: "pipe",
+				});
+				await proc.exited;
+
+				if (proc.exitCode === 0) {
+					ui.success("Deployed");
+				} else {
+					const stderr = await new Response(proc.stderr).text();
+					ui.warn(`Deploy failed: ${stderr.slice(0, 200)}`);
+				}
+			}
 		}
 
 		return true;

package/src/lib/managed-deploy.ts

@@ -4,12 +4,15 @@
  * Isolates managed deployment logic from BYO (wrangler) path.
  */
 
+import { stat } from "node:fs/promises";
 import { validateBindings } from "./binding-validator.ts";
 import { buildProject, parseWranglerConfig } from "./build-helper.ts";
 import { createManagedProject, syncProjectTags, uploadSourceSnapshot } from "./control-plane.ts";
 import { debug } from "./debug.ts";
 import { uploadDeployment } from "./deploy-upload.ts";
 import { JackError, JackErrorCode } from "./errors.ts";
+import { formatSize } from "./format.ts";
+import { createUploadProgress } from "./progress.ts";
 import type { OperationReporter } from "./project-operations.ts";
 import { getProjectTags } from "./tags.ts";
 import { Events, track } from "./telemetry.ts";
@@ -120,7 +123,28 @@ export async function deployCodeToManagedProject(
 		reporter?.success("Packaged artifacts");
 
 		// Step 4: Upload to control plane
-		reporter?.start("Uploading to jack cloud...");
+		// Calculate total upload size for progress display
+		const fileSizes = await Promise.all([
+			stat(pkg.bundleZipPath).then((s) => s.size),
+			stat(pkg.sourceZipPath).then((s) => s.size),
+			stat(pkg.manifestPath).then((s) => s.size),
+			pkg.schemaPath ? stat(pkg.schemaPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.secretsPath ? stat(pkg.secretsPath).then((s) => s.size) : Promise.resolve(0),
+			pkg.assetsZipPath ? stat(pkg.assetsZipPath).then((s) => s.size) : Promise.resolve(0),
+		]);
+		const totalUploadSize = fileSizes.reduce((sum, size) => sum + size, 0);
+		debug(`Upload size: ${formatSize(totalUploadSize)}`);
+
+		// Stop the reporter spinner - we'll use our own progress display
+		reporter?.stop();
+
+		// Use custom progress with pulsing bar (since fetch doesn't support upload progress)
+		const uploadProgress = createUploadProgress({
+			totalSize: totalUploadSize,
+			label: "Uploading to jack cloud",
+		});
+		uploadProgress.start();
+
 		const result = await uploadDeployment({
 			projectId,
 			bundleZipPath: pkg.bundleZipPath,
@@ -132,7 +156,7 @@ export async function deployCodeToManagedProject(
 			assetManifest: pkg.assetManifest ?? undefined,
 		});
 
-		reporter?.stop();
+		uploadProgress.complete();
 		reporter?.success("Deployed to jack cloud");
 
 		// Track success

package/src/lib/output.ts

@@ -2,6 +2,19 @@ import yoctoSpinner from "yocto-spinner";
 
 const isColorEnabled = !process.env.NO_COLOR && process.stderr.isTTY !== false;
 
+/**
+ * ANSI color codes for terminal output
+ */
+export const colors = {
+	green: isColorEnabled ? "\x1b[32m" : "",
+	red: isColorEnabled ? "\x1b[31m" : "",
+	yellow: isColorEnabled ? "\x1b[33m" : "",
+	cyan: isColorEnabled ? "\x1b[36m" : "",
+	dim: isColorEnabled ? "\x1b[90m" : "",
+	bold: isColorEnabled ? "\x1b[1m" : "",
+	reset: isColorEnabled ? "\x1b[0m" : "",
+};
+
 let currentSpinner: ReturnType<typeof yoctoSpinner> | null = null;
 
 /**
@@ -95,8 +108,10 @@ export function item(message: string): void {
 	console.error(`  ${message}`);
 }
 
-// Random neon purple for cyberpunk styling
-function getRandomPurple(): string {
+/**
+ * Random neon purple for cyberpunk styling
+ */
+export function getRandomPurple(): string {
 	const purples = [177, 165, 141, 129];
 	const colorCode = purples[Math.floor(Math.random() * purples.length)];
 	return `\x1b[38;5;${colorCode}m`;
@@ -117,12 +132,15 @@ export function box(title: string, lines: string[]): void {
 	const fill = "▓".repeat(innerWidth);
 	const gradient = "░".repeat(innerWidth);
 
+	// Pad plain text first, then apply colors (ANSI codes break padEnd calculation)
 	const pad = (text: string) => `  ${text.padEnd(maxLen)}  `;
+	const padTitle = (text: string) =>
+		`  ${bold}${text}${reset}${purple}${" ".repeat(maxLen - text.length)}  `;
 
 	console.error("");
 	console.error(`  ${purple}╔${bar}╗${reset}`);
 	console.error(`  ${purple}║${fill}║${reset}`);
-	console.error(`  ${purple}║${pad(bold + title + reset + purple)}║${reset}`);
+	console.error(`  ${purple}║${padTitle(title)}║${reset}`);
 	console.error(`  ${purple}║${"─".repeat(innerWidth)}║${reset}`);
 	for (const line of lines) {
 		console.error(`  ${purple}║${pad(line)}║${reset}`);

package/src/lib/progress.ts

@@ -0,0 +1,160 @@
+/**
+ * Progress tracker with delayed bar display
+ * Shows a simple spinner initially, then reveals a progress bar
+ * after a configurable delay (aligned with SPIRIT.md principles)
+ */
+
+import { formatSize } from "./format.ts";
+import { colors, getRandomPurple } from "./output.ts";
+
+export interface ProgressOptions {
+	total: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+export interface UploadProgressOptions {
+	totalSize: number;
+	delayMs?: number;
+	barWidth?: number;
+	label?: string;
+}
+
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+/**
+ * Creates a progress tracker that shows a spinner initially,
+ * then reveals a progress bar after a delay.
+ *
+ * Usage:
+ *   const progress = createProgressTracker({ total: fileSize });
+ *   progress.start();
+ *   // ... during upload
+ *   progress.update(bytesUploaded);
+ *   // ... when done
+ *   progress.complete();
+ */
+export function createProgressTracker(options: ProgressOptions) {
+	const { total, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	let frame = 0;
+	let intervalId: Timer | null = null;
+	let current = 0;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const pct = Math.min(Math.round((current / total) * 100), 100);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show progress bar after delay
+			const purple = getRandomPurple();
+			const filled = Math.round((pct / 100) * barWidth);
+			const empty = barWidth - filled;
+			const bar = "▓".repeat(filled) + "░".repeat(empty);
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${pct}% ${colors.dim}(${formatSize(current)} / ${formatSize(total)})${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			render();
+			intervalId = setInterval(render, 80);
+		},
+
+		update(bytes: number) {
+			current = bytes;
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+/**
+ * Creates an upload progress indicator for operations where we know the total
+ * size but can't track byte-level progress (e.g., fetch uploads).
+ *
+ * Shows spinner first, then after delay shows an animated bar with size info.
+ * The bar pulses to indicate activity without false progress claims.
+ */
+export function createUploadProgress(options: UploadProgressOptions) {
+	const { totalSize, delayMs = 2000, barWidth = 25, label = "Uploading" } = options;
+	const startTime = Date.now();
+	let frame = 0;
+	let pulsePos = 0;
+	let intervalId: Timer | null = null;
+
+	function render() {
+		const elapsed = Date.now() - startTime;
+		const elapsedSec = (elapsed / 1000).toFixed(1);
+
+		clearLine();
+
+		if (elapsed < delayMs) {
+			// Just spinner for first N seconds
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label}...`,
+			);
+		} else {
+			// Show pulsing bar after delay (indicates activity without false progress)
+			const purple = getRandomPurple();
+
+			// Create pulsing effect - a bright section that moves across the bar
+			const pulseWidth = 5;
+			pulsePos = (pulsePos + 1) % (barWidth + pulseWidth);
+
+			let bar = "";
+			for (let i = 0; i < barWidth; i++) {
+				const distFromPulse = Math.abs(i - pulsePos);
+				if (distFromPulse < pulseWidth) {
+					bar += "▓";
+				} else {
+					bar += "░";
+				}
+			}
+
+			process.stderr.write(
+				`${colors.cyan}${frames[frame++ % frames.length]}${colors.reset} ${label} ${purple}[${bar}]${colors.reset} ${colors.dim}${formatSize(totalSize)} • ${elapsedSec}s${colors.reset}`,
+			);
+		}
+	}
+
+	return {
+		start() {
+			if (process.stderr.isTTY) {
+				render();
+				intervalId = setInterval(render, 80);
+			}
+		},
+
+		complete() {
+			if (intervalId) {
+				clearInterval(intervalId);
+				intervalId = null;
+			}
+			clearLine();
+		},
+	};
+}
+
+function clearLine() {
+	if (process.stderr.isTTY) {
+		process.stderr.write("\r\x1b[K");
+	}
+}