@jive-ai/cli 0.0.30 → 0.0.32

package/README.md

@@ -0,0 +1,109 @@
+# Jive CLI
+
+The official CLI for Jive AI - autonomous development workflows powered by Claude.
+
+## Installation
+
+### npm
+
+```bash
+npm install -g @jive-ai/cli
+```
+
+### Docker
+
+```bash
+docker pull jive-ai/task:latest
+```
+
+## Configuration
+
+### Environment Variables
+
+The CLI can be configured using environment variables:
+
+- `JIVE_TASK_IDLE_TIMEOUT` - Minutes of idle time before a task automatically terminates (default: 5). Tasks are ephemeral and will gracefully shutdown after this period of inactivity, freeing up runner capacity. Session data is preserved for resume.
+  - Development: `JIVE_TASK_IDLE_TIMEOUT=10` (10 minutes - more forgiving)
+  - Production: `JIVE_TASK_IDLE_TIMEOUT=5` (5 minutes - default)
+  - CI/CD: `JIVE_TASK_IDLE_TIMEOUT=30` (30 minutes - long builds)
+
+- `JIVE_API_KEY` - Your Jive API authentication key (required for task runners)
+- `JIVE_TEAM_ID` - The team ID to run tasks for (required for task runners)
+- `JIVE_API_URL` - API endpoint (defaults to production)
+- `JIVE_WS_URL` - WebSocket endpoint (defaults to production)
+- `JIVE_LOG_FILE` - MCP server log path (defaults to `/tmp/jive-mcp.log`)
+
+## Docker Image
+
+The docker image is used for each task process container. Whenever you spin up a new task in Jive,
+it will start a new container with this image. You can specify your own custom image in the project settings
+as long as the same entrypoint script is provided. The task runner relies on it.
+
+### Building Your Own Images
+
+You can extend the Jive task runner image to add custom tools or dependencies:
+
+```dockerfile
+FROM jive-ai/task:latest
+
+# Add your custom dependencies
+RUN apk add --no-cache python3 py3-pip
+
+# Install additional tools
+RUN pip install --break-system-packages black ruff
+```
+
+## Publishing the Docker Image (Maintainers)
+
+### One-Time Setup
+
+1. Login to Docker Hub:
+   ```bash
+   docker login
+   ```
+
+2. Create a buildx builder for multi-platform builds:
+   ```bash
+   docker buildx create --name mybuilder --use
+   docker buildx inspect --bootstrap
+   ```
+
+### Publishing a New Version
+
+After publishing a new version to npm, publish the corresponding Docker image:
+
+```bash
+cd cli
+npm run docker:publish
+```
+
+This will:
+- Build for both `linux/amd64` and `linux/arm64` platforms
+- Tag with both `latest` and the current package version (e.g., `0.0.31`)
+- Push both tags to Docker Hub
+
+The image pulls the CLI from npm (using the `@jive-ai/cli` package), so make sure you've published to npm first.
+
+### Manual Steps
+
+If you need more control:
+
+```bash
+# Build only (no push)
+npm run docker:build:public
+
+# Push to Docker Hub
+npm run docker:push
+```
+
+## Development
+
+### Local Development with Docker
+
+To test the Docker image with your local code changes:
+
+```bash
+npm run docker:build:local
+```
+
+This builds an image using the local CLI tarball instead of pulling from npm.

package/dist/graphql-client-DtLFKd4m.mjs

@@ -0,0 +1,3 @@
+import { a as queries, i as mutations, n as cliMutations, r as cliQueries, t as getGraphQLClient } from "./index.mjs";
+
+export { getGraphQLClient };

package/dist/index.mjs

@@ -14,6 +14,7 @@ import crypto from "crypto";
 import "gray-matter";
 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 { z } from "zod";
 import dedent from "dedent";
