@getjack/jack 0.1.28 → 0.1.30

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

@@ -479,7 +479,14 @@ export async function executeSql(options: ExecuteSqlOptions): Promise<ExecuteSql
 export async function executeSqlFile(
 	options: Omit<ExecuteSqlOptions, "sql"> & { filePath: string },
 ): Promise<ExecuteSqlResult> {
-	const { projectDir, filePath, databaseName, allowWrite = false, interactive = true, confirmed = false } = options;
+	const {
+		projectDir,
+		filePath,
+		databaseName,
+		allowWrite = false,
+		interactive = true,
+		confirmed = false,
+	} = options;
 
 	// Read the file
 	if (!existsSync(filePath)) {

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

@@ -63,7 +63,10 @@ export async function listDatabases(projectDir: string): Promise<DatabaseListEnt
 		// Get metadata based on deploy mode
 		if (isManaged && managedDbInfo) {
 			// For managed: use control plane data (match by ID or name)
-			if (managedDbInfo.id === binding.database_id || managedDbInfo.name.includes(binding.database_name)) {
+			if (
+				managedDbInfo.id === binding.database_id ||
+				managedDbInfo.name.includes(binding.database_name)
+			) {
 				entry.sizeBytes = managedDbInfo.sizeBytes;
 				entry.numTables = managedDbInfo.numTables;
 			}

package/src/lib/services/domain-operations.ts

@@ -0,0 +1,379 @@
+/**
+ * Domain operations service layer for jack cloud
+ *
+ * Provides shared domain management functions for both CLI and MCP.
+ * Returns pure data - no console.log or process.exit.
+ */
+
+import { authFetch } from "../auth/index.ts";
+import { findProjectBySlug, getControlApiUrl } from "../control-plane.ts";
+import { JackError, JackErrorCode } from "../errors.ts";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type DomainStatus =
+	| "claimed"
+	| "pending"
+	| "pending_owner"
+	| "pending_ssl"
+	| "active"
+	| "blocked"
+	| "moved"
+	| "failed"
+	| "deleting";
+
+export interface DomainVerification {
+	type: "cname";
+	target: string;
+	instructions: string;
+}
+
+export interface DomainOwnershipVerification {
+	type: "txt";
+	name: string;
+	value: string;
+}
+
+export interface DomainInfo {
+	id: string;
+	hostname: string;
+	status: DomainStatus;
+	ssl_status: string | null;
+	project_id: string | null;
+	project_slug: string | null;
+	verification?: DomainVerification;
+	ownership_verification?: DomainOwnershipVerification;
+	created_at: string;
+}
+
+export interface DomainSlots {
+	used: number;
+	max: number;
+}
+
+export interface ListDomainsResult {
+	domains: DomainInfo[];
+	slots: DomainSlots;
+}
+
+export interface ConnectDomainResult {
+	id: string;
+	hostname: string;
+	status: DomainStatus;
+}
+
+export interface AssignDomainResult {
+	id: string;
+	hostname: string;
+	status: DomainStatus;
+	ssl_status: string | null;
+	project_id: string;
+	project_slug: string;
+	verification?: DomainVerification;
+	ownership_verification?: DomainOwnershipVerification;
+}
+
+export interface UnassignDomainResult {
+	id: string;
+	hostname: string;
+	status: DomainStatus;
+}
+
+export interface DisconnectDomainResult {
+	success: boolean;
+	hostname: string;
+}
+
+// ============================================================================
+// API Response Types (internal)
+// ============================================================================
+
+interface ListDomainsApiResponse {
+	domains: DomainInfo[];
+	slots: DomainSlots;
+}
+
+interface ConnectDomainApiResponse {
+	id: string;
+	hostname: string;
+	status: string;
+}
+
+interface AssignDomainApiResponse {
+	id: string;
+	hostname: string;
+	status: string;
+	ssl_status: string | null;
+	verification?: DomainVerification;
+	ownership_verification?: DomainOwnershipVerification;
+}
+
+interface ApiErrorResponse {
+	message?: string;
+	error?: string;
+}
+
+// ============================================================================
+// Error Codes for Domain Operations
+// ============================================================================
+
+/**
+ * Extended error codes for domain operations.
+ * Maps to JackErrorCode where possible, uses specific codes where needed.
+ */
+export const DomainErrorCode = {
+	PLAN_LIMIT_REACHED: "PLAN_LIMIT_REACHED",
+	RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
+	ALREADY_EXISTS: "ALREADY_EXISTS",
+	ALREADY_ASSIGNED: "ALREADY_ASSIGNED",
+	NOT_ASSIGNED: "NOT_ASSIGNED",
+} as const;
+
+export type DomainErrorCodeType = (typeof DomainErrorCode)[keyof typeof DomainErrorCode];
+
+// ============================================================================
+// Service Functions
+// ============================================================================
+
+/**
+ * List all domains for the current user.
+ */
+export async function listDomains(): Promise<ListDomainsResult> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains`);
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to list domains: ${response.status}`,
+		);
+	}
+
+	const data = (await response.json()) as ListDomainsApiResponse;
+	return {
+		domains: data.domains,
+		slots: data.slots,
+	};
+}
+
+/**
+ * Find a domain by hostname.
+ * Returns null if not found.
+ */
+export async function getDomainByHostname(hostname: string): Promise<DomainInfo | null> {
+	const result = await listDomains();
+	return result.domains.find((d) => d.hostname === hostname) ?? null;
+}
+
+/**
+ * Reserve a domain slot (connect a domain).
+ *
+ * @throws JackError with PLAN_LIMIT_REACHED if no slots available
+ * @throws JackError with ALREADY_EXISTS if domain already reserved
+ */
+export async function connectDomain(hostname: string): Promise<ConnectDomainResult> {
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ hostname }),
+	});
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+
+		// Handle plan limit errors
+		if (response.status === 403 || err.error === "plan_limit_reached") {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				"No domain slots available",
+				"Upgrade your plan for more slots: jack upgrade",
+				{ exitCode: 1 },
+			);
+		}
+
+		// Handle "already exists"
+		if (response.status === 409 || err.error === "domain_exists") {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				`Domain ${hostname} is already reserved`,
+				"Run 'jack domain' to see all domains",
+				{ exitCode: 1 },
+			);
+		}
+
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to reserve domain: ${response.status}`,
+		);
+	}
+
+	const data = (await response.json()) as ConnectDomainApiResponse;
+	return {
+		id: data.id,
+		hostname: data.hostname,
+		status: data.status as DomainStatus,
+	};
+}
+
+/**
+ * Assign a reserved domain to a project.
+ *
+ * @throws JackError with RESOURCE_NOT_FOUND if domain or project not found
+ * @throws JackError with ALREADY_ASSIGNED if domain already assigned to a project
+ */
+export async function assignDomain(
+	hostname: string,
+	projectSlug: string,
+): Promise<AssignDomainResult> {
+	// Find the domain
+	const domain = await getDomainByHostname(hostname);
+	if (!domain) {
+		throw new JackError(
+			JackErrorCode.PROJECT_NOT_FOUND,
+			`Domain not found: ${hostname}`,
+			"Reserve it first: jack domain connect <hostname>",
+			{ exitCode: 1 },
+		);
+	}
+
+	// Find the project
+	const project = await findProjectBySlug(projectSlug);
+	if (!project) {
+		throw new JackError(
+			JackErrorCode.PROJECT_NOT_FOUND,
+			`Project not found: ${projectSlug}`,
+			"Check your projects: jack ls",
+			{ exitCode: 1 },
+		);
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains/${domain.id}/assign`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ project_id: project.id }),
+	});
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+
+		// Handle already assigned
+		if (err.error === "already_assigned") {
+			throw new JackError(
+				JackErrorCode.VALIDATION_ERROR,
+				"Domain is already assigned to a project",
+				"Unassign it first: jack domain unassign <hostname>",
+				{ exitCode: 1 },
+			);
+		}
+
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to assign domain: ${response.status}`,
+		);
+	}
+
+	const data = (await response.json()) as AssignDomainApiResponse;
+	return {
+		id: data.id,
+		hostname: data.hostname,
+		status: data.status as DomainStatus,
+		ssl_status: data.ssl_status,
+		project_id: project.id,
+		project_slug: projectSlug,
+		verification: data.verification,
+		ownership_verification: data.ownership_verification,
+	};
+}
+
+/**
+ * Unassign a domain from its project (keep the slot).
+ *
+ * @throws JackError with RESOURCE_NOT_FOUND if domain not found
+ * @throws JackError with NOT_ASSIGNED if domain is not assigned to any project
+ */
+export async function unassignDomain(hostname: string): Promise<UnassignDomainResult> {
+	// Find the domain
+	const domain = await getDomainByHostname(hostname);
+	if (!domain) {
+		throw new JackError(
+			JackErrorCode.PROJECT_NOT_FOUND,
+			`Domain not found: ${hostname}`,
+			"Run 'jack domain' to see all domains",
+			{ exitCode: 1 },
+		);
+	}
+
+	if (!domain.project_id) {
+		throw new JackError(
+			JackErrorCode.VALIDATION_ERROR,
+			`Domain ${hostname} is not assigned to any project`,
+			undefined,
+			{ exitCode: 1 },
+		);
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains/${domain.id}/unassign`, {
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to unassign domain: ${response.status}`,
+		);
+	}
+
+	return {
+		id: domain.id,
+		hostname: domain.hostname,
+		status: "claimed" as DomainStatus,
+	};
+}
+
+/**
+ * Disconnect (fully remove) a domain.
+ *
+ * @throws JackError with RESOURCE_NOT_FOUND if domain not found
+ */
+export async function disconnectDomain(hostname: string): Promise<DisconnectDomainResult> {
+	// Find the domain
+	const domain = await getDomainByHostname(hostname);
+	if (!domain) {
+		throw new JackError(
+			JackErrorCode.PROJECT_NOT_FOUND,
+			`Domain not found: ${hostname}`,
+			"Run 'jack domain' to see all domains",
+			{ exitCode: 1 },
+		);
+	}
+
+	const response = await authFetch(`${getControlApiUrl()}/v1/domains/${domain.id}`, {
+		method: "DELETE",
+	});
+
+	if (!response.ok) {
+		const err = (await response
+			.json()
+			.catch(() => ({ message: "Unknown error" }))) as ApiErrorResponse;
+		throw new JackError(
+			JackErrorCode.INTERNAL_ERROR,
+			err.message || `Failed to disconnect domain: ${response.status}`,
+		);
+	}
+
+	return {
+		success: true,
+		hostname: domain.hostname,
+	};
+}

package/src/lib/services/storage-config.ts

@@ -643,11 +643,7 @@ function findObjectEndAfter(content: string, fromPos: number): number {
 /**
  * Remove the entire r2_buckets property when it becomes empty.
  */
-function removeR2BucketsProperty(
-	content: string,
-	propertyStart: number,
-	arrayEnd: number,
-): string {
+function removeR2BucketsProperty(content: string, propertyStart: number, arrayEnd: number): string {
 	let removeStart = propertyStart;
 	let removeEnd = arrayEnd + 1;
 

package/src/lib/services/storage-delete.ts

@@ -59,7 +59,7 @@ export async function deleteStorageBucket(
 		throw new Error(`Bucket "${bucketName}" not found in this project.`);
 	}
 
-	let deleted = true;
+	const deleted = true;
 
 	if (link.deploy_mode === "managed") {
 		// Managed mode: delete via control plane (don't call wrangler - user may not have CF auth)

package/src/lib/services/storage-info.ts

@@ -5,8 +5,8 @@
  * since R2 doesn't have a simple stats API via wrangler.
  */
 
-import { $ } from "bun";
 import { join } from "node:path";
+import { $ } from "bun";
 import { fetchProjectResources } from "../control-plane.ts";
 import { readProjectLink } from "../project-link.ts";
 import { getExistingR2Bindings } from "./storage-config.ts";
@@ -59,9 +59,7 @@ export async function getStorageBucketInfo(
 	}
 
 	// Find the requested bucket (or first if not specified)
-	const binding = bucketName
-		? bindings.find((b) => b.bucket_name === bucketName)
-		: bindings[0];
+	const binding = bucketName ? bindings.find((b) => b.bucket_name === bucketName) : bindings[0];
 
 	if (!binding) {
 		return null;

package/src/lib/services/vectorize-config.ts

@@ -257,11 +257,7 @@ function removeVectorizeEntryFromContent(content: string, indexName: string): st
 /**
  * Remove the entire vectorize property when it becomes empty.
  */
-function removeVectorizeProperty(
-	content: string,
-	propertyStart: number,
-	arrayEnd: number,
-): string {
+function removeVectorizeProperty(content: string, propertyStart: number, arrayEnd: number): string {
 	let removeStart = propertyStart;
 	let removeEnd = arrayEnd + 1;
 

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

@@ -102,7 +102,9 @@ async function createIndexViaWrangler(
 	}
 
 	const result =
-		await $`wrangler vectorize create ${indexName} --dimensions=${dimensions} --metric=${metric}`.nothrow().quiet();
+		await $`wrangler vectorize create ${indexName} --dimensions=${dimensions} --metric=${metric}`
+			.nothrow()
+			.quiet();
 
 	if (result.exitCode !== 0) {
 		const stderr = result.stderr.toString().trim();

package/src/lib/shell-integration.ts

@@ -0,0 +1,202 @@
+/**
+ * Shell integration for jack cd/new/clone to auto-change directories.
+ * Shell function lives in ~/.config/jack/shell.sh, sourced from rc file.
+ * jack update regenerates the managed file.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import pkg from "../../package.json";
+
+type Shell = "bash" | "zsh" | "unknown";
+
+// Markers for detection
+const LEGACY_MARKER = "# jack shell integration";
+const SOURCE_LINE_MARKER = "# jack: shell integration (do not edit)";
+
+export function getShellFilePath(): string {
+	return join(homedir(), ".config", "jack", "shell.sh");
+}
+
+export function getSourceLine(): string {
+	const shellFile = getShellFilePath();
+	return `${SOURCE_LINE_MARKER}\n[ -f "${shellFile}" ] && source "${shellFile}"`;
+}
+
+function getShellFunction(): string {
+	return `# jack shell integration v${pkg.version}
+# This file is managed by jack. Do not edit manually.
+# It will be regenerated by 'jack update'.
+
+jack() {
+  case "$1" in
+    cd)
+      # Get project path and cd to it
+      local dir
+      dir="$(command jack cd "\${@:2}" 2>/dev/null)"
+      if [[ -n "$dir" && -d "$dir" ]]; then
+        cd "$dir" || return 1
+      else
+        # Show error output if cd failed
+        command jack cd "\${@:2}"
+      fi
+      ;;
+    new|clone)
+      # Run the command, then cd to the project
+      command jack "$@"
+      local exit_code=$?
+      if [[ $exit_code -eq 0 ]]; then
+        # Extract project name from args (skip flags)
+        local name=""
+        shift  # remove 'new' or 'clone'
+        for arg in "$@"; do
+          if [[ ! "$arg" =~ ^- ]]; then
+            name="$arg"
+            break
+          fi
+        done
+        if [[ -n "$name" ]]; then
+          local dir
+          dir="$(command jack cd "$name" 2>/dev/null)"
+          [[ -n "$dir" && -d "$dir" ]] && cd "$dir"
+        fi
+      fi
+      return $exit_code
+      ;;
+    "")
+      # No args: interactive picker - cd if it outputs a directory
+      local output
+      output="$(command jack)"
+      if [[ -n "$output" && -d "$output" ]]; then
+        cd "$output" || return 1
+      elif [[ -n "$output" ]]; then
+        # Not a directory (e.g., help text) - show it
+        echo "$output"
+      fi
+      ;;
+    *)
+      # Pass through all other commands
+      command jack "$@"
+      ;;
+  esac
+}`;
+}
+
+export function detectShell(): Shell {
+	const shell = process.env.SHELL || "";
+	if (shell.endsWith("/bash") || shell.endsWith("/bash5")) return "bash";
+	if (shell.endsWith("/zsh")) return "zsh";
+	return "unknown";
+}
+
+export function getRcFilePath(shell: Shell): string | null {
+	const home = homedir();
+
+	switch (shell) {
+		case "zsh":
+			return join(home, ".zshrc");
+		case "bash": {
+			// Prefer .bashrc, fall back to .bash_profile on macOS
+			const bashrc = join(home, ".bashrc");
+			const profile = join(home, ".bash_profile");
+			if (existsSync(bashrc)) return bashrc;
+			if (existsSync(profile)) return profile;
+			// Default to .bashrc (will be created)
+			return bashrc;
+		}
+		default:
+			return null;
+	}
+}
+
+export function isInstalled(rcFile: string): boolean {
+	if (!existsSync(rcFile)) return false;
+
+	try {
+		const content = readFileSync(rcFile, "utf-8");
+		return content.includes(SOURCE_LINE_MARKER);
+	} catch {
+		return false;
+	}
+}
+
+export function hasLegacyInstall(rcFile: string): boolean {
+	if (!existsSync(rcFile)) return false;
+
+	try {
+		const content = readFileSync(rcFile, "utf-8");
+		// Has old marker but not new source line
+		return content.includes(LEGACY_MARKER) && !content.includes(SOURCE_LINE_MARKER);
+	} catch {
+		return false;
+	}
+}
+
+export function removeLegacyInstall(rcFile: string): void {
+	if (!existsSync(rcFile)) return;
+
+	const content = readFileSync(rcFile, "utf-8");
+
+	const legacyPattern = /\n?# jack shell integration\njack\(\) \{[\s\S]*?\n\}\n?/g;
+
+	const newContent = content.replace(legacyPattern, "\n");
+
+	writeFileSync(rcFile, newContent, "utf-8");
+}
+
+export function writeShellFile(): void {
+	const shellFile = getShellFilePath();
+	const dir = dirname(shellFile);
+
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(shellFile, getShellFunction(), "utf-8");
+}
+
+export function addSourceLine(rcFile: string): void {
+	const sourceLine = getSourceLine();
+	appendFileSync(rcFile, `\n${sourceLine}\n`, "utf-8");
+}
+
+export function install(rcFile: string): { migrated: boolean } {
+	let migrated = false;
+
+	if (hasLegacyInstall(rcFile)) {
+		removeLegacyInstall(rcFile);
+		migrated = true;
+	}
+
+	writeShellFile();
+	if (!isInstalled(rcFile)) {
+		addSourceLine(rcFile);
+	}
+
+	return { migrated };
+}
+
+export function update(): void {
+	writeShellFile();
+}
+
+export function getShellCode(): string {
+	return getShellFunction();
+}
+
+export function getShellName(shell: Shell): string {
+	switch (shell) {
+		case "bash":
+			return "Bash";
+		case "zsh":
+			return "Zsh";
+		default:
+			return "your shell";
+	}
+}
+
+export function getRcFileName(rcFile: string): string {
+	return rcFile.split("/").pop() || rcFile;
+}
+
+export function getShellFileDisplayPath(): string {
+	return "~/.config/jack/shell.sh";
+}