ds-01 1.0.14 → 1.1.1

package/src/commands/login.ts

@@ -1,41 +1,26 @@
 import { Command } from "commander";
-import {
-  intro,
-  outro,
-  spinner,
-  note,
-  cancel,
-} from "@clack/prompts";
+import { intro, outro, spinner, note, cancel } from "@clack/prompts";
 import pc from "picocolors";
 import open from "open";
 import machineIdPkg from "node-machine-id";
-
 import { saveToken } from "../utils/config.js";
 import {
   createDeviceKey,
   getDevicePublicKey,
 } from "../utils/secureKeyStore.js";
 
-const API_BASE_URL =
-  process.env.DS01_API_URL ||
-  "https://ds-01.vercel.app";
+const API_BASE_URL = process.env.DS01_API_URL || "https://ds-01.vercel.app";
 
 const { machineIdSync } = machineIdPkg;
 
 export const login = new Command()
   .name("login")
-  .description(
-    "Authenticate your terminal with DS01 via browser",
-  )
+  .description("Authenticate your terminal with DS01 via browser")
   .action(async () => {
     console.log();
 
     intro(
-      `${pc.bgWhite(
-        pc.black(
-          pc.bold(" DS01 "),
-        ),
-      )} ${pc.gray(
+      `${pc.bgWhite(pc.black(pc.bold(" DS01 ")))} ${pc.gray(
         "v1.0.0 — Terminal Authentication",
       )}`,
     );
@@ -43,300 +28,142 @@ export const login = new Command()
     const s = spinner();
 
     try {
-      // ==================================================
-      // 1. CREATE / LOAD SECURE DEVICE KEY
-      // ==================================================
-
-      s.start(
-        "Preparing secure device identity...",
-      );
+      s.start("Preparing secure device identity...");
 
       await createDeviceKey();
-
-      const publicKey =
-        await getDevicePublicKey();
-
-      const hardwareId =
-        machineIdSync();
-
+      const publicKey = await getDevicePublicKey();
+      const hardwareId = machineIdSync();
       const publicKeyType =
-        process.platform === "win32"
-          ? "windows-rsa"
-          : "macos-ec";
-
-      // ==================================================
-      // 2. REQUEST DEVICE CODE
-      // ==================================================
-
-      s.start(
-        "Requesting pairing code...",
-      );
+        process.platform === "win32" ? "windows-rsa" : "macos-ec";
 
-      const initResponse =
-        await fetch(
-          `${API_BASE_URL}/api/auth/device/code`,
-          {
-            method: "POST",
+      //  Req to my server with machineId and certificate for now but eventually will send the publicKey
+      s.start("Requesting pairing code...");
 
-            headers: {
-              "Content-Type":
-                "application/json",
-            },
+      const initResponse = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
 
-            body: JSON.stringify({
-              machineId:
-                hardwareId,
-
-              publicKey,
-
-              publicKeyType,
-            }),
-          },
-        );
+        body: JSON.stringify({
+          machineId: hardwareId,
+          publicKey,
+          publicKeyType,
+        }),
+      });
 
       if (!initResponse.ok) {
-        s.stop(
-          pc.red(
-            "Failed to reach DS01 authorization server.",
-          ),
-        );
-
-        cancel(
-          `Server responded with HTTP ${initResponse.status}`,
-        );
-
+        s.stop(pc.red("Failed to reach DS01 authorization server."));
+        cancel(`Server responded with HTTP ${initResponse.status}`);
         process.exit(1);
       }
 
-      const {
-        deviceCode,
-        userCode,
-        verificationUrl,
-        interval,
-      } =
+      const { deviceCode, userCode, verificationUrl, interval } =
         await initResponse.json();
 
-      if (
-        !deviceCode ||
-        !userCode ||
-        !verificationUrl
-      ) {
+      if (!deviceCode || !userCode || !verificationUrl) {
         throw new Error(
           "Authorization server returned an invalid device response.",
         );
       }
 
-      s.stop(
-        pc.green(
-          "Secure device identity registered.",
-        ),
-      );
-
-      // ==================================================
-      // 3. SHOW BROWSER AUTHORIZATION
-      // ==================================================
+      s.stop(pc.green("Secure device identity registered."));
 
+      // Opening users browser with verification URL
       note(
-        `${pc.bold(
-          "Pairing Code:",
-        )}    ${pc.cyan(
-          pc.bold(
-            ` ${userCode} `,
-          ),
+        `${pc.bold("Pairing Code:")}    ${pc.cyan(
+          pc.bold(` ${userCode} `),
         )}\n` +
-          `${pc.bold(
-            "Verification URL:",
-          )} ${pc.underline(
-            verificationUrl,
-          )}`,
+          `${pc.bold("Verification URL:")} ${pc.underline(verificationUrl)}`,
         "Action Required",
       );
 
       try {
-        await open(
-          verificationUrl,
-        );
+        await open(verificationUrl);
       } catch {
         // Browser launch failure is non-fatal.
       }
+      
+      // we polling to one of my server endpoint to check wether the temporary req is approved or not ??
+      s.start("Waiting for web authorization...");
 
-      // ==================================================
-      // 4. POLL FOR AUTHORIZATION
-      // ==================================================
-
-      s.start(
-        "Waiting for web authorization...",
-      );
-
-      const pollInterval =
-        (interval || 5) * 1000;
-
-      let token: string | null =
-        null;
+      const pollInterval = (interval || 5) * 1000;
+      let token: string | null = null;
 
       while (true) {
-        await new Promise(
-          (resolve) =>
-            setTimeout(
-              resolve,
-              pollInterval,
-            ),
-        );
-
-        const tokenResponse =
-          await fetch(
-            `${API_BASE_URL}/api/auth/device/token`,
-            {
-              method: "POST",
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
 
-              headers: {
-                "Content-Type":
-                  "application/json",
-              },
-
-              body: JSON.stringify({
-                deviceCode,
-                machineId:
-                  hardwareId,
-              }),
+        const tokenResponse = await fetch(
+          `${API_BASE_URL}/api/auth/device/token`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
             },
-          );
+            body: JSON.stringify({
+              deviceCode,
+              machineId: hardwareId,
+            }),
+          },
+        );
 
         let tokenData: any;
-
         try {
-          tokenData =
-            await tokenResponse.json();
+          tokenData = await tokenResponse.json();
         } catch {
-          s.stop(
-            pc.red(
-              "Authorization server returned invalid JSON.",
-            ),
-          );
-
-          cancel(
-            "Unable to read authorization response.",
-          );
-
+          s.stop(pc.red("Authorization server returned invalid JSON."));
+          cancel("Unable to read authorization response.");
           process.exit(1);
         }
 
-        // ==================================================
-        // AUTHORIZATION SUCCESS
-        // ==================================================
-
+        // Auth success stop polling
         if (
           tokenResponse.ok &&
-          typeof tokenData.accessToken ===
-            "string" &&
+          typeof tokenData.accessToken === "string" &&
           tokenData.accessToken.length > 0
         ) {
-          token =
-            tokenData.accessToken;
-
+          token = tokenData.accessToken;
           break;
         }
 
-        // ==================================================
-        // STILL WAITING
-        // ==================================================
-
-        if (
-          tokenData.error ===
-          "authorization_pending"
-        ) {
+        // Still waiting keep polling
+        if (tokenData.error === "authorization_pending") {
           continue;
         }
 
-        // ==================================================
-        // AUTHORIZATION FAILED
-        // ==================================================
-
-        s.stop(
-          pc.red(
-            "Authorization failed or expired.",
-          ),
-        );
-
-        cancel(
-          `Reason: ${
-            tokenData.error ||
-            "Unknown authorization error"
-          }`,
-        );
-
+        // Authorization Failed
+        s.stop(pc.red("Authorization failed or expired."));
+        cancel(`Reason: ${tokenData.error || "Unknown authorization error"}`);
         process.exit(1);
       }
 
-      // ==================================================
-      // 5. STOP POLLING SPINNER
-      // ==================================================
-
-      s.stop(
-        pc.green(
-          "Hardware signature linked & token verified!",
-        ),
-      );
-
-      // ==================================================
-      // 6. ENSURE TOKEN EXISTS
-      // ==================================================
+      // outside the loop stop the spinner
+      s.stop(pc.green("Hardware signature linked & token verified!"));
 
+      //  ENSURE TOKEN EXISTS
       if (!token) {
         throw new Error(
           "Authorization completed without receiving an access token.",
         );
       }
 
-      // ==================================================
-      // 7. SAVE TOKEN
-      // ==================================================
-
-      saveToken(
-        token,
-        hardwareId,
-      );
-
-      // ==================================================
-      // 8. SUCCESS
-      // ==================================================
-
+      saveToken(token, hardwareId);
       outro(
-        `${pc.white(
-          "✔",
-        )} ${pc.bold(
-          "Terminal synced successfully",
-        )}\n` +
-          pc.gray(
-            "Secure device key and session token are ready.",
-          ),
+        `${pc.white("✔")} ${pc.bold("Terminal synced successfully")}\n` +
+          pc.gray("Secure device key and session token are ready."),
       );
 
-      // ==================================================
-      // 9. HARD EXIT
-      // ==================================================
-      //
+      // Hard Exit
       // The login command is completely finished.
-      //
+
       // This prevents any lingering CLI handles
       // (spinner timers, readline handles, etc.)
       // from keeping the Node process alive.
       //
       process.exit(0);
     } catch (error: any) {
-      s.stop(
-        pc.red(
-          "An error occurred during login.",
-        ),
-      );
-
-      cancel(
-        pc.gray(
-          error?.message ||
-            "Unknown CLI Error",
-        ),
-      );
-
+      s.stop(pc.red("An error occurred during login."));
+      cancel(pc.gray(error?.message || "Unknown CLI Error"));
       process.exit(1);
     }
-  });
+  });

