onedeploy-cli 0.1.5 → 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";
@@ -9,10 +10,15 @@ import { parse } from "yaml";
 const getNebulaPackageName = () => {
     switch (process.platform) {
         case "linux":
-            if (process.arch !== "x64") {
+            if (process.arch === "x64") {
+                return `nebula-linux-amd64.tar.gz`;
+            }
+            else if (process.arch === "arm64") {
+                return `nebula-linux-arm64.tar.gz`;
+            }
+            else {
                 throw new Error(`Unsupported architecture: ${process.arch}`);
             }
-            return `nebula-linux-amd64.tar.gz`;
         case "darwin":
             return `nebula-darwin.zip`;
         case "win32":
@@ -47,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) {
@@ -81,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.5",
+	"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"
 	}
 }