@jive-ai/cli 0.0.39 → 0.0.40

package/dist/index.mjs

@@ -16,12 +16,15 @@ import WebSocket from "ws";
 import { decode, encode } from "js-base64";
 import { GraphQLClient } from "graphql-request";
 import { createSdkMcpServer, query, tool } from "@anthropic-ai/claude-agent-sdk";
+import yaml from "js-yaml";
 import { z } from "zod";
 import dedent from "dedent";
 import { exists } from "fs-extra";
 import chokidar from "chokidar";
 import { Tunnel } from "cloudflared";
 import getPort from "get-port";
+import http from "http";
+import httpProxy from "http-proxy";
 
 //#region src/lib/config.ts
 /**
@@ -153,11 +156,36 @@ async function isProjectInitialized() {
 	return await getProjectConfig() !== null;
 }
 
+//#endregion
+//#region src/runner/task/debugLog.ts
+function debugLog(message) {
+	console.log(JSON.stringify({
+		type: "debug_log",
+		message
+	}).replace(/\n/g, "\\n"));
+}
+
 //#endregion
 //#region src/constants.ts
 const API_URL = process.env.JIVE_API_URL || "https://getjive.app";
 const GRAPHQL_API_URL = process.env.JIVE_GRAPHQL_API_URL || "https://api.getjive.app/graphql";
 const WS_URL = process.env.JIVE_WS_URL || "wss://api.getjive.app";
+/**
+* Detect if running in local development mode based on configured URLs or NODE_ENV.
+* Used to enable dev-only features like localhost iframe embedding.
+*/
+function isDevMode() {
+	const localCheck = [
+		"localhost",
+		"127.0.0.1",
+		"host.docker.internal"
+	];
+	return process.env.NODE_ENV === "development" || localCheck.some((check) => API_URL.includes(check)) || localCheck.some((check) => WS_URL.includes(check));
+}
+debugLog(`[Constants] isDevMode: ${isDevMode()}`);
+debugLog(`[Constants] NODE_ENV: ${process.env.NODE_ENV}`);
+debugLog(`[Constants] API_URL: ${API_URL}`);
+debugLog(`[Constants] WS_URL: ${WS_URL}`);
 
 //#endregion
 //#region src/commands/auth.ts
