onedeploy-cli 0.1.6 → 0.1.7

package/dist/config.js

@@ -5,7 +5,6 @@ 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(),

package/dist/index.js

@@ -14,16 +14,11 @@ const setupConnection = async () => {
             name: "url",
             message: "Enter OneDeploy URL",
         },
-        {
-            type: "password",
-            name: "apiKey",
-            message: "Enter OneDeploy API key",
-        },
     ]);
-    if (result.apiKey === undefined || result.url === undefined) {
+    if (result.url === undefined) {
         return;
     }
-    config.instances.push({ url: result.url, apiKey: result.apiKey });
+    config.instances.push({ url: result.url });
     await saveConfig(config);
 };
 const removeConnection = async () => {

package/dist/nebula.js

@@ -1,6 +1,7 @@
 import { execFile, spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { chmod, mkdir, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { Readable } from "node:stream";
@@ -52,10 +53,10 @@ export const installNebula = async () => {
 export const cleanupNebula = async () => {
     await rm(tmpDir, { recursive: true, force: true });
 };
-export const getNebulaCert = async (instance) => {
+export const getNebulaCert = async (instance, session) => {
     const response = await fetch(`${instance.url}/api/nebula/cert`, {
         headers: {
-            authorization: `Bearer ${instance.apiKey}`,
+            authorization: `Bearer ${session}`,
         },
     });
     if (!response.ok) {
@@ -86,13 +87,57 @@ export const getNebulaCert = async (instance) => {
     process.stdout.write(stdout);
 };
 export let isNebulaRunning = false;
+const getSession = (instance) => {
+    const verificationCode = randomBytes(8).toString("base64url");
+    return new Promise((resolve) => {
+        const getServerAddr = () => {
+            const addr = server.address();
+            if (addr === null || typeof addr === "string") {
+                // just a placeholder, should not happen
+                return "http://localhost:70000";
+            }
+            return `http://localhost:${addr.port}`;
+        };
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://localhost");
+            if (url.pathname === "/authenticated") {
+                const token = url.searchParams.get("token");
+                if (token === null) {
+                    throw new Error("Missing token in callback URL");
+                }
+                // authentication complete
+                res.writeHead(200);
+                res.write("Authentication successful! You can close this window.");
+                res.end();
+                server.close();
+                resolve(token);
+            }
+            else {
+                const target = `${getServerAddr()}/authenticated`;
+                res.writeHead(302, {
+                    location: `${instance.url}/auth/nebula?redirect=${encodeURIComponent(target)}&code=${encodeURIComponent(verificationCode)}`,
+                });
+                res.end();
+            }
+        });
+        server.on("listening", () => {
+            const addr = server.address();
+            if (addr === null || typeof addr === "string") {
+                throw new Error("Unexpected address type");
+            }
+            console.log(`Visit ${getServerAddr()} to authenticate. Client verification code: ${verificationCode}`);
+        });
+        server.listen();
+    });
+};
 export const connectNebula = async (instance) => {
-    await getNebulaCert(instance);
+    const session = await getSession(instance);
+    await getNebulaCert(instance, session);
     isNebulaRunning = true;
     const nebula = spawn(`${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);
+        await getNebulaCert(instance, session);
         nebula.kill("SIGHUP");
     }, 10 * 60 * 1000);
     await new Promise((resolve) => nebula.on("exit", resolve));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "onedeploy-cli",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"description": "CLI tool for connecting to OneDeploy via Nebula",
 	"keywords": [
 		"onedeploy",
@@ -32,14 +32,14 @@
 		"fix": "biome check src/* --fix"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.2.3",
-		"@types/node": "^24.3.1",
+		"@biomejs/biome": "^2.3.1",
+		"@types/node": "^24.9.1",
 		"@types/prompts": "^2.4.9",
-		"typescript": "^5.9.2"
+		"typescript": "^5.9.3"
 	},
 	"dependencies": {
 		"prompts": "^2.4.2",
 		"yaml": "^2.8.1",
-		"yedra": "^0.17.9"
+		"yedra": "^0.18.0"
 	}
 }

package/src/index.ts

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-import prompts from "prompts";
-import { loadConfig, saveConfig } from "./config.js";
-import {
-	cleanupNebula,
-	connectNebula,
-	installNebula,
-	isNebulaRunning,
-} from "./nebula.js";
-
-if (process.argv.includes("--version")) {
-	console.log("onedeploy-cli version 0.1.4");
-	process.exit();
-}
-
-const config = await loadConfig();
-
-const setupConnection = async () => {
-	const result = await prompts([
-		{
-			type: "text",
-			name: "url",
-			message: "Enter OneDeploy URL",
-		},
-		{
-			type: "password",
-			name: "apiKey",
-			message: "Enter OneDeploy API key",
-		},
-	]);
-	if (result.apiKey === undefined || result.url === undefined) {
-		return;
-	}
-	config.instances.push({ url: result.url, apiKey: result.apiKey });
-	await saveConfig(config);
-};
-
-const removeConnection = async () => {
-	const { connection } = await prompts([
-		{
-			type: "select",
-			name: "connection",
-			message: "Select connection to remove",
-			choices: config.instances.map((instance, index) => ({
-				title: instance.url,
-				value: index,
-			})),
-		},
-	]);
-	if (connection === undefined) {
-		return;
-	}
-	const { confirm } = await prompts([
-		{
-			type: "confirm",
-			name: "confirm",
-			message: `Are you sure you want to remove connection to ${config.instances[connection].url}?`,
-			initial: false,
-		},
-	]);
-	if (confirm === true) {
-		config.instances.splice(connection, 1);
-		await saveConfig(config);
-	}
-};
-
-const mainMenu = async (): Promise<boolean> => {
-	const { action } = await prompts([
-		{
-			type: "select",
-			name: "action",
-			message: "What do you want to do?",
-			choices: [
-				{
-					title: "Connect",
-					value: "connect",
-					disabled: config.instances.length === 0,
-				},
-				{
-					title: "Setup new connection",
-					value: "setup",
-				},
-				{
-					title: "Remove connection",
-					value: "remove",
-				},
-			],
-		},
-	]);
-	if (action === "connect") {
-		const result = await prompts([
-			{
-				type: "select",
-				name: "connection",
-				message: "Select OneDeploy instance",
-				choices: config.instances.map((instance) => ({
-					title: instance.url,
-					value: instance,
-				})),
-			},
-		]);
-		if (result.connection !== undefined) {
-			await connectNebula(result.connection);
-		}
-	} else if (action === "setup") {
-		await setupConnection();
-	} else if (action === "remove") {
-		await removeConnection();
-	} else {
-		return false;
-	}
-	return true;
-};
-
-process.on("SIGINT", () => {
-	if (!isNebulaRunning) {
-		process.exit();
-	}
-	// ignore SIGINTs to continue after Nebula is disconnected
-});
-await installNebula();
-try {
-	while (true) {
-		const shouldContinue = await mainMenu();
-		if (!shouldContinue) {
-			break;
-		}
-	}
-} finally {
-	await cleanupNebula();
-}