@getjack/jack 0.1.13 → 0.1.15

package/src/lib/project-resolver.ts

@@ -373,6 +373,18 @@ export async function listAllProjects(): Promise<ResolvedProject[]> {
 					projectMap.set(managed.id, resolved);
 				}
 			}
+
+			// Mark orphaned local managed projects (not found on control plane) as errors
+			for (const [, project] of projectMap) {
+				if (
+					project.deployMode === "managed" &&
+					project.status === "syncing" &&
+					!project.sources.controlPlane
+				) {
+					project.status = "error";
+					project.errorMessage = "Project not found in jack cloud. Run: jack unlink && jack ship";
+				}
+			}
 		} catch {
 			// Control plane unavailable, use local-only data
 		}

package/src/lib/prompts.ts

@@ -1,4 +1,4 @@
-import { input, select } from "@inquirer/prompts";
+import { isCancel, select, text } from "@clack/prompts";
 import type { DetectedSecret } from "./env-parser.ts";
 import { info, success, warn } from "./output.ts";
 import { getSavedSecrets, getSecretsPath, maskSecret, saveSecrets } from "./secrets.ts";
@@ -25,14 +25,14 @@ export async function promptSaveSecrets(detected: DetectedSecret[]): Promise<voi
 
 	const action = await select({
 		message: "What would you like to do?",
-		choices: [
-			{ value: "save", name: "Save to jack for future projects" },
-			{ value: "paste", name: "Paste additional secrets" },
-			{ value: "skip", name: "Skip for now" },
+		options: [
+			{ value: "save", label: "Save to jack for future projects" },
+			{ value: "paste", label: "Paste additional secrets" },
+			{ value: "skip", label: "Skip for now" },
 		],
 	});
 
-	if (action === "skip") {
+	if (isCancel(action) || action === "skip") {
 		return;
 	}
 
@@ -65,18 +65,22 @@ async function promptAdditionalSecrets(): Promise<
 	const secrets: Array<{ key: string; value: string; source: string }> = [];
 
 	while (true) {
-		const key = await input({
+		const key = await text({
 			message: "Enter secret name (or press enter to finish):",
 		});
 
-		if (!key.trim()) {
+		if (isCancel(key) || !key.trim()) {
 			break;
 		}
 
-		const value = await input({
+		const value = await text({
 			message: `Enter value for ${key}:`,
 		});
 
+		if (isCancel(value)) {
+			break;
+		}
+
 		if (value.trim()) {
 			secrets.push({ key: key.trim(), value: value.trim(), source: "manual" });
 		}
@@ -107,20 +111,19 @@ export async function promptUseSecrets(): Promise<Record<string, string> | null>
 	}
 	console.error("");
 
-	console.error("  Esc to skip\n");
 	const action = await select({
 		message: "Use them for this project?",
-		choices: [
-			{ name: "1. Yes", value: "yes" },
-			{ name: "2. No", value: "no" },
+		options: [
+			{ label: "Yes", value: "yes" },
+			{ label: "No", value: "no" },
 		],
 	});
 
-	if (action === "yes") {
-		return saved;
+	if (isCancel(action) || action !== "yes") {
+		return null;
 	}
 
-	return null;
+	return saved;
 }
 
 /**
@@ -151,14 +154,13 @@ export async function promptUseSecretsFromList(
 		return false;
 	}
 
-	console.error("  Esc to skip\n");
 	const action = await select({
 		message: "Use saved secrets for this project?",
-		choices: [
-			{ name: "1. Yes", value: "yes" },
-			{ name: "2. No", value: "no" },
+		options: [
+			{ label: "Yes", value: "yes" },
+			{ label: "No", value: "no" },
 		],
 	});
 
-	return action === "yes";
+	return !isCancel(action) && action === "yes";
 }

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

@@ -0,0 +1,187 @@
+/**
+ * Database creation logic for jack services db create
+ *
+ * Handles both managed (control plane) and BYO (wrangler d1 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 { addD1Binding, getExistingD1Bindings } from "../wrangler-config.ts";
+
+export interface CreateDatabaseOptions {
+	name?: string;
+	interactive?: boolean; // Whether to prompt for deploy
+}
+
+export interface CreateDatabaseResult {
+	databaseName: string;
+	databaseId: string;
+	bindingName: string;
+	created: boolean; // false if reused existing
+}
+
+/**
+ * Convert a database name to SCREAMING_SNAKE_CASE for the binding name.
+ * Special case: first database in a project gets "DB" as the binding.
+ */
+function toBindingName(dbName: string, isFirst: boolean): string {
+	if (isFirst) {
+		return "DB";
+	}
+	// Convert kebab-case/snake_case to SCREAMING_SNAKE_CASE
+	return dbName
+		.replace(/-/g, "_")
+		.replace(/[^a-zA-Z0-9_]/g, "")
+		.toUpperCase();
+}
+
+/**
+ * Generate a unique database name for a project.
+ * First DB: {project}-db
+ * Subsequent DBs: {project}-db-{n}
+ */
+function generateDatabaseName(projectName: string, existingCount: number): string {
+	if (existingCount === 0) {
+		return `${projectName}-db`;
+	}
+	return `${projectName}-db-${existingCount + 1}`;
+}
+
+interface ExistingDatabase {
+	uuid: string;
+	name: string;
+}
+
+/**
+ * List all D1 databases in the Cloudflare account via wrangler
+ */
+async function listDatabasesViaWrangler(): Promise<ExistingDatabase[]> {
+	const result = await $`wrangler d1 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 d1 list --json returns array: [{ "uuid": "...", "name": "...", ... }]
+		return Array.isArray(data) ? data : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Find an existing D1 database by name
+ */
+async function findExistingDatabase(dbName: string): Promise<ExistingDatabase | null> {
+	const databases = await listDatabasesViaWrangler();
+	return databases.find((db) => db.name === dbName) ?? null;
+}
+
+/**
+ * Create a D1 database via wrangler (for BYO mode)
+ */
+async function createDatabaseViaWrangler(
+	dbName: string,
+): Promise<{ id: string; created: boolean }> {
+	// Check if database already exists
+	const existing = await findExistingDatabase(dbName);
+	if (existing) {
+		return { id: existing.uuid, created: false };
+	}
+
+	const result = await $`wrangler d1 create ${dbName} --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to create database ${dbName}`);
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+		// wrangler d1 create --json returns: { "uuid": "...", "name": "..." }
+		return { id: data.uuid || "", created: true };
+	} catch {
+		throw new Error("Failed to parse wrangler d1 create output");
+	}
+}
+
+/**
+ * Create a D1 database for the current project.
+ *
+ * For managed projects: calls control plane POST /v1/projects/:id/resources/d1
+ * For BYO projects: uses wrangler d1 create
+ *
+ * In both cases, updates wrangler.jsonc with the new binding.
+ */
+export async function createDatabase(
+	projectDir: string,
+	options: CreateDatabaseOptions = {},
+): Promise<CreateDatabaseResult> {
+	// 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 D1 bindings to determine naming
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+	const existingBindings = await getExistingD1Bindings(wranglerPath);
+	const existingCount = existingBindings.length;
+
+	// Determine database name
+	const databaseName = options.name ?? generateDatabaseName(projectName, existingCount);
+
+	// Determine binding name
+	const isFirst = existingCount === 0;
+	const bindingName = toBindingName(databaseName, 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 database name.`);
+	}
+
+	let databaseId: string;
+	let created = true;
+
+	if (link.deploy_mode === "managed") {
+		// Managed mode: call control plane
+		// Note: Control plane will reuse existing DB if name matches
+		const resource = await createProjectResource(link.project_id, "d1", {
+			name: databaseName,
+			bindingName,
+		});
+		databaseId = resource.provider_id;
+		// Control plane always creates for now; could add reuse logic there too
+	} else {
+		// BYO mode: use wrangler d1 create (checks for existing first)
+		const result = await createDatabaseViaWrangler(databaseName);
+		databaseId = result.id;
+		created = result.created;
+	}
+
+	// Update wrangler.jsonc with the new binding
+	await addD1Binding(wranglerPath, {
+		binding: bindingName,
+		database_name: databaseName,
+		database_id: databaseId,
+	});
+
+	return {
+		databaseName,
+		databaseId,
+		bindingName,
+		created,
+	};
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Database listing logic for jack services db list
+ *
+ * Lists D1 databases configured in wrangler.jsonc with their metadata.
+ */
+
+import { join } from "node:path";
+import { getExistingD1Bindings } from "../wrangler-config.ts";
+import { getDatabaseInfo } from "./db.ts";
+
+export interface DatabaseListEntry {
+	name: string;
+	binding: string;
+	id: string;
+	sizeBytes?: number;
+	numTables?: number;
+}
+
+/**
+ * List all D1 databases configured for a project.
+ *
+ * Reads bindings from wrangler.jsonc and fetches additional metadata
+ * (size, table count) via wrangler d1 info for each database.
+ */
+export async function listDatabases(projectDir: string): Promise<DatabaseListEntry[]> {
+	const wranglerPath = join(projectDir, "wrangler.jsonc");
+
+	// Get existing D1 bindings from wrangler.jsonc
+	const bindings = await getExistingD1Bindings(wranglerPath);
+
+	if (bindings.length === 0) {
+		return [];
+	}
+
+	// Fetch detailed info for each database
+	const entries: DatabaseListEntry[] = [];
+
+	for (const binding of bindings) {
+		const entry: DatabaseListEntry = {
+			name: binding.database_name,
+			binding: binding.binding,
+			id: binding.database_id,
+		};
+
+		// Try to get additional metadata via wrangler
+		const info = await getDatabaseInfo(binding.database_name);
+		if (info) {
+			entry.sizeBytes = info.sizeBytes;
+			entry.numTables = info.numTables;
+		}
+
+		entries.push(entry);
+	}
+
+	return entries;
+}

package/src/lib/version-check.ts

@@ -0,0 +1,170 @@
+/**
+ * Version checking utilities for self-update functionality
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { $ } from "bun";
+import pkg from "../../package.json";
+import { CONFIG_DIR } from "./config.ts";
+
+const VERSION_CACHE_PATH = join(CONFIG_DIR, "version-cache.json");
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const PACKAGE_NAME = "@getjack/jack";
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+
+interface VersionCache {
+	latestVersion: string;
+	checkedAt: number;
+}
+
+/**
+ * Get the current installed version
+ */
+export function getCurrentVersion(): string {
+	return pkg.version;
+}
+
+/**
+ * Fetch the latest version from npm registry
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+	try {
+		const response = await fetch(NPM_REGISTRY_URL, {
+			headers: { Accept: "application/json" },
+			signal: AbortSignal.timeout(5000), // 5 second timeout
+		});
+		if (!response.ok) return null;
+		const data = (await response.json()) as { version: string };
+		return data.version;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read cached version info
+ */
+async function readVersionCache(): Promise<VersionCache | null> {
+	if (!existsSync(VERSION_CACHE_PATH)) return null;
+	try {
+		return await Bun.file(VERSION_CACHE_PATH).json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Write version info to cache
+ */
+async function writeVersionCache(cache: VersionCache): Promise<void> {
+	try {
+		await Bun.write(VERSION_CACHE_PATH, JSON.stringify(cache));
+	} catch {
+		// Ignore cache write errors
+	}
+}
+
+/**
+ * Compare semver versions (simple comparison, assumes valid semver)
+ */
+function isNewerVersion(latest: string, current: string): boolean {
+	const latestParts = latest.split(".").map(Number);
+	const currentParts = current.split(".").map(Number);
+
+	for (let i = 0; i < 3; i++) {
+		const l = latestParts[i] ?? 0;
+		const c = currentParts[i] ?? 0;
+		if (l > c) return true;
+		if (l < c) return false;
+	}
+	return false;
+}
+
+/**
+ * Check if an update is available (uses cache, non-blocking)
+ * Returns the latest version if newer, null otherwise
+ */
+export async function checkForUpdate(): Promise<string | null> {
+	const currentVersion = getCurrentVersion();
+
+	// Check cache first
+	const cache = await readVersionCache();
+	const now = Date.now();
+
+	if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
+		// Use cached value
+		if (isNewerVersion(cache.latestVersion, currentVersion)) {
+			return cache.latestVersion;
+		}
+		return null;
+	}
+
+	// Fetch fresh version (don't await in caller for non-blocking)
+	const latestVersion = await fetchLatestVersion();
+	if (!latestVersion) return null;
+
+	// Update cache
+	await writeVersionCache({ latestVersion, checkedAt: now });
+
+	if (isNewerVersion(latestVersion, currentVersion)) {
+		return latestVersion;
+	}
+	return null;
+}
+
+/**
+ * Perform the actual update
+ */
+export async function performUpdate(): Promise<{
+	success: boolean;
+	version?: string;
+	error?: string;
+}> {
+	try {
+		// Run bun add -g to update
+		const result = await $`bun add -g ${PACKAGE_NAME}@latest`.nothrow().quiet();
+
+		if (result.exitCode !== 0) {
+			return {
+				success: false,
+				error: result.stderr.toString() || "Update failed",
+			};
+		}
+
+		// Verify the new version
+		const newVersionResult = await $`bun pm ls -g`.nothrow().quiet();
+		const output = newVersionResult.stdout.toString();
+
+		// Try to extract version from output
+		const versionMatch = output.match(/@getjack\/jack@(\d+\.\d+\.\d+)/);
+		const newVersion = versionMatch?.[1];
+
+		// Clear version cache so next check gets fresh data
+		try {
+			await Bun.write(VERSION_CACHE_PATH, "");
+		} catch {
+			// Ignore
+		}
+
+		return {
+			success: true,
+			version: newVersion,
+		};
+	} catch (err) {
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : "Unknown error",
+		};
+	}
+}
+
+/**
+ * Check if running via bunx (vs global install)
+ * bunx runs from a temp cache directory
+ */
+export function isRunningViaBunx(): boolean {
+	// bunx runs from ~/.bun/install/cache or similar temp location
+	const execPath = process.argv[1] ?? "";
+	return execPath.includes(".bun/install/cache") || execPath.includes("/.cache/");
+}

package/src/mcp/resources/index.ts

@@ -5,6 +5,7 @@ import {
 	ListResourcesRequestSchema,
 	ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
+import packageJson from "../../../package.json" with { type: "json" };
 import type { DebugLogger, McpServerOptions } from "../types.ts";
 
 export function registerResources(
@@ -24,6 +25,12 @@ export function registerResources(
 						"Project-specific context files (AGENTS.md, CLAUDE.md) for AI agents working on this project",
 					mimeType: "text/markdown",
 				},
+				{
+					uri: "jack://capabilities",
+					name: "Jack Capabilities",
+					description: "Semantic information about jack's capabilities for AI agents",
+					mimeType: "application/json",
+				},
 			],
 		};
 	});
@@ -33,6 +40,31 @@ export function registerResources(
 		const uri = request.params.uri;
 		debug("resources/read requested", { uri });
 
+		if (uri === "jack://capabilities") {
+			const capabilities = {
+				version: packageJson.version,
+				services: {
+					supported: ["d1", "kv", "r2"],
+					create_supported: ["d1"],
+				},
+				guidance: {
+					prefer_jack_over_wrangler: true,
+					database_creation: "Use create_database tool or jack services db create",
+					deployment: "Use deploy_project tool or jack ship",
+				},
+			};
+
+			return {
+				contents: [
+					{
+						uri,
+						mimeType: "application/json",
+						text: JSON.stringify(capabilities, null, 2),
+					},
+				],
+			};
+		}
+
 		if (uri === "agents://context") {
 			const projectPath = options.projectPath ?? process.cwd();
 			const agentsPath = join(projectPath, "AGENTS.md");