oauth.do 0.1.7 → 0.1.10

package/dist/cli.js

@@ -11,6 +11,10 @@ var __esm = (fn, res) => function __init() {
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -29,23 +33,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  CompositeTokenStorage: () => CompositeTokenStorage,
+  FileTokenStorage: () => FileTokenStorage,
+  KeychainTokenStorage: () => KeychainTokenStorage,
+  LocalStorageTokenStorage: () => LocalStorageTokenStorage,
+  MemoryTokenStorage: () => MemoryTokenStorage,
+  SecureFileTokenStorage: () => SecureFileTokenStorage,
+  createSecureStorage: () => createSecureStorage
+});
 function isNode() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
-function getEnv3(key) {
+function getEnv2(key) {
   if (typeof process !== "undefined" && process.env?.[key]) return process.env[key];
   return void 0;
 }
 function createSecureStorage() {
   if (isNode()) {
-    return new CompositeTokenStorage();
+    return new SecureFileTokenStorage();
   }
   if (typeof localStorage !== "undefined") {
     return new LocalStorageTokenStorage();
   }
   return new MemoryTokenStorage();
 }
-var KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, KeychainTokenStorage, SecureFileTokenStorage, MemoryTokenStorage, LocalStorageTokenStorage, CompositeTokenStorage;
+var KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, KeychainTokenStorage, SecureFileTokenStorage, FileTokenStorage, MemoryTokenStorage, LocalStorageTokenStorage, CompositeTokenStorage;
 var init_storage = __esm({
   "src/storage.ts"() {
     KEYCHAIN_SERVICE = "oauth.do";
@@ -67,7 +81,7 @@ var init_storage = __esm({
           const keytarModule = imported.default || imported;
           this.keytar = keytarModule;
           if (typeof this.keytar.getPassword !== "function") {
-            if (getEnv3("DEBUG")) {
+            if (getEnv2("DEBUG")) {
               console.warn("Keytar module loaded but getPassword is not a function:", Object.keys(this.keytar));
             }
             this.keytar = null;
@@ -75,7 +89,7 @@ var init_storage = __esm({
           }
           return this.keytar;
         } catch (error) {
-          if (getEnv3("DEBUG")) {
+          if (getEnv2("DEBUG")) {
             console.warn("Keychain storage not available:", error);
           }
           return null;
@@ -90,7 +104,7 @@ var init_storage = __esm({
           const token = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
           return token;
         } catch (error) {
-          if (getEnv3("DEBUG")) {
+          if (getEnv2("DEBUG")) {
             console.warn("Failed to get token from keychain:", error);
           }
           return null;
@@ -132,7 +146,7 @@ var init_storage = __esm({
           await keytar.getPassword(KEYCHAIN_SERVICE, "__test__");
           return true;
         } catch (error) {
-          if (getEnv3("DEBUG")) {
+          if (getEnv2("DEBUG")) {
             console.warn("Keychain not available:", error);
           }
           return false;
@@ -163,7 +177,7 @@ var init_storage = __esm({
           const fs = await import('fs/promises');
           const stats = await fs.stat(this.tokenPath);
           const mode = stats.mode & 511;
-          if (mode !== 384 && getEnv3("DEBUG")) {
+          if (mode !== 384 && getEnv2("DEBUG")) {
             console.warn(
               `Warning: Token file has insecure permissions (${mode.toString(8)}). Expected 600. Run: chmod 600 ${this.tokenPath}`
             );
@@ -196,6 +210,63 @@ var init_storage = __esm({
         } catch {
         }
       }
+      /**
+       * Get information about the storage backend
+       */
+      async getStorageInfo() {
+        await this.init();
+        return { type: "file", secure: true, path: this.tokenPath };
+      }
+    };
+    FileTokenStorage = class {
+      tokenPath = null;
+      configDir = null;
+      initialized = false;
+      async init() {
+        if (this.initialized) return this.tokenPath !== null;
+        this.initialized = true;
+        if (!isNode()) return false;
+        try {
+          const os = await import('os');
+          const path = await import('path');
+          this.configDir = path.join(os.homedir(), ".oauth.do");
+          this.tokenPath = path.join(this.configDir, "token");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async getToken() {
+        if (!await this.init() || !this.tokenPath) return null;
+        try {
+          const fs = await import('fs/promises');
+          const token = await fs.readFile(this.tokenPath, "utf-8");
+          return token.trim();
+        } catch {
+          return null;
+        }
+      }
+      async setToken(token) {
+        if (!await this.init() || !this.tokenPath || !this.configDir) {
+          throw new Error("File storage not available");
+        }
+        try {
+          const fs = await import('fs/promises');
+          await fs.mkdir(this.configDir, { recursive: true });
+          await fs.writeFile(this.tokenPath, token, "utf-8");
+        } catch (error) {
+          console.error("Failed to save token:", error);
+          throw error;
+        }
+      }
+      async removeToken() {
+        if (!await this.init() || !this.tokenPath) return;
+        try {
+          const fs = await import('fs/promises');
+          await fs.unlink(this.tokenPath);
+        } catch {
+        }
+      }
     };
     MemoryTokenStorage = class {
       token = null;
@@ -263,7 +334,7 @@ var init_storage = __esm({
             try {
               await this.keychainStorage.setToken(fileToken);
               await this.fileStorage.removeToken();
-              if (getEnv3("DEBUG")) {
+              if (getEnv2("DEBUG")) {
                 console.log("Migrated token from file to keychain");
               }
             } catch {
@@ -298,7 +369,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "oauth.do",
-      version: "0.1.7",
+      version: "0.1.10",
       description: "OAuth authentication SDK and CLI for .do Platform",
       type: "module",
       main: "./dist/index.js",
@@ -311,6 +382,10 @@ var require_package = __commonJS({
           types: "./dist/index.d.ts",
           import: "./dist/index.js"
         },
+        "./node": {
+          types: "./dist/node.d.ts",
+          import: "./dist/node.js"
+        },
         "./mdx/*": "./src/mdx/*"
       },
       files: [
@@ -476,41 +551,22 @@ async function pollForTokens(deviceCode, interval = 5, expiresIn = 600) {
 }
 
 // src/auth.ts
-function getEnv2(key) {
+async function resolveSecret(value) {
+  if (!value) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && typeof value.get === "function") {
+    return await value.get();
+  }
+  return null;
+}
+function getEnv3(key) {
   if (globalThis[key]) return globalThis[key];
   if (typeof process !== "undefined" && process.env?.[key]) return process.env[key];
   return void 0;
 }
-async function auth(token) {
-  const config = getConfig();
-  const authToken = token || getEnv2("DO_TOKEN") || "";
-  if (!authToken) {
-    return { user: null };
-  }
-  try {
-    const response = await config.fetch(`${config.apiUrl}/me`, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${authToken}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      if (response.status === 401) {
-        return { user: null };
-      }
-      throw new Error(`Authentication failed: ${response.statusText}`);
-    }
-    const user = await response.json();
-    return { user, token: authToken };
-  } catch (error) {
-    console.error("Auth error:", error);
-    return { user: null };
-  }
-}
 async function logout(token) {
   const config = getConfig();
-  const authToken = token || getEnv2("DO_TOKEN") || "";
+  const authToken = token || getEnv3("DO_TOKEN") || "";
   if (!authToken) {
     return;
   }
@@ -529,6 +585,30 @@ async function logout(token) {
     console.error("Logout error:", error);
   }
 }
+async function getToken() {
+  const adminToken = getEnv3("DO_ADMIN_TOKEN");
+  if (adminToken) return adminToken;
+  const doToken = getEnv3("DO_TOKEN");
+  if (doToken) return doToken;
+  try {
+    const { env } = await import('cloudflare:workers');
+    const cfAdminToken = await resolveSecret(env.DO_ADMIN_TOKEN);
+    if (cfAdminToken) return cfAdminToken;
+    const cfToken = await resolveSecret(env.DO_TOKEN);
+    if (cfToken) return cfToken;
+  } catch {
+  }
+  try {
+    const { createSecureStorage: createSecureStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+    const storage2 = createSecureStorage2();
+    return await storage2.getToken();
+  } catch {
+    return null;
+  }
+}
+function auth() {
+  return getToken;
+}
 
 // src/cli.ts
 init_storage();
@@ -616,19 +696,6 @@ function printVersion() {
     console.log("oauth.do");
   }
 }
-async function waitForEnter(prompt) {
-  const readline = await import('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    rl.question(prompt, () => {
-      rl.close();
-      resolve();
-    });
-  });
-}
 async function loginCommand() {
   try {
     console.log(`${colors.bright}Starting OAuth login...${colors.reset}
@@ -644,7 +711,6 @@ ${colors.bright}To complete login:${colors.reset}`);
   ${colors.dim}Or open this URL directly:${colors.reset}`);
     console.log(`  ${colors.blue}${authResponse.verification_uri_complete}${colors.reset}
 `);
-    await waitForEnter(`${colors.cyan}Press Enter to open browser...${colors.reset}`);
     const open = await import('open').catch(() => null);
     if (open) {
       try {
@@ -677,12 +743,11 @@ ${colors.dim}Logged in as:${colors.reset}`);
         console.log(`  ${colors.gray}${authResult.user.email}${colors.reset}`);
       }
     }
-    const compositeStorage = storage;
-    if (typeof compositeStorage.getStorageInfo === "function") {
-      const storageInfo = await compositeStorage.getStorageInfo();
-      const storageLabel = storageInfo.type === "keychain" ? `${colors.green}OS Keychain${colors.reset}` : `${colors.yellow}Secure File${colors.reset}`;
+    const fileStorage = storage;
+    if (typeof fileStorage.getStorageInfo === "function") {
+      const storageInfo = await fileStorage.getStorageInfo();
       console.log(`
-${colors.dim}Token stored in: ${storageLabel}${colors.reset}`);
+${colors.dim}Token stored in: ${colors.green}~/.oauth.do/token${colors.reset}${colors.reset}`);
     }
   } catch (error) {
     printError("Login failed", error instanceof Error ? error : void 0);
@@ -754,16 +819,11 @@ async function statusCommand() {
   try {
     console.log(`${colors.bright}OAuth.do Status${colors.reset}
 `);
-    const compositeStorage = storage;
-    if (typeof compositeStorage.getStorageInfo === "function") {
-      const storageInfo = await compositeStorage.getStorageInfo();
-      const storageLabel = storageInfo.type === "keychain" ? `${colors.green}OS Keychain${colors.reset}` : `${colors.yellow}Secure File${colors.reset}`;
-      console.log(`${colors.cyan}Storage:${colors.reset} ${storageLabel}`);
-      if (storageInfo.type === "keychain") {
-        console.log(`  ${colors.dim}Using system credential manager (most secure)${colors.reset}`);
-      } else {
-        console.log(`  ${colors.dim}Using ~/.oauth.do/token with 0600 permissions${colors.reset}`);
-      }
+    const fileStorage = storage;
+    if (typeof fileStorage.getStorageInfo === "function") {
+      const storageInfo = await fileStorage.getStorageInfo();
+      console.log(`${colors.cyan}Storage:${colors.reset} ${colors.green}Secure File${colors.reset}`);
+      console.log(`  ${colors.dim}Using ~/.oauth.do/token with 0600 permissions${colors.reset}`);
     }
     const token = await storage.getToken();
     if (!token) {
@@ -791,6 +851,32 @@ Run ${colors.cyan}oauth.do login${colors.reset} to re-authenticate`);
     process.exit(1);
   }
 }
+async function autoLoginOrShowUser() {
+  try {
+    const token = await storage.getToken();
+    if (token) {
+      const authResult = await auth(token);
+      if (authResult.user) {
+        console.log(`${colors.green}\u2713${colors.reset} Already authenticated
+`);
+        if (authResult.user.name) {
+          console.log(`  ${colors.bright}${authResult.user.name}${colors.reset}`);
+        }
+        if (authResult.user.email) {
+          console.log(`  ${colors.gray}${authResult.user.email}${colors.reset}`);
+        }
+        if (authResult.user.id) {
+          console.log(`  ${colors.dim}ID: ${authResult.user.id}${colors.reset}`);
+        }
+        return;
+      }
+      printInfo("Session expired, logging in again...\n");
+    }
+    await loginCommand();
+  } catch (error) {
+    await loginCommand();
+  }
+}
 async function main() {
   configureFromEnv();
   const args = process.argv.slice(2);
@@ -808,9 +894,11 @@ async function main() {
   const command = args.find((arg) => !arg.startsWith("--"));
   switch (command) {
     case "login":
-    case void 0:
       await loginCommand();
       break;
+    case void 0:
+      await autoLoginOrShowUser();
+      break;
     case "logout":
       await logoutCommand();
       break;