rework the docker:shell script to reuse an existing container

docker/.dockerignore

@@ -0,0 +1,48 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Node modules
+node_modules
+npm-debug.log
+
+# Build artifacts
+dist
+dist-standalone
+build
+*.log
+
+# Generated code
+src/generated
+
+# CLI build artifacts
+cli/bin
+cli/dist
+
+# Webview build artifacts
+webview-ui/dist
+webview-ui/build
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+*.md
+!README.md
+
+# Tests
+tests
+*.test.js
+*.spec.js
+
+# CI/CD
+.github
+.gitlab-ci.yml

docker/Dockerfile

@@ -0,0 +1,49 @@
+FROM node:22-slim
+
+# TARGETARCH enables multi-architecture support without emulation warnings:
+# - Docker automatically sets TARGETARCH to the build platform's architecture
+# - On arm64 machines (Apple Silicon): TARGETARCH=arm64, uses linux-arm64 binaries
+# - On amd64 machines (Intel/AMD): TARGETARCH=amd64, uses linux-x64 binaries
+# The corresponding platform-specific binaries and native modules (better-sqlite3)
+# are pre-built by scripts/package-standalone.mjs during the build process.
+ARG TARGETARCH
+
+# Install only runtime dependencies
+RUN apt-get update && apt-get install -y \
+    git curl ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /opt/cline
+
+# Copy the entire pre-built distribution
+COPY dist-standalone/ ./
+
+# Create symlink for Linux native modules
+# Map Docker's TARGETARCH (arm64/amd64) to Node's platform naming (x64 for amd64)
+RUN if [ "$TARGETARCH" = "amd64" ]; then \
+        ln -sf /opt/cline/binaries/linux-x64/node_modules/better-sqlite3 /opt/cline/node_modules/better-sqlite3; \
+    else \
+        ln -sf /opt/cline/binaries/linux-$TARGETARCH/node_modules/better-sqlite3 /opt/cline/node_modules/better-sqlite3; \
+    fi
+
+# Set up CLI binaries
+# The Linux binaries are already in /opt/cline/bin/ from dist-standalone
+# Just need to create symlinks to the platform-specific ones
+RUN cd /opt/cline/bin && \
+    ln -sf cline-linux-$TARGETARCH cline && \
+    ln -sf cline-host-linux-$TARGETARCH cline-host && \
+    chmod +x cline-linux-$TARGETARCH cline-host-linux-$TARGETARCH cline cline-host
+
+# Add binaries to PATH
+ENV PATH="/opt/cline/bin:${PATH}"
+ENV NODE_ENV=production
+ENV CLINE_HOME=/root/.cline
+
+RUN mkdir -p $CLINE_HOME
+
+WORKDIR /workspace
+
+EXPOSE 8000
+
+ENTRYPOINT ["/opt/cline/bin/cline"]
+CMD ["--help"]

package.json

@@ -306,6 +306,8 @@
 		"compile-cli-all-platforms": "scripts/build-cli-all-platforms.sh",
 		"compile-cli-man-page": "pandoc cli/man/cline.1.md -s -t man -o cli/man/cline.1",
 		"build:npm": "scripts/build-npm-package.sh",
+		"build:docker:dev": "node scripts/build-docker-dev.mjs",
+		"docker:shell": "node scripts/docker-shell.mjs",
 		"test:install": "bash scripts/test-install.sh",
 		"dev:cli:watch": "node scripts/dev-cli-watch.mjs",
 		"postcompile-standalone": "node scripts/package-standalone.mjs",

scripts/build-docker-dev.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process"
+
+/**
+ * Build Docker image for Cline CLI
+ * This script builds a Docker image using pre-built binaries from dist-standalone/
+ *
+ * Prerequisites:
+ * - Run `npm run compile-standalone` first to build all platform binaries
+ * - Run `npm run compile-cli` first to build CLI binaries
+ */
+
+function runCommand(command, description) {
+	console.log(`\n${description}...`)
+	try {
+		execSync(command, { stdio: "inherit" })
+		console.log("✓ Success\n")
+	} catch (error) {
+		console.error(`✗ Failed: ${error.message}`)
+		process.exit(1)
+	}
+}
+
+function getCommandOutput(command) {
+	try {
+		return execSync(command, { encoding: "utf-8" }).trim()
+	} catch (error) {
+		return ""
+	}
+}
+
+function buildPrerequisites() {
+	console.log("Building prerequisites...\n")
+
+	// Build standalone (includes cline-core and platform-specific native modules)
+	runCommand("npm run compile-standalone", "Running npm run compile-standalone")
+
+	// Build CLI binaries for all platforms
+	runCommand("npm run compile-cli-all-platforms", "Running npm run compile-cli-all-platforms")
+
+	console.log("✓ All prerequisites built successfully\n")
+}
+
+function main() {
+	console.log("🐳 Building Cline CLI Docker Image\n")
+
+	// Remove existing container to ensure clean state after rebuild
+	const containerId = getCommandOutput(`docker ps -aq --filter "name=^cline-cli-dev$"`)
+	if (containerId) {
+		console.log("🗑️  Removing existing container to ensure fresh start...")
+		try {
+			execSync(`docker rm -f cline-cli-dev`, { stdio: "inherit" })
+			console.log("✓ Container removed\n")
+		} catch (error) {
+			console.log("Note: Container cleanup failed, continuing anyway\n")
+		}
+	}
+
+	buildPrerequisites()
+
+	// Build Docker image for native platform
+	// Docker will automatically use the correct architecture (arm64 on Apple Silicon, amd64 on Intel)
+	runCommand("docker build -f docker/Dockerfile -t cline-cli:dev .", "Building Docker image")
+
+	console.log("✅ Docker image built successfully!")
+	console.log("\n📋 Next steps:\n")
+	console.log("Interactive shell:")
+	console.log("  npm run docker:shell\n")
+	console.log("This will:")
+	console.log("  • Reuse existing 'cline-cli-dev' container if running")
+	console.log("  • Start stopped container if it exists")
+	console.log("  • Create new persistent container if none exists")
+	console.log("  • Mount current directory at /workspace")
+	console.log("  • Provide all CLI commands (cline auth, cline task, etc.)")
+	console.log("\nContainer persists between sessions. To remove:")
+	console.log("  docker rm -f cline-cli-dev\n")
+}
+
+main()

scripts/docker-shell.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process"
+import { platform } from "os"
+
+const CONTAINER_NAME = "cline-cli-dev"
+
+function runCommand(command) {
+	try {
+		return execSync(command, { encoding: "utf-8" }).trim()
+	} catch (error) {
+		return ""
+	}
+}
+
+function getCurrentDirectory() {
+	// Get current working directory in a cross-platform way
+	return process.cwd()
+}
+
+function main() {
+	console.log("🐳 Cline CLI Docker Shell\n")
+
+	// Check if container exists (running or stopped)
+	const containerId = runCommand(`docker ps -a --filter "name=^${CONTAINER_NAME}$" --format "{{.ID}}"`)
+
+	if (containerId) {
+		// Check if container is running
+		const isRunning = runCommand(`docker ps --filter "id=${containerId}" --format "{{.ID}}"`)
+
+		if (isRunning) {
+			console.log(`📦 Connecting to running container: ${CONTAINER_NAME}\n`)
+			try {
+				execSync(`docker exec -it ${containerId} /bin/bash`, { stdio: "inherit" })
+			} catch (error) {
+				// User exited shell normally
+			}
+		} else {
+			console.log(`▶️  Starting stopped container: ${CONTAINER_NAME}\n`)
+			try {
+				execSync(`docker start ${containerId}`, { stdio: "inherit" })
+				execSync(`docker exec -it ${containerId} /bin/bash`, { stdio: "inherit" })
+			} catch (error) {
+				// User exited shell normally
+			}
+		}
+	} else {
+		console.log(`🚀 Creating new container: ${CONTAINER_NAME}\n`)
+		const cwd = getCurrentDirectory()
+
+		try {
+			// Use different volume mount syntax for Windows vs Unix
+			const isWindows = platform() === "win32"
+			const volumeMount = isWindows ? `${cwd.replace(/\\/g, "/")}:/workspace` : `${cwd}:/workspace`
+
+			execSync(
+				`docker run -it --name ${CONTAINER_NAME} -v "${volumeMount}" -w /workspace --entrypoint /bin/bash cline-cli:dev`,
+				{ stdio: "inherit" },
+			)
+		} catch (error) {
+			// User exited shell normally
+		}
+	}
+}
+
+main()

scripts/package-standalone.mjs

@@ -24,6 +24,7 @@ const TARGET_PLATFORMS = [
 	{ platform: "darwin", arch: "x64", targetDir: "darwin-x64" },
 	{ platform: "darwin", arch: "arm64", targetDir: "darwin-arm64" },
 	{ platform: "linux", arch: "x64", targetDir: "linux-x64" },
+	{ platform: "linux", arch: "arm64", targetDir: "linux-arm64" },
 ]
 const SUPPORTED_BINARY_MODULES = ["better-sqlite3"]