@getjack/jack 0.1.14 → 0.1.16

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/lib/wrangler.ts

@@ -32,6 +32,7 @@ export async function ensureWrangler(): Promise<void> {
 
 		if (install.exitCode !== 0) {
 			spin.error("Failed to install wrangler");
+			error("Try manually: bun add -g wrangler");
 			process.exit(1);
 		}
 		spin.success("Installed wrangler");
@@ -53,6 +54,7 @@ export async function ensureAuth(): Promise<void> {
 
 		if (login.exitCode !== 0) {
 			error("Failed to authenticate with Cloudflare");
+			error("Try manually: wrangler login");
 			process.exit(1);
 		}
 	}

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");

package/src/mcp/tools/index.ts

@@ -4,6 +4,8 @@ import { z } from "zod";
 import { JackError, JackErrorCode } from "../../lib/errors.ts";
 import { createProject, deployProject, getProjectStatus } from "../../lib/project-operations.ts";
 import { listAllProjects } from "../../lib/project-resolver.ts";
+import { createDatabase } from "../../lib/services/db-create.ts";
+import { listDatabases } from "../../lib/services/db-list.ts";
 import { Events, track, withTelemetry } from "../../lib/telemetry.ts";
 import type { DebugLogger, McpServerOptions } from "../types.ts";
 import { formatErrorResponse, formatSuccessResponse } from "../utils.ts";
@@ -36,6 +38,21 @@ const ListProjectsSchema = z.object({
 		.describe("Filter projects by status (defaults to 'all')"),
 });
 
+const CreateDatabaseSchema = z.object({
+	name: z.string().optional().describe("Database name (auto-generated if not provided)"),
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
+const ListDatabasesSchema = z.object({
+	project_path: z
+		.string()
+		.optional()
+		.describe("Path to project directory (defaults to current directory)"),
+});
+
 export function registerTools(server: McpServer, _options: McpServerOptions, debug: DebugLogger) {
 	// Register tool list handler
 	server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -107,6 +124,37 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 						},
 					},
 				},
+				{
+					name: "create_database",
+					description:
+						"Create a D1 database for a project. Returns deploy_required=true since binding needs deploy to activate.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							name: {
+								type: "string",
+								description: "Database name (auto-generated if not provided)",
+							},
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+					},
+				},
+				{
+					name: "list_databases",
+					description: "List all D1 databases for a project.",
+					inputSchema: {
+						type: "object",
+						properties: {
+							project_path: {
+								type: "string",
+								description: "Path to project directory (defaults to current directory)",
+							},
+						},
+					},
+				},
 			],
 		};
 	});
@@ -195,7 +243,15 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					const wrappedGetProjectStatus = withTelemetry(
 						"get_project_status",
 						async (name?: string, projectPath?: string) => {
-							return await getProjectStatus(name, projectPath);
+							const status = await getProjectStatus(name, projectPath);
+							if (status === null) {
+								return null;
+							}
+							// Add available_services to tell agents what services can be created
+							return {
+								...status,
+								available_services: ["d1", "kv", "r2"],
+							};
 						},
 						{ platform: "mcp" },
 					);
@@ -259,6 +315,80 @@ export function registerTools(server: McpServer, _options: McpServerOptions, deb
 					};
 				}
 
+				case "create_database": {
+					const args = CreateDatabaseSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedCreateDatabase = withTelemetry(
+						"create_database",
+						async (projectDir: string, name?: string) => {
+							const result = await createDatabase(projectDir, {
+								name,
+								interactive: false,
+							});
+
+							// Track business event
+							track(Events.SERVICE_CREATED, {
+								service_type: "d1",
+								platform: "mcp",
+							});
+
+							return {
+								database_name: result.databaseName,
+								database_id: result.databaseId,
+								binding_name: result.bindingName,
+								created: result.created,
+								deploy_required: true,
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedCreateDatabase(projectPath, args.name);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
+				case "list_databases": {
+					const args = ListDatabasesSchema.parse(request.params.arguments ?? {});
+					const projectPath = args.project_path ?? process.cwd();
+
+					const wrappedListDatabases = withTelemetry(
+						"list_databases",
+						async (projectDir: string) => {
+							const databases = await listDatabases(projectDir);
+							return {
+								databases: databases.map((db) => ({
+									name: db.name,
+									binding: db.binding,
+									id: db.id,
+									size_bytes: db.sizeBytes,
+									num_tables: db.numTables,
+								})),
+							};
+						},
+						{ platform: "mcp" },
+					);
+
+					const result = await wrappedListDatabases(projectPath);
+
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(formatSuccessResponse(result, startTime), null, 2),
+							},
+						],
+					};
+				}
+
 				default:
 					throw new Error(`Unknown tool: ${toolName}`);
 			}

package/src/mcp/utils.ts

@@ -142,6 +142,6 @@ export function getSuggestionForError(code: McpErrorCode): string {
 			return "Review the error message and ensure all required fields are provided correctly.";
 
 		default:
-			return "An unexpected error occurred. Check the error message for details.";
+			return "Check the error message above for details. If the problem persists, try running the equivalent CLI command directly.";
 	}
 }