npm - @genex-ai/cli-demo - Versions diffs - 0.1.0 → 0.1.2 - Mend

@genex-ai/cli-demo 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/index.js +1015 -0
package/package.json +8 -4
package/src/commands/init.ts +0 -131
package/src/commands/publish.ts +0 -151
package/src/config.ts +0 -102
package/src/index.ts +0 -238
package/src/lib/auth.ts +0 -365
package/src/lib/copy-templates.ts +0 -81
package/src/lib/env.ts +0 -109
package/src/lib/project.ts +0 -109
package/src/lib/ssh.ts +0 -104
package/src/lib/store.ts +0 -102
package/src/utils/colors.ts +0 -25
package/src/utils/logger.ts +0 -40

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1015 @@
+#!/usr/bin/env node
+// src/index.ts
+import { readFileSync } from "fs";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+// src/commands/init.ts
+import path6 from "path";
+// src/config.ts
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_AUTH_URL = "https://demo-web.glotech.world";
+var DEFAULT_API_URL = "https://demo-api.glotech.world";
+var DEFAULT_COLYSEUS_URL = "wss://demo-colyseus.glotech.world";
+var ENV_TOKEN_KEY = "GENEX_TOKEN";
+var AUTH_URL_ENV = "GENEX_AUTH_URL";
+var API_URL_ENV = "GENEX_API_URL";
+var COLYSEUS_URL_ENV = "GENEX_COLYSEUS_URL";
+function getAuthUrl(override) {
+  const raw = override || process.env[AUTH_URL_ENV] || DEFAULT_AUTH_URL;
+  return raw.replace(/\/+$/, "");
+}
+function getApiUrl(override) {
+  const raw = override || process.env[API_URL_ENV] || DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+function getColyseusUrl(override) {
+  const raw = override || process.env[COLYSEUS_URL_ENV] || DEFAULT_COLYSEUS_URL;
+  return raw.replace(/\/+$/, "");
+}
+function getGenexDir() {
+  return path.join(os.homedir(), ".genex");
+}
+function getGenexEnvPath(override) {
+  if (override) return path.resolve(override);
+  return path.join(getGenexDir(), "env");
+}
+function getTemplatesDir() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..", "templates");
+}
+function getClaudeDir(override) {
+  if (override) return path.resolve(override);
+  return path.join(os.homedir(), ".claude");
+}
+// src/lib/copy-templates.ts
+import fs from "fs/promises";
+import path2 from "path";
+async function copyTemplates(srcDir, destDir, opts = {}) {
+  const result = { copied: [], skipped: [] };
+  await walk(srcDir, srcDir, destDir, opts, result);
+  return result;
+}
+async function walk(rootSrc, src, dest, opts, result) {
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    const rel = path2.relative(rootSrc, srcPath);
+    if (entry.isDirectory()) {
+      await fs.mkdir(destPath, { recursive: true });
+      await walk(rootSrc, srcPath, destPath, opts, result);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!opts.force && await exists(destPath)) {
+      result.skipped.push(rel);
+      continue;
+    }
+    await fs.mkdir(path2.dirname(destPath), { recursive: true });
+    await fs.copyFile(srcPath, destPath);
+    result.copied.push(rel);
+  }
+}
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+// src/lib/auth.ts
+import http from "http";
+import crypto from "crypto";
+import readline from "readline";
+import { spawn } from "child_process";
+import { URL } from "url";
+var SUCCESS_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>Genex</title>
+<style>body{font-family:system-ui,sans-serif;background:#0b0b0f;color:#eaeaea;display:grid;place-items:center;height:100vh;margin:0}
+.card{text-align:center;padding:2rem 3rem;border:1px solid #26262e;border-radius:14px;background:#13131a}
+h1{font-size:1.3rem;margin:0 0 .5rem}p{color:#9a9aa6;margin:0}</style></head>
+<body><div class="card"><h1>\u2713 Authorized</h1><p>You can close this tab and return to your terminal.</p></div></body></html>`;
+var ERROR_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>Genex</title></head>
+<body style="font-family:system-ui,sans-serif"><h1>Authorization failed</h1>
+<p>No token was provided. Please return to your terminal and try again.</p></body></html>`;
+async function authorize(authBaseUrl, options) {
+  const {
+    log,
+    timeoutMs = 5 * 60 * 1e3,
+    open = openBrowser,
+    interactive = Boolean(process.stdin.isTTY)
+  } = options;
+  const state = crypto.randomBytes(16).toString("hex");
+  const server = http.createServer();
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let timer;
+    let rl;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (rl) rl.close();
+      server.close();
+    };
+    const succeed = (token) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(token);
+    };
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    server.on("request", (req, res) => {
+      handleCallback(req, res, state, log).then((token) => {
+        if (token) succeed(token);
+      }).catch((err) => {
+        log.dim(`callback error: ${String(err)}`);
+        if (!res.writableEnded) {
+          res.writeHead(500);
+          res.end();
+        }
+      });
+    });
+    server.on("error", (err) => fail(err));
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      const redirectUri = `http://127.0.0.1:${port}/callback`;
+      const authUrl = buildAuthUrl(authBaseUrl, redirectUri, state);
+      log.step("Opening your browser to authorize\u2026");
+      log.dim(authUrl);
+      let warned = false;
+      const warnManual = () => {
+        if (warned || settled) return;
+        warned = true;
+        log.warn(
+          "Couldn't open a browser automatically. Open the URL above manually to continue."
+        );
+      };
+      const opened = open(authUrl, warnManual);
+      if (!opened) warnManual();
+      if (interactive) {
+        rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        rl.question(
+          "\nWaiting for the browser redirect\u2026 or paste your token here and press Enter:\n> ",
+          (answer) => {
+            const token = answer.trim();
+            if (token) succeed(token);
+          }
+        );
+      }
+      timer = setTimeout(() => {
+        fail(
+          new Error(
+            "Timed out waiting for authorization. Re-run the command to try again."
+          )
+        );
+      }, timeoutMs);
+    });
+  });
+}
+function buildAuthUrl(authBaseUrl, redirectUri, state) {
+  const url = new URL(`${authBaseUrl}/cli/auth`);
+  url.searchParams.set("redirect_uri", redirectUri);
+  url.searchParams.set("state", state);
+  return url.toString();
+}
+async function handleCallback(req, res, expectedState, log) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  const reqUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return null;
+  }
+  if (reqUrl.pathname !== "/callback") {
+    res.writeHead(404);
+    res.end();
+    return null;
+  }
+  let token = null;
+  let state = null;
+  if (req.method === "GET") {
+    token = reqUrl.searchParams.get("token");
+    state = reqUrl.searchParams.get("state");
+  } else if (req.method === "POST") {
+    let parsed;
+    try {
+      parsed = await readBody(req);
+    } catch (err) {
+      log.dim(`ignoring malformed callback body: ${String(err)}`);
+      res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(ERROR_HTML);
+      return null;
+    }
+    token = parsed.token;
+    state = parsed.state ?? reqUrl.searchParams.get("state");
+  } else {
+    res.writeHead(405);
+    res.end();
+    return null;
+  }
+  if (state !== expectedState) {
+    log.dim("ignoring callback with missing or mismatched state");
+    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(ERROR_HTML);
+    return null;
+  }
+  if (!token) {
+    res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(ERROR_HTML);
+    return null;
+  }
+  res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+  res.end(SUCCESS_HTML);
+  return token;
+}
+async function readBody(req) {
+  const chunks = [];
+  let total = 0;
+  const MAX = 1024 * 1024;
+  for await (const chunk of req) {
+    const buf = chunk;
+    total += buf.length;
+    if (total > MAX) {
+      throw new Error("request body too large");
+    }
+    chunks.push(buf);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return { token: null, state: null };
+  const contentType = req.headers["content-type"] ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      const obj = JSON.parse(raw);
+      return {
+        token: typeof obj.token === "string" ? obj.token : null,
+        state: typeof obj.state === "string" ? obj.state : null
+      };
+    } catch {
+      return { token: null, state: null };
+    }
+  }
+  const params = new URLSearchParams(raw);
+  return {
+    token: params.get("token"),
+    state: params.get("state")
+  };
+}
+function openBrowser(url, onError = () => {
+}) {
+  let command;
+  let args;
+  const custom = (process.env.GENEX_BROWSER || process.env.BROWSER)?.trim();
+  const customParts = custom ? tokenizeCommand(custom) : [];
+  if (customParts.length > 0) {
+    command = customParts[0];
+    args = [...customParts.slice(1), url];
+  } else {
+    switch (process.platform) {
+      case "darwin":
+        command = "open";
+        args = [url];
+        break;
+      case "win32":
+        command = "cmd";
+        args = ["/c", "start", "", url];
+        break;
+      default:
+        command = "xdg-open";
+        args = [url];
+        break;
+    }
+  }
+  try {
+    const child = spawn(command, args, {
+      stdio: "ignore",
+      detached: true
+    });
+    child.on("error", () => onError());
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tokenizeCommand(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let inToken = false;
+  for (const ch of input) {
+    if (quote) {
+      if (ch === quote) quote = null;
+      else current += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      inToken = true;
+    } else if (/\s/.test(ch)) {
+      if (inToken) {
+        tokens.push(current);
+        current = "";
+        inToken = false;
+      }
+    } else {
+      current += ch;
+      inToken = true;
+    }
+  }
+  if (inToken) tokens.push(current);
+  return tokens;
+}
+// src/lib/project.ts
+import crypto2 from "crypto";
+// src/utils/colors.ts
+var useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb";
+var ESC = String.fromCharCode(27);
+var code = (open, close) => (s) => useColor ? `${ESC}[${open}m${s}${ESC}[${close}m` : s;
+var c = {
+  bold: code(1, 22),
+  dim: code(2, 22),
+  red: code(31, 39),
+  green: code(32, 39),
+  yellow: code(33, 39),
+  blue: code(34, 39),
+  cyan: code(36, 39),
+  gray: code(90, 39)
+};
+// src/lib/project.ts
+async function createDraftProject(opts) {
+  const { apiUrl, token, deployKey, colyseusUrl, dashboardUrl, log } = opts;
+  log.step("Creating your project\u2026");
+  const names = [opts.name, `${opts.name}-${randomSuffix()}`];
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    let res;
+    try {
+      res = await fetch(`${apiUrl}/api/projects`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ name, deployKey })
+      });
+    } catch (err) {
+      log.warn(`Couldn't reach the API at ${apiUrl} to create the project.`);
+      log.dim(`  ${String(err)}`);
+      return null;
+    }
+    if (res.status === 409 && i === 0) continue;
+    if (res.status === 401) {
+      log.warn("Not authorized to create the project (token rejected).");
+      return null;
+    }
+    if (res.status === 400) {
+      log.warn("The API rejected the deploy key (must be an OpenSSH public key).");
+      return null;
+    }
+    if (!res.ok) {
+      log.warn(`Couldn't create the project (HTTP ${res.status}).`);
+      return null;
+    }
+    const data = await res.json().catch(() => null);
+    const project = data?.project;
+    if (!project || !data?.sshUrl) {
+      log.warn("Project created, but the API response was unexpected.");
+      return null;
+    }
+    log.success(`Created project ${c.cyan(project.slug)}.`);
+    if (project.playUrl) log.dim(`  play (after publish): ${project.playUrl}`);
+    log.dim(`  dashboard: ${dashboardUrl}/dashboard`);
+    return {
+      id: project.id,
+      slug: project.slug,
+      sshUrl: data.sshUrl,
+      apiUrl,
+      colyseusUrl,
+      playUrl: project.playUrl ?? void 0,
+      status: "draft"
+    };
+  }
+  log.warn("Couldn't create a project with a unique name. Try `--name <unique>`.");
+  return null;
+}
+function randomSuffix() {
+  return crypto2.randomBytes(3).toString("hex");
+}
+// src/lib/ssh.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import { spawn as spawn2 } from "child_process";
+var KEY_NAME = "genex_key";
+async function generateSshKeypair(dir, log) {
+  const keyPath = path3.join(dir, KEY_NAME);
+  const pubPath = `${keyPath}.pub`;
+  try {
+    const existing = (await fs2.readFile(pubPath, "utf8")).trim();
+    if (existing) {
+      log.dim(`Reusing existing deploy key (${KEY_NAME}).`);
+      return { publicKey: existing };
+    }
+  } catch {
+  }
+  log.step("Generating a deploy key\u2026");
+  const ok = await runSshKeygen(keyPath, log);
+  if (!ok) return null;
+  try {
+    const pub = (await fs2.readFile(pubPath, "utf8")).trim();
+    if (!pub) {
+      log.warn("ssh-keygen produced no public key.");
+      return null;
+    }
+    await fs2.chmod(keyPath, 384).catch(() => {
+    });
+    return { publicKey: pub };
+  } catch (err) {
+    log.warn(`Couldn't read the generated public key: ${String(err)}`);
+    return null;
+  }
+}
+function runSshKeygen(keyPath, log) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn2(
+        "ssh-keygen",
+        ["-t", "ed25519", "-f", keyPath, "-N", "", "-C", "genex-agent"],
+        { stdio: "ignore" }
+      );
+    } catch {
+      log.warn("ssh-keygen not found \u2014 install OpenSSH (ssh-keygen) and re-run.");
+      resolve(false);
+      return;
+    }
+    child.on("error", () => {
+      log.warn("ssh-keygen not found \u2014 install OpenSSH (ssh-keygen) and re-run.");
+      resolve(false);
+    });
+    child.on("close", (code2) => resolve(code2 === 0));
+  });
+}
+async function writeGitignore(dir, log) {
+  const file = path3.join(dir, ".gitignore");
+  let content = "";
+  try {
+    content = await fs2.readFile(file, "utf8");
+  } catch {
+  }
+  const present = new Set(content.split("\n").map((l) => l.trim()));
+  const toAdd = [KEY_NAME, `${KEY_NAME}.pub`, ".genex/"].filter((e) => !present.has(e));
+  if (toAdd.length === 0) return;
+  let next = content;
+  if (next.length > 0 && !next.endsWith("\n")) next += "\n";
+  if (!content.trim()) next += "# genex (deploy key + local metadata \u2014 never publish)\n";
+  next += toAdd.join("\n") + "\n";
+  await fs2.writeFile(file, next);
+  log.dim(`Updated .gitignore (${toAdd.join(", ")}).`);
+}
+// src/lib/store.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+// src/lib/env.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+import { spawn as spawn3 } from "child_process";
+async function writeEnvVar(envPath, key, value) {
+  let content = "";
+  let existed = false;
+  try {
+    content = await fs3.readFile(envPath, "utf8");
+    existed = true;
+  } catch {
+  }
+  const assignment = `${key}=${formatValue(value)}`;
+  const keyPattern = new RegExp(
+    `^(\\s*export\\s+)?${escapeRegExp(key)}=.*$`,
+    "gm"
+  );
+  let next;
+  let mode;
+  if (keyPattern.test(content)) {
+    next = content.replace(keyPattern, assignment);
+    mode = "updated";
+  } else {
+    let prefix = content;
+    if (prefix.length > 0 && !prefix.endsWith("\n")) prefix += "\n";
+    next = prefix + assignment + "\n";
+    mode = existed ? "appended" : "created";
+  }
+  await fs3.mkdir(path4.dirname(envPath), { recursive: true });
+  await fs3.writeFile(envPath, next, { mode: 384 });
+  await restrictFilePermissions(envPath);
+  return { mode, path: envPath };
+}
+async function restrictFilePermissions(filePath) {
+  if (process.platform !== "win32") {
+    await fs3.chmod(filePath, 384).catch(() => {
+    });
+    return;
+  }
+  const user = process.env.USERNAME ?? process.env.USER;
+  if (!user) return;
+  await new Promise((resolve) => {
+    try {
+      const child = spawn3(
+        "icacls",
+        [filePath, "/inheritance:r", "/grant:r", `${user}:F`],
+        { stdio: "ignore" }
+      );
+      child.on("error", () => resolve());
+      child.on("close", () => resolve());
+    } catch {
+      resolve();
+    }
+  });
+}
+function formatValue(value) {
+  if (/[\s#"'$`\\]/.test(value)) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// src/lib/store.ts
+function getProjectMetadataPath(cwd = process.cwd()) {
+  return path5.join(cwd, ".genex", "project.json");
+}
+async function writeUserToken(token, envPath) {
+  const { path: written } = await writeEnvVar(getGenexEnvPath(envPath), ENV_TOKEN_KEY, token);
+  return { path: written };
+}
+async function readUserToken(envPath) {
+  const fromGenex = await readTokenFromFile(getGenexEnvPath(envPath));
+  if (fromGenex) return fromGenex;
+  if (!envPath) {
+    return readTokenFromFile(path5.join(process.cwd(), ".env"));
+  }
+  return null;
+}
+async function readTokenFromFile(file) {
+  let content;
+  try {
+    content = await fs4.readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+  const m = content.match(/^\s*(?:export\s+)?GENEX_TOKEN=(.*)$/m);
+  if (!m) return null;
+  return stripQuotes(m[1].trim()) || null;
+}
+function stripQuotes(v) {
+  if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1);
+  }
+  return v;
+}
+async function readProject(cwd = process.cwd()) {
+  try {
+    const raw = await fs4.readFile(getProjectMetadataPath(cwd), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeProject(meta, cwd = process.cwd()) {
+  const file = getProjectMetadataPath(cwd);
+  await fs4.mkdir(path5.dirname(file), { recursive: true });
+  await fs4.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 384 });
+  await fs4.chmod(file, 384).catch(() => {
+  });
+  return { path: file };
+}
+// src/utils/logger.ts
+function createLogger(opts = {}) {
+  const out = (s) => {
+    if (!opts.quiet) process.stdout.write(s + "\n");
+  };
+  const err = (s) => {
+    process.stderr.write(s + "\n");
+  };
+  return {
+    info: (m) => out(`${c.cyan("i")} ${m}`),
+    success: (m) => out(`${c.green("\u2713")} ${m}`),
+    warn: (m) => out(`${c.yellow("!")} ${m}`),
+    error: (m) => err(`${c.red("\u2717")} ${m}`),
+    step: (m) => out(`${c.blue("\u203A")} ${m}`),
+    dim: (m) => out(c.dim(m)),
+    plain: (m) => out(m)
+  };
+}
+// src/commands/init.ts
+async function runInit(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  log.plain(c.bold("genex init"));
+  log.plain("");
+  const templatesDir = getTemplatesDir();
+  const claudeDir = getClaudeDir(opts.dir);
+  log.step(`Setting up your workspace at ${c.cyan(claudeDir)}`);
+  const { copied, skipped } = await copyTemplates(templatesDir, claudeDir, {
+    force: opts.force
+  });
+  if (copied.length > 0) {
+    log.success(`Added ${copied.length} file${copied.length === 1 ? "" : "s"}.`);
+    for (const f of copied) log.dim(`  + ${f}`);
+  }
+  if (skipped.length > 0) {
+    log.info(
+      `Left ${skipped.length} existing file${skipped.length === 1 ? "" : "s"} untouched.`
+    );
+    for (const f of skipped) log.dim(`  = ${f}`);
+  }
+  if (copied.length === 0 && skipped.length === 0) {
+    log.info("No template files to install.");
+  }
+  log.plain("");
+  if (opts.noAuth) {
+    log.info("Skipping authorization (--no-auth).");
+    log.success("Done.");
+    return;
+  }
+  const authBaseUrl = getAuthUrl(opts.authUrl);
+  let token;
+  try {
+    token = await authorize(authBaseUrl, {
+      log,
+      timeoutMs: opts.timeoutSec ? opts.timeoutSec * 1e3 : void 0
+    });
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    log.dim("Your workspace files were installed. Re-run `genex init` to finish authorizing.");
+    throw err;
+  }
+  log.success("Authorized.");
+  const { path: tokenPath } = await writeUserToken(token, opts.envPath);
+  log.success(`Saved your token to ${c.cyan(tokenPath)} (${ENV_TOKEN_KEY}).`);
+  log.plain("");
+  const key = await generateSshKeypair(process.cwd(), log);
+  await writeGitignore(process.cwd(), log);
+  if (!key) {
+    log.warn(
+      "Skipping project creation \u2014 no deploy key. Install ssh-keygen (OpenSSH) and re-run `genex init`."
+    );
+    log.plain("");
+    log.success("Workspace ready (no project created yet).");
+    return;
+  }
+  const apiUrl = getApiUrl(opts.apiUrl);
+  const colyseusUrl = getColyseusUrl(opts.colyseusUrl);
+  const projectName = opts.name?.trim() || path6.basename(process.cwd());
+  const meta = await createDraftProject({
+    apiUrl,
+    token,
+    name: projectName,
+    deployKey: key.publicKey,
+    colyseusUrl,
+    dashboardUrl: authBaseUrl,
+    log
+  });
+  if (meta) {
+    const { path: metaPath } = await writeProject(meta);
+    log.dim(`  saved ${c.cyan(metaPath)}`);
+  }
+  log.plain("");
+  log.success("All set. \u{1F680}");
+}
+// src/commands/publish.ts
+import { spawn as spawn4 } from "child_process";
+import fs5 from "fs/promises";
+import path7 from "path";
+function run(cmd, args, env) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn4(cmd, args, { env: env ? { ...process.env, ...env } : process.env });
+    } catch {
+      resolve({ code: -1, out: "", err: `${cmd} not found` });
+      return;
+    }
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (d) => out += String(d));
+    child.stderr?.on("data", (d) => err += String(d));
+    child.on("error", () => resolve({ code: -1, out, err: `${cmd} not found` }));
+    child.on("close", (code2) => resolve({ code: code2 ?? -1, out, err }));
+  });
+}
+async function runPublish(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  log.plain(c.bold("genex publish"));
+  log.plain("");
+  const token = opts.token ?? await readUserToken(opts.envPath);
+  if (!token) {
+    log.error("Not authorized. Run `genex init` first to sign in.");
+    process.exitCode = 1;
+    return;
+  }
+  const meta = await readProject();
+  if (!meta) {
+    log.error("No genex project here. Run `genex init` in this directory first.");
+    process.exitCode = 1;
+    return;
+  }
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta.apiUrl);
+  let pushed = null;
+  if (opts.noPush) {
+    log.info("Skipping git push (--no-push).");
+  } else {
+    pushed = await pushGame(meta.sshUrl, log);
+  }
+  log.step("Publishing to the gallery\u2026");
+  let res;
+  try {
+    const body = {};
+    if (opts.title) body.title = opts.title;
+    if (opts.description) body.description = opts.description;
+    res = await fetch(`${apiUrl}/api/projects/${meta.id}/publish`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    log.error(`Couldn't reach the API at ${apiUrl}: ${String(err)}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!res.ok) {
+    log.error(`Publish failed (HTTP ${res.status}).`);
+    process.exitCode = 1;
+    return;
+  }
+  log.plain("");
+  if (pushed === false) {
+    log.warn(
+      "Listed in the gallery, but the game wasn't pushed \u2014 the play URL won't work until the push succeeds."
+    );
+    log.dim("  Fix the push error above and re-run `genex publish`.");
+  } else {
+    log.success("Published. \u{1F389}");
+  }
+  if (meta.playUrl) {
+    log.dim(`  play: ${meta.playUrl}`);
+    if (pushed === true) log.dim("  (GitHub Pages rebuilds ~30\u201390s after a push.)");
+  }
+}
+async function pushGame(sshUrl, log) {
+  try {
+    await fs5.access(path7.join(process.cwd(), "index.html"));
+  } catch {
+    log.warn("No index.html at the project root \u2014 GitHub Pages needs one to serve the game.");
+  }
+  const isRepo = (await run("git", ["rev-parse", "--git-dir"])).code === 0;
+  if (!isRepo) {
+    log.step("Initializing git\u2026");
+    if ((await run("git", ["init"])).code !== 0) {
+      log.warn("git init failed \u2014 the game was not pushed (use `genex publish --no-push` to silence).");
+      return false;
+    }
+  }
+  await run("git", ["add", "-A"]);
+  const commit = await run("git", ["commit", "-m", "build"]);
+  if (commit.code !== 0 && !/nothing to commit/i.test(commit.out + commit.err)) {
+    log.dim("  (no new commit to push)");
+  }
+  log.step("Pushing your game over SSH\u2026");
+  const push = await run("git", ["push", sshUrl, "+HEAD:main"], {
+    GIT_SSH_COMMAND: `ssh -i ./${KEY_NAME} -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new`
+  });
+  if (push.code === 0) {
+    log.success("Pushed to main.");
+    return true;
+  }
+  log.warn("git push failed \u2014 your live game was NOT updated.");
+  const tail = push.err.trim().split("\n").slice(-2).join(" ");
+  if (tail) log.dim(`  ${tail}`);
+  return false;
+}
+// src/index.ts
+function getVersion() {
+  try {
+    const here = path8.dirname(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(
+      readFileSync(path8.resolve(here, "..", "package.json"), "utf8")
+    );
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var HELP = `${c.bold("genex")} \u2014 set up your ~/.claude workspace, authorize, and publish 3D games.
+${c.bold("Usage")}
+  genex init [<name>] [options]      Scaffold + authorize + create the draft project.
+  genex publish [options]            Push the built game and list it in the gallery.
+${c.bold("Options for `init`")}
+  <name>               Project name (positional; default: current directory name).
+  --name <name>        Same as the positional name.
+  --dir <path>         Destination workspace (default: ~/.claude).
+  --env <path>         Token env file (default: ~/.genex/env).
+  --auth-url <url>     Override the auth site (default: ${DEFAULT_AUTH_URL}).
+  --api-url <url>      Override the API base URL (default: ${DEFAULT_API_URL}).
+  --colyseus-url <url> Override the multiplayer URL (stored in project metadata).
+  --no-auth            Only scaffold templates; skip authorization.
+  --force              Overwrite existing files (default: never overwrite).
+  --timeout <seconds>  How long to wait for the auth redirect (default: 300).
+${c.bold("Options for `publish`")}
+  --no-push            Skip the git push; only flip the gallery flag.
+  --title <title>      Gallery title.
+  --description <text> Gallery description.
+  --api-url <url>      Override the API base URL.
+  --env <path>         Token env file (default: ~/.genex/env).
+${c.bold("Global")}
+  --quiet              Reduce output.
+  -h, --help           Show this help.
+  -v, --version        Show the version.
+${c.bold("Environment")}
+  GENEX_AUTH_URL       Overrides the default auth site URL.
+  GENEX_API_URL        Overrides the default API base URL.
+  GENEX_COLYSEUS_URL   Overrides the default multiplayer URL.
+  GENEX_BROWSER        Command used to open the browser (falls back to BROWSER).
+${c.bold("Examples")}
+  genex init my-game
+  genex init my-game --api-url http://localhost:3000 --auth-url http://localhost:5173
+  genex publish
+  genex publish --no-push --title "My Game"
+`;
+function parseArgs(argv) {
+  const parsed = {
+    command: void 0,
+    options: {},
+    help: false,
+    version: false
+  };
+  const needsValue = /* @__PURE__ */ new Set([
+    "--dir",
+    "--env",
+    "--auth-url",
+    "--api-url",
+    "--colyseus-url",
+    "--name",
+    "--title",
+    "--description",
+    "--timeout"
+  ]);
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i++];
+    if (arg === void 0) break;
+    switch (arg) {
+      case "-h":
+      case "--help":
+        parsed.help = true;
+        break;
+      case "-v":
+      case "--version":
+        parsed.version = true;
+        break;
+      case "--no-auth":
+        parsed.options.noAuth = true;
+        break;
+      case "--no-push":
+        parsed.options.noPush = true;
+        break;
+      case "--force":
+        parsed.options.force = true;
+        break;
+      case "--quiet":
+        parsed.options.quiet = true;
+        break;
+      default: {
+        if (needsValue.has(arg)) {
+          const value = argv[i++];
+          if (value === void 0) {
+            parsed.error = `Missing value for ${arg}`;
+            return parsed;
+          }
+          applyValueFlag(parsed.options, arg, value);
+        } else if (arg.startsWith("-")) {
+          parsed.error = `Unknown option: ${arg}`;
+          return parsed;
+        } else if (parsed.command === void 0) {
+          parsed.command = arg;
+        } else if (parsed.options.name === void 0) {
+          parsed.options.name = arg;
+        } else {
+          parsed.error = `Unexpected argument: ${arg}`;
+          return parsed;
+        }
+        break;
+      }
+    }
+  }
+  return parsed;
+}
+function applyValueFlag(options, flag, value) {
+  switch (flag) {
+    case "--dir":
+      options.dir = value;
+      break;
+    case "--env":
+      options.envPath = value;
+      break;
+    case "--auth-url":
+      options.authUrl = value;
+      break;
+    case "--api-url":
+      options.apiUrl = value;
+      break;
+    case "--colyseus-url":
+      options.colyseusUrl = value;
+      break;
+    case "--name":
+      options.name = value;
+      break;
+    case "--title":
+      options.title = value;
+      break;
+    case "--description":
+      options.description = value;
+      break;
+    case "--timeout": {
+      const n = Number(value);
+      if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`Invalid --timeout value: ${value}`);
+      }
+      options.timeoutSec = n;
+      break;
+    }
+  }
+}
+async function main() {
+  const log = createLogger();
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.error) {
+    log.error(parsed.error);
+    log.plain(`Run ${c.cyan("genex --help")} for usage.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.version) {
+    log.plain(getVersion());
+    return;
+  }
+  if (parsed.help || parsed.command === void 0) {
+    log.plain(HELP);
+    return;
+  }
+  switch (parsed.command) {
+    case "init":
+      await runInit(parsed.options);
+      break;
+    case "publish":
+      await runPublish(parsed.options);
+      break;
+    default:
+      log.error(`Unknown command: ${parsed.command}`);
+      log.plain(`Run ${c.cyan("genex --help")} for usage.`);
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  const log = createLogger();
+  log.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});