@jive-ai/cli 0.0.32 → 0.0.35

package/README.md

@@ -13,7 +13,7 @@ npm install -g @jive-ai/cli
 ### Docker
 
 ```bash
-docker pull jive-ai/task:latest
+docker pull jiveai/task:latest
 ```
 
 ## Configuration
@@ -44,7 +44,7 @@ as long as the same entrypoint script is provided. The task runner relies on it.
 You can extend the Jive task runner image to add custom tools or dependencies:
 
 ```dockerfile
-FROM jive-ai/task:latest
+FROM jiveai/task:latest
 
 # Add your custom dependencies
 RUN apk add --no-cache python3 py3-pip

package/dist/config-7rVDmj2u.mjs

@@ -0,0 +1,3 @@
+import { A as getProjectConfig, D as clearCredentials, F as saveCredentials, I as saveProjectConfig, L as updateCredentials, M as isProjectInitialized, N as requireAuth, O as getActiveTeamId, P as requireProjectConfig, R as updateProjectConfig, j as getTasksConfigSync, k as getCredentials } from "./index.mjs";
+
+export { getCredentials };

package/dist/graphql-client-DtN1tbTC.mjs

@@ -0,0 +1,3 @@
+import { C as queries, S as mutations, b as cliMutations, x as cliQueries, y as getGraphQLClient } from "./index.mjs";
+
+export { getGraphQLClient };

package/dist/index.mjs

@@ -185,9 +185,9 @@ async function openBrowser(url) {
 async function loginCommand() {
 	console.log(chalk.bold("\n👋 Login to Jive\n"));
 	console.log(chalk.white("Opening browser for authentication...\n"));
-	await openBrowser(`${API_URL}/cli-auth`);
+	await openBrowser(`${API_URL}/app/cli-auth`);
 	console.log(chalk.gray("If the browser did not open, visit:"));
-	console.log(chalk.cyan(`${API_URL}/cli-auth\n`));
+	console.log(chalk.cyan(`${API_URL}/app/cli-auth\n`));
 	const response = await prompts({
 		type: "password",
 		name: "apiKey",
@@ -2613,6 +2613,18 @@ const cliQueries = {
         gitDefaultBranch
         team {
           id
+          settings {
+            claude {
+              defaultModel
+              environmentVariables
+              betaFlags
+            }
+          }
+        }
+        settings {
+          defaultModel
+          environmentVariables
+          betaFlags
         }
         createdAt
         updatedAt
@@ -2951,16 +2963,24 @@ var ApiClient = class {
 		};
 	}
 	async getSessionLines(taskId, sessionId, excludePending = false) {
-		return (await (await getGraphQLClient()).request(queries.GetSessionLines, {
-			taskId: String(taskId),
-			sessionId: String(sessionId),
-			excludePending
-		})).sessionLines.edges.map((edge) => ({
-			uuid: edge.node.uuid,
-			schema: edge.node.schema,
-			payload: edge.node.payload,
-			createdAt: new Date(edge.node.createdAt)
-		}));
+		const client = await getGraphQLClient();
+		const allLines = [];
+		let hasNextPage = true;
+		let after = void 0;
+		while (hasNextPage) {
+			const response = await client.request(queries.GetSessionLines, {
+				taskId: String(taskId),
+				sessionId: String(sessionId),
+				excludePending,
+				first: 100,
+				after
+			});
+			const pageLines = response.sessionLines.edges.map((edge) => edge.node);
+			allLines.push(...pageLines);
+			hasNextPage = response.sessionLines.pageInfo.hasNextPage;
+			after = response.sessionLines.pageInfo.endCursor ?? void 0;
+		}
+		return allLines;
 	}
 	async getTaskSessions(taskId) {
 		return (await (await getGraphQLClient()).request(queries.GetSessions, { taskId: String(taskId) })).sessions.map((s) => ({
@@ -3337,7 +3357,10 @@ async function spawnTaskDocker(ctx, config$2, opts) {
 		console.log(chalk.yellow("Warning: Using Docker socket mount (no isolation). Set JIVE_USE_SYSBOX=true on Linux for secure mode."));
 	}
 	dockerArgs.push("--network", "bridge");
-	if (isDevMode) dockerArgs.push("--add-host", "host.docker.internal:host-gateway");
+	if (isDevMode) {
+		dockerArgs.push("--add-host", "host.docker.internal:host-gateway");
+		dockerArgs.push("--pull", "never");
+	}
 	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 });
@@ -3396,6 +3419,10 @@ async function createGraphQLClient() {
 	};
 }
 
+//#endregion
+//#region package.json
+var version = "0.0.35";
+
 //#endregion
 //#region src/runner/index.ts
 const execAsync$3 = promisify(exec);
@@ -3407,7 +3434,7 @@ function getEffectiveResourceLimits(config$2, projectLimits) {
 		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"
+			image: projectLimits?.dockerImage || process.env.JIVE_DOCKER_IMAGE || config$2.resourceLimits?.docker?.image || `jiveai/task:${version}`
 		}
 	};
 }
@@ -3484,7 +3511,7 @@ var TaskRunner = class {
 	}
 	async fetchTaskContext(taskId) {
 		try {
-			const { getGraphQLClient: getGraphQLClient$1 } = await import("./graphql-client-DtLFKd4m.mjs");
+			const { getGraphQLClient: getGraphQLClient$1 } = await import("./graphql-client-DtN1tbTC.mjs");
 			const client = await getGraphQLClient$1();
 			const query$1 = graphql(`
         query TaskContext($taskId: ID!) {
@@ -3496,6 +3523,7 @@ var TaskRunner = class {
             directory
             repository
             branch
+            defaultBranch
             gitAuth {
               privateKey
               repositoryUrl
@@ -3528,6 +3556,7 @@ var TaskRunner = class {
 				directory: data.taskContext.directory,
 				repository: data.taskContext.repository,
 				branch: data.taskContext.branch,
+				defaultBranch: data.taskContext.defaultBranch,
 				gitAuth: auth || void 0,
 				permissionMode: data.taskContext.permissionMode
 			};
@@ -3792,27 +3821,11 @@ async function queryClaude(prompt, mcpServer, 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;
-	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 || [];
+	const { defaultModel, environmentVariables, betaFlags } = await getTaskClaudeSettings({ projectId: task.projectId.toString() });
 	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 (Object.keys(environmentVariables).length > 0) debugLog(`[Task ${task.id}] Environment variables: ${Object.keys(environmentVariables).join(", ")}`);
 	if (betaFlags.length > 0) debugLog(`[Task ${task.id}] Beta flags: ${betaFlags.join(", ")}`);
 	return query({
 		prompt,
@@ -3851,6 +3864,49 @@ async function queryClaude(prompt, mcpServer, opts) {
 		}
 	});
 }
+async function getTaskClaudeSettings(opts) {
+	const { projectId } = opts;
+	let teamSettings;
+	let projectSettings;
+	try {
+		const client = await getGraphQLClient();
+		const projectData = await client.request(cliQueries.Project, { id: projectId });
+		if (projectData.project) {
+			const projectSettingsData = projectData.project?.settings;
+			if (projectSettingsData) projectSettings = {
+				defaultModel: projectSettingsData.defaultModel,
+				environmentVariables: projectSettingsData.environmentVariables,
+				betaFlags: projectSettingsData.betaFlags
+			};
+			if (projectData.project.team) {
+				const teamClaude = (await client.request(cliQueries.Team, { id: projectData.project.team.id })).team?.settings?.claude;
+				if (teamClaude) teamSettings = {
+					defaultModel: teamClaude.defaultModel,
+					environmentVariables: teamClaude.environmentVariables,
+					betaFlags: teamClaude.betaFlags
+				};
+			}
+		}
+	} catch (error$1) {
+		debugLog(`[Task] Failed to fetch settings, using defaults: ${error$1}`);
+	}
+	const defaultModel = projectSettings?.defaultModel || teamSettings?.defaultModel || "sonnet";
+	const teamEnvVars = teamSettings?.environmentVariables || {};
+	const projectEnvVars = projectSettings?.environmentVariables || {};
+	const environmentVariables = {
+		...teamEnvVars,
+		...projectEnvVars
+	};
+	const betaFlags = [...teamSettings?.betaFlags || [], ...projectSettings?.betaFlags || []];
+	debugLog(`[Task] Default model: ${defaultModel}`);
+	debugLog(`[Task] Environment variables: ${Object.keys(environmentVariables).join(", ")}`);
+	debugLog(`[Task] Beta flags: ${betaFlags.join(", ")}`);
+	return {
+		defaultModel,
+		environmentVariables,
+		betaFlags
+	};
+}
 function mapPermissionMode(permissionMode) {
 	switch (permissionMode) {
 		case "DEFAULT": return "default";
@@ -4731,8 +4787,8 @@ Host gitlab.com
 			this.debugLog("Branch does not exist, creating...");
 			await execAsync$1(`git checkout -b ${this.ctx.branch}`);
 		}
-		this.debugLog("Pulling from default branch (main)...");
-		await execAsync$1(`git pull origin main`);
+		this.debugLog(`Pulling from default branch (${this.ctx.defaultBranch})...`);
+		await execAsync$1(`git pull origin ${this.ctx.defaultBranch}`);
 		this.debugLog("Pulling from task branch...");
 		try {
 			await execAsync$1(`git pull origin ${this.ctx.branch}`);
@@ -4753,7 +4809,7 @@ Host gitlab.com
 		const jsonlContent = sessionLines.map((m) => JSON.stringify(m)).join("\n");
 		await writeFile(this.claudeSessionFilePath, jsonlContent + "\n");
 		this.debugLog(`✓ Saved session file to ${this.claudeSessionFilePath}`);
-		this.debugLog(`Contents: ${jsonlContent}`);
+		this.debugLog(`Contains ${messages.length.toLocaleString()} session lines`);
 	}
 	async readNewSessionLines() {
 		try {
@@ -4879,7 +4935,7 @@ Host gitlab.com
 				}
 			});
 		} finally {
-			this.claudeAbortController.signal.removeEventListener("abort", abortHandler);
+			this.claudeAbortController?.signal.removeEventListener("abort", abortHandler);
 			this.stopSessionFileWatcher();
 			this.claudeAbortController = null;
 			this.sendStatusUpdate("idle");
@@ -5219,6 +5275,207 @@ async function logsCommand() {
 async function startTaskCommand(taskCtx) {
 	new Task(JSON.parse(decode(taskCtx))).start();
 }
+/**
+* Install the task runner as a system service
+*/
+async function installServiceCommand() {
+	console.log(chalk.bold("\nJive Task Runner Service Installation"));
+	console.log(chalk.dim("=========================================\n"));
+	try {
+		const { getServiceManager, validateServiceInstallation, detectPlatform } = await import("./service-DTf-SkmQ.mjs");
+		if (detectPlatform() === "unsupported") {
+			console.error(chalk.red("Service installation is not supported on this platform."));
+			console.log(chalk.dim("\nCurrently supported platforms:"));
+			console.log(chalk.dim("  - Linux (systemd)"));
+			console.log(chalk.dim("\nMacOS and Windows support coming soon!"));
+			process.exit(1);
+		}
+		const spinner = ora("Validating service installation requirements...").start();
+		const validation = await validateServiceInstallation();
+		spinner.stop();
+		console.log(chalk.bold("\nValidation Results:\n"));
+		for (const check of validation.checks) {
+			let icon = "✓";
+			let color = chalk.green;
+			if (check.status === "warning") {
+				icon = "⚠";
+				color = chalk.yellow;
+			} else if (check.status === "error") {
+				icon = "✗";
+				color = chalk.red;
+			}
+			console.log(color(`${icon} ${check.name.padEnd(20)} ${check.message}`));
+			if (check.detail) console.log(chalk.dim(`  ${check.detail}`));
+		}
+		if (!validation.canInstall) {
+			console.log(chalk.red("\n✗ Cannot install service due to validation errors."));
+			console.log(chalk.dim("Please fix the errors above and try again."));
+			process.exit(1);
+		}
+		if (validation.hasWarnings) console.log(chalk.yellow("\n⚠ Installation can proceed, but there are warnings."));
+		console.log(chalk.dim(`\nPlatform: Linux (systemd)`));
+		console.log(chalk.dim(`Service file: ~/.config/systemd/user/jive-task-runner.service\n`));
+		const { confirm } = await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: "Continue with installation?",
+			initial: true
+		});
+		if (!confirm) {
+			console.log(chalk.yellow("Installation cancelled"));
+			return;
+		}
+		spinner.start("Creating service file...");
+		const manager = getServiceManager();
+		await manager.install();
+		spinner.succeed("Service installed successfully!");
+		const { startNow } = await prompts({
+			type: "confirm",
+			name: "startNow",
+			message: "Start service now?",
+			initial: true
+		});
+		if (startNow) {
+			spinner.start("Starting service...");
+			await manager.start();
+			spinner.succeed("Service started");
+			const status = await manager.status();
+			console.log(chalk.green(`\nService Status: ● Running`));
+			if (status.uptime) console.log(chalk.dim(`Uptime: ${status.uptime}`));
+		}
+		console.log(chalk.bold("\nNext steps:"));
+		console.log(chalk.dim("  • View logs:    ") + chalk.cyan("jive task-runner service-logs"));
+		console.log(chalk.dim("  • Check status: ") + chalk.cyan("jive task-runner service-status"));
+		console.log(chalk.dim("  • Restart:      ") + chalk.cyan("jive task-runner service-restart"));
+	} catch (error$1) {
+		console.error(chalk.red(`\n✗ Installation failed: ${error$1.message}`));
+		process.exit(1);
+	}
+}
+/**
+* Uninstall the task runner service
+*/
+async function uninstallServiceCommand() {
+	try {
+		const { getServiceManager } = await import("./service-DTf-SkmQ.mjs");
+		const manager = getServiceManager();
+		if (!await manager.isInstalled()) {
+			console.log(chalk.yellow("Service is not installed."));
+			return;
+		}
+		const { confirm } = await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: chalk.yellow("⚠  Remove the task runner service?"),
+			initial: false
+		});
+		if (!confirm) {
+			console.log(chalk.yellow("Cancelled"));
+			return;
+		}
+		const spinner = ora("Uninstalling service...").start();
+		await manager.uninstall();
+		spinner.succeed("Service uninstalled successfully");
+		console.log(chalk.dim("\nTo reinstall, run: ") + chalk.cyan("jive task-runner install-service"));
+	} catch (error$1) {
+		console.error(chalk.red(`\n✗ Uninstall failed: ${error$1.message}`));
+		process.exit(1);
+	}
+}
+/**
+* Show service status
+*/
+async function serviceStatusCommand() {
+	try {
+		const { getServiceManager } = await import("./service-DTf-SkmQ.mjs");
+		const manager = getServiceManager();
+		if (!await manager.isInstalled()) {
+			console.log(chalk.dim("Service is not installed."));
+			console.log(chalk.dim("\nTo install, run: ") + chalk.cyan("jive task-runner install-service"));
+			return;
+		}
+		const spinner = ora("Checking service status...").start();
+		const status = await manager.status();
+		spinner.stop();
+		console.log(chalk.bold("\nJive Task Runner Service"));
+		console.log(chalk.dim("═".repeat(60)));
+		const statusIcon = status.running ? "●" : "○";
+		const statusColor = status.running ? chalk.green : chalk.dim;
+		const statusText = status.running ? "Running" : "Stopped";
+		console.log(`\nStatus: ${statusColor(statusIcon)} ${statusColor(statusText)}`);
+		if (status.pid) console.log(chalk.dim(`PID: ${status.pid}`));
+		if (status.uptime) console.log(chalk.dim(`Uptime: ${status.uptime}`));
+		const autoStartIcon = status.enabled ? "✓" : "✗";
+		const autoStartColor = status.enabled ? chalk.green : chalk.dim;
+		console.log(`Auto-start: ${autoStartColor(autoStartIcon)} ${status.enabled ? "Enabled" : "Disabled"}`);
+		if (status.running) {
+			console.log(chalk.bold("\nRecent Logs:"));
+			console.log(chalk.dim("─".repeat(60)));
+			try {
+				await manager.logs({ lines: 20 });
+			} catch {
+				console.log(chalk.dim("No logs available"));
+			}
+		}
+		console.log(chalk.bold("\nCommands:"));
+		console.log(chalk.dim("─".repeat(60)));
+		console.log(chalk.dim("  Logs:      ") + chalk.cyan("jive task-runner service-logs [-f]"));
+		console.log(chalk.dim("  Restart:   ") + chalk.cyan("jive task-runner service-restart"));
+		if (status.running) console.log(chalk.dim("  Stop:      ") + chalk.cyan("systemctl --user stop jive-task-runner"));
+		else console.log(chalk.dim("  Start:     ") + chalk.cyan("systemctl --user start jive-task-runner"));
+		console.log(chalk.dim("  Uninstall: ") + chalk.cyan("jive task-runner uninstall-service"));
+		console.log();
+	} catch (error$1) {
+		console.error(chalk.red(`\n✗ Failed to get status: ${error$1.message}`));
+		process.exit(1);
+	}
+}
+/**
+* View service logs
+*/
+async function serviceLogsCommand(options) {
+	try {
+		const { getServiceManager } = await import("./service-DTf-SkmQ.mjs");
+		const manager = getServiceManager();
+		if (!await manager.isInstalled()) {
+			console.log(chalk.dim("Service is not installed."));
+			return;
+		}
+		const lines = options.lines ? parseInt(options.lines, 10) : 50;
+		await manager.logs({
+			follow: options.follow,
+			lines
+		});
+	} catch (error$1) {
+		if (error$1.message.includes("SIGTERM")) return;
+		console.error(chalk.red(`\n✗ Failed to view logs: ${error$1.message}`));
+		process.exit(1);
+	}
+}
+/**
+* Restart the service
+*/
+async function serviceRestartCommand() {
+	try {
+		const { getServiceManager } = await import("./service-DTf-SkmQ.mjs");
+		const manager = getServiceManager();
+		if (!await manager.isInstalled()) {
+			console.log(chalk.dim("Service is not installed."));
+			return;
+		}
+		const spinner = ora("Restarting service...").start();
+		await manager.restart();
+		spinner.succeed("Service restarted");
+		const status = await manager.status();
+		if (status.running) {
+			console.log(chalk.green(`\n● Service is running`));
+			if (status.uptime) console.log(chalk.dim(`Uptime: ${status.uptime}`));
+		}
+	} catch (error$1) {
+		console.error(chalk.red(`\n✗ Failed to restart: ${error$1.message}`));
+		process.exit(1);
+	}
+}
 const taskRunnerCommands = {
 	init: initCommand$1,
 	setup: setupRunnerCommand,
@@ -5227,7 +5484,12 @@ const taskRunnerCommands = {
 	stop: stopRunnerCommand,
 	remove: removeRunnerCommand,
 	logs: logsCommand,
-	startTask: startTaskCommand
+	startTask: startTaskCommand,
+	installService: installServiceCommand,
+	uninstallService: uninstallServiceCommand,
+	serviceStatus: serviceStatusCommand,
+	serviceLogs: serviceLogsCommand,
+	serviceRestart: serviceRestartCommand
 };
 
 //#endregion
@@ -5445,10 +5707,6 @@ async function resumeCommand(taskId) {
 }
 const taskCommands = { resume: resumeCommand };
 
-//#endregion
-//#region package.json
-var version = "0.0.32";
-
 //#endregion
 //#region src/index.ts
 const program = new Command();
@@ -5468,8 +5726,13 @@ taskRunner.command("stop").description("Stop the task runner").action(taskRunner
 taskRunner.command("remove").description("Remove the task runner configuration").action(taskRunnerCommands.remove);
 taskRunner.command("logs").description("View logs from the task runner").action(taskRunnerCommands.logs);
 taskRunner.command("start-task").description("Start a task").argument("<task-ctx>", "JSON Context of the task to start").action(taskRunnerCommands.startTask);
+taskRunner.command("install-service").description("Install task runner as a system service").action(taskRunnerCommands.installService);
+taskRunner.command("uninstall-service").description("Uninstall task runner service").action(taskRunnerCommands.uninstallService);
+taskRunner.command("service-status").description("Show service status").action(taskRunnerCommands.serviceStatus);
+taskRunner.command("service-logs").description("View service logs").option("-f, --follow", "Follow log output").option("-n, --lines <number>", "Number of lines to show", "50").action(taskRunnerCommands.serviceLogs);
+taskRunner.command("service-restart").description("Restart the service").action(taskRunnerCommands.serviceRestart);
 program.command("task").description("Manage tasks").command("resume").description("Resume a remote task session locally using Claude Code").argument("<taskId>", "ID of the task to resume").action(taskCommands.resume);
 program.parse();
 
 //#endregion
-export { queries as a, mutations as i, cliMutations as n, cliQueries as r, getGraphQLClient as t };
+export { getProjectConfig as A, queries as C, clearCredentials as D, WS_URL as E, saveCredentials as F, saveProjectConfig as I, updateCredentials as L, isProjectInitialized as M, requireAuth as N, getActiveTeamId as O, requireProjectConfig as P, updateProjectConfig as R, mutations as S, GRAPHQL_API_URL as T, taskRunnerCommands as _, installServiceCommand as a, cliMutations as b, runnerInfoCommand as c, serviceRestartCommand as d, serviceStatusCommand as f, stopRunnerCommand as g, startTaskCommand as h, initCommand$1 as i, getTasksConfigSync as j, getCredentials as k, saveRunnerConfig as l, startRunnerCommand as m, ensureTasksConfig as n, logsCommand as o, setupRunnerCommand as p, getRunnerConfig as r, removeRunnerCommand as s, createTasksConfig as t, serviceLogsCommand as u, uninstallServiceCommand as v, API_URL as w, cliQueries as x, getGraphQLClient as y };

package/dist/service-DTf-SkmQ.mjs

@@ -0,0 +1,347 @@
+import { E as WS_URL, T as GRAPHQL_API_URL, w as API_URL } from "./index.mjs";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+
+//#region src/lib/service/systemd.ts
+const execAsync$1 = promisify(exec);
+const SERVICE_TEMPLATE = `[Unit]
+Description=Jive Task Runner
+Documentation=https://getjive.app/docs
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart={{JIVE_BINARY_PATH}} task-runner start
+Restart=on-failure
+RestartSec=30
+TimeoutStartSec=90
+TimeoutStopSec=30
+StartLimitBurst=5
+StartLimitIntervalSec=10m
+KillMode=mixed
+Environment="PATH={{NODE_BIN_PATH}}:/usr/local/bin:/usr/bin:/bin"
+Environment="JIVE_API_KEY={{JIVE_API_KEY}}"
+Environment="ANTHROPIC_API_KEY={{ANTHROPIC_API_KEY}}"
+Environment="JIVE_TEAM_ID={{JIVE_TEAM_ID}}"
+Environment="JIVE_RUNNER_ID={{JIVE_RUNNER_ID}}"
+Environment="JIVE_API_URL={{JIVE_API_URL}}"
+Environment="JIVE_WS_URL={{JIVE_WS_URL}}"
+Environment="JIVE_GRAPHQL_API_URL={{JIVE_GRAPHQL_API_URL}}"
+
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=jive-task-runner
+
+# Security hardening (safe for Docker runners)
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectKernelTunables=true
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+
+[Install]
+WantedBy=default.target
+`;
+var SystemdServiceManager = class {
+	servicePath;
+	serviceName = "jive-task-runner";
+	constructor() {
+		const homeDir = os.homedir();
+		this.servicePath = path.join(homeDir, ".config", "systemd", "user", `${this.serviceName}.service`);
+	}
+	async install() {
+		const { getRunnerConfig } = await import("./tasks-Py86q1u7.mjs");
+		const { getCredentials } = await import("./config-7rVDmj2u.mjs");
+		const runnerConfig = await getRunnerConfig();
+		const credentials = await getCredentials();
+		if (!credentials?.token) throw new Error("No API key found. Run `jive login` first.");
+		const { stdout: binaryPath } = await execAsync$1("which jive", { timeout: 3e4 });
+		const resolvedPath = binaryPath.trim();
+		if (!resolvedPath) throw new Error("Cannot locate jive binary in PATH");
+		const { stdout: nodePath } = await execAsync$1("readlink -f $(which node)", { timeout: 3e4 });
+		const resolvedNodePath = nodePath.trim();
+		const variables = {
+			JIVE_BINARY_PATH: resolvedPath,
+			NODE_BIN_PATH: path.dirname(resolvedNodePath),
+			JIVE_API_KEY: credentials.token,
+			ANTHROPIC_API_KEY: credentials.anthropicApiKey || "",
+			JIVE_TEAM_ID: runnerConfig.teamId,
+			JIVE_RUNNER_ID: runnerConfig.id.toString(),
+			JIVE_API_URL: process.env.JIVE_API_URL || API_URL,
+			JIVE_WS_URL: process.env.JIVE_WS_URL || WS_URL,
+			JIVE_GRAPHQL_API_URL: process.env.JIVE_GRAPHQL_API_URL || GRAPHQL_API_URL
+		};
+		let serviceContent = SERVICE_TEMPLATE;
+		for (const [key, value] of Object.entries(variables)) serviceContent = serviceContent.replace(new RegExp(`{{${key}}}`, "g"), value);
+		const serviceDir = path.dirname(this.servicePath);
+		await fs.mkdir(serviceDir, {
+			recursive: true,
+			mode: 493
+		});
+		const dirMode = (await fs.stat(serviceDir)).mode & 511;
+		if (dirMode > 493) throw new Error(`Systemd user directory has overly permissive permissions: ${dirMode.toString(8)}\nExpected 0755 or stricter. Fix with: chmod 755 ${serviceDir}`);
+		await fs.writeFile(this.servicePath, serviceContent, { mode: 384 });
+		try {
+			await execAsync$1("systemctl --user daemon-reload", { timeout: 3e4 });
+			await execAsync$1(`systemctl --user enable ${this.serviceName}`, { timeout: 3e4 });
+		} catch (error) {
+			try {
+				await fs.unlink(this.servicePath);
+				await execAsync$1("systemctl --user daemon-reload", { timeout: 3e4 });
+			} catch (cleanupError) {
+				console.error("Failed to clean up after installation failure:", cleanupError);
+			}
+			throw new Error(`Service installation failed: ${error.message}\nPartial installation has been rolled back.`);
+		}
+	}
+	async uninstall() {
+		try {
+			await this.stop();
+		} catch (error) {
+			if (error.message?.includes("inactive") || error.message?.includes("not be found")) {} else if (error.code === "EACCES") console.warn("Warning: Permission denied when stopping service");
+			else console.warn(`Warning: Failed to stop service: ${error.message}`);
+		}
+		try {
+			await execAsync$1(`systemctl --user disable ${this.serviceName}`, { timeout: 3e4 });
+		} catch (error) {
+			if (error.stderr?.includes("No such file") || error.message?.includes("not be found")) {} else if (error.code === "EACCES") console.warn("Warning: Permission denied when disabling service");
+			else console.warn(`Warning: Failed to disable service: ${error.message}`);
+		}
+		try {
+			await fs.unlink(this.servicePath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw new Error(`Failed to remove service file: ${error.message}`);
+		}
+		await execAsync$1("systemctl --user daemon-reload", { timeout: 3e4 });
+	}
+	async start() {
+		await execAsync$1(`systemctl --user start ${this.serviceName}`, { timeout: 3e4 });
+	}
+	async stop() {
+		await execAsync$1(`systemctl --user stop ${this.serviceName}`, { timeout: 3e4 });
+	}
+	async restart() {
+		await execAsync$1(`systemctl --user restart ${this.serviceName}`, { timeout: 3e4 });
+	}
+	async status() {
+		if (!await this.isInstalled()) return {
+			installed: false,
+			running: false,
+			enabled: false
+		};
+		try {
+			const { stdout } = await execAsync$1(`systemctl --user status ${this.serviceName} --no-pager`, { timeout: 3e4 });
+			const running = stdout.includes("Active: active (running)");
+			const pid = this.extractPid(stdout);
+			const uptime = this.extractUptime(stdout);
+			const { stdout: isEnabledOutput } = await execAsync$1(`systemctl --user is-enabled ${this.serviceName}`, { timeout: 3e4 });
+			return {
+				installed: true,
+				running,
+				enabled: isEnabledOutput.trim() === "enabled",
+				uptime,
+				pid
+			};
+		} catch (error) {
+			const { stdout: isEnabledOutput } = await execAsync$1(`systemctl --user is-enabled ${this.serviceName}`, { timeout: 3e4 }).catch(() => ({ stdout: "disabled" }));
+			return {
+				installed: true,
+				running: false,
+				enabled: isEnabledOutput.trim() === "enabled"
+			};
+		}
+	}
+	async logs(options) {
+		const args = [
+			"--user",
+			"-u",
+			this.serviceName
+		];
+		if (options?.follow) args.push("-f");
+		if (options?.lines) args.push("-n", options.lines.toString());
+		const logsProcess = spawn("journalctl", args, { stdio: "inherit" });
+		return new Promise((resolve, reject) => {
+			logsProcess.on("exit", (code) => {
+				if (code === 0) resolve();
+				else reject(/* @__PURE__ */ new Error(`journalctl exited with code ${code}`));
+			});
+			logsProcess.on("error", (error) => {
+				reject(error);
+			});
+			if (options?.follow) process.on("SIGINT", () => {
+				logsProcess.kill("SIGTERM");
+				resolve();
+			});
+		});
+	}
+	async isInstalled() {
+		try {
+			await fs.access(this.servicePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	extractPid(statusOutput) {
+		const pidMatch = statusOutput.match(/Main PID: (\d+)/);
+		return pidMatch ? parseInt(pidMatch[1], 10) : void 0;
+	}
+	extractUptime(statusOutput) {
+		const uptimeMatch = statusOutput.match(/Active: active \(running\) since (.+?);/);
+		if (!uptimeMatch) return void 0;
+		const sinceStr = uptimeMatch[1];
+		const sinceDate = new Date(sinceStr);
+		const diffMs = (/* @__PURE__ */ new Date()).getTime() - sinceDate.getTime();
+		const seconds = Math.floor(diffMs / 1e3);
+		const minutes = Math.floor(seconds / 60);
+		const hours = Math.floor(minutes / 60);
+		const days = Math.floor(hours / 24);
+		if (days > 0) return `${days}d ${hours % 24}h`;
+		if (hours > 0) return `${hours}h ${minutes % 60}m`;
+		if (minutes > 0) return `${minutes}m`;
+		return "Just now";
+	}
+};
+
+//#endregion
+//#region src/lib/service/index.ts
+const execAsync = promisify(exec);
+/**
+* Detect the current platform and service management system
+*/
+function detectPlatform() {
+	if (os.platform() === "linux") return "linux-systemd";
+	return "unsupported";
+}
+/**
+* Get a service manager instance for the current platform
+*/
+function getServiceManager() {
+	if (detectPlatform() === "unsupported") throw new Error(`Service installation is not supported on ${os.platform()}.\nCurrently supported platforms:
+  - Linux (systemd)`);
+	return new SystemdServiceManager();
+}
+/**
+* Validate that the system is ready for service installation
+*/
+async function validateServiceInstallation() {
+	const checks = [];
+	let canInstall = true;
+	let hasWarnings = false;
+	try {
+		const { getRunnerConfig } = await import("./tasks-Py86q1u7.mjs");
+		const runnerConfig = await getRunnerConfig();
+		checks.push({
+			name: "Runner config",
+			status: "success",
+			message: `${runnerConfig.name} (${runnerConfig.type})`
+		});
+	} catch (error) {
+		checks.push({
+			name: "Runner config",
+			status: "error",
+			message: "Not configured",
+			detail: "Run `jive task-runner setup` first"
+		});
+		canInstall = false;
+	}
+	try {
+		const { getCredentials } = await import("./config-7rVDmj2u.mjs");
+		const credentials = await getCredentials();
+		if (!credentials?.token) throw new Error("No API key found");
+		if (!credentials?.anthropicApiKey) {
+			checks.push({
+				name: "Credentials",
+				status: "warning",
+				message: "Anthropic API key not found",
+				detail: "Runner may fail to start without it"
+			});
+			hasWarnings = true;
+		} else checks.push({
+			name: "Credentials",
+			status: "success",
+			message: "API keys configured"
+		});
+	} catch (error) {
+		checks.push({
+			name: "Credentials",
+			status: "error",
+			message: "Not configured",
+			detail: "Run `jive login` first"
+		});
+		canInstall = false;
+	}
+	try {
+		const { getRunnerConfig } = await import("./tasks-Py86q1u7.mjs");
+		if ((await getRunnerConfig()).type === "docker") try {
+			await execAsync("docker ps", { timeout: 1e4 });
+			checks.push({
+				name: "Docker",
+				status: "success",
+				message: "Docker daemon running"
+			});
+		} catch {
+			checks.push({
+				name: "Docker",
+				status: "error",
+				message: "Docker daemon not running",
+				detail: "Start Docker daemon or install from https://docs.docker.com/get-docker/"
+			});
+			canInstall = false;
+		}
+	} catch {}
+	try {
+		if (await getServiceManager().isInstalled()) {
+			checks.push({
+				name: "Service status",
+				status: "error",
+				message: "Service already installed",
+				detail: "Run `jive task-runner uninstall-service` first"
+			});
+			canInstall = false;
+		} else checks.push({
+			name: "Service status",
+			status: "success",
+			message: "Not installed"
+		});
+	} catch (error) {
+		if (error.message.includes("not supported")) {
+			checks.push({
+				name: "Service status",
+				status: "error",
+				message: "Platform not supported",
+				detail: error.message
+			});
+			canInstall = false;
+		}
+	}
+	try {
+		const { stdout } = await execAsync("which jive", { timeout: 3e4 });
+		const binaryPath = stdout.trim();
+		if (!binaryPath) throw new Error("Binary not in PATH");
+		checks.push({
+			name: "Binary path",
+			status: "success",
+			message: binaryPath
+		});
+	} catch (error) {
+		checks.push({
+			name: "Binary path",
+			status: "error",
+			message: "Cannot locate jive binary",
+			detail: "Ensure jive is installed and in PATH"
+		});
+		canInstall = false;
+	}
+	return {
+		checks,
+		canInstall,
+		hasWarnings
+	};
+}
+
+//#endregion
+export { detectPlatform, getServiceManager, validateServiceInstallation };

package/dist/tasks-Py86q1u7.mjs

@@ -0,0 +1,3 @@
+import { _ as taskRunnerCommands, a as installServiceCommand, c as runnerInfoCommand, d as serviceRestartCommand, f as serviceStatusCommand, g as stopRunnerCommand, h as startTaskCommand, i as initCommand, l as saveRunnerConfig, m as startRunnerCommand, n as ensureTasksConfig, o as logsCommand, p as setupRunnerCommand, r as getRunnerConfig, s as removeRunnerCommand, t as createTasksConfig, u as serviceLogsCommand, v as uninstallServiceCommand } from "./index.mjs";
+
+export { getRunnerConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@jive-ai/cli",
-  "version": "0.0.32",
+  "version": "0.0.35",
   "main": "index.js",
   "files": [
     "dist",
@@ -15,11 +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-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",
+    "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: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",
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "author": "",

package/dist/graphql-client-DtLFKd4m.mjs

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