@xbrowser/cli 0.14.0

package/dist/marketplace-FPT5YLKB.js

@@ -0,0 +1,351 @@
+import {
+  createTarball
+} from "./chunk-OLB6UJ25.js";
+import {
+  loadAuth,
+  saveAuth
+} from "./chunk-KTSQU4QT.js";
+import {
+  ensureProxyFetch
+} from "./chunk-VEKPHQBR.js";
+import {
+  getRegistryUrl
+} from "./chunk-M7CMBPCA.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/plugin/builtins/marketplace.ts
+import { z } from "zod";
+import { createInterface } from "readline";
+var marketResult = z.object({
+  success: z.boolean(),
+  data: z.record(z.unknown()).optional(),
+  message: z.string().optional()
+});
+function prompt(rl, question, hidden = false) {
+  return new Promise((resolve) => {
+    if (hidden) {
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      if (stdin.isTTY) stdin.setRawMode(true);
+      let input = "";
+      process.stdout.write(question);
+      const onData = (char) => {
+        const c = char.toString();
+        switch (c) {
+          case "\n":
+          case "\r":
+            if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
+            stdin.removeListener("data", onData);
+            console.log();
+            resolve(input);
+            break;
+          case "":
+            process.exit();
+            break;
+          case "\x7F":
+            input = input.slice(0, -1);
+            break;
+          default:
+            input += c;
+            process.stdout.write("*");
+        }
+      };
+      stdin.on("data", onData);
+    } else {
+      rl.question(question, resolve);
+    }
+  });
+}
+function setupMarketplacePlugin(xcli) {
+  const site = xcli.createSite({
+    name: "marketplace",
+    url: "https://xbrowser.dev",
+    description: "xbrowser marketplace \u2014 publish, login, register, whoami, logout"
+  });
+  const cmd = (name, config) => site.command(name, config);
+  cmd("publish", {
+    description: "Publish a plugin to the marketplace",
+    scope: "global",
+    parameters: z.object({
+      dir: z.string().optional().describe("Plugin directory (defaults to cwd)"),
+      registry: z.string().optional().describe("Custom registry URL"),
+      dryRun: z.boolean().optional().default(false).describe("Validate without publishing")
+    }),
+    result: marketResult,
+    handler: async (params) => {
+      const pluginDir = params.dir || process.cwd();
+      const auth = loadAuth();
+      if (!auth?.token) {
+        return { success: false, message: "Not logged in. Run: xbrowser marketplace login" };
+      }
+      const registryUrl = getRegistryUrl(params, auth.registry);
+      await ensureProxyFetch();
+      try {
+        const result = await createTarball(pluginDir, {
+          registry: registryUrl,
+          token: auth.token,
+          dryRun: !!params.dryRun
+        });
+        if (params.dryRun) {
+          const lines = [
+            "Dry run - validation passed:",
+            `  Name: ${result.name}`,
+            `  Version: ${result.version}`,
+            `  Slug: ${result.slug}`,
+            `  Description: ${result.description}`
+          ];
+          if (result.commands?.length) lines.push(`  Commands: ${result.commands.join(", ")}`);
+          if (result.tags?.length) lines.push(`  Tags: ${result.tags.join(", ")}`);
+          if (result.sites?.length) lines.push(`  Sites: ${result.sites.join(", ")}`);
+          if (result.commandsDocs?.length) {
+            lines.push("  Command Docs:");
+            for (const c of result.commandsDocs) {
+              lines.push(`    ${c.name}: ${c.description}`);
+              for (const p of c.parameters) {
+                const req = p.required ? "required" : "optional";
+                const def = p.default !== void 0 ? `, default: ${JSON.stringify(p.default)}` : "";
+                lines.push(`      - ${p.name} (${p.type}, ${req}${def}): ${p.description}`);
+              }
+              if (c.examples?.length) {
+                for (const ex of c.examples) lines.push(`      example: ${ex.cmd} \u2014 ${ex.description}`);
+              }
+            }
+          }
+          if (result.readme) {
+            const preview = result.readme.slice(0, 200).replace(/\n/g, "\\n");
+            lines.push(`  README: ${preview.length < result.readme.length ? preview + "..." : preview}`);
+          }
+          lines.push(`  Files: ${result.fileCount} files, ${(result.size / 1024).toFixed(1)}KB`);
+          return { success: true, data: { text: lines.join("\n"), name: result.name, version: result.version, slug: result.slug } };
+        }
+        const response = await fetch(`${registryUrl}/api/plugins/publish`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${auth.token}` },
+          body: result.formData
+        });
+        if (!response.ok) {
+          const errBody = await response.json().catch(() => ({}));
+          const errMsg = errBody.error || response.statusText;
+          if (errMsg.includes("R2 storage")) {
+            return { success: false, message: "R2 storage unavailable. Cannot publish plugin without source code.\n  Please configure R2 bucket or use --storage local" };
+          }
+          return { success: false, message: `Publish failed (${response.status}): ${errMsg}` };
+        }
+        const body = await response.json();
+        const slug = body.data?.slug || result.slug;
+        const text = `
+  Published: ${result.name}@${result.version}
+  URL: ${registryUrl}/plugins/${slug}`;
+        return { success: true, data: { ok: true, name: result.name, version: result.version, slug, text } };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const cause = e instanceof Error && e.cause instanceof Error ? ` (${e.cause.message})` : "";
+        return { success: false, message: `Error: ${msg}${cause}` };
+      }
+    }
+  });
+  cmd("login", {
+    description: "Login to the marketplace",
+    scope: "global",
+    parameters: z.object({
+      email: z.string().optional().describe("Email (skip interactive prompt)"),
+      password: z.string().optional().describe("Password (skip interactive prompt)"),
+      token: z.string().optional().describe("Auth token (skip interactive login)"),
+      registry: z.string().optional().describe("Custom registry URL")
+    }),
+    result: marketResult,
+    handler: async (params) => {
+      const registryUrl = getRegistryUrl(params);
+      await ensureProxyFetch();
+      if (params.token) {
+        saveAuth({ token: params.token, registry: registryUrl });
+        const auth = loadAuth();
+        let username = "unknown";
+        if (auth?.token) {
+          try {
+            const resp = await fetch(`${registryUrl}/api/auth/verify`, {
+              headers: { Authorization: `Bearer ${auth.token}` }
+            });
+            if (resp.ok) {
+              const body = await resp.json();
+              username = body.data?.username || body.data?.email || "unknown";
+            }
+          } catch {
+          }
+        }
+        return { success: true, data: { ok: true, text: `Token saved.
+Logged in as ${username}` } };
+      }
+      let email = params.email;
+      let password = params.password;
+      if (!email || !password) {
+        console.log(`
+Login to ${registryUrl}
+`);
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        if (!email) email = await prompt(rl, "Email: ");
+        if (!password) password = await prompt(rl, "Password: ", true);
+        rl.close();
+        console.log();
+      }
+      if (!email || !password) {
+        return { success: false, message: "Email and password are required" };
+      }
+      try {
+        const res = await fetch(`${registryUrl}/api/auth/login`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, password })
+        });
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => ({}));
+          return { success: false, message: `Login failed: ${errBody.error || errBody.message || res.statusText}` };
+        }
+        const body = await res.json();
+        const result = body.data;
+        if (!result?.token) {
+          return { success: false, message: "No token received from server" };
+        }
+        saveAuth({ token: result.token, registry: registryUrl });
+        const username = result.profile?.username || result.profile?.email || "unknown";
+        return { success: true, data: { ok: true, text: `Logged in as ${username}` } };
+      } catch (e) {
+        return { success: false, message: e instanceof Error ? e.message : String(e) };
+      }
+    }
+  });
+  cmd("register", {
+    description: "Register a new marketplace account",
+    scope: "global",
+    parameters: z.object({
+      username: z.string().optional().describe("Username (2-50 chars)"),
+      email: z.string().optional().describe("Email"),
+      password: z.string().optional().describe("Password (min 6 chars)"),
+      registry: z.string().optional().describe("Custom registry URL")
+    }),
+    result: marketResult,
+    handler: async (params) => {
+      const registryUrl = getRegistryUrl(params);
+      await ensureProxyFetch();
+      let username = params.username;
+      let email = params.email;
+      let password = params.password;
+      const needsInteractive = !username || !email || !password;
+      let confirmPassword = "";
+      if (needsInteractive) {
+        console.log("\nRegister for xbrowser developer account\n");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        if (!username) username = await prompt(rl, "Username (2-50 chars): ");
+        if (!email) email = await prompt(rl, "Email: ");
+        if (!password) password = await prompt(rl, "Password (min 6 chars): ", true);
+        confirmPassword = await prompt(rl, "Confirm password: ", true);
+        rl.close();
+      }
+      if (!username || username.length < 2 || username.length > 50) {
+        return { success: false, message: "Username must be 2-50 characters" };
+      }
+      if (!email || !email.includes("@")) {
+        return { success: false, message: "Invalid email" };
+      }
+      if (!password || password.length < 6) {
+        return { success: false, message: "Password must be at least 6 characters" };
+      }
+      if (needsInteractive && password !== confirmPassword) {
+        return { success: false, message: "Passwords do not match" };
+      }
+      try {
+        const regRes = await fetch(`${registryUrl}/api/auth/register`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ username, email, password })
+        });
+        if (!regRes.ok) {
+          const errBody = await regRes.json().catch(() => ({}));
+          return { success: false, message: `Registration failed: ${errBody.error || errBody.message || regRes.statusText}` };
+        }
+        const loginRes = await fetch(`${registryUrl}/api/auth/login`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, password })
+        });
+        if (!loginRes.ok) {
+          return { success: false, message: "Registration succeeded but auto-login failed. Run: xbrowser marketplace login" };
+        }
+        const loginBody = await loginRes.json();
+        const token = loginBody.data?.token;
+        const profile = loginBody.data?.profile;
+        if (!token) {
+          return { success: false, message: "Registration succeeded but no token received. Run: xbrowser marketplace login" };
+        }
+        saveAuth({ token, registry: registryUrl });
+        const text = [
+          "\n  Registered successfully!",
+          `  Username: ${profile?.username || username}`,
+          `  Email: ${profile?.email || email}`,
+          `  Saved to ~/.xbrowser/auth.json`,
+          "\nYou can now publish plugins with: xbrowser marketplace publish"
+        ].join("\n");
+        return { success: true, data: { ok: true, username: profile?.username, text } };
+      } catch (e) {
+        return { success: false, message: e instanceof Error ? e.message : String(e) };
+      }
+    }
+  });
+  cmd("whoami", {
+    description: "Show current logged-in user",
+    scope: "global",
+    parameters: z.object({
+      registry: z.string().optional().describe("Custom registry URL")
+    }),
+    result: marketResult,
+    handler: async (params) => {
+      const auth = loadAuth();
+      if (!auth?.token) {
+        return { success: false, message: "Not logged in. Run: xbrowser marketplace login" };
+      }
+      const registryUrl = getRegistryUrl(params, auth.registry);
+      await ensureProxyFetch();
+      try {
+        const resp = await fetch(`${registryUrl}/api/auth/verify`, {
+          headers: { Authorization: `Bearer ${auth.token}` }
+        });
+        if (!resp.ok) {
+          return { success: false, message: "Token invalid or expired. Run: xbrowser marketplace login" };
+        }
+        const body = await resp.json();
+        return {
+          success: true,
+          data: {
+            username: body.data?.username,
+            email: body.data?.email,
+            role: body.data?.role,
+            registry: registryUrl,
+            text: `Username: ${body.data?.username || "unknown"}
+Email: ${body.data?.email || "unknown"}
+Role: ${body.data?.role || "user"}
+Registry: ${registryUrl}`
+          }
+        };
+      } catch (e) {
+        return { success: false, message: e instanceof Error ? e.message : String(e) };
+      }
+    }
+  });
+  cmd("logout", {
+    description: "Logout from the marketplace",
+    scope: "global",
+    parameters: z.object({}),
+    result: marketResult,
+    handler: async (_params) => {
+      const auth = loadAuth();
+      if (!auth?.token) {
+        return { success: false, message: "Not logged in" };
+      }
+      saveAuth({ token: "", registry: "" });
+      return { success: true, data: { ok: true, text: "Logged out" } };
+    }
+  });
+}
+export {
+  setupMarketplacePlugin as default
+};