@getjack/jack 0.1.0 → 0.1.1

package/src/commands/services.ts

@@ -0,0 +1,315 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { select } from "@inquirer/prompts";
+import { formatSize } from "../lib/format.ts";
+import { error, info, item, output as outputSpinner, success, warn } from "../lib/output.ts";
+import {
+	type Project,
+	getProject,
+	getProjectDatabaseName,
+	updateProjectDatabase,
+} from "../lib/registry.ts";
+import {
+	deleteDatabase,
+	exportDatabase,
+	generateExportFilename,
+	getDatabaseInfo,
+} from "../lib/services/db.ts";
+import { getProjectNameFromDir } from "../lib/storage/index.ts";
+
+/**
+ * Get database name from wrangler.jsonc/toml file
+ * Fallback when registry doesn't have the info
+ */
+async function getDatabaseFromWranglerConfig(projectPath: string): Promise<string | null> {
+	// Try wrangler.jsonc first
+	const jsoncPath = join(projectPath, "wrangler.jsonc");
+	if (existsSync(jsoncPath)) {
+		try {
+			const content = await Bun.file(jsoncPath).text();
+			// Remove comments for JSON parsing (simple approach)
+			const jsonContent = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+			const config = JSON.parse(jsonContent);
+			if (config.d1_databases?.[0]?.database_name) {
+				return config.d1_databases[0].database_name;
+			}
+		} catch {
+			// Ignore parse errors
+		}
+	}
+
+	// Try wrangler.toml
+	const tomlPath = join(projectPath, "wrangler.toml");
+	if (existsSync(tomlPath)) {
+		try {
+			const content = await Bun.file(tomlPath).text();
+			// Simple regex to extract database_name from [[d1_databases]] section
+			const match = content.match(/database_name\s*=\s*"([^"]+)"/);
+			if (match?.[1]) {
+				return match[1];
+			}
+		} catch {
+			// Ignore read errors
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Get database name for a project, with fallback to wrangler config
+ */
+async function resolveDbName(project: Project): Promise<string | null> {
+	// First check registry
+	const dbFromRegistry = getProjectDatabaseName(project);
+	if (dbFromRegistry) {
+		return dbFromRegistry;
+	}
+
+	// Fallback: read from wrangler config file
+	if (project.localPath && existsSync(project.localPath)) {
+		return await getDatabaseFromWranglerConfig(project.localPath);
+	}
+
+	return null;
+}
+
+interface ServiceOptions {
+	project?: string;
+}
+
+export default async function services(
+	subcommand?: string,
+	args: string[] = [],
+	options: ServiceOptions = {},
+): Promise<void> {
+	if (!subcommand) {
+		return showHelp();
+	}
+
+	switch (subcommand) {
+		case "db":
+			return await dbCommand(args, options);
+		default:
+			error(`Unknown service: ${subcommand}`);
+			info("Available: db");
+			process.exit(1);
+	}
+}
+
+function showHelp(): void {
+	console.error("");
+	info("jack services - Manage project services");
+	console.error("");
+	console.error("Commands:");
+	console.error("  db         Manage database");
+	console.error("");
+	console.error("Run 'jack services <command>' for more information.");
+	console.error("");
+}
+
+async function dbCommand(args: string[], options: ServiceOptions): Promise<void> {
+	const action = args[0] || "info"; // Default to info
+
+	switch (action) {
+		case "info":
+			return await dbInfo(options);
+		case "export":
+			return await dbExport(options);
+		case "delete":
+			return await dbDelete(options);
+		default:
+			error(`Unknown action: ${action}`);
+			info("Available: info, export, delete");
+			process.exit(1);
+	}
+}
+
+/**
+ * Resolve project name from options or current directory
+ */
+async function resolveProjectName(options: ServiceOptions): Promise<string> {
+	if (options.project) {
+		return options.project;
+	}
+
+	try {
+		return await getProjectNameFromDir(process.cwd());
+	} catch {
+		error("Could not determine project");
+		info("Run from a project directory, or use --project <name>");
+		process.exit(1);
+	}
+}
+
+/**
+ * Show database information
+ */
+async function dbInfo(options: ServiceOptions): Promise<void> {
+	const projectName = await resolveProjectName(options);
+	const project = await getProject(projectName);
+
+	if (!project) {
+		error(`Project "${projectName}" not found in registry`);
+		info("List projects with: jack projects list");
+		process.exit(1);
+	}
+
+	const dbName = await resolveDbName(project);
+
+	if (!dbName) {
+		console.error("");
+		info("No database configured for this project");
+		console.error("");
+		return;
+	}
+
+	// Fetch database info
+	outputSpinner.start("Fetching database info...");
+	const dbInfo = await getDatabaseInfo(dbName);
+	outputSpinner.stop();
+
+	if (!dbInfo) {
+		console.error("");
+		error("Database not found");
+		info("It may have been deleted");
+		console.error("");
+		process.exit(1);
+	}
+
+	// Display info
+	console.error("");
+	success(`Database: ${dbInfo.name}`);
+	console.error("");
+	item(`Size: ${formatSize(dbInfo.sizeBytes)}`);
+	item(`Tables: ${dbInfo.numTables}`);
+	item(`ID: ${dbInfo.id}`);
+	console.error("");
+}
+
+/**
+ * Export database to SQL file
+ */
+async function dbExport(options: ServiceOptions): Promise<void> {
+	const projectName = await resolveProjectName(options);
+	const project = await getProject(projectName);
+
+	if (!project) {
+		error(`Project "${projectName}" not found in registry`);
+		info("List projects with: jack projects list");
+		process.exit(1);
+	}
+
+	const dbName = await resolveDbName(project);
+
+	if (!dbName) {
+		console.error("");
+		info("No database configured for this project");
+		console.error("");
+		return;
+	}
+
+	// Generate filename
+	const filename = generateExportFilename(dbName);
+
+	// Determine output directory (project dir if in it, cwd otherwise)
+	let outputDir = process.cwd();
+	if (project.localPath && existsSync(project.localPath)) {
+		// Check if we're in the project directory or subdirectory
+		const cwd = process.cwd();
+		if (cwd === project.localPath || cwd.startsWith(`${project.localPath}/`)) {
+			outputDir = project.localPath;
+		}
+	}
+
+	const outputPath = join(outputDir, filename);
+
+	// Export
+	outputSpinner.start("Exporting database...");
+	try {
+		await exportDatabase(dbName, outputPath);
+		outputSpinner.stop();
+
+		console.error("");
+		success(`Exported to ./${filename}`);
+		console.error("");
+	} catch (err) {
+		outputSpinner.stop();
+		console.error("");
+		error(`Failed to export: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}
+
+/**
+ * Delete database with full cleanup
+ */
+async function dbDelete(options: ServiceOptions): Promise<void> {
+	const projectName = await resolveProjectName(options);
+	const project = await getProject(projectName);
+
+	if (!project) {
+		error(`Project "${projectName}" not found in registry`);
+		info("List projects with: jack projects list");
+		process.exit(1);
+	}
+
+	const dbName = await resolveDbName(project);
+
+	if (!dbName) {
+		console.error("");
+		info("No database configured for this project");
+		console.error("");
+		return;
+	}
+
+	// Get database info to show what will be deleted
+	outputSpinner.start("Fetching database info...");
+	const dbInfo = await getDatabaseInfo(dbName);
+	outputSpinner.stop();
+
+	// Show what will be deleted
+	console.error("");
+	info(`Database: ${dbName}`);
+	if (dbInfo) {
+		item(`Size: ${formatSize(dbInfo.sizeBytes)}`);
+		item(`Tables: ${dbInfo.numTables}`);
+	}
+	console.error("");
+	warn("This will permanently delete the database and all its data");
+	console.error("");
+
+	// Confirm deletion
+	console.error("  Esc to skip\n");
+	const action = await select({
+		message: `Delete database '${dbName}'?`,
+		choices: [
+			{ name: "1. Yes", value: "yes" },
+			{ name: "2. No", value: "no" },
+		],
+	});
+
+	if (action === "no") {
+		info("Cancelled");
+		return;
+	}
+
+	// Delete database
+	outputSpinner.start("Deleting database...");
+	try {
+		await deleteDatabase(dbName);
+		outputSpinner.stop();
+
+		// Update registry (set db to null in services structure)
+		await updateProjectDatabase(projectName, null);
+
+		console.error("");
+		success("Database deleted");
+		console.error("");
+	} catch (err) {
+		outputSpinner.stop();
+		console.error("");
+		error(`Failed to delete: ${err instanceof Error ? err.message : String(err)}`);
+		process.exit(1);
+	}
+}

package/src/commands/ship.ts

@@ -1,150 +1,44 @@
-import { existsSync } from "node:fs";
-import { basename } from "node:path";
-import { $ } from "bun";
-import { getSyncConfig } from "../lib/config.ts";
-import { detectSecrets } from "../lib/env-parser.ts";
-import { error, info, spinner, success, warn } from "../lib/output.ts";
-import { filterNewSecrets, promptSaveSecrets } from "../lib/prompts.ts";
-import { applySchema, getD1DatabaseName, hasD1Config } from "../lib/schema.ts";
-import { getProjectNameFromDir, syncToCloud } from "../lib/storage/index.ts";
-
-function hasWranglerConfig(): boolean {
-	return (
-		existsSync("./wrangler.toml") || existsSync("./wrangler.jsonc") || existsSync("./wrangler.json")
-	);
-}
-
-function isViteProject(): boolean {
-	return (
-		existsSync("./vite.config.ts") ||
-		existsSync("./vite.config.js") ||
-		existsSync("./vite.config.mjs")
-	);
-}
-
-async function getProjectName(): Promise<string> {
-	const configPaths = ["./wrangler.jsonc", "./wrangler.json", "./wrangler.toml"];
-
-	for (const configPath of configPaths) {
-		if (existsSync(configPath)) {
-			try {
-				const content = await Bun.file(configPath).text();
-				// For JSON/JSONC - strip comments and parse
-				if (configPath.endsWith(".json") || configPath.endsWith(".jsonc")) {
-					const cleaned = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-					const config = JSON.parse(cleaned);
-					if (config.name) return config.name;
-				}
-				// For TOML
-				if (configPath.endsWith(".toml")) {
-					const match = content.match(/name\s*=\s*"([^"]+)"/);
-					if (match?.[1]) return match[1];
-				}
-			} catch {}
-		}
-	}
-
-	// Fallback to directory name
-	return basename(process.cwd());
-}
+import { getErrorDetails } from "../lib/errors.ts";
+import { output, spinner } from "../lib/output.ts";
+import { deployProject } from "../lib/project-operations.ts";
 
 export default async function ship(): Promise<void> {
-	if (!hasWranglerConfig()) {
-		error("No wrangler config found in current directory");
-		error("Run: jack new <project-name>");
-		process.exit(1);
-	}
-
-	// For Vite projects, build first
-	if (isViteProject()) {
-		const buildSpin = spinner("Building...");
-		const buildResult = await $`npx vite build`.nothrow().quiet();
-
-		if (buildResult.exitCode !== 0) {
-			buildSpin.error("Build failed");
-			console.error(buildResult.stderr.toString());
-			process.exit(buildResult.exitCode);
-		}
-		buildSpin.success("Built");
-	}
-
-	const spin = spinner("Deploying...");
-
-	const result = await $`wrangler deploy`.nothrow().quiet();
-
-	if (result.exitCode !== 0) {
-		spin.error("Deploy failed");
-		console.error(result.stderr.toString());
-		process.exit(result.exitCode);
-	}
-
-	// Parse URL from output
-	const output = result.stdout.toString();
-	const urlMatch = output.match(/https:\/\/[\w-]+\.[\w-]+\.workers\.dev/);
-
-	if (urlMatch) {
-		spin.success(`Live: ${urlMatch[0]}`);
-	} else {
-		spin.success("Deployed");
-		console.error(output);
-	}
-
-	// Update registry after successful deploy
+	const isCi = process.env.CI === "true" || process.env.CI === "1";
 	try {
-		const { registerProject } = await import("../lib/registry.ts");
-		const projectName = await getProjectNameFromDir(process.cwd());
-
-		await registerProject(projectName, {
-			localPath: process.cwd(),
-			workerUrl: urlMatch ? urlMatch[0] : null,
-			lastDeployed: new Date().toISOString(),
+		const result = await deployProject({
+			projectPath: process.cwd(),
+			reporter: {
+				start: output.start,
+				stop: output.stop,
+				spinner,
+				info: output.info,
+				warn: output.warn,
+				error: output.error,
+				success: output.success,
+				box: output.box,
+			},
+			interactive: !isCi,
+			includeSecrets: true,
+			includeSync: true,
 		});
-	} catch {
-		// Don't fail the deploy if registry update fails
-	}
 
-	// Apply schema.sql after deploy (database auto-provisioned by wrangler)
-	const projectDir = process.cwd();
-	if (await hasD1Config(projectDir)) {
-		const dbName = await getD1DatabaseName(projectDir);
-		if (dbName) {
-			try {
-				await applySchema(dbName, projectDir);
-			} catch (err) {
-				warn(`Schema application failed: ${err}`);
-				info("Run manually: bun run db:migrate");
-			}
+		if (!result.workerUrl && result.deployOutput) {
+			console.error(result.deployOutput);
+		}
+	} catch (error) {
+		const details = getErrorDetails(error);
+		if (!details.meta?.reported) {
+			output.error(details.message);
 		}
-	}
-
-	// Detect and offer to save secrets
-	const detected = await detectSecrets();
-	const newSecrets = await filterNewSecrets(detected);
 
-	if (newSecrets.length > 0) {
-		await promptSaveSecrets(newSecrets);
-	}
+		if (details.meta?.stderr) {
+			console.error(details.meta.stderr);
+		}
 
-	// Auto-sync to cloud storage
-	const syncConfig = await getSyncConfig();
-	if (syncConfig.enabled && syncConfig.autoSync) {
-		const syncSpin = spinner("Syncing source to cloud...");
-		try {
-			const projectName = await getProjectNameFromDir(process.cwd());
-			const result = await syncToCloud(process.cwd());
-			if (result.success) {
-				if (result.filesUploaded > 0 || result.filesDeleted > 0) {
-					syncSpin.success(
-						`Backed up ${result.filesUploaded} files to jack-storage/${projectName}/`,
-					);
-				} else {
-					syncSpin.success("Source already synced");
-				}
-			}
-		} catch (err) {
-			syncSpin.stop();
-			warn("Cloud sync failed (deploy succeeded)");
-			info("Run: jack sync");
+		if (details.suggestion && !details.meta?.reported) {
+			output.info(details.suggestion);
 		}
+
+		process.exit(details.meta?.exitCode ?? 1);
 	}
 }

package/src/index.ts

@@ -20,9 +20,11 @@ const cli = meow(
     sync                Sync to cloud storage
     clone <project>     Pull project from cloud
     cloud               Manage cloud storage
-    down [name]         Shut down a deployed worker
+    down [name]         Undeploy from cloud
     open [name]         Open project in browser
     projects            Manage project registry
+    services            Manage project services
+    mcp serve           Start MCP server for AI agents
     telemetry           Manage anonymous usage data
     about               The story behind jack
 
@@ -37,12 +39,13 @@ const cli = meow(
     --dry-run       Preview changes without applying
     --force         Force operation
     --as <name>     Clone to different directory name
-    --dash          Open Cloudflare dashboard
+    --dash          Open cloud dashboard
     --logs          Open logs page
     --yes           Skip confirmation prompts
     --local         Filter by local projects
     --deployed      Filter by deployed projects
     --cloud         Filter by cloud-backed projects
+    --skip-mcp      Skip MCP config installation during init
 
   Examples
     $ jack init           Set up once
@@ -100,6 +103,14 @@ const cli = meow(
 				type: "boolean",
 				default: false,
 			},
+			project: {
+				type: "string",
+				shortFlag: "p",
+			},
+			skipMcp: {
+				type: "boolean",
+				default: false,
+			},
 		},
 	},
 );
@@ -123,7 +134,7 @@ identify({
 switch (command) {
 	case "init": {
 		const { default: init } = await import("./commands/init.ts");
-		await withTelemetry("init", init)();
+		await withTelemetry("init", init)({ skipMcp: cli.flags.skipMcp });
 		break;
 	}
 	case "new":
@@ -207,6 +218,19 @@ switch (command) {
 		await withTelemetry("projects", projects)(args[0], projectArgs);
 		break;
 	}
+	case "services": {
+		const { default: services } = await import("./commands/services.ts");
+		await withTelemetry("services", services)(args[0], args.slice(1), {
+			project: cli.flags.project,
+		});
+		break;
+	}
+	case "mcp": {
+		const { default: mcp } = await import("./commands/mcp.ts");
+		// Note: Don't use withTelemetry wrapper for MCP serve - it runs indefinitely
+		await mcp(args[0], { project: cli.flags.project });
+		break;
+	}
 	case "ls": {
 		const { default: projects } = await import("./commands/projects.ts");
 		const lsArgs: string[] = [];

package/src/lib/agent-files.ts

@@ -50,43 +50,6 @@ Never run \`wrangler\` commands directly. All deployment is handled by jack.
 `;
 }
 
-/**
- * Template for .cursorrules
- */
-function generateCursorrules(): string {
-	return `# Cursor Rules
-
-See AGENTS.md for project context and deployment instructions.
-
-## Deployment Commands
-
-- Deploy: \`jack ship\`
-- Logs: \`jack logs\`
-- Dev server: \`jack dev\`
-
-Do not suggest \`wrangler\` commands - all deployment is handled by jack.
-`;
-}
-
-/**
- * Template for .windsurfrules
- */
-function generateWindsurfrules(): string {
-	return `# Windsurf Rules
-
-See AGENTS.md for project context and deployment instructions.
-
-## Deployment
-
-This project uses jack for deployment:
-- \`jack ship\` - Deploy to production
-- \`jack logs\` - View logs
-- \`jack dev\` - Local development
-
-Never suggest wrangler commands directly.
-`;
-}
-
 /**
  * Generate content for a specific template type
  */
@@ -100,10 +63,6 @@ function generateFileContent(
 			return generateAgentsMd(projectName, template);
 		case "claude-md":
 			return generateClaudeMd();
-		case "cursorrules":
-			return generateCursorrules();
-		case "windsurfrules":
-			return generateWindsurfrules();
 		default:
 			throw new Error(`Unknown template type: ${templateType}`);
 	}