package/src/commands/logout.ts

@@ -41,9 +41,7 @@ export const logout = new Command()
 
       // NEW: Delete local credentials only after the server confirms
       // that the CLI session has been revoked.
-      console.log("✅ Server confirmed CLI session was revoked.");
       deleteToken();
-      console.log("✅ Local credentials deleted.");
       spinner.succeed(chalk.green("Successfully logged out."));
       console.log(
         chalk.gray(

package/src/utils/secureKeyStore.ts

@@ -11,13 +11,16 @@ const execFileAsync = promisify(execFile);
 const KEY_NAME = "DS01-CLI-Device-Key";
 
 const __filename = fileURLToPath(import.meta.url);
+// import.meta.ur -- current module ka location URL form mein deta hai
+
 const __dirname = path.dirname(__filename);
+//C:\Projects\DS01\cli\dist\utils
+
+// __filename = where is THIS FILE?
+// __dirname  = which folder contains THIS FILE?
 
 function getMacHelperPath(): string {
-  return path.resolve(
-    __dirname,
-    "../native/macos-key-helper.swift",
-  );
+  return path.resolve(__dirname, "../native/macos-key-helper.swift");
 }
 
 function ensureSupportedOS(): void {
@@ -30,11 +33,7 @@ function ensureSupportedOS(): void {
   }
 }
 
-/**
- * ---------------------------------------------------------
- * WINDOWS
- * ---------------------------------------------------------
- */
+// for windows
 
 async function createWindowsDeviceKey(): Promise<void> {
   const script = `
@@ -102,21 +101,10 @@ Write-Output "CREATED"
   const result = stdout.trim();
 
   if (result !== "CREATED" && result !== "EXISTS") {
-    throw new Error(
-      "Failed to create Windows DS01 device key.",
-    );
+    throw new Error("Failed to create Windows DS01 device key.");
   }
 }
 
-/**
- * Find exactly one valid DS01 certificate.
- *
- * We intentionally do not use Select-Object -First 1.
- *
- * 0 certificates  -> error
- * 1 certificate   -> use it
- * 2+ certificates -> error
- */
 function getWindowsCertificateLookup(): string {
   return `
 $certificates = @(Get-ChildItem Cert:\\CurrentUser\\My |
@@ -138,6 +126,12 @@ $cert = [System.Security.Cryptography.X509Certificates.X509Certificate2]$certifi
 `;
 }
 
+// cert - just a variable holding the certificate object
+// X509Certificate2 is a Windows/.NET certificate object 
+// that gives the code a standard way to work with the certificate and its associated key information
+// X509Certificate2 a class/type, rather than simply a "format"
+
+
 async function getWindowsPublicKey(): Promise<string> {
   const script = `
 $ErrorActionPreference = "Stop"
@@ -165,19 +159,14 @@ ${getWindowsCertificateLookup()}
   const certificate = stdout.trim();
 
   if (!certificate) {
-    throw new Error(
-      "Unable to read Windows DS01 public certificate.",
-    );
+    throw new Error("Unable to read Windows DS01 public certificate.");
   }
 
   return certificate;
 }
 
-async function signWindowsDeviceKey(
-  data: Uint8Array,
-): Promise<Uint8Array> {
-  const dataBase64 =
-    Buffer.from(data).toString("base64");
+async function signWindowsDeviceKey(data: Uint8Array): Promise<Uint8Array> {
+  const dataBase64 = Buffer.from(data).toString("base64");
 
   const script = `
 $ErrorActionPreference = "Stop"
@@ -226,17 +215,16 @@ finally {
     },
   );
 
+
+  
+
   const signature = stdout.trim();
 
   if (!signature) {
-    throw new Error(
-      "Failed to sign data with Windows device key.",
-    );
+    throw new Error("Failed to sign data with Windows device key.");
   }
 
-  return new Uint8Array(
-    Buffer.from(signature, "base64"),
-  );
+  return new Uint8Array(Buffer.from(signature, "base64"));
 }
 
 async function deleteWindowsDeviceKey(): Promise<void> {
@@ -277,18 +265,10 @@ Write-Output "DELETED"
   );
 }
 
-/**
- * ---------------------------------------------------------
- * MACOS
- * ---------------------------------------------------------
- */
+// for Mac
 
 async function runMacHelper(
-  operation:
-    | "create"
-    | "public"
-    | "sign"
-    | "delete",
+  operation: "create" | "public" | "sign" | "delete",
   data?: Uint8Array,
 ): Promise<string> {
   const helper = getMacHelperPath();
@@ -296,76 +276,51 @@ async function runMacHelper(
   const args = [helper, operation];
 
   if (data) {
-    args.push(
-      Buffer.from(data).toString("base64"),
-    );
+    args.push(Buffer.from(data).toString("base64"));
   }
 
-  const { stdout } = await execFileAsync(
-    "swift",
-    args,
-    {
-      windowsHide: true,
-    },
-  );
+  const { stdout } = await execFileAsync("swift", args, {
+    windowsHide: true,
+  });
 
   return stdout.trim();
 }
 
 async function createMacDeviceKey(): Promise<void> {
-  const result =
-    await runMacHelper("create");
+  const result = await runMacHelper("create");
 
-  if (
-    result !== "CREATED" &&
-    result !== "EXISTS"
-  ) {
+  if (result !== "CREATED" && result !== "EXISTS") {
     throw new Error(
-      result ||
-        "Failed to create macOS Secure Enclave device key.",
+      result || "Failed to create macOS Secure Enclave device key.",
     );
   }
 }
 
 async function getMacPublicKey(): Promise<string> {
-  const result =
-    await runMacHelper("public");
+  const result = await runMacHelper("public");
 
   if (!result) {
-    throw new Error(
-      "Unable to read macOS DS01 public key.",
-    );
+    throw new Error("Unable to read macOS DS01 public key.");
   }
 
   return result;
 }
 
-async function signMacDeviceKey(
-  data: Uint8Array,
-): Promise<Uint8Array> {
-  const result =
-    await runMacHelper("sign", data);
+async function signMacDeviceKey(data: Uint8Array): Promise<Uint8Array> {
+  const result = await runMacHelper("sign", data);
 
   if (!result) {
-    throw new Error(
-      "Failed to sign data with macOS Secure Enclave key.",
-    );
+    throw new Error("Failed to sign data with macOS Secure Enclave key.");
   }
 
-  return new Uint8Array(
-    Buffer.from(result, "base64"),
-  );
+  return new Uint8Array(Buffer.from(result, "base64"));
 }
 
 async function deleteMacDeviceKey(): Promise<void> {
   await runMacHelper("delete");
 }
 
-/**
- * ---------------------------------------------------------
- * PUBLIC API
- * ---------------------------------------------------------
- */
+// Public APIs which we use this for creating keys and certificate
 
 export async function createDeviceKey(): Promise<void> {
   ensureSupportedOS();
@@ -388,9 +343,7 @@ export async function getDevicePublicKey(): Promise<string> {
   return getMacPublicKey();
 }
 
-export async function signWithDeviceKey(
-  data: Uint8Array,
-): Promise<Uint8Array> {
+export async function signWithDeviceKey(data: Uint8Array): Promise<Uint8Array> {
   ensureSupportedOS();
 
   if (os.platform() === "win32") {
@@ -409,4 +362,4 @@ export async function deleteDeviceKey(): Promise<void> {
   }
 
   await deleteMacDeviceKey();
-}
+}

package/src/test-key.ts

@@ -1,20 +0,0 @@
-import {
-  createDeviceKey,
-  getDevicePublicKey,
-  signWithDeviceKey,
-} from "./utils/secureKeyStore.js";
-
-await createDeviceKey();
-
-const publicKey = await getDevicePublicKey();
-
-console.log("Public key:", publicKey);
-
-const message = new TextEncoder().encode("hello DS01");
-
-const signature = await signWithDeviceKey(message);
-
-console.log(
-  "Signature:",
-  Buffer.from(signature).toString("base64"),
-);