@jive-ai/cli 0.0.31 → 0.0.33

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.31",
+  "version": "0.0.33",
   "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 jiveai/task:latest . && rm -f jive-ai-cli-*.tgz",
+    "docker:build:local": "bun run build && docker build --build-arg USE_LOCAL=true -t jiveai/task:latest .",
+    "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": "",
@@ -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"
   }
 }