onedeploy-cli 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Relyon AG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# OneDeploy CLI
+
+This CLI allows you to connect to a OneDeploy cluster via [Nebula](https://github.com/slackhq/nebula). First, you need to create an API key on your dashboard. Then, you can `Setup new connection` with your dashboard URL and API key. Afterwards, you can `Connect` to the cluster you added. Please note that Nebula requires administrator permissions to run, so you'll need to enter your password.
+
+## License
+
+The OneDeploy CLI licensed under MIT, see [here](./LICENSE). It uses the Nebula overlay network, which is also MIT licensed.

package/dist/config.js

@@ -0,0 +1,27 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { y } from "yedra";
+const configDir = `${homedir()}/.config/onedeploy`;
+await mkdir(configDir, { recursive: true });
+const Instance = y.object({
+    url: y.string(),
+    apiKey: y.string(),
+});
+const Config = y.object({
+    instances: Instance.array(),
+});
+export const loadConfig = async () => {
+    try {
+        const result = await readFile(`${configDir}/config.json`, "utf-8");
+        const config = JSON.parse(result);
+        return Config.parse(config);
+    }
+    catch (_error) {
+        // no config yet
+        return { instances: [] };
+    }
+};
+export const saveConfig = async (config) => {
+    await writeFile(`${configDir}/config.json`, JSON.stringify(config, null, 2));
+    await chmod(`${configDir}/config.json`, 0o600);
+};

package/dist/index.js

@@ -1,79 +1,8 @@
-import { execFile, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { Readable } from "node:stream";
-import { promisify } from "node:util";
+#!/usr/bin/env node
 import prompts from "prompts";
-import { y } from "yedra";
-const nebulaUrl = `https://github.com/slackhq/nebula/releases/download/v1.9.6/nebula-linux-amd64.tar.gz`;
-const configDir = `${homedir()}/.config/onedeploy`;
-const tmpDir = `/tmp/onedeploy-${randomUUID()}`;
-await mkdir(configDir, { recursive: true });
-await mkdir(tmpDir, { recursive: true });
-const Instance = y.object({
-    url: y.string(),
-    apiKey: y.string(),
-});
-const Config = y.object({
-    instances: Instance.array(),
-});
-const installNebula = async () => {
-    console.log("Downloading Nebula...");
-    const file = await fetch(nebulaUrl);
-    if (file.body === null) {
-        throw new Error("Could not download Nebula executable.");
-    }
-    await writeFile(`${tmpDir}/nebula.tar.gz`, Readable.from(file.body));
-    console.log("Extracting Nebula...");
-    await promisify(execFile)("tar", [
-        "-xf",
-        `${tmpDir}/nebula.tar.gz`,
-        "-C",
-        tmpDir,
-    ]);
-};
-const loadConfig = async () => {
-    try {
-        const result = await readFile(`${configDir}/config.json`, "utf-8");
-        const config = JSON.parse(result);
-        return Config.parse(config);
-    }
-    catch (_error) {
-        // no config yet
-        return { instances: [] };
-    }
-};
-const saveConfig = async () => {
-    await writeFile(`${configDir}/config.json`, JSON.stringify(config, null, 2));
-    await chmod(`${configDir}/config.json`, 0o600);
-};
-const getNebulaCert = async (instance) => {
-    const response = await fetch(`${instance.url}/api/nebula/cert`, {
-        headers: {
-            authorization: `Bearer ${instance.apiKey}`,
-        },
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch Nebula certificate: ${response.status}`);
-    }
-    const { nebulaConfig } = await response.json();
-    await writeFile(`${tmpDir}/nebula.yml`, nebulaConfig);
-    await chmod(`${tmpDir}/nebula.yml`, 0o600);
-};
-const connectNebula = async (instance) => {
-    await getNebulaCert(instance);
-    const nebula = spawn("sudo", [`${tmpDir}/nebula`, "-config", `${tmpDir}/nebula.yml`], {
-        stdio: "inherit",
-    });
-    const interval = setInterval(async () => {
-        // refresh Nebula cert every 10 minutes (lifetime is 15 minutes)
-        await getNebulaCert(instance);
-        nebula.kill("SIGHUP");
-    }, 10 * 60 * 1000);
-    await new Promise((resolve) => nebula.on("exit", resolve));
-    clearInterval(interval);
-};
+import { loadConfig, saveConfig } from "./config.js";
+import { cleanupNebula, connectNebula, installNebula } from "./nebula.js";
+const config = await loadConfig();
 const setupConnection = async () => {
     const result = await prompts([
         {
@@ -91,7 +20,7 @@ const setupConnection = async () => {
         return;
     }
     config.instances.push({ url: result.url, apiKey: result.apiKey });
-    await saveConfig();
+    await saveConfig(config);
 };
 const removeConnection = async () => {
     const { connection } = await prompts([
@@ -118,12 +47,10 @@ const removeConnection = async () => {
     ]);
     if (confirm === true) {
         config.instances.splice(connection, 1);
-        await saveConfig();
+        await saveConfig(config);
     }
 };
-await installNebula();
-const config = await loadConfig();
-while (true) {
+const mainMenu = async () => {
     const { action } = await prompts([
         {
             type: "select",
@@ -169,7 +96,19 @@ while (true) {
         await removeConnection();
     }
     else {
-        break;
+        return false;
     }
+    return true;
+};
+await installNebula();
+try {
+    while (true) {
+        const shouldContinue = await mainMenu();
+        if (!shouldContinue) {
+            break;
+        }
+    }
+}
+finally {
+    await cleanupNebula();
 }
-await rm(tmpDir, { recursive: true, force: true });

package/dist/nebula.js

@@ -0,0 +1,83 @@
+import { execFile, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { promisify } from "node:util";
+const getNebulaPackageName = () => {
+    switch (process.platform) {
+        case "linux":
+            if (process.arch !== "x64") {
+                throw new Error(`Unsupported architecture: ${process.arch}`);
+            }
+            return `nebula-linux-amd64.tar.gz`;
+        case "darwin":
+            return `nebula-darwin.zip`;
+        case "win32":
+            if (process.arch !== "x64") {
+                throw new Error(`Unsupported architecture: ${process.arch}`);
+            }
+            return `nebula-windows-amd64.zip`;
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+};
+const nebulaVersion = "v1.9.6";
+const packageName = getNebulaPackageName();
+const nebulaUrl = `https://github.com/slackhq/nebula/releases/download/${nebulaVersion}/${packageName}`;
+const tmpDir = path.join(tmpdir(), `onedeploy-${randomUUID()}`);
+await mkdir(tmpDir, { recursive: true });
+export const installNebula = async () => {
+    console.log("Downloading Nebula...");
+    const file = await fetch(nebulaUrl);
+    if (file.body === null) {
+        throw new Error("Could not download Nebula executable.");
+    }
+    await writeFile(`${tmpDir}/${packageName}`, Readable.from(file.body));
+    console.log("Extracting Nebula...");
+    await promisify(execFile)("tar", [
+        "-xf",
+        `${tmpDir}/${packageName}`,
+        "-C",
+        tmpDir,
+    ]);
+};
+export const cleanupNebula = async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+};
+export const getNebulaCert = async (instance) => {
+    const response = await fetch(`${instance.url}/api/nebula/cert`, {
+        headers: {
+            authorization: `Bearer ${instance.apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch Nebula certificate: ${response.status}`);
+    }
+    const { nebulaConfig } = (await response.json());
+    await writeFile(`${tmpDir}/nebula.yml`, nebulaConfig);
+    await chmod(`${tmpDir}/nebula.yml`, 0o600);
+};
+const spawnNebula = () => {
+    if (process.platform === "win32") {
+        return spawn("powershell.exe", [
+            "-Command",
+            `Start-Process ${tmpDir}\\nebula.exe -ArgumentList '-config','${tmpDir}\\nebula.yml' -Verb RunAs`,
+        ]);
+    }
+    return spawn("sudo", [`${tmpDir}/nebula`, "-config", `${tmpDir}/nebula.yml`], {
+        stdio: "inherit",
+    });
+};
+export const connectNebula = async (instance) => {
+    await getNebulaCert(instance);
+    const nebula = spawnNebula();
+    const interval = setInterval(async () => {
+        // refresh Nebula cert every 10 minutes (lifetime is 15 minutes)
+        await getNebulaCert(instance);
+        nebula.kill("SIGHUP");
+    }, 10 * 60 * 1000);
+    await new Promise((resolve) => nebula.on("exit", resolve));
+    clearInterval(interval);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "onedeploy-cli",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "CLI tool for connecting to OneDeploy via Nebula",
 	"keywords": [
 		"onedeploy",
@@ -24,7 +24,7 @@
 	"type": "module",
 	"main": "src/index.ts",
 	"bin": {
-		"onedeploy": "./dist/index.js"
+		"onedeploy-cli": "./dist/index.js"
 	},
 	"scripts": {
 		"build": "tsc",

package/src/index.ts

@@ -1,99 +1,9 @@
-import { execFile, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { Readable } from "node:stream";
-import { promisify } from "node:util";
+#!/usr/bin/env node
 import prompts from "prompts";
-import { y } from "yedra";
+import { loadConfig, saveConfig } from "./config.js";
+import { cleanupNebula, connectNebula, installNebula } from "./nebula.js";
 
-const nebulaUrl = `https://github.com/slackhq/nebula/releases/download/v1.9.6/nebula-linux-amd64.tar.gz`;
-const configDir = `${homedir()}/.config/onedeploy`;
-const tmpDir = `/tmp/onedeploy-${randomUUID()}`;
-await mkdir(configDir, { recursive: true });
-await mkdir(tmpDir, { recursive: true });
-
-const Instance = y.object({
-	url: y.string(),
-	apiKey: y.string(),
-});
-
-const Config = y.object({
-	instances: Instance.array(),
-});
-
-type Instance = y.Typeof<typeof Instance>;
-type Config = y.Typeof<typeof Config>;
-
-const installNebula = async (): Promise<void> => {
-	console.log("Downloading Nebula...");
-	const file = await fetch(nebulaUrl);
-	if (file.body === null) {
-		throw new Error("Could not download Nebula executable.");
-	}
-	await writeFile(`${tmpDir}/nebula.tar.gz`, Readable.from(file.body));
-	console.log("Extracting Nebula...");
-	await promisify(execFile)("tar", [
-		"-xf",
-		`${tmpDir}/nebula.tar.gz`,
-		"-C",
-		tmpDir,
-	]);
-};
-
-const loadConfig = async (): Promise<Config> => {
-	try {
-		const result = await readFile(`${configDir}/config.json`, "utf-8");
-		const config = JSON.parse(result);
-		return Config.parse(config);
-	} catch (_error) {
-		// no config yet
-		return { instances: [] };
-	}
-};
-
-const saveConfig = async (): Promise<void> => {
-	await writeFile(`${configDir}/config.json`, JSON.stringify(config, null, 2));
-	await chmod(`${configDir}/config.json`, 0o600);
-};
-
-const getNebulaCert = async (instance: Instance) => {
-	const response = await fetch(`${instance.url}/api/nebula/cert`, {
-		headers: {
-			authorization: `Bearer ${instance.apiKey}`,
-		},
-	});
-	if (!response.ok) {
-		throw new Error(`Failed to fetch Nebula certificate: ${response.status}`);
-	}
-	const { nebulaConfig } = (await response.json()) as { nebulaConfig: string };
-	await writeFile(`${tmpDir}/nebula.yml`, nebulaConfig);
-	await chmod(`${tmpDir}/nebula.yml`, 0o600);
-};
-
-const connectNebula = async (instance: {
-	url: string;
-	apiKey: string;
-}): Promise<void> => {
-	await getNebulaCert(instance);
-	const nebula = spawn(
-		"sudo",
-		[`${tmpDir}/nebula`, "-config", `${tmpDir}/nebula.yml`],
-		{
-			stdio: "inherit",
-		},
-	);
-	const interval = setInterval(
-		async () => {
-			// refresh Nebula cert every 10 minutes (lifetime is 15 minutes)
-			await getNebulaCert(instance);
-			nebula.kill("SIGHUP");
-		},
-		10 * 60 * 1000,
-	);
-	await new Promise((resolve) => nebula.on("exit", resolve));
-	clearInterval(interval);
-};
+const config = await loadConfig();
 
 const setupConnection = async () => {
 	const result = await prompts([
@@ -112,7 +22,7 @@ const setupConnection = async () => {
 		return;
 	}
 	config.instances.push({ url: result.url, apiKey: result.apiKey });
-	await saveConfig();
+	await saveConfig(config);
 };
 
 const removeConnection = async () => {
@@ -140,13 +50,11 @@ const removeConnection = async () => {
 	]);
 	if (confirm === true) {
 		config.instances.splice(connection, 1);
-		await saveConfig();
+		await saveConfig(config);
 	}
 };
 
-await installNebula();
-const config = await loadConfig();
-while (true) {
+const mainMenu = async (): Promise<boolean> => {
 	const { action } = await prompts([
 		{
 			type: "select",
@@ -189,8 +97,19 @@ while (true) {
 	} else if (action === "remove") {
 		await removeConnection();
 	} else {
-		break;
+		return false;
 	}
+	return true;
 }
 
-await rm(tmpDir, { recursive: true, force: true });
+await installNebula();
+try {
+	while (true) {
+		const shouldContinue = await mainMenu();
+		if (!shouldContinue) {
+			break;
+		}
+	}
+} finally {
+	await cleanupNebula();
+}

package/dist/index.d.ts

@@ -1 +0,0 @@
-export {};