@joystack/cli 0.0.0-stage → 0.1.44

package/lib/login.mjs

@@ -0,0 +1,134 @@
+// `joystack login` — device-flow authentication (the `gh auth login` shape):
+//
+//   1. ask the platform for a pairing (device_code for us, user_code for the
+//      human),
+//   2. show the human the short code and open /activate in their browser,
+//   3. poll until they approve,
+//   4. store the minted creator token in ~/.joystack/config.json.
+//
+// The secret never passes through the human's hands or the chat — non-dev
+// creators can't fumble a 40-char paste (why web-paste was rejected).
+import { spawn } from 'node:child_process';
+import { clearToken, setToken, getToken, getApiBase, DEFAULT_API_BASE } from './config.mjs';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function defaultOpenBrowser(url) {
+  const [cmd, args] =
+    process.platform === 'darwin'
+      ? ['open', [url]]
+      : process.platform === 'win32'
+        ? ['cmd', ['/c', 'start', '', url]]
+        : ['xdg-open', [url]];
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+  } catch {
+    // No browser available (headless) — the printed URL is the fallback.
+  }
+}
+
+async function postJson(url, body) {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body ?? {}),
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+export async function login({
+  apiBase = getApiBase(DEFAULT_API_BASE),
+  log = console.log,
+  openBrowser = defaultOpenBrowser,
+  pollIntervalMsOverride,
+} = {}) {
+  const { status, body: grant } = await postJson(`${apiBase}/api/device/code`);
+  if (status !== 200 || !grant.device_code) {
+    throw new Error(`could not start login against ${apiBase} (HTTP ${status})`);
+  }
+
+  log('');
+  log('  To connect this computer to your Joystack account:');
+  log('');
+  log(`  1. Open   ${grant.verification_uri}`);
+  log(`  2. Enter  ${grant.user_code}`);
+  log('');
+  log('  (opening your browser…)');
+  openBrowser(grant.verification_uri_complete ?? grant.verification_uri);
+
+  const intervalMs = pollIntervalMsOverride ?? (grant.interval ?? 5) * 1000;
+  const deadline = Date.now() + (grant.expires_in ?? 900) * 1000;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    const poll = await postJson(`${apiBase}/api/device/token`, { device_code: grant.device_code });
+    if (poll.status === 200 && poll.body.token) {
+      setToken(poll.body.token, { apiBase, userId: poll.body.user_id });
+      log('');
+      log(`  ✅ Logged in. This machine now builds and publishes as your account (${poll.body.user_id}).`);
+      return { userId: poll.body.user_id };
+    }
+    if (poll.body.error === 'authorization_pending') continue;
+    if (poll.body.error === 'expired_token') {
+      throw new Error('that login code expired before it was approved — run `joystack login` again for a fresh one.');
+    }
+    throw new Error(`login failed: ${poll.body.error ?? `HTTP ${poll.status}`}`);
+  }
+  throw new Error('login timed out — run `joystack login` again.');
+}
+
+export async function whoami({ apiBase = getApiBase(DEFAULT_API_BASE), log = console.log } = {}) {
+  const token = getToken();
+  if (!token) throw new Error('not logged in — run `joystack login` first.');
+  const res = await fetch(`${apiBase}/api/me`, { headers: { Authorization: `Bearer ${token}` } });
+  if (res.status === 401) throw new Error('stored token was rejected (unauthenticated) — run `joystack login` again.');
+  if (!res.ok) throw new Error(`whoami failed: HTTP ${res.status}`);
+  const me = await res.json();
+  log(`${me.name ?? me.userId}  (${me.userId})  via ${apiBase}`);
+  return me;
+}
+
+// `joystack logout [--all]`: revokes the stored token on the platform, or with
+// `all` every token of the account (every machine it is signed in on), then
+// forgets it here. The local copy is forgotten even when the platform cannot be
+// reached, and the output says what may still be valid in that case.
+export async function logout({ all = false, apiBase = getApiBase(DEFAULT_API_BASE), log = console.log, timeoutMs = 15_000 } = {}) {
+  const token = getToken();
+  if (!token) {
+    log('Not logged in on this machine.');
+    return { revoked: 0 };
+  }
+  let revoked = null;
+  let rejected = false;
+  let problem = null;
+  try {
+    const res = await fetch(`${apiBase}/api/creator/logout`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ all }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (res.ok) {
+      const body = await res.json().catch(() => null);
+      revoked = typeof body?.revoked === 'number' ? body.revoked : null;
+    } else if (res.status === 401) {
+      rejected = true;
+    } else {
+      problem = `HTTP ${res.status}`;
+    }
+  } catch (err) {
+    problem = err?.message ?? String(err);
+  }
+  clearToken();
+  if (problem) {
+    log(`Logged out on this machine, but ${apiBase} could not revoke the token (${problem}); it stays valid until it expires.`);
+  } else if (rejected && all) {
+    log('Logged out on this machine. Its token had already expired or been revoked, so other machines were not signed out: run `joystack login`, then `joystack logout --all`.');
+  } else if (rejected) {
+    log('Logged out: the token had already expired or been revoked, and is removed from this machine.');
+  } else if (all) {
+    log(revoked === null ? 'Logged out everywhere.' : `Logged out everywhere: ${revoked} token${revoked === 1 ? '' : 's'} revoked.`);
+  } else {
+    log('Logged out: the token is revoked and removed from this machine.');
+  }
+  return { revoked, rejected, problem };
+}

package/lib/model-bake-cli.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// Thin executable wrapper over the model baker. The normal front door is
+// `joystack model bake <glb>` (bin/joystack.mjs); this file exists so other tooling
+// can exec the same implementation directly. One baker, two entrances.
+import { bakeModel } from './model-bake.mjs';
+
+const glb = process.argv[2];
+if (!glb) {
+  console.error('usage: model-bake <file.glb>   (bakes <file>.skeleton.json + <file>.mesh.json beside it)');
+  process.exit(2);
+}
+try {
+  await bakeModel(glb);
+} catch (err) {
+  console.error(`model bake: ${err.message}`);
+  process.exit(1);
+}