@@ -154,9 +155,9 @@ async function isProjectInitialized() {
 
 //#endregion
 //#region src/constants.ts
-const API_URL = process.env.JIVE_API_URL || "http://localhost:5173";
-const GRAPHQL_API_URL = process.env.JIVE_GRAPHQL_API_URL || "http://localhost:4000/graphql";
-const WS_URL = process.env.JIVE_WS_URL || "ws://localhost:4000";
+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";
 
 //#endregion
 //#region src/commands/auth.ts
@@ -2337,12 +2338,13 @@ const queries = {
     }
   `),
 	GetSessionLines: graphql(`
-    query GetSessionLines($taskId: ID!, $sessionId: ID!, $first: Int, $after: String) {
-      sessionLines(taskId: $taskId, sessionId: $sessionId, first: $first, after: $after) {
+    query GetSessionLines($taskId: ID!, $sessionId: ID!, $first: Int, $after: String, $excludePending: Boolean) {
+      sessionLines(taskId: $taskId, sessionId: $sessionId, first: $first, after: $after, excludePending: $excludePending) {
         edges {
           node {
             uuid
             schema
+            status
             payload
             createdAt
           }
@@ -2404,9 +2406,9 @@ const mutations = {
       }
     }
   `),
-	CreateSessionLine: graphql(`
-    mutation CreateSessionLine($input: CreateSessionLineInput!) {
-      createSessionLine(input: $input) {
+	PromptSendToAgent: graphql(`
+    mutation PromptSendToAgent($input: PromptSendToAgentInput!) {
+      promptSendToAgent(input: $input) {
         line {
           uuid
           schema
@@ -2433,34 +2435,6 @@ const mutations = {
         }
       }
     }
-  `),
-	RefreshPreview: graphql(`
-    mutation RefreshPreview($input: RefreshPreviewInput!) {
-      refreshPreview(input: $input) {
-        task {
-          id
-          previewUrl
-        }
-        errors {
-          message
-          code
-        }
-      }
-    }
-  `),
-	AddressReview: graphql(`
-    mutation AddressReview($input: AddressReviewInput!) {
-      addressReview(input: $input) {
-        task {
-          id
-          status
-        }
-        errors {
-          message
-          code
-        }
-      }
-    }
   `),
 	CreatePlan: graphql(`
     mutation CreatePlan($input: CreatePlanInput!) {
@@ -2565,6 +2539,21 @@ const cliQueries = {
         createdAt
       }
     }
+  `),
+	Team: graphql(`
+    query Team($id: ID!) {
+      team(id: $id) {
+        id
+        name
+        settings {
+          claude {
+            defaultModel
+            environmentVariables
+            betaFlags
+          }
+        }
+      }
+    }
   `),
 	InterruptedTasks: graphql(`
     query InterruptedTasks($runnerId: ID!, $limit: Int) {
@@ -2577,7 +2566,13 @@ const cliQueries = {
           directory
           repository
           branch
-          gitAuth
+          gitAuth {
+            privateKey
+            repositoryUrl
+            provider
+            method
+          }
+          permissionMode
         }
         sessionId
       }
@@ -2616,6 +2611,9 @@ const cliQueries = {
         description
         gitRepoUrl
         gitDefaultBranch
+        team {
+          id
+        }
         createdAt
         updatedAt
       }
@@ -2763,6 +2761,7 @@ async function getGraphQLClient() {
 function mapStatusToGraphQL(dbStatus) {
 	return {
 		"draft": "DRAFT",
+		"pending": "PENDING",
 		"planning": "PLANNING",
 		"planned": "PLANNED",
 		"in-progress": "IN_PROGRESS",
@@ -2951,10 +2950,11 @@ var ApiClient = class {
 			} : null
 		};
 	}
-	async getSessionLines(taskId, sessionId) {
+	async getSessionLines(taskId, sessionId, excludePending = false) {
 		return (await (await getGraphQLClient()).request(queries.GetSessionLines, {
 			taskId: String(taskId),
-			sessionId: String(sessionId)
+			sessionId: String(sessionId),
+			excludePending
 		})).sessionLines.edges.map((edge) => ({
 			uuid: edge.node.uuid,
 			schema: edge.node.schema,
@@ -3269,15 +3269,42 @@ async function fetchProject(teamId) {
 
 //#endregion
 //#region src/runner/taskUtils.ts
+const ProjectResourceLimitsQuery = graphql(`
+  query ProjectResourceLimits($projectId: ID!) {
+    project(id: $projectId) {
+      id
+      dockerCpus
+      dockerMemory
+      dockerImage
+    }
+  }
+`);
+async function fetchProjectResourceLimits(projectId) {
+	try {
+		const result = await (await getGraphQLClient()).request(ProjectResourceLimitsQuery, { projectId: projectId.toString() });
+		if (!result.project) {
+			console.log(chalk.yellow(`Warning: Could not fetch project ${projectId} resource limits`));
+			return;
+		}
+		return {
+			dockerCpus: result.project.dockerCpus,
+			dockerMemory: result.project.dockerMemory,
+			dockerImage: result.project.dockerImage
+		};
+	} catch (error$1) {
+		console.log(chalk.yellow(`Warning: Failed to fetch project resource limits: ${error$1.message}`));
+		return;
+	}
+}
 function spawnTask(ctx, opts) {
 	throw new Error("Shell executor not supported anymore.");
 }
-async function spawnTaskDocker(ctx, opts) {
+async function spawnTaskDocker(ctx, config$2, opts) {
 	mkdirSync(ctx.directory, { recursive: true });
+	const limits = getEffectiveResourceLimits(config$2, await fetchProjectResourceLimits(ctx.projectId));
 	const envVars = [];
 	const credentials = await getCredentials();
 	if (!credentials) throw new Error("No credentials found");
-	const config$2 = await getRunnerConfig();
 	envVars.push("-e", `JIVE_API_KEY=${credentials.token}`);
 	envVars.push("-e", `ANTHROPIC_API_KEY=${credentials.anthropicApiKey}`);
 	envVars.push("-e", `JIVE_TEAM_ID=${config$2.teamId}`);
@@ -3311,7 +3338,8 @@ async function spawnTaskDocker(ctx, opts) {
 	}
 	dockerArgs.push("--network", "bridge");
 	if (isDevMode) dockerArgs.push("--add-host", "host.docker.internal:host-gateway");
-	dockerArgs.push("--cpus", "2", "--memory", "2g", "-v", `${ctx.directory}:/workspace`, "-w", "/workspace", ...envVars, "jive-task-runner:latest", encode(JSON.stringify(ctx)));
+	dockerArgs.push("--cpus", limits.docker.cpus, "--memory", limits.docker.memory, "-v", `${ctx.directory}:/workspace`, "-w", "/workspace", ...envVars, limits.docker.image, encode(JSON.stringify(ctx)));
+	console.log(chalk.dim(`[Task ${ctx.taskId}] Spawning Docker container with args:`, JSON.stringify(dockerArgs, null, 2)));
 	const taskProcess = spawn("docker", dockerArgs, { cwd: ctx.directory });
 	let buffer = "";
 	taskProcess.stdout.on("data", (data) => {
@@ -3352,21 +3380,49 @@ async function spawnTaskDocker(ctx, opts) {
 	return taskProcess;
 }
 
+//#endregion
+//#region src/runner/graphql-client.ts
+async function createGraphQLClient() {
+	const credentials = await getCredentials();
+	if (!credentials?.token) throw new Error("No credentials found, run `jive login` first");
+	const client = new GraphQLClient(GRAPHQL_API_URL, { headers: { "X-API-Key": credentials.token } });
+	return {
+		async request(document, variables) {
+			return client.request(document, variables);
+		},
+		async rawRequest(document, variables) {
+			return client.request(document, variables);
+		}
+	};
+}
+
 //#endregion
 //#region src/runner/index.ts
 const execAsync$3 = promisify(exec);
-const MAX_CONCURRENT_TASKS = 5;
-const INTERRUPTED_TASK_POLL_INTERVAL = 3e4;
+const PENDING_TASK_POLL_INTERVAL = 3e4;
+function getEffectiveResourceLimits(config$2, projectLimits) {
+	const maxConcurrentTasksEnv = process.env.JIVE_MAX_CONCURRENT_TASKS;
+	return {
+		maxConcurrentTasks: maxConcurrentTasksEnv && !isNaN(parseInt(maxConcurrentTasksEnv)) ? parseInt(maxConcurrentTasksEnv) : config$2.resourceLimits?.maxConcurrentTasks ?? 5,
+		docker: {
+			cpus: projectLimits?.dockerCpus?.toString() || process.env.JIVE_DOCKER_CPUS || config$2.resourceLimits?.docker?.cpus || "2",
+			memory: projectLimits?.dockerMemory || process.env.JIVE_DOCKER_MEMORY || config$2.resourceLimits?.docker?.memory || "2g",
+			image: projectLimits?.dockerImage || process.env.JIVE_DOCKER_IMAGE || config$2.resourceLimits?.docker?.image || "jive-ai/task:latest"
+		}
+	};
+}
 var TaskRunner = class {
 	config;
 	ws = null;
 	heartbeatInterval = null;
-	interruptedTaskPollInterval = null;
+	pendingTaskPollInterval = null;
 	isRunning = false;
 	reconnectTimeout = null;
+	maxConcurrentTasks;
 	taskProcesses = {};
 	constructor(config$2) {
 		this.config = config$2;
+		this.maxConcurrentTasks = getEffectiveResourceLimits(config$2).maxConcurrentTasks;
 	}
 	async start() {
 		this.isRunning = true;
@@ -3384,7 +3440,7 @@ var TaskRunner = class {
 			clearInterval(this.heartbeatInterval);
 			this.heartbeatInterval = null;
 		}
-		this.stopInterruptedTaskPolling();
+		this.stopPendingTaskPolling();
 		if (this.reconnectTimeout) {
 			clearTimeout(this.reconnectTimeout);
 			this.reconnectTimeout = null;
@@ -3426,12 +3482,75 @@ var TaskRunner = class {
 			}
 		});
 	}
-	fetchTaskProcess(ctx) {
-		const existingProcess = this.taskProcesses[ctx.taskId.toString()];
+	async fetchTaskContext(taskId) {
+		try {
+			const { getGraphQLClient: getGraphQLClient$1 } = await import("./graphql-client-DtLFKd4m.mjs");
+			const client = await getGraphQLClient$1();
+			const query$1 = graphql(`
+        query TaskContext($taskId: ID!) {
+          taskContext(taskId: $taskId) {
+            taskId
+            sessionId
+            claudeSessionId
+            projectId
+            directory
+            repository
+            branch
+            gitAuth {
+              privateKey
+              repositoryUrl
+              provider
+              method
+            }
+            permissionMode
+          }
+        }
+      `);
+			const data = await client.request(query$1, { taskId: taskId.toString() });
+			if (!data.taskContext) {
+				console.error(chalk.red(`No context found for task ${taskId}`));
+				return null;
+			}
+			const auth = (() => {
+				const gitAuth = data.taskContext.gitAuth;
+				if (!gitAuth) return null;
+				return {
+					...gitAuth,
+					provider: gitAuth.provider,
+					method: gitAuth.method
+				};
+			})();
+			return {
+				taskId: data.taskContext.taskId,
+				sessionId: data.taskContext.sessionId,
+				claudeSessionId: data.taskContext.claudeSessionId,
+				projectId: data.taskContext.projectId,
+				directory: data.taskContext.directory,
+				repository: data.taskContext.repository,
+				branch: data.taskContext.branch,
+				gitAuth: auth || void 0,
+				permissionMode: data.taskContext.permissionMode
+			};
+		} catch (error$1) {
+			console.error(error$1);
+			console.error(chalk.red(`Failed to fetch task context: ${error$1.message}`));
+			return null;
+		}
+	}
+	async fetchTaskProcess(taskId) {
+		const existingProcess = this.taskProcesses[taskId.toString()];
 		if (existingProcess) return existingProcess;
-		if (Object.values(this.taskProcesses).filter((p$1) => p$1 !== null).length >= MAX_CONCURRENT_TASKS) throw new Error(`Maximum concurrent tasks reached (${MAX_CONCURRENT_TASKS})`);
-		return this.taskProcesses[ctx.taskId.toString()] = new Promise((resolve) => {
-			resolve((this.config.type === "docker" ? spawnTaskDocker : spawnTask)(ctx, {
+		if (Object.values(this.taskProcesses).filter((p$1) => p$1 !== null).length >= this.maxConcurrentTasks) {
+			console.warn(chalk.yellow(`Maximum concurrent tasks reached (${this.maxConcurrentTasks})`));
+			return null;
+		}
+		const ctx = await this.fetchTaskContext(taskId);
+		if (!ctx) {
+			console.error(chalk.red(`Failed to fetch context for task ${taskId}`));
+			return null;
+		}
+		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;
@@ -3439,11 +3558,29 @@ var TaskRunner = class {
 				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;
+				},
+				onClose: () => {
+					this.taskProcesses[ctx.taskId.toString()] = null;
+				}
+			}))).then((process$1) => {
+				resolve({
+					process: process$1,
+					ctx
+				});
+			});
 		});
 	}
-	async sendToTask(ctx, message) {
-		(await this.fetchTaskProcess(ctx)).stdin?.write(JSON.stringify(message) + "\n");
+	async sendToTask(taskId, message) {
+		const result = await this.fetchTaskProcess(taskId);
+		if (!result) {
+			console.warn(chalk.yellow(`Cannot write message for task ${taskId}, process not found or unobtainable`));
+			return;
+		}
+		result.process.stdin?.write(JSON.stringify(message) + "\n");
 	}
 	async connect() {
 		console.log(chalk.dim(`Connecting to ${WS_URL}...`));
@@ -3475,7 +3612,7 @@ var TaskRunner = class {
 			process.exit(1);
 		}
 		this.startHeartbeat();
-		this.startInterruptedTaskPolling();
+		this.startPendingTaskPolling();
 		this.send({
 			type: "runner_connected",
 			payload: {
@@ -3518,7 +3655,20 @@ var TaskRunner = class {
 					});
 					break;
 				case "task_message":
-					this.sendToTask(message.payload.ctx, message.payload.message);
+					const { taskId, message: taskMsg } = message.payload;
+					const messageId = message.payload.messageId;
+					const activeCount = Object.values(this.taskProcesses).filter((p$1) => p$1 !== null).length;
+					const accepted = activeCount < this.maxConcurrentTasks;
+					if (messageId) this.send({
+						type: "task_ack",
+						payload: {
+							messageId,
+							accepted,
+							reason: accepted ? void 0 : "capacity_full"
+						}
+					});
+					if (accepted) this.sendToTask(taskId, taskMsg);
+					else console.warn(chalk.yellow(`Rejected task ${taskId} - at capacity (${activeCount}/${this.maxConcurrentTasks})`));
 					break;
 				default: console.warn(chalk.yellow(`Unable to handle message:\n\n${JSON.stringify(message, null, 2)}`));
 			}
@@ -3532,7 +3682,7 @@ var TaskRunner = class {
 			clearInterval(this.heartbeatInterval);
 			this.heartbeatInterval = null;
 		}
-		this.stopInterruptedTaskPolling();
+		this.stopPendingTaskPolling();
 		if (this.isRunning) {
 			console.log(chalk.dim("Attempting to reconnect in 5 seconds..."));
 			this.reconnectTimeout = setTimeout(() => {
@@ -3549,59 +3699,131 @@ var TaskRunner = class {
 				type: "heartbeat",
 				payload: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }
 			});
-		}, 3e4);
+		}, 5e3);
 	}
-	startInterruptedTaskPolling() {
-		this.pollForInterruptedTasks();
-		this.interruptedTaskPollInterval = setInterval(() => {
-			this.pollForInterruptedTasks();
-		}, INTERRUPTED_TASK_POLL_INTERVAL);
+	startPendingTaskPolling() {
+		this.pollForPendingTasks();
+		this.pendingTaskPollInterval = setInterval(() => {
+			this.pollForPendingTasks();
+		}, PENDING_TASK_POLL_INTERVAL);
 	}
-	stopInterruptedTaskPolling() {
-		if (this.interruptedTaskPollInterval) {
-			clearInterval(this.interruptedTaskPollInterval);
-			this.interruptedTaskPollInterval = null;
+	stopPendingTaskPolling() {
+		if (this.pendingTaskPollInterval) {
+			clearInterval(this.pendingTaskPollInterval);
+			this.pendingTaskPollInterval = null;
 		}
 	}
-	async pollForInterruptedTasks() {
-		console.log("TODO: pollForInterruptedTasks graphql migration");
+	async pollForPendingTasks() {
+		const activeCount = Object.values(this.taskProcesses).filter((p$1) => p$1 !== null).length;
+		if (activeCount >= this.maxConcurrentTasks) {
+			console.log(chalk.dim(`At capacity (${activeCount}/${this.maxConcurrentTasks}), skipping poll`));
+			return;
+		}
+		const availableSlots = this.maxConcurrentTasks - activeCount;
+		console.log(`Finding pending tasks, ${availableSlots} / ${this.maxConcurrentTasks} task slots available`);
+		try {
+			const client = await createGraphQLClient();
+			const query$1 = graphql(`
+        query PendingTasks($limit: Int!) {
+          tasks(
+            status: [PENDING]
+            first: $limit
+          ) {
+            edges {
+              node {
+                id
+                title
+                project { id team { id } }
+              }
+            }
+          }
+        }
+      `);
+			const pendingTasks = (await client.request(query$1, { limit: availableSlots })).tasks.edges.map((e$3) => e$3.node);
+			if (pendingTasks.length > 0) console.log(chalk.yellow(`Found ${pendingTasks.length} pending task(s) to pick up`));
+			for (const task of pendingTasks) await this.pickupPendingTask(parseInt(task.id));
+		} catch (error$1) {
+			if (!error$1.message?.includes("Unable to connect")) console.error(chalk.red(`Failed to poll for pending tasks: ${error$1.message}`));
+		}
 	}
-	async resumeTask(ctx, sessionId) {
-		console.log(chalk.yellow(`Resuming interrupted task ${ctx.taskId}...`));
+	async pickupPendingTask(taskId) {
+		console.log(chalk.yellow(`Picking up pending task ${taskId}...`));
 		try {
-			const taskProcess = await this.fetchTaskProcess(ctx);
-			const resumeMessage = {
-				type: "user_message",
-				payload: {
-					content: "Your task was interrupted and some of your progress may have been lost. Assess what has been lost, attempt to restore, then resume your original task.",
-					sessionId: sessionId.toString()
-				}
-			};
-			taskProcess.stdin?.write(JSON.stringify(resumeMessage) + "\n");
-			console.log(chalk.green(`Task ${ctx.taskId} resume message sent`));
+			const client = await createGraphQLClient();
+			const mutation = graphql(`
+        mutation PickupPendingTask($taskId: ID!, $runnerId: ID!) {
+          pickupPendingTask(taskId: $taskId, runnerId: $runnerId) {
+            success
+            task { id status }
+            errors { message code }
+          }
+        }
+      `);
+			const result = await client.request(mutation, {
+				taskId: taskId.toString(),
+				runnerId: this.config.id.toString()
+			});
+			if (result.pickupPendingTask.success) {
+				console.log(chalk.green(`Successfully picked up task ${taskId}`));
+				await this.fetchTaskProcess(taskId);
+			} else {
+				const error$1 = result.pickupPendingTask.errors?.[0];
+				console.warn(chalk.yellow(`Failed to pickup task ${taskId}: ${error$1?.message || "unknown error"}`));
+			}
 		} catch (error$1) {
-			console.error(chalk.red(`Failed to resume task ${ctx.taskId}: ${error$1.message}`));
+			console.error(chalk.red(`Failed to pickup task ${taskId}: ${error$1.message}`));
 		}
 	}
 };
 
+//#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) {
-	const { sessionId, abortController, permissionMode = "bypassPermissions", task } = opts;
+	const { sessionId, abortController, permissionMode = "BYPASS_PERMISSIONS", task } = opts;
 	const credentials = await getCredentials();
 	if (!credentials?.anthropicApiKey) throw new Error("Anthropic API key not found in credentials JSON");
 	process.env.ANTHROPIC_API_KEY = credentials.anthropicApiKey;
-	console.log(`Querying Claude with permission mode: ${permissionMode}`);
+	let teamSettings;
+	try {
+		const client = await getGraphQLClient();
+		const projectData = await client.request(cliQueries.Project, { id: task.projectId.toString() });
+		if (projectData.project?.team) {
+			const claude = (await client.request(cliQueries.Team, { id: projectData.project.team.id })).team?.settings?.claude;
+			if (claude) teamSettings = {
+				defaultModel: claude.defaultModel,
+				environmentVariables: claude.environmentVariables,
+				betaFlags: claude.betaFlags
+			};
+		}
+	} catch (error$1) {
+		console.error("Failed to fetch team settings, using defaults:", error$1);
+	}
+	const defaultModel = teamSettings?.defaultModel || "sonnet";
+	const environmentVariables = teamSettings?.environmentVariables || {};
+	const betaFlags = teamSettings?.betaFlags || [];
+	for (const [key, value$1] of Object.entries(environmentVariables)) process.env[key] = value$1;
+	debugLog(`[Task ${task.id}] Querying Claude with permission mode: ${permissionMode}`);
+	debugLog(`[Task ${task.id}] Using model: ${defaultModel}`);
+	if (betaFlags.length > 0) debugLog(`[Task ${task.id}] Beta flags: ${betaFlags.join(", ")}`);
 	return query({
 		prompt,
 		options: {
 			abortController,
 			resume: sessionId,
-			model: "claude-sonnet-4-5",
+			model: defaultModel,
 			includePartialMessages: false,
 			mcpServers: { "jive-tasks": mcpServer },
-			permissionMode,
+			permissionMode: mapPermissionMode(permissionMode),
+			...betaFlags.length > 0 && { betas: betaFlags },
 			canUseTool: async (toolName, input) => {
 				if (toolName === "AskUserQuestion") {
 					const result = await task.requestUserQuestions(input);
@@ -3629,6 +3851,15 @@ async function queryClaude(prompt, mcpServer, opts) {
 		}
 	});
 }
+function mapPermissionMode(permissionMode) {
+	switch (permissionMode) {
+		case "DEFAULT": return "default";
+		case "BYPASS_PERMISSIONS": return "bypassPermissions";
+		default:
+			console.error(`[Task] Invalid permission mode: ${permissionMode}`);
+			return;
+	}
+}
 
 //#endregion
 //#region src/runner/TasksMCPServer.ts
@@ -3866,6 +4097,7 @@ function createTasksSdkServer(task) {
 						type: "text",
 						text: `Failed to set up cloudflare tunnel, error: ${result.error}`
 					}] };
+					task.disableIdleTimeout();
 					await setTaskUrl(args.taskId, `https://${result.host}`);
 					return { content: [{
 						type: "text",
@@ -4013,6 +4245,11 @@ var Task = class {
 	tunnel = null;
 	fileWatcher = null;
 	lastFilePosition = 0;
+	currentPendingLineUuid = null;
+	idleTimeoutMs;
+	lastActivityTime = Date.now();
+	idleWatchdogInterval = null;
+	idleTimeoutDisabled = false;
 	get defaultBranch() {
 		const tasksConfig = getTasksConfigSync();
 		if (!tasksConfig) {
@@ -4021,16 +4258,19 @@ var Task = class {
 		}
 		return tasksConfig.git.default_branch;
 	}
+	get projectId() {
+		return this.ctx.projectId;
+	}
 	constructor(ctx) {
 		this.id = ctx.taskId;
 		this.ctx = ctx;
 		this.mcpServer = createTasksSdkServer(this);
+		const timeoutMinutes = parseInt(process.env.JIVE_TASK_IDLE_TIMEOUT ?? "5", 10);
+		this.idleTimeoutMs = isNaN(timeoutMinutes) ? 300 * 1e3 : timeoutMinutes * 60 * 1e3;
+		this.debugLog(`Idle timeout configured: ${this.idleTimeoutMs / 6e4} minutes`);
 	}
 	debugLog(message) {
-		console.log(JSON.stringify({
-			type: "debug_log",
-			message
-		}).replace(/\n/g, "\\n"));
+		debugLog(`[Task ${this.id}] ${message}`);
 	}
 	startHeartbeat() {
 		this.heartbeatInterval = setInterval(() => {
@@ -4043,6 +4283,59 @@ var Task = class {
 			this.heartbeatInterval = null;
 		}
 	}
+	updateLastActivity() {
+		this.lastActivityTime = Date.now();
+		this.debugLog(`Activity recorded at ${new Date(this.lastActivityTime).toISOString()}`);
+	}
+	startIdleWatchdog() {
+		this.idleWatchdogInterval = setInterval(() => {
+			this.checkIdleTimeout();
+		}, 3e4);
+		this.debugLog("Idle watchdog started");
+	}
+	stopIdleWatchdog() {
+		if (this.idleWatchdogInterval) {
+			clearInterval(this.idleWatchdogInterval);
+			this.idleWatchdogInterval = null;
+			this.debugLog("Idle watchdog stopped");
+		}
+	}
+	checkIdleTimeout() {
+		if (this.idleTimeoutDisabled) {
+			this.debugLog("Idle timeout is disabled, skipping check");
+			return;
+		}
+		const idleDuration = Date.now() - this.lastActivityTime;
+		const idleMinutes = Math.floor(idleDuration / 6e4);
+		const idleSeconds = Math.floor(idleDuration % 6e4 / 1e3);
+		this.debugLog(`Idle check: ${idleMinutes}m ${idleSeconds}s (threshold: ${this.idleTimeoutMs / 6e4}m)`);
+		if (idleDuration >= this.idleTimeoutMs) {
+			this.debugLog(`Idle timeout reached (${idleDuration}ms >= ${this.idleTimeoutMs}ms)`);
+			this.handleIdleTimeout();
+		}
+	}
+	async handleIdleTimeout() {
+		this.debugLog("Task idle timeout - initiating graceful shutdown");
+		this.stopIdleWatchdog();
+		this.sendToTaskRunner({
+			type: "process_status_changed",
+			payload: {
+				status: "exited",
+				reason: "idle_timeout",
+				idleDuration: Date.now() - this.lastActivityTime
+			}
+		});
+		if (this.claudeAbortController) {
+			this.debugLog("Aborting ongoing Claude query due to timeout");
+			this.claudeAbortController.abort();
+			this.claudeAbortController = null;
+		}
+		this.stopHeartbeat();
+		this.stopSessionFileWatcher();
+		this.cleanupCloudflareTunnel();
+		this.debugLog("Task process exiting due to idle timeout");
+		process.exit(0);
+	}
 	async start() {
 		this.listenForMessages();
 		this.sendStatusUpdate("starting");
@@ -4057,12 +4350,14 @@ var Task = class {
 		}
 		this.debugLog(`✓ Git repository and session file setup complete`);
 		this.startHeartbeat();
+		this.startIdleWatchdog();
 		this.sendStatusUpdate("idle");
 		this.listenForProcessExit();
 	}
 	listenForProcessExit() {
 		const cleanup = () => {
 			this.stopHeartbeat();
+			this.stopIdleWatchdog();
 			this.stopSessionFileWatcher();
 			this.cleanupCloudflareTunnel();
 			this.sendStatusUpdate("exited");
@@ -4199,6 +4494,7 @@ var Task = class {
 			this.debugLog(`Received permission response for unknown request: ${payload.requestId}`);
 			return;
 		}
+		this.updateLastActivity();
 		clearTimeout(pending.timeout);
 		pending.resolve(payload.approved);
 		this.pendingPermissions.delete(payload.requestId);
@@ -4212,11 +4508,13 @@ var Task = class {
 			this.debugLog(`Received question response for unknown request: ${payload.requestId}`);
 			return;
 		}
+		this.updateLastActivity();
 		clearTimeout(pending.timeout);
 		pending.resolve(payload.answers);
 		this.pendingQuestions.delete(payload.requestId);
 	}
 	processMessage(inputMessage) {
+		this.updateLastActivity();
 		switch (inputMessage.type) {
 			case "stop":
 				this.handleStop();
@@ -4264,6 +4562,14 @@ var Task = class {
 		});
 	}
 	/**
+	* Disable the idle timeout for this task.
+	* Useful when the task is serving an application and should not timeout while waiting for user testing.
+	*/
+	disableIdleTimeout() {
+		this.idleTimeoutDisabled = true;
+		this.debugLog("Idle timeout disabled");
+	}
+	/**
 	* Set up Cloudflare tunnel for exposing local services to the internet.
 	* Sets HOST and PORT environment variables for use by the task.
 	*/
@@ -4309,12 +4615,12 @@ var Task = class {
 	}
 	convertToHttpsUrl(repository, gitAuth) {
 		if (repository.startsWith("https://")) return repository;
-		if (gitAuth.provider === "github" && repository.includes("git@github.com:")) {
+		if (gitAuth.provider === "GITHUB" && repository.includes("git@github.com:")) {
 			const httpsUrl = `https://github.com/${repository.replace("git@github.com:", "")}`;
 			this.debugLog(`Converting SSH URL to HTTPS: ${repository} -> ${httpsUrl}`);
 			return httpsUrl;
 		}
-		if (gitAuth.provider === "gitlab" && repository.includes("git@gitlab.com:")) {
+		if (gitAuth.provider === "GITLAB" && repository.includes("git@gitlab.com:")) {
 			const httpsUrl = `https://gitlab.com/${repository.replace("git@gitlab.com:", "")}`;
 			this.debugLog(`Converting SSH URL to HTTPS: ${repository} -> ${httpsUrl}`);
 			return httpsUrl;
@@ -4361,9 +4667,6 @@ Host gitlab.com
 		this.debugLog("✓ SSH authentication configured with deploy key");
 	}
 	/**
-	* Clean up SSH key files and environment variables
-	*/
-	/**
 	* Stop the Cloudflare tunnel and clean up resources
 	*/
 	cleanupCloudflareTunnel() {
@@ -4382,8 +4685,8 @@ Host gitlab.com
 		const { gitAuth } = this.ctx;
 		await execAsync$1("git init");
 		await execAsync$1("git config user.name \"Claude Agent | Jive\"");
-		await execAsync$1("git config user.email \"claude@tryjive.app\"");
-		if (gitAuth) if (gitAuth.method === "ssh") {
+		await execAsync$1("git config user.email \"claude@getjive.app\"");
+		if (gitAuth) if (gitAuth.method === "SSH") {
 			await this.setupSshAuthentication(gitAuth);
 			if (gitAuth.repositoryUrl) {
 				repository = gitAuth.repositoryUrl;
@@ -4444,7 +4747,7 @@ Host gitlab.com
 	sentLineIds = /* @__PURE__ */ new Set();
 	async ensureSessionFile() {
 		if (!await exists(this.claudeSessionFilePath)) await mkdir(path$1.dirname(this.claudeSessionFilePath), { recursive: true });
-		const messages = await getApiClient().getSessionLines(this.ctx.taskId, this.ctx.sessionId);
+		const messages = await getApiClient().getSessionLines(this.ctx.taskId, this.ctx.sessionId, true);
 		const sessionLines = [...messages.length === 0 ? makeInitialLines(this.ctx.claudeSessionId) : [], ...messages.map((m) => m.payload)];
 		this.sentLineIds = new Set(sessionLines.map((l$1) => l$1.uuid ?? null));
 		const jsonlContent = sessionLines.map((m) => JSON.stringify(m)).join("\n");
@@ -4486,18 +4789,22 @@ Host gitlab.com
 			}
 		});
 		this.fileWatcher.on("change", async () => {
+			this.updateLastActivity();
 			const newLines = await this.readNewSessionLines();
 			for (const line of newLines) try {
 				const parsed = JSON.parse(line);
 				const uuid = parsed.uuid ?? null;
 				if (this.sentLineIds.has(uuid)) continue;
 				this.sentLineIds.add(uuid);
+				const pendingLineUuid = parsed.type === "user" && this.currentPendingLineUuid ? this.currentPendingLineUuid : void 0;
+				if (pendingLineUuid) this.currentPendingLineUuid = null;
 				this.sendToTaskRunner({
 					type: "session_changed",
 					payload: {
 						sessionId: this.ctx.sessionId,
 						line: parsed,
-						timestamp: (/* @__PURE__ */ new Date()).toISOString()
+						timestamp: parsed.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+						pendingLineUuid
 					}
 				});
 			} catch (parseError) {
@@ -4517,6 +4824,7 @@ Host gitlab.com
 		this.lastFilePosition = 0;
 	}
 	async handleUserMessage(payload) {
+		if (payload.pendingLineUuid) this.currentPendingLineUuid = payload.pendingLineUuid;
 		await this.queryClaude(payload.content, this.ctx.permissionMode);
 	}
 	claudeAbortController = null;
@@ -4525,11 +4833,12 @@ Host gitlab.com
 		this.claudeAbortController = null;
 		this.sendStatusUpdate("idle");
 	}
-	async queryClaude(prompt, mode = "bypassPermissions") {
+	async queryClaude(prompt, mode = "BYPASS_PERMISSIONS") {
 		if (this.status !== "idle") {
 			this.debugLog(`WARNING: queryClaude called while status is '${this.status}'`);
 			return;
 		}
+		this.updateLastActivity();
 		this.sendStatusUpdate("working");
 		this.claudeAbortController = new AbortController();
 		await this.startSessionFileWatcher();
@@ -4702,18 +5011,43 @@ async function setupRunnerCommand(options) {
 	}
 	await requireAuth();
 	try {
-		const answers = await prompts([{
-			type: options.name ? null : "text",
-			name: "name",
-			message: "Runner name:",
-			initial: `runner-${Date.now()}`,
-			validate: (value$1) => value$1.length > 0 || "Name is required"
-		}, {
-			type: "password",
-			name: "anthropicApiKey",
-			message: "Anthropic API key (https://console.anthropic.com/settings/keys):",
-			validate: (value$1) => value$1.startsWith("sk-ant-") || "Invalid API key format"
-		}]);
+		const answers = await prompts([
+			{
+				type: options.name ? null : "text",
+				name: "name",
+				message: "Runner name:",
+				initial: `runner-${Date.now()}`,
+				validate: (value$1) => value$1.length > 0 || "Name is required"
+			},
+			{
+				type: "password",
+				name: "anthropicApiKey",
+				message: "Anthropic API key (https://console.anthropic.com/settings/keys):",
+				validate: (value$1) => value$1.startsWith("sk-ant-") || "Invalid API key format"
+			},
+			{
+				type: "number",
+				name: "dockerCpus",
+				message: "Docker CPU cores:",
+				initial: 2,
+				min: 1
+			},
+			{
+				type: "text",
+				name: "dockerMemory",
+				message: "Docker memory limit (e.g., 2g, 4g, 512m):",
+				initial: "2g",
+				validate: (val) => /^\d+[kmg]$/i.test(val) || "Format: number + unit (k/m/g)"
+			},
+			{
+				type: "number",
+				name: "maxConcurrentTasks",
+				message: "Maximum concurrent tasks:",
+				initial: 5,
+				min: 1,
+				max: 50
+			}
+		]);
 		if (!answers.name && !options.name) {
 			console.log(chalk.yellow("Setup cancelled"));
 			return;
@@ -4736,7 +5070,14 @@ async function setupRunnerCommand(options) {
 			name: runnerName,
 			type: runnerType,
 			teamId: team$1.id.toString(),
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			resourceLimits: {
+				maxConcurrentTasks: answers.maxConcurrentTasks,
+				docker: {
+					cpus: answers.dockerCpus.toString(),
+					memory: answers.dockerMemory
+				}
+			}
 		});
 		await updateCredentials({ anthropicApiKey });
 		spinner.succeed(`Runner '${runnerName}' configured!`);
@@ -5106,7 +5447,7 @@ const taskCommands = { resume: resumeCommand };
 
 //#endregion
 //#region package.json
-var version = "0.0.30";
+var version = "0.0.32";
 
 //#endregion
 //#region src/index.ts
@@ -5131,4 +5472,4 @@ program.command("task").description("Manage tasks").command("resume").descriptio
 program.parse();
 
 //#endregion
-export {  };
+export { queries as a, mutations as i, cliMutations as n, cliQueries as r, getGraphQLClient as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@jive-ai/cli",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "main": "index.js",
   "files": [
     "dist",
@@ -15,8 +15,11 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "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 jive-task-runner:latest . && rm -f jive-ai-cli-*.tgz",
-    "docker:build:local": "bun run build && docker build --build-arg USE_LOCAL=true -t jive-task-runner:latest .",
+    "docker:build": "touch jive-ai-cli-0.0.0.tgz && docker build -t jive-ai/task:latest . && rm -f jive-ai-cli-*.tgz",
+    "docker:build:local": "bun run build && docker build --build-arg USE_LOCAL=true -t jive-ai/task:latest .",
+    "docker:build:public": "touch jive-ai-cli-0.0.0.tgz && docker buildx build --platform linux/amd64,linux/arm64 -t jive-ai/task:latest -t jive-ai/task:$npm_package_version . && rm -f jive-ai-cli-*.tgz",
+    "docker:push": "docker buildx build --platform linux/amd64,linux/arm64 --push -t jive-ai/task:latest -t jive-ai/task:$npm_package_version .",
+    "docker:publish": "touch jive-ai-cli-0.0.0.tgz && docker buildx build --platform linux/amd64,linux/arm64 --push -t jive-ai/task:latest -t jive-ai/task:$npm_package_version . && rm -f jive-ai-cli-*.tgz",
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "author": "",
@@ -31,7 +34,7 @@
     "tsx": "^4.20.6"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.46",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.7",
     "@modelcontextprotocol/sdk": "^1.22.0",
     "chalk": "^5.6.2",
     "change-case": "^5.4.4",
@@ -50,6 +53,6 @@
     "typescript": "^5.9.3",
     "uuid": "^13.0.0",
     "ws": "^8.18.0",
-    "zod": "^3.25.76"
+    "zod": "^4.3.5"
   }
 }