@@ -3346,10 +3374,9 @@ async function spawnTaskDocker(ctx, config$2, opts) {
 	envVars.push("-e", `JIVE_RUNNER_ID=${config$2.id}`);
 	envVars.push("-e", `JIVE_PROJECT_ID=${ctx.projectId}`);
 	envVars.push("-e", `JIVE_TASK_ID=${ctx.taskId}`);
-	const isDevMode = API_URL.includes("localhost") || process.env.NODE_ENV === "development";
-	const dockerApiUrl = isDevMode ? API_URL.replace("localhost", "host.docker.internal") : API_URL;
-	const dockerGraphqlApiUrl = isDevMode ? GRAPHQL_API_URL.replace("localhost", "host.docker.internal") : GRAPHQL_API_URL;
-	const dockerWsUrl = isDevMode ? WS_URL.replace("localhost", "host.docker.internal") : WS_URL;
+	const dockerApiUrl = isDevMode() ? API_URL.replace("localhost", "host.docker.internal") : API_URL;
+	const dockerGraphqlApiUrl = isDevMode() ? GRAPHQL_API_URL.replace("localhost", "host.docker.internal") : GRAPHQL_API_URL;
+	const dockerWsUrl = isDevMode() ? WS_URL.replace("localhost", "host.docker.internal") : WS_URL;
 	envVars.push("-e", `JIVE_API_URL=${dockerApiUrl}`);
 	envVars.push("-e", `JIVE_GRAPHQL_API_URL=${dockerGraphqlApiUrl}`);
 	envVars.push("-e", `JIVE_WS_URL=${dockerWsUrl}`);
@@ -3366,7 +3393,7 @@ async function spawnTaskDocker(ctx, config$2, opts) {
 	];
 	console.log(chalk.dim("Using Sysbox runtime for isolated Docker-in-Docker"));
 	dockerArgs.push("--network", "bridge");
-	if (isDevMode) {
+	if (isDevMode()) {
 		dockerArgs.push("--add-host", "host.docker.internal:host-gateway");
 		dockerArgs.push("--pull", "never");
 	}
@@ -3430,7 +3457,7 @@ async function createGraphQLClient() {
 
 //#endregion
 //#region package.json
-var version = "0.0.39";
+var version = "0.0.40";
 
 //#endregion
 //#region src/runner/index.ts
@@ -3602,17 +3629,13 @@ var TaskRunner = class {
 		return this.taskProcesses[taskId.toString()] = new Promise((resolve) => {
 			(this.config.type === "docker" ? spawnTaskDocker(ctx, this.config, {
 				onMessage: (message) => this.onTaskMessage(ctx.taskId, message),
-				onError: () => {
-					this.taskProcesses[ctx.taskId.toString()] = null;
-				},
+				onError: () => {},
 				onClose: () => {
 					this.taskProcesses[ctx.taskId.toString()] = null;
 				}
 			}) : Promise.resolve(spawnTask(ctx, {
 				onMessage: (message) => this.onTaskMessage(ctx.taskId, message),
-				onError: () => {
-					this.taskProcesses[ctx.taskId.toString()] = null;
-				},
+				onError: () => {},
 				onClose: () => {
 					this.taskProcesses[ctx.taskId.toString()] = null;
 				}
@@ -3826,15 +3849,6 @@ var TaskRunner = class {
 	}
 };
 
-//#endregion
-//#region src/runner/task/debugLog.ts
-function debugLog(message) {
-	console.log(JSON.stringify({
-		type: "debug_log",
-		message
-	}).replace(/\n/g, "\\n"));
-}
-
 //#endregion
 //#region src/runner/query.ts
 async function queryClaude(prompt, mcpServer, opts) {
@@ -3974,14 +3988,6 @@ async function commitChanges(commitMessage, branch) {
 	await execAsync$2(`git push origin ${branch}`);
 }
 /**
-* Tool: jive-tasks__set_task_url
-* Set the preview URL for a task
-*/
-async function setTaskUrl(taskId, url) {
-	if (!context) throw new Error("Task context not initialized");
-	await getApiClient().updateTask(taskId, { previewUrl: url });
-}
-/**
 * Tool: jive-tasks__create_pull_request
 * Create a pull request or merge request for the task
 */
@@ -4124,18 +4130,12 @@ function createTasksSdkServer(task) {
 					};
 				}
 			}),
-			tool("setup_cloudflare_tunnel", "Run this before serving an application for user/automated testing. Spin up a cloudflare tunnel and returns the public host and port.", { taskId: z.number() }, async (args) => {
+			tool("refresh_preview", "Reads the .jiverc file, regenerates the specified cloudflare tunnels and starts the serve command. Call this if the user reports the preview is not working or otherwise inaccessible.", {}, async () => {
 				try {
-					const result = await task.ensureCloudflareTunnel();
-					if ("error" in result) return { content: [{
-						type: "text",
-						text: `Failed to set up cloudflare tunnel, error: ${result.error}`
-					}] };
-					task.disableIdleTimeout();
-					await setTaskUrl(args.taskId, `https://${result.host}`);
+					await task.setup();
 					return { content: [{
 						type: "text",
-						text: `Tunnel set up successfully. Host: ${result.host} Port: ${result.port}. If you start a server it may be accessible to the public.`
+						text: `Preview refreshed successfully`
 					}] };
 				} catch (error$1) {
 					return {
@@ -4262,6 +4262,67 @@ function getClaudeSessionPath(directory, sessionId) {
 	return path.join(process.env.HOME || "~", ".claude", "projects", sanitizedDir, `${sessionId}.jsonl`);
 }
 
+//#endregion
+//#region src/runner/PreviewProxy.ts
+const ALLOWED_FRAME_ANCESTORS = isDevMode() ? "'self' https://*.getjive.app https://getjive.app http://localhost:* http://127.0.0.1:*" : "'self' https://*.getjive.app https://getjive.app";
+var PreviewProxy = class {
+	server = null;
+	proxy = null;
+	constructor(config$2) {
+		this.config = config$2;
+	}
+	log(message) {
+		debugLog(`[PreviewProxy:${this.config.name}] ${message}`);
+	}
+	async start() {
+		this.proxy = httpProxy.createProxyServer({
+			target: `http://localhost:${this.config.targetPort}`,
+			ws: true
+		});
+		this.proxy.on("proxyRes", (proxyRes, req, res) => {
+			delete proxyRes.headers["x-frame-options"];
+			delete proxyRes.headers["X-Frame-Options"];
+			let csp = proxyRes.headers["content-security-policy"] || "";
+			csp = csp.replace(/frame-ancestors[^;]*;?/gi, "").trim();
+			const frameAncestors = `frame-ancestors ${ALLOWED_FRAME_ANCESTORS}`;
+			csp = csp ? `${csp}; ${frameAncestors}` : frameAncestors;
+			debugLog(`[PreviewProxy:${this.config.name}] CSP: ${csp}`);
+			proxyRes.headers["content-security-policy"] = csp;
+		});
+		this.proxy.on("error", (err, req, res) => {
+			this.log(`Proxy error: ${err.message}`);
+			if (res instanceof http.ServerResponse && !res.headersSent) {
+				res.writeHead(502, { "Content-Type": "text/plain" });
+				res.end("Proxy error: " + err.message);
+			}
+		});
+		this.server = http.createServer((req, res) => {
+			this.proxy.web(req, res);
+		});
+		this.server.on("upgrade", (req, socket, head) => {
+			this.proxy.ws(req, socket, head);
+		});
+		await new Promise((resolve, reject) => {
+			this.server.listen(this.config.proxyPort, () => {
+				this.log(`Proxy listening on port ${this.config.proxyPort}, forwarding to ${this.config.targetPort}`);
+				resolve();
+			});
+			this.server.on("error", reject);
+		});
+	}
+	stop() {
+		if (this.server) {
+			this.server.close();
+			this.server = null;
+		}
+		if (this.proxy) {
+			this.proxy.close();
+			this.proxy = null;
+		}
+		this.log("Proxy stopped");
+	}
+};
+
 //#endregion
 //#region src/runner/Task.ts
 const ACK_TIMEOUT_MS = 1e3;
@@ -4276,7 +4337,9 @@ var Task = class {
 	pendingAcks = /* @__PURE__ */ new Map();
 	pendingPermissions = /* @__PURE__ */ new Map();
 	pendingQuestions = /* @__PURE__ */ new Map();
-	tunnel = null;
+	tunnels = /* @__PURE__ */ new Map();
+	proxies = /* @__PURE__ */ new Map();
+	primaryTunnelHost = null;
 	fileWatcher = null;
 	lastFilePosition = 0;
 	currentPendingLineUuid = null;
@@ -4284,6 +4347,7 @@ var Task = class {
 	lastActivityTime = Date.now();
 	idleWatchdogInterval = null;
 	idleTimeoutDisabled = false;
+	serveProcess = null;
 	get defaultBranch() {
 		const tasksConfig = getTasksConfigSync();
 		if (!tasksConfig) {
@@ -4373,7 +4437,8 @@ var Task = class {
 		}
 		this.stopHeartbeat();
 		this.stopSessionFileWatcher();
-		this.cleanupCloudflareTunnel();
+		this.cleanupServeProcess();
+		this.cleanupAllTunnels();
 		this.debugLog("Task process exiting due to idle timeout");
 		process.exit(0);
 	}
@@ -4390,6 +4455,7 @@ var Task = class {
 			process.exit(1);
 		}
 		this.debugLog(`✓ Git repository and session file setup complete`);
+		await this.setup();
 		this.startHeartbeat();
 		this.startIdleWatchdog();
 		this.sendStatusUpdate("idle");
@@ -4400,13 +4466,28 @@ var Task = class {
 			this.stopHeartbeat();
 			this.stopIdleWatchdog();
 			this.stopSessionFileWatcher();
-			this.cleanupCloudflareTunnel();
+			this.cleanupServeProcess();
+			this.cleanupAllTunnels();
 			this.sendStatusUpdate("exited");
 		};
 		process.on("exit", cleanup);
 		process.on("SIGINT", cleanup);
 		process.on("SIGTERM", cleanup);
 	}
+	/**
+	* Stop the serve process if it's running
+	*/
+	cleanupServeProcess() {
+		if (this.serveProcess) {
+			try {
+				if (this.serveProcess.pid) process.kill(-this.serveProcess.pid, "SIGTERM");
+				this.debugLog("Serve process stopped");
+			} catch (error$1) {
+				this.debugLog(`Warning: Failed to stop serve process: ${error$1.message}`);
+			}
+			this.serveProcess = null;
+		}
+	}
 	stdinBuffer = "";
 	listenForMessages() {
 		process.stdin.on("data", (data) => {
@@ -4611,41 +4692,44 @@ var Task = class {
 		this.debugLog("Idle timeout disabled");
 	}
 	/**
-	* Set up Cloudflare tunnel for exposing local services to the internet.
+	* Set up a single Cloudflare tunnel for exposing local services to the internet.
+	* This is the legacy method for backwards compatibility when no tunnels are configured.
 	* Sets HOST and PORT environment variables for use by the task.
 	*/
 	async ensureCloudflareTunnel() {
-		this.cleanupCloudflareTunnel();
-		this.debugLog("Setting up Cloudflare tunnel...");
+		this.cleanupAllTunnels();
+		this.debugLog("Setting up Cloudflare tunnel (legacy mode)...");
 		const idealPort = parseInt(process.env.PORT ?? "", 10);
 		if (!isNaN(idealPort)) this.debugLog(`Trying ideal port: ${idealPort}`);
 		const port = await getPort({ port: idealPort });
 		this.debugLog(`Selected available port: ${port}`);
 		process.env.PORT = port.toString();
 		try {
-			this.tunnel = Tunnel.quick(`http://localhost:${port}`);
+			const tunnel = Tunnel.quick(`http://localhost:${port}`);
 			const tunnelUrl = await new Promise((resolve, reject) => {
 				const timeout = setTimeout(() => {
 					reject(/* @__PURE__ */ new Error("Cloudflare tunnel URL resolution timed out after 30 seconds"));
 				}, 3e4);
-				this.tunnel.once("url", (url) => {
+				tunnel.once("url", (url) => {
 					clearTimeout(timeout);
 					resolve(url);
 				});
-				this.tunnel.once("exit", (code) => {
+				tunnel.once("exit", (code) => {
 					clearTimeout(timeout);
 					reject(/* @__PURE__ */ new Error(`Cloudflare tunnel exited unexpectedly with code ${code}`));
 				});
 			});
 			const host = new URL(tunnelUrl).host;
 			process.env.JIVE_PUBLIC_HOST = host;
+			this.tunnels.set("_legacy", tunnel);
+			this.primaryTunnelHost = host;
 			this.debugLog(`Cloudflare tunnel established: Host: ${host}, Port: ${port}`);
 			return {
 				port,
 				host
 			};
 		} catch (error$1) {
-			this.cleanupCloudflareTunnel();
+			this.cleanupAllTunnels();
 			return { error: error$1 };
 		}
 	}
@@ -4708,18 +4792,100 @@ Host gitlab.com
 		this.debugLog("✓ SSH authentication configured with deploy key");
 	}
 	/**
-	* Stop the Cloudflare tunnel and clean up resources
+	* Stop all Cloudflare tunnels, proxies, and clean up resources
+	*/
+	cleanupAllTunnels() {
+		if (this.proxies.size > 0) {
+			this.debugLog(`Stopping ${this.proxies.size} preview proxy(ies)...`);
+			for (const [name$1, proxy] of this.proxies) try {
+				proxy.stop();
+				this.debugLog(`Preview proxy '${name$1}' stopped`);
+			} catch (error$1) {
+				console.warn(chalk.yellow(`Warning: Failed to stop preview proxy '${name$1}': ${error$1.message}`));
+			}
+			this.proxies.clear();
+		}
+		if (this.tunnels.size === 0) return;
+		this.debugLog(`Stopping ${this.tunnels.size} Cloudflare tunnel(s)...`);
+		for (const [name$1, tunnel] of this.tunnels) try {
+			tunnel.stop();
+			this.debugLog(`Cloudflare tunnel '${name$1}' stopped`);
+		} catch (error$1) {
+			console.warn(chalk.yellow(`Warning: Failed to stop Cloudflare tunnel '${name$1}': ${error$1.message}`));
+		}
+		this.tunnels.clear();
+		this.primaryTunnelHost = null;
+	}
+	/**
+	* Set up all configured tunnels from .jiverc config.
+	* Sets environment variables for each tunnel:
+	* - {NAME}_PORT = actual port used (for dev server to bind to)
+	* - JIVE_{NAME}_HOST or custom envVarName = tunnel host
+	*
+	* When embedded !== false (default), a proxy server is inserted between
+	* the tunnel and the dev server to modify CSP headers for iframe embedding.
 	*/
-	cleanupCloudflareTunnel() {
-		if (this.tunnel) {
+	async setupTunnels(tunnelConfigs) {
+		this.debugLog(`Setting up ${tunnelConfigs.length} tunnel(s)...`);
+		this.cleanupAllTunnels();
+		const primaryTunnel = tunnelConfigs.find((t$2) => t$2.primary) ?? tunnelConfigs[0];
+		for (const config$2 of tunnelConfigs) {
+			const name$1 = config$2.name.toUpperCase();
+			const useProxy = config$2.embedded !== false;
 			try {
-				this.tunnel.stop();
-				this.debugLog("Cloudflare tunnel stopped");
+				let tunnelPort;
+				let targetPort;
+				if (useProxy) {
+					const proxyPort = await getPort({ port: config$2.port + 1 });
+					targetPort = await getPort({ port: config$2.port });
+					tunnelPort = proxyPort;
+					this.debugLog(`Tunnel '${config$2.name}': proxy on ${proxyPort}, dev server on ${targetPort}`);
+					const proxy = new PreviewProxy({
+						proxyPort,
+						targetPort,
+						name: config$2.name
+					});
+					await proxy.start();
+					this.proxies.set(config$2.name, proxy);
+				} else {
+					tunnelPort = await getPort({ port: config$2.port });
+					targetPort = tunnelPort;
+					this.debugLog(`Tunnel '${config$2.name}': direct connection on port ${tunnelPort} (proxy disabled)`);
+				}
+				process.env[`${name$1}_PORT`] = targetPort.toString();
+				const tunnel = Tunnel.quick(`http://localhost:${tunnelPort}`);
+				const tunnelUrl = await new Promise((resolve, reject) => {
+					const timeout = setTimeout(() => {
+						reject(/* @__PURE__ */ new Error(`Cloudflare tunnel '${config$2.name}' URL resolution timed out after 30 seconds`));
+					}, 3e4);
+					tunnel.once("url", (url) => {
+						clearTimeout(timeout);
+						resolve(url);
+					});
+					tunnel.once("exit", (code) => {
+						clearTimeout(timeout);
+						reject(/* @__PURE__ */ new Error(`Cloudflare tunnel '${config$2.name}' exited unexpectedly with code ${code}`));
+					});
+				});
+				const host = new URL(tunnelUrl).host;
+				const hostEnvVar = config$2.envVarName ?? `JIVE_${name$1}_HOST`;
+				process.env[hostEnvVar] = host;
+				if (config$2 === primaryTunnel) {
+					this.primaryTunnelHost = host;
+					process.env.JIVE_PUBLIC_HOST = host;
+					process.env.PORT = targetPort.toString();
+					this.debugLog(`Tunnel '${config$2.name}' is primary (previewUrl)`);
+				}
+				this.tunnels.set(config$2.name, tunnel);
+				const proxyStatus = useProxy ? " (proxy enabled)" : " (proxy disabled)";
+				this.debugLog(`✓ Tunnel '${config$2.name}' established: ${hostEnvVar}=${host}, ${name$1}_PORT=${targetPort}${proxyStatus}`);
 			} catch (error$1) {
-				console.warn(chalk.yellow(`Warning: Failed to stop Cloudflare tunnel: ${error$1.message}`));
+				this.debugLog(`✗ Failed to set up tunnel '${config$2.name}': ${error$1.message}`);
+				this.cleanupAllTunnels();
+				throw error$1;
 			}
-			this.tunnel = null;
 		}
+		this.debugLog(`✓ All ${tunnelConfigs.length} tunnel(s) established`);
 	}
 	async setupGitRepository() {
 		let { repository } = this.ctx;
@@ -4783,6 +4949,151 @@ Host gitlab.com
 		await execAsync$1(`git status`);
 		this.debugLog(`✓ Git repository setup complete`);
 	}
+	/**
+	* Read and parse the .jiverc.yml or .jiverc.json config file from the project root.
+	* Returns null if neither file exists.
+	*/
+	async readJivercConfig() {
+		const { directory } = this.ctx;
+		const ymlPath = path$1.join(directory, ".jiverc.yml");
+		const jsonPath = path$1.join(directory, ".jiverc.json");
+		try {
+			if (existsSync(ymlPath)) {
+				this.debugLog(`Found config file: .jiverc.yml`);
+				const content = await promises.readFile(ymlPath, "utf-8");
+				return yaml.load(content);
+			}
+			if (existsSync(jsonPath)) {
+				this.debugLog(`Found config file: .jiverc.json`);
+				const content = await promises.readFile(jsonPath, "utf-8");
+				return JSON.parse(content);
+			}
+			this.debugLog(`No .jiverc.yml or .jiverc.json found`);
+			return null;
+		} catch (error$1) {
+			this.debugLog(`Error reading jiverc config: ${error$1.message}`);
+			return null;
+		}
+	}
+	/**
+	* Run a shell command and return success/failure status.
+	* Logs stdout/stderr appropriately.
+	*/
+	async runSetupCommand(command, label) {
+		this.debugLog(`Running ${label} command: ${command}`);
+		try {
+			const { stdout, stderr } = await execAsync$1(command, {
+				cwd: this.ctx.directory,
+				env: process.env,
+				maxBuffer: 10 * 1024 * 1024
+			});
+			if (stdout) this.debugLog(`${label} stdout:\n${stdout}`);
+			if (stderr) this.debugLog(`${label} stderr:\n${stderr}`);
+			this.debugLog(`✓ ${label} command completed successfully`);
+			return true;
+		} catch (error$1) {
+			this.debugLog(`✗ ${label} command failed: ${error$1.message}`);
+			if (error$1.stdout) this.debugLog(`stdout:\n${error$1.stdout}`);
+			if (error$1.stderr) this.debugLog(`stderr:\n${error$1.stderr}`);
+			return false;
+		}
+	}
+	/**
+	* Run project setup based on .jiverc config file.
+	* - Sets up tunnels first (if configured) so env vars are available
+	* - Runs setup command synchronously if defined
+	* - Starts serve command if defined
+	* 
+	* Note: this is also called by the 'refresh_preview' tool.
+	*/
+	async setup() {
+		this.cleanupServeProcess();
+		this.cleanupAllTunnels();
+		try {
+			const config$2 = await this.readJivercConfig();
+			if (!config$2) {
+				this.debugLog("No jiverc config found, skipping setup");
+				return;
+			}
+			if (config$2.tunnels && config$2.tunnels.length > 0) await this.setupTunnels(config$2.tunnels);
+			if (config$2.commands?.setup) {
+				this.debugLog("Running setup command...");
+				if (!await this.runSetupCommand(config$2.commands.setup, "setup")) this.debugLog("Setup command failed, continuing anyway...");
+			}
+			if (config$2.commands?.serve) await this.serve();
+		} catch (error$1) {
+			this.debugLog(`Error during setup: ${error$1.message}`);
+		}
+	}
+	/**
+	* Start the serve command from .jiverc config.
+	* Tunnels should already be set up by setup() - this just starts the serve process.
+	* If tunnels aren't set up yet (e.g., serve() called directly), it will set them up.
+	* Updates the task's previewUrl using the primary tunnel.
+	*/
+	async serve() {
+		try {
+			const config$2 = await this.readJivercConfig();
+			if (!config$2?.commands?.serve) {
+				this.debugLog("No serve command configured in .jiverc");
+				return;
+			}
+			const serveCommand = config$2.commands.serve;
+			this.debugLog(`Starting serve command: ${serveCommand}`);
+			this.cleanupServeProcess();
+			if (this.tunnels.size === 0 && config$2.tunnels && config$2.tunnels.length > 0) await this.setupTunnels(config$2.tunnels);
+			if (this.tunnels.size === 0) {
+				this.debugLog("No tunnels configured, setting up legacy single tunnel...");
+				const tunnelResult = await this.ensureCloudflareTunnel();
+				if ("error" in tunnelResult) {
+					this.debugLog(`Failed to establish Cloudflare tunnel: ${tunnelResult.error}`);
+					return;
+				}
+				this.primaryTunnelHost = tunnelResult.host;
+			}
+			this.serveProcess = spawn(serveCommand, [], {
+				cwd: this.ctx.directory,
+				env: process.env,
+				shell: true,
+				detached: true,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			this.serveProcess.unref();
+			this.serveProcess.stdout?.on("data", (data) => {
+				this.debugLog(`[serve] ${data.toString().trim()}`);
+			});
+			this.serveProcess.stderr?.on("data", (data) => {
+				this.debugLog(`[serve:err] ${data.toString().trim()}`);
+			});
+			this.serveProcess.on("error", (error$1) => {
+				this.debugLog(`[serve] Process error: ${error$1.message}`);
+			});
+			this.serveProcess.on("exit", (code, signal) => {
+				this.debugLog(`[serve] Process exited with code ${code}, signal ${signal}`);
+				this.serveProcess = null;
+			});
+			this.disableIdleTimeout();
+			if (this.primaryTunnelHost) {
+				const previewUrl = `https://${this.primaryTunnelHost}`;
+				this.debugLog(`✓ Serve command started in background`);
+				this.debugLog(`Public URL: ${previewUrl}`);
+				try {
+					this.debugLog("Waiting 5 seconds to ensure tunnel is ready...");
+					await new Promise((resolve) => setTimeout(resolve, 5e3));
+					await getApiClient().updateTask(this.id, { previewUrl });
+					this.debugLog(`✓ Task previewUrl updated to ${previewUrl}`);
+				} catch (error$1) {
+					this.debugLog(`Failed to update task previewUrl: ${error$1.message}`);
+				}
+			} else this.debugLog(`✓ Serve command started in background (no tunnel configured)`);
+		} catch (error$1) {
+			this.debugLog(`Error during serve: ${error$1.message}`);
+		}
+	}
 	get claudeSessionFilePath() {
 		return path$1.join(process.env.HOME || "~", ".claude", "projects", this.ctx.directory.replace(/\//g, "-"), `${this.ctx.claudeSessionId}.jsonl`);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@jive-ai/cli",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "main": "index.js",
   "files": [
     "dist",
@@ -16,7 +16,7 @@
     "typecheck": "tsc --noEmit",
     "build": "tsdown && npm pack && npm install -g jive-ai-cli-*.tgz",
     "docker:build": "touch jive-ai-cli-0.0.0.tgz && docker build -t jiveai/task:latest . && rm -f jive-ai-cli-*.tgz",
-    "docker:build:local": "docker rmi jiveai/task:$npm_package_version jiveai/task:latest; bun run build && docker build --build-arg USE_LOCAL=true -t jiveai/task:latest -t jiveai/task:$npm_package_version .",
+    "docker:build:local": "docker rmi jiveai/task:$npm_package_version jiveai/task:latest; bun run build && docker build --no-cache  --build-arg USE_LOCAL=true -t jiveai/task:latest -t jiveai/task:$npm_package_version .",
     "docker:build:public": "touch jive-ai-cli-0.0.0.tgz && docker buildx build --platform linux/amd64 -t jiveai/task:latest -t jiveai/task:$npm_package_version . && rm -f jive-ai-cli-*.tgz",
     "docker:push": "docker buildx build --platform linux/amd64 --push -t jiveai/task:latest -t jiveai/task:$npm_package_version .",
     "docker:publish": "touch jive-ai-cli-0.0.0.tgz && docker buildx build --platform linux/amd64 --push -t jiveai/task:latest -t jiveai/task:$npm_package_version . && rm -f jive-ai-cli-*.tgz",
@@ -27,6 +27,8 @@
   "description": "",
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
+    "@types/http-proxy": "^1.17.16",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.1",
     "@types/prompts": "^2.4.9",
     "@types/ws": "^8.5.13",
@@ -46,8 +48,10 @@
     "get-port": "^7.1.0",
     "graphql": "^16.12.0",
     "graphql-request": "^7.4.0",
+    "http-proxy": "^1.18.1",
     "gray-matter": "^4.0.3",
     "js-base64": "^3.7.8",
+    "js-yaml": "^3.14.2",
     "ora": "^9.0.0",
     "prompts": "^2.4.2",
     "typescript": "^5.9.3",