@genex-ai/cli-demo 0.1.0 → 0.1.1

package/src/lib/ssh.ts

@@ -1,104 +0,0 @@
-// Per-project SSH deploy key for `genex init` / `genex publish`.
-//
-// We generate an ed25519 keypair in the project dir; the PUBLIC key is sent to
-// the API as the repo's write deploy key, the PRIVATE key (`genex_key`) stays
-// local and is used by `genex publish` to push over SSH. The private key is
-// gitignored so it never lands in the public game repo.
-import fs from "node:fs/promises";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import type { Logger } from "../utils/logger.ts";
-
-/** The private key filename in the project dir (public key is `<name>.pub`). */
-export const KEY_NAME = "genex_key";
-
-/**
- * Ensure a per-project ed25519 deploy keypair exists in `dir` and return its
- * public key. Idempotent: a re-run of `genex init` reuses the existing key (it's
- * already registered as the repo's deploy key). Returns null if `ssh-keygen`
- * isn't available — the caller warns and skips project creation.
- */
-export async function generateSshKeypair(
-  dir: string,
-  log: Logger,
-): Promise<{ publicKey: string } | null> {
-  const keyPath = path.join(dir, KEY_NAME);
-  const pubPath = `${keyPath}.pub`;
-
-  // Reuse an existing key (idempotent re-init).
-  try {
-    const existing = (await fs.readFile(pubPath, "utf8")).trim();
-    if (existing) {
-      log.dim(`Reusing existing deploy key (${KEY_NAME}).`);
-      return { publicKey: existing };
-    }
-  } catch {
-    /* no existing key — generate below */
-  }
-
-  log.step("Generating a deploy key…");
-  const ok = await runSshKeygen(keyPath, log);
-  if (!ok) return null;
-
-  try {
-    const pub = (await fs.readFile(pubPath, "utf8")).trim();
-    if (!pub) {
-      log.warn("ssh-keygen produced no public key.");
-      return null;
-    }
-    await fs.chmod(keyPath, 0o600).catch(() => {});
-    return { publicKey: pub };
-  } catch (err) {
-    log.warn(`Couldn't read the generated public key: ${String(err)}`);
-    return null;
-  }
-}
-
-function runSshKeygen(keyPath: string, log: Logger): Promise<boolean> {
-  return new Promise((resolve) => {
-    let child;
-    try {
-      child = spawn(
-        "ssh-keygen",
-        ["-t", "ed25519", "-f", keyPath, "-N", "", "-C", "genex-agent"],
-        { stdio: "ignore" },
-      );
-    } catch {
-      log.warn("ssh-keygen not found — install OpenSSH (ssh-keygen) and re-run.");
-      resolve(false);
-      return;
-    }
-    child.on("error", () => {
-      log.warn("ssh-keygen not found — install OpenSSH (ssh-keygen) and re-run.");
-      resolve(false);
-    });
-    child.on("close", (code) => resolve(code === 0));
-  });
-}
-
-/**
- * Append the genex artifacts to `<dir>/.gitignore` so `genex publish`'s
- * `git add -A` never pushes the PRIVATE key (or local metadata) to the public
- * game repo. Idempotent; creates the file if absent; never rewrites existing rules.
- */
-export async function writeGitignore(dir: string, log: Logger): Promise<void> {
-  const file = path.join(dir, ".gitignore");
-  let content = "";
-  try {
-    content = await fs.readFile(file, "utf8");
-  } catch {
-    /* create below */
-  }
-
-  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 — never publish)\n";
-  next += toAdd.join("\n") + "\n";
-
-  await fs.writeFile(file, next);
-  log.dim(`Updated .gitignore (${toAdd.join(", ")}).`);
-}

package/src/lib/store.ts

@@ -1,102 +0,0 @@
-// Single source of truth for CLI credential + project storage.
-//
-//  - The USER token lives at ~/.genex/env (per-user, reused across projects),
-//    written via the existing writeEnvVar (0600 + Windows ACL). A legacy
-//    ./.env GENEX_TOKEN is still read as a fallback for older projects.
-//  - PER-PROJECT metadata (id, slug, sshUrl, urls) lives at <cwd>/.genex/project.json
-//    so `genex publish` can run from the project dir without re-authing. The
-//    private SSH key (genex_key) is NEVER stored here — it stays a plain file in
-//    the project dir and is gitignored.
-import fs from "node:fs/promises";
-import path from "node:path";
-import { ENV_TOKEN_KEY, getGenexEnvPath } from "../config.ts";
-import { writeEnvVar } from "./env.ts";
-
-export interface ProjectMetadata {
-  /** API project id (used by `POST /api/projects/:id/publish`). */
-  id: string;
-  /** URL-safe slug (used as the multiplayer room + play URL path). */
-  slug: string;
-  /** git@github.com:org/slug.git — what the agent pushes to (deploy key). */
-  sshUrl: string;
-  /** API base this project was created against. */
-  apiUrl: string;
-  /** Colyseus relay URL for the game's connect(). */
-  colyseusUrl: string;
-  /** Public play URL (GitHub Pages). */
-  playUrl?: string;
-  /** "draft" | "published". */
-  status?: string;
-}
-
-/** Path to the per-project metadata file (`<cwd>/.genex/project.json`). */
-export function getProjectMetadataPath(cwd: string = process.cwd()): string {
-  return path.join(cwd, ".genex", "project.json");
-}
-
-/** Persist the user token to `~/.genex/env` (or an explicit env path). */
-export async function writeUserToken(
-  token: string,
-  envPath?: string,
-): Promise<{ path: string }> {
-  const { path: written } = await writeEnvVar(getGenexEnvPath(envPath), ENV_TOKEN_KEY, token);
-  return { path: written };
-}
-
-/**
- * Read the user token from `~/.genex/env`, falling back to a legacy `./.env`
- * (read-only; never deleted). Returns null if no token is found.
- */
-export async function readUserToken(envPath?: string): Promise<string | null> {
-  const fromGenex = await readTokenFromFile(getGenexEnvPath(envPath));
-  if (fromGenex) return fromGenex;
-  if (!envPath) {
-    // Backcompat: older `genex init` wrote GENEX_TOKEN into the project's ./.env.
-    return readTokenFromFile(path.join(process.cwd(), ".env"));
-  }
-  return null;
-}
-
-async function readTokenFromFile(file: string): Promise<string | null> {
-  let content: string;
-  try {
-    content = await fs.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: string): string {
-  if (
-    (v.startsWith('"') && v.endsWith('"')) ||
-    (v.startsWith("'") && v.endsWith("'"))
-  ) {
-    return v.slice(1, -1);
-  }
-  return v;
-}
-
-/** Read `<cwd>/.genex/project.json`, or null if absent/unparseable. */
-export async function readProject(cwd: string = process.cwd()): Promise<ProjectMetadata | null> {
-  try {
-    const raw = await fs.readFile(getProjectMetadataPath(cwd), "utf8");
-    return JSON.parse(raw) as ProjectMetadata;
-  } catch {
-    return null;
-  }
-}
-
-/** Write `<cwd>/.genex/project.json` (0600 — it identifies the repo, not a secret). */
-export async function writeProject(
-  meta: ProjectMetadata,
-  cwd: string = process.cwd(),
-): Promise<{ path: string }> {
-  const file = getProjectMetadataPath(cwd);
-  await fs.mkdir(path.dirname(file), { recursive: true });
-  await fs.writeFile(file, JSON.stringify(meta, null, 2) + "\n", { mode: 0o600 });
-  await fs.chmod(file, 0o600).catch(() => {});
-  return { path: file };
-}

package/src/utils/colors.ts

@@ -1,25 +0,0 @@
-// Tiny zero-dependency ANSI color helpers. Colors are disabled when stdout is
-// not a TTY, when NO_COLOR is set, or for dumb terminals — so piped/CI output
-// stays clean.
-const useColor =
-  Boolean(process.stdout.isTTY) &&
-  process.env.NO_COLOR === undefined &&
-  process.env.TERM !== "dumb";
-
-const ESC = String.fromCharCode(27); // ASCII escape (\x1b)
-
-const code =
-  (open: number, close: number) =>
-  (s: string): string =>
-    useColor ? `${ESC}[${open}m${s}${ESC}[${close}m` : s;
-
-export const 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),
-};

package/src/utils/logger.ts

@@ -1,40 +0,0 @@
-import { c } from "./colors.ts";
-
-export interface Logger {
-  info(msg: string): void;
-  success(msg: string): void;
-  warn(msg: string): void;
-  error(msg: string): void;
-  step(msg: string): void;
-  dim(msg: string): void;
-  plain(msg: string): void;
-}
-
-export function createLogger(opts: { quiet?: boolean } = {}): Logger {
-  const out = (s: string): void => {
-    if (!opts.quiet) process.stdout.write(s + "\n");
-  };
-  const err = (s: string): void => {
-    process.stderr.write(s + "\n");
-  };
-  return {
-    info: (m) => out(`${c.cyan("i")} ${m}`),
-    success: (m) => out(`${c.green("✓")} ${m}`),
-    warn: (m) => out(`${c.yellow("!")} ${m}`),
-    error: (m) => err(`${c.red("✗")} ${m}`),
-    step: (m) => out(`${c.blue("›")} ${m}`),
-    dim: (m) => out(c.dim(m)),
-    plain: (m) => out(m),
-  };
-}
-
-// A no-op logger, handy for tests.
-export const silentLogger: Logger = {
-  info: () => {},
-  success: () => {},
-  warn: () => {},
-  error: () => {},
-  step: () => {},
-  dim: () => {},
-  plain: () => {},
-};