@getjack/jack 0.1.0 → 0.1.1

package/src/lib/prompts.ts

@@ -1,4 +1,4 @@
-import { confirm, input, select } from "@inquirer/prompts";
+import { input, select } from "@inquirer/prompts";
 import type { DetectedSecret } from "./env-parser.ts";
 import { info, success, warn } from "./output.ts";
 import { getSavedSecrets, getSecretsPath, maskSecret, saveSecrets } from "./secrets.ts";
@@ -107,12 +107,16 @@ export async function promptUseSecrets(): Promise<Record<string, string> | null>
 	}
 	console.error("");
 
-	const useSecrets = await confirm({
+	console.error("  Esc to skip\n");
+	const action = await select({
 		message: "Use them for this project?",
-		default: true,
+		choices: [
+			{ name: "1. Yes", value: "yes" },
+			{ name: "2. No", value: "no" },
+		],
 	});
 
-	if (useSecrets) {
+	if (action === "yes") {
 		return saved;
 	}
 
@@ -147,10 +151,14 @@ export async function promptUseSecretsFromList(
 		return false;
 	}
 
-	const useSecrets = await confirm({
+	console.error("  Esc to skip\n");
+	const action = await select({
 		message: "Use saved secrets for this project?",
-		default: true,
+		choices: [
+			{ name: "1. Yes", value: "yes" },
+			{ name: "2. No", value: "no" },
+		],
 	});
 
-	return useSecrets;
+	return action === "yes";
 }

package/src/lib/registry.ts

@@ -15,7 +15,9 @@ export interface Project {
 		workerId: string;
 	};
 	resources: {
-		d1Databases: string[];
+		services: {
+			db: string | null;
+		};
 	};
 }
 
@@ -112,3 +114,29 @@ export async function getAllProjects(): Promise<Record<string, Project>> {
 	const registry = await readRegistry();
 	return registry.projects;
 }
+
+/**
+ * Get database name for a project
+ * @returns Database name or null if no database is configured
+ */
+export function getProjectDatabaseName(project: Project): string | null {
+	return project.resources?.services?.db ?? null;
+}
+
+/**
+ * Update the database for a project using the new services structure
+ */
+export async function updateProjectDatabase(name: string, dbName: string | null): Promise<void> {
+	const project = await getProject(name);
+	if (!project) return;
+
+	await updateProject(name, {
+		resources: {
+			...project.resources,
+			services: {
+				...project.resources.services,
+				db: dbName,
+			},
+		},
+	});
+}

package/src/lib/services/db.ts

@@ -0,0 +1,81 @@
+import { $ } from "bun";
+
+export interface DatabaseInfo {
+	name: string;
+	id: string;
+	sizeBytes: number;
+	numTables: number;
+}
+
+/**
+ * Get database info via wrangler d1 info
+ */
+export async function getDatabaseInfo(dbName: string): Promise<DatabaseInfo | null> {
+	const result = await $`wrangler d1 info ${dbName} --json`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		return null;
+	}
+
+	try {
+		const output = result.stdout.toString().trim();
+		const data = JSON.parse(output);
+
+		// wrangler d1 info --json returns:
+		// {
+		//   "uuid": "...",
+		//   "name": "...",
+		//   "version": "...",
+		//   "num_tables": N,
+		//   "file_size": N
+		// }
+		return {
+			name: data.name || dbName,
+			id: data.uuid || "",
+			sizeBytes: data.file_size || 0,
+			numTables: data.num_tables || 0,
+		};
+	} catch (error) {
+		// Failed to parse JSON output
+		return null;
+	}
+}
+
+/**
+ * Export database to SQL file
+ */
+export async function exportDatabase(dbName: string, outputPath: string): Promise<void> {
+	const result = await $`wrangler d1 export ${dbName} --output ${outputPath}`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to export database ${dbName} to ${outputPath}`);
+	}
+}
+
+/**
+ * Generate export filename with timestamp
+ * Format: {db-name}-{YYYY-MM-DD-HHMMSS}.sql
+ */
+export function generateExportFilename(dbName: string): string {
+	const now = new Date();
+	const year = now.getFullYear();
+	const month = String(now.getMonth() + 1).padStart(2, "0");
+	const day = String(now.getDate()).padStart(2, "0");
+	const hours = String(now.getHours()).padStart(2, "0");
+	const minutes = String(now.getMinutes()).padStart(2, "0");
+	const seconds = String(now.getSeconds()).padStart(2, "0");
+	return `${dbName}-${year}-${month}-${day}-${hours}${minutes}${seconds}.sql`;
+}
+
+/**
+ * Delete database via wrangler
+ */
+export async function deleteDatabase(dbName: string): Promise<void> {
+	const result = await $`wrangler d1 delete ${dbName} --skip-confirmation`.nothrow().quiet();
+
+	if (result.exitCode !== 0) {
+		const stderr = result.stderr.toString().trim();
+		throw new Error(stderr || `Failed to delete database ${dbName}`);
+	}
+}

package/src/lib/services/index.ts

@@ -0,0 +1,27 @@
+// Normalized service type constants
+export const ServiceType = {
+	DB: "db",
+	KV: "kv",
+	CRON: "cron",
+	QUEUE: "queue",
+	STORAGE: "storage",
+} as const;
+
+export type ServiceTypeKey = keyof typeof ServiceType;
+export type ServiceTypeValue = (typeof ServiceType)[ServiceTypeKey];
+
+// Template metadata interface for service requirements
+export interface TemplateServiceRequirements {
+	requires: ServiceTypeKey[];
+}
+
+// Helper to check if template requires a service
+export function templateRequiresService(
+	templateMetadata: TemplateServiceRequirements | undefined,
+	serviceType: ServiceTypeKey,
+): boolean {
+	if (!templateMetadata) {
+		return false;
+	}
+	return templateMetadata.requires.includes(serviceType);
+}

package/src/lib/telemetry.ts

@@ -159,6 +159,10 @@ export async function track(event: EventName, properties?: Record<string, unknow
 // THE MAGIC: withTelemetry() wrapper
 // Commands wrapped with this get automatic tracking
 // ============================================
+export interface TelemetryOptions {
+	platform?: "cli" | "mcp";
+}
+
 /**
  * Wrap a command function with automatic telemetry tracking
  * Tracks command_invoked, command_completed, and command_failed events
@@ -167,22 +171,27 @@ export async function track(event: EventName, properties?: Record<string, unknow
 export function withTelemetry<T extends (...args: any[]) => Promise<any>>(
 	commandName: string,
 	fn: T,
+	options?: TelemetryOptions,
 ): T {
+	const platform = options?.platform ?? "cli";
+
 	return (async (...args: Parameters<T>) => {
 		// Fire-and-forget: don't await track() to avoid blocking command execution
-		track(Events.COMMAND_INVOKED, { command: commandName });
+		track(Events.COMMAND_INVOKED, { command: commandName, platform });
 		const start = Date.now();
 
 		try {
 			const result = await fn(...args);
 			track(Events.COMMAND_COMPLETED, {
 				command: commandName,
+				platform,
 				duration_ms: Date.now() - start,
 			});
 			return result;
 		} catch (error) {
 			track(Events.COMMAND_FAILED, {
 				command: commandName,
+				platform,
 				error_type: classifyError(error),
 				duration_ms: Date.now() - start,
 			});

package/src/mcp/README.md

@@ -0,0 +1,142 @@
+# Jack MCP Server
+
+This directory contains the Model Context Protocol (MCP) server implementation for jack CLI.
+
+## Architecture
+
+```
+src/mcp/
+├── server.ts              # Main MCP server setup and initialization
+├── types.ts               # TypeScript types for MCP responses
+├── utils.ts               # Response formatting utilities
+├── tools/
+│   └── index.ts          # Tool registration and handlers
+└── resources/
+    └── index.ts          # Resource registration (agents_md)
+```
+
+## Key Components
+
+### `server.ts`
+- Creates and configures the MCP server instance
+- Registers tools and resources
+- Exports `startMcpServer()` for stdio transport
+
+### `tools/index.ts`
+- Centralized tool registration and dispatch
+- Implements 4 core tools:
+  - `create_project` - Create new Cloudflare Workers project
+  - `deploy_project` - Deploy existing project
+  - `get_project_status` - Get project status info
+  - `list_projects` - List all projects with filters
+- Each tool wraps corresponding function from `lib/project-operations.ts`
+- All tools track telemetry with `platform: 'mcp'`
+
+### `resources/index.ts`
+- Registers `agents://context` resource
+- Reads and combines AGENTS.md and CLAUDE.md from project directory
+- Provides AI agents with project-specific context
+
+### `types.ts`
+- Defines `McpToolResponse<T>` interface
+- Enum of error codes for structured error handling
+- `McpServerOptions` configuration interface
+
+### `utils.ts`
+- `formatSuccessResponse()` - Creates success response with metadata
+- `formatErrorResponse()` - Classifies errors and provides suggestions
+- `classifyMcpError()` - Maps error messages to error codes
+- `getSuggestionForError()` - Returns actionable suggestions
+
+## Response Format
+
+All tools return structured JSON responses:
+
+```typescript
+{
+  success: boolean
+  data?: T
+  error?: {
+    code: string          // Machine-readable
+    message: string       // Human-readable
+    suggestion?: string   // Actionable next steps
+  }
+  meta?: {
+    duration_ms: number
+    jack_version: string
+  }
+}
+```
+
+## Integration with Project Operations
+
+The MCP tools are thin wrappers around functions in `lib/project-operations.ts`:
+
+- `createProject()` - Handles project creation with templates
+- `deployProject()` - Manages builds and deployments
+- `getProjectStatus()` - Fetches project status
+- `listAllProjects()` - Lists all registered projects
+
+All operations run in "silent mode" (no console output) when called from MCP.
+
+## Telemetry
+
+All tool calls are tracked via the existing telemetry system:
+
+- Automatic tracking: `command_invoked`, `command_completed`, `command_failed`
+- Business events: `project_created`, `deploy_started`
+- All events tagged with `platform: 'mcp'`
+
+## Development
+
+### Running the Server
+
+```bash
+# Start server via CLI (uses stdio transport)
+jack mcp serve
+
+# With explicit project path
+jack mcp serve --project /path/to/project
+
+# The server communicates via stdin/stdout
+# Do NOT use console.log in MCP code
+```
+
+### Adding New Tools
+
+1. Add tool definition to `tools/list` handler in `tools/index.ts`
+2. Add case to `tools/call` handler switch statement
+3. Create zod schema for tool parameters
+4. Wrap function from `project-operations.ts` with telemetry
+5. Return formatted response using utils
+
+### Testing
+
+The MCP server can be tested using:
+- Claude Desktop (see `/docs/mcp-configuration.md`)
+- MCP Inspector (https://github.com/modelcontextprotocol/inspector)
+- Manual JSON-RPC over stdio
+
+## Error Handling
+
+Errors are classified into categories:
+
+- `AUTH_FAILED` - Authentication issues
+- `WRANGLER_AUTH_EXPIRED` - Wrangler needs re-auth
+- `PROJECT_NOT_FOUND` - Project doesn't exist
+- `TEMPLATE_NOT_FOUND` - Invalid template
+- `BUILD_FAILED` - Build errors
+- `DEPLOY_FAILED` - Deployment errors
+- `VALIDATION_ERROR` - Invalid parameters
+- `INTERNAL_ERROR` - Unexpected failures
+
+Each error code includes a helpful suggestion for resolution.
+
+## Protocol Compliance
+
+This implementation follows the MCP specification:
+- Uses stdio transport for client communication
+- Implements required handlers: `tools/list`, `tools/call`
+- Implements optional handlers: `resources/list`, `resources/read`
+- Returns properly formatted JSON-RPC responses
+- Never writes to stdout except for protocol messages

package/src/mcp/resources/index.ts

@@ -0,0 +1,87 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+	ListResourcesRequestSchema,
+	ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import type { McpServerOptions } from "../types.ts";
+
+export function registerResources(server: McpServer, options: McpServerOptions) {
+	// Register resource list handler
+	server.setRequestHandler(ListResourcesRequestSchema, async () => {
+		return {
+			resources: [
+				{
+					uri: "agents://context",
+					name: "Agent Context Files",
+					description:
+						"Project-specific context files (AGENTS.md, CLAUDE.md) for AI agents working on this project",
+					mimeType: "text/markdown",
+				},
+			],
+		};
+	});
+
+	// Register resource read handler
+	server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+		const uri = request.params.uri;
+
+		if (uri === "agents://context") {
+			const projectPath = options.projectPath ?? process.cwd();
+			const agentsPath = join(projectPath, "AGENTS.md");
+			const claudePath = join(projectPath, "CLAUDE.md");
+
+			const contents: string[] = [];
+
+			// Try to read AGENTS.md
+			if (existsSync(agentsPath)) {
+				try {
+					const agentsContent = await Bun.file(agentsPath).text();
+					contents.push("# AGENTS.md\n\n");
+					contents.push(agentsContent);
+				} catch {
+					// Ignore read errors
+				}
+			}
+
+			// Try to read CLAUDE.md
+			if (existsSync(claudePath)) {
+				try {
+					const claudeContent = await Bun.file(claudePath).text();
+					if (contents.length > 0) {
+						contents.push("\n\n---\n\n");
+					}
+					contents.push("# CLAUDE.md\n\n");
+					contents.push(claudeContent);
+				} catch {
+					// Ignore read errors
+				}
+			}
+
+			if (contents.length === 0) {
+				return {
+					contents: [
+						{
+							uri,
+							mimeType: "text/plain",
+							text: "No agent context files found in project directory",
+						},
+					],
+				};
+			}
+
+			return {
+				contents: [
+					{
+						uri,
+						mimeType: "text/markdown",
+						text: contents.join(""),
+					},
+				],
+			};
+		}
+
+		throw new Error(`Unknown resource URI: ${uri}`);
+	});
+}

package/src/mcp/server.ts

@@ -0,0 +1,32 @@
+import { Server as McpServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import pkg from "../../package.json" with { type: "json" };
+import { registerResources } from "./resources/index.ts";
+import { registerTools } from "./tools/index.ts";
+import type { McpServerOptions } from "./types.ts";
+
+export async function createMcpServer(options: McpServerOptions = {}) {
+	const server = new McpServer(
+		{
+			name: "jack",
+			version: pkg.version,
+		},
+		{
+			capabilities: {
+				tools: {},
+				resources: {},
+			},
+		},
+	);
+
+	registerTools(server, options);
+	registerResources(server, options);
+
+	return server;
+}
+
+export async function startMcpServer(options: McpServerOptions = {}) {
+	const server = await createMcpServer(options);
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}