create-sl-ide 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# create-sl-ide
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Start a slide deck with [sl-ide](https://github.com/dberm312/sl-ide-template),
+the IDE for building slides with Claude Code or Codex.
+
+```sh
+pnpm create sl-ide my-deck
+# or: npm create sl-ide@latest my-deck · bun create sl-ide my-deck
+```
+
+It asks a few questions, then:
+
+1. Clones the **latest** sl-ide template from GitHub, keeping its history as
+   the `upstream` remote, so `git pull upstream main` brings later editor
+   updates into your deck. The editor isn't bundled in this package, so every
+   new deck starts from the template's current `main`.
+2. Creates the deck's own GitHub repo (private by default).
+3. Sets it up to publish to [sl-ide cloud](https://sl-ide.com): signs you in
+   through your browser, saves a token for your team, writes
+   `sl-ide.config.json` and sets the repo's `SL_IDE_PUBLISH_TOKEN` secret.
+   Every push to `main` then updates `sl-ide.com/d/my-deck/`.
+4. Runs `pnpm install`.
+
+Then `cd my-deck && pnpm dev`, open Claude Code or Codex there, and run
+`/new-deck`.
+
+## Options
+
+```
+--dir <path>                    folder for the deck (default ./<name>)
+--github <private|public|none>  the deck's repo (default private)
+--team <slug>                   the sl-ide cloud team that owns the deck
+--share <team|public>           who can open its link (default team)
+--no-publish                    skip sl-ide cloud
+--no-install                    skip pnpm install
+--no-open                       print the sign-in link instead of opening it
+-y, --yes                       take the defaults instead of asking
+```
+
+```sh
+pnpm create sl-ide login     # sign in and save a token for a team
+pnpm create sl-ide logout    # forget saved tokens
+```
+
+Tokens are saved in `~/.config/sl-ide/credentials.json`, readable only by
+you, and can be revoked at sl-ide.com/tokens.
+
+Needs Node 20.12+, git and pnpm, plus the GitHub CLI (`gh`) for the repo
+and publishing.

package/index.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+// pnpm create sl-ide [name] [options]   (also npm create sl-ide, bunx create-sl-ide)
+//
+// Starts a new deck: clones the latest sl-ide template from GitHub (with its
+// history, as `upstream`, so `git pull upstream main` brings later editor
+// updates), creates the deck's own repo, sets it up to publish to sl-ide
+// cloud, and installs dependencies. The editor itself is never bundled here,
+// so a new deck always starts from the template's main.
+//
+//   pnpm create sl-ide login     sign in to sl-ide cloud and save a team token
+//   pnpm create sl-ide logout    forget saved tokens
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import * as p from '@clack/prompts';
+import { CLOUD, credsPath, deviceLogin, forget, legacyToken, readCreds, saveToken, slugAvailable, whoami } from './lib/cloud.mjs';
+import { ghReady, has, run } from './lib/run.mjs';
+
+const TEMPLATE = process.env.SL_IDE_TEMPLATE || 'https://github.com/dberm312/sl-ide-template.git';
+const SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+
+const HELP = `
+  pnpm create sl-ide [name] [options]
+
+  Start a new deck from the latest sl-ide template.
+
+  Options
+    --dir <path>             folder to create the deck in (default: ./<name>)
+    --github <private|public|none>   the deck's GitHub repo (default: private)
+    --team <slug>            the sl-ide cloud team that owns the deck
+    --share <team|public>    who can open its link (default: team)
+    --no-publish             don't set up publishing to sl-ide cloud
+    --no-install             skip pnpm install
+    --no-open                print the sign-in link instead of opening a browser
+    -y, --yes                take the defaults instead of asking
+    -h, --help
+
+  Commands
+    login                    sign in to sl-ide cloud and save a team token
+    logout [team]            forget saved tokens
+
+  Every push to the deck's repo publishes it to ${CLOUD}/d/<name>/.
+`;
+
+const { values: o, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    dir: { type: 'string' },
+    github: { type: 'string' },
+    team: { type: 'string' },
+    share: { type: 'string' },
+    publish: { type: 'boolean', default: true },
+    'no-publish': { type: 'boolean' },
+    install: { type: 'boolean', default: true },
+    'no-install': { type: 'boolean' },
+    open: { type: 'boolean', default: true },
+    'no-open': { type: 'boolean' },
+    yes: { type: 'boolean', short: 'y' },
+    help: { type: 'boolean', short: 'h' },
+  },
+});
+if (o['no-publish']) o.publish = false;
+if (o['no-install']) o.install = false;
+if (o['no-open']) o.open = false;
+if (o.help) { console.log(HELP); process.exit(0); }
+
+const interactive = process.stdin.isTTY && !o.yes;
+const bail = (msg) => { p.cancel(msg); process.exit(1); };
+const ask = async (prompt) => {
+  const v = await prompt;
+  if (p.isCancel(v)) bail('Cancelled.');
+  return v;
+};
+
+// --- sign-in ---------------------------------------------------------------
+
+async function signIn() {
+  const s = p.spinner();
+  const got = await deviceLogin({
+    open: o.open,
+    onCode: (code, url) => {
+      p.note(`${url}\n\nCode: ${code}`, o.open ? 'Approve in your browser' : 'Open this link to approve');
+      s.start('Waiting for approval');
+    },
+  }).catch((e) => { s.stop('Sign-in failed'); bail(e.message); });
+  s.stop(`Signed in for team ${got.team}`);
+  saveToken(got.team, got.token);
+  return got;
+}
+
+// A token for the deck's team: a saved one, the legacy admin token, or a new
+// browser sign-in. Returns { team, token } or null to skip publishing.
+async function publishCredentials() {
+  const saved = readCreds().teams;
+  const teams = Object.keys(saved);
+  const admin = legacyToken();
+
+  if (o.team) {
+    if (!SLUG_RE.test(o.team)) bail(`--team "${o.team}" isn't a team slug`);
+    if (saved[o.team]) return { team: o.team, token: saved[o.team].token };
+    if (admin) return { team: o.team, token: admin };
+    p.log.info(`No saved token for team ${o.team}. Sign in to make one.`);
+    const got = await signIn();
+    if (got.team !== o.team) p.log.warn(`You approved team ${got.team}; publishing for that team instead.`);
+    return got;
+  }
+
+  if (!interactive) {
+    if (teams.length === 1) return { team: teams[0], token: saved[teams[0]].token };
+    p.log.warn('Not publishing: pass --team <slug>, or run pnpm create sl-ide login first.');
+    return null;
+  }
+
+  const choice = await ask(p.select({
+    message: 'Publish this deck to sl-ide cloud?',
+    options: [
+      ...teams.map((t) => ({ value: `team:${t}`, label: `Yes, for team ${t}` })),
+      { value: 'login', label: teams.length ? 'Yes, for another team (sign in)' : 'Yes (sign in to sl-ide cloud)', hint: 'opens your browser' },
+      { value: 'skip', label: 'Not now', hint: 'add sl-ide.config.json later' },
+    ],
+  }));
+  if (choice === 'skip') return null;
+  if (choice === 'login') return signIn();
+  const team = choice.slice(5);
+  return { team, token: saved[team].token };
+}
+
+// --- commands --------------------------------------------------------------
+
+async function login() {
+  p.intro('sl-ide cloud');
+  await signIn();
+  p.outro(`Saved to ${credsPath}. New decks can publish for this team.`);
+}
+
+function logout() {
+  forget(positionals[1]);
+  console.log(positionals[1] ? `Forgot the token for ${positionals[1]}.` : 'Forgot all saved sl-ide tokens.');
+}
+
+async function create() {
+  p.intro('sl-ide · new deck');
+
+  let name = positionals[0];
+  if (!name) {
+    if (!interactive) bail('Give the deck a name: pnpm create sl-ide my-deck');
+    name = await ask(p.text({
+      message: 'Deck name',
+      placeholder: 'acme-pitch',
+      validate: (v) => (/^[A-Za-z0-9._-]+$/.test(v ?? '') ? undefined : 'Letters, digits, . _ and - only'),
+    }));
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(name)) bail(`"${name}" isn't a valid name (letters, digits, . _ -)`);
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  if (!SLUG_RE.test(slug)) bail(`can't make a link name from "${name}"`);
+
+  const dest = path.resolve(o.dir ?? name);
+  if (fs.existsSync(dest) && fs.readdirSync(dest).length) bail(`${dest} already exists and isn't empty`);
+
+  for (const tool of ['git', 'pnpm']) {
+    if (!has(tool)) bail(tool === 'pnpm' ? 'pnpm is needed: corepack enable pnpm' : 'git is needed');
+  }
+
+  // GitHub repo
+  let github = o.github;
+  const gh = ghReady();
+  if (!github) {
+    github = !gh ? 'none'
+      : interactive ? await ask(p.select({
+        message: 'GitHub repo for the deck',
+        options: [
+          { value: 'private', label: 'Private', hint: 'recommended' },
+          { value: 'public', label: 'Public' },
+          { value: 'none', label: 'None for now' },
+        ],
+      })) : 'private';
+    if (!gh) p.log.warn('GitHub CLI not signed in (gh auth login), so no repo will be made. Publishing needs one.');
+  }
+  if (!['private', 'public', 'none'].includes(github)) bail('--github is private, public or none');
+  if (github !== 'none' && !gh) bail('gh is not installed or not signed in: gh auth login');
+  let owner = null;
+  if (github !== 'none') {
+    owner = await run('gh', ['api', 'user', '-q', '.login']);
+    const exists = await run('gh', ['repo', 'view', `${owner}/${name}`]).then(() => true, () => false);
+    if (exists) bail(`github.com/${owner}/${name} already exists`);
+  }
+
+  // Publishing
+  let pub = null;
+  let share = o.share ?? 'team';
+  if (o.publish && github !== 'none') {
+    pub = await publishCredentials();
+    if (pub) {
+      const ok = await whoami(pub.token);
+      if (!ok) bail(`The saved token for ${pub.team} was rejected (revoked?). Run: pnpm create sl-ide login`);
+      const avail = await slugAvailable(pub.token, slug);
+      if (!avail.available) bail(`Can't publish as ${slug}: ${avail.reason}. Pick another name.`);
+      if (avail.exists) p.log.warn(`Team ${pub.team} already has a deck called ${slug}; this one will publish over it.`);
+      if (!o.share && interactive) {
+        share = await ask(p.select({
+          message: 'Who can open its link?',
+          options: [
+            { value: 'team', label: `Team ${pub.team} only`, hint: 'signed in' },
+            { value: 'public', label: 'Anyone with the link' },
+          ],
+        }));
+      }
+      if (!['team', 'public'].includes(share)) bail('--share is team or public');
+    }
+  } else if (o.publish && github === 'none') {
+    p.log.info('Publishing runs in GitHub Actions, so it is off without a repo.');
+  }
+
+  // Do it
+  const s = p.spinner();
+  try {
+    s.start('Cloning the latest sl-ide template');
+    await run('git', ['clone', '-q', TEMPLATE, dest]);
+    await run('git', ['remote', 'rename', 'origin', 'upstream'], { cwd: dest });
+    await run('git', ['config', 'pull.rebase', 'false'], { cwd: dest });
+    const head = await run('git', ['log', '-1', '--format=%h %s'], { cwd: dest });
+    s.stop(`Cloned sl-ide (${head.split(' ')[0]})`);
+
+    if (pub) {
+      const config = { slug, team: pub.team, visibility: share };
+      fs.writeFileSync(path.join(dest, 'sl-ide.config.json'), `${JSON.stringify(config, null, 2)}\n`);
+      await run('git', ['add', 'sl-ide.config.json'], { cwd: dest });
+      await run('git', ['-c', 'core.hooksPath=/dev/null', 'commit', '-q', '-m', `Publish to sl-ide cloud as ${slug} (${share}, team ${pub.team})`], { cwd: dest });
+    }
+
+    if (github !== 'none') {
+      s.start(`Creating github.com/${owner}/${name}`);
+      await run('gh', ['repo', 'create', name, `--${github}`, '--source', '.', '--remote', 'origin'], { cwd: dest });
+      // Before the first push, so its CI run publishes.
+      if (pub) await run('gh', ['secret', 'set', 'SL_IDE_PUBLISH_TOKEN', '--repo', `${owner}/${name}`], { cwd: dest, input: pub.token });
+      await run('git', ['push', '-q', '-u', 'origin', 'main'], { cwd: dest });
+      s.stop(`Created github.com/${owner}/${name} (${github})`);
+    }
+
+    if (o.install) {
+      s.start('Installing dependencies');
+      await run('pnpm', ['install', '--silent'], { cwd: dest });
+      s.stop('Installed dependencies');
+    }
+  } catch (e) {
+    s.stop('Stopped');
+    bail(e.message);
+  }
+
+  const rel = path.relative(process.cwd(), dest) || '.';
+  const lines = [
+    `cd ${rel}`,
+    ...(o.install ? [] : ['pnpm install']),
+    'pnpm dev',
+    '',
+    'Then open Claude Code or Codex in that folder and run /new-deck',
+    '(Codex: $new-deck) to learn your style and outline the story.',
+  ];
+  p.note(lines.join('\n'), 'Next');
+  if (pub) {
+    p.log.success(`Every push to main publishes ${CLOUD}/d/${slug}/ (${share === 'public' ? 'anyone with the link' : `team ${pub.team}`}).`);
+  } else {
+    p.log.info('Not publishing. To publish later, add sl-ide.config.json (see the deck\'s README).');
+  }
+  p.outro('Deck ready.');
+}
+
+const cmd = positionals[0];
+if (cmd === 'login') await login();
+else if (cmd === 'logout') logout();
+else await create();

package/lib/cloud.mjs

@@ -0,0 +1,92 @@
+// sl-ide cloud: saved credentials, browser sign-in, and the API calls the
+// create flow needs. Credentials live in ~/.config/sl-ide/credentials.json
+// (mode 600): one publish token per team.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+export const CLOUD = (process.env.SL_IDE_URL || 'https://sl-ide.com').replace(/\/$/, '');
+const CONF = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'sl-ide');
+const CREDS = path.join(CONF, 'credentials.json');
+const LEGACY = path.join(CONF, 'publish-token');
+
+export function readCreds() {
+  try {
+    const c = JSON.parse(fs.readFileSync(CREDS, 'utf8'));
+    return { teams: {}, ...c };
+  } catch {
+    return { teams: {} };
+  }
+}
+
+export function saveToken(team, token) {
+  const c = readCreds();
+  c.url = CLOUD;
+  c.teams[team] = { token, savedAt: new Date().toISOString() };
+  fs.mkdirSync(CONF, { recursive: true });
+  fs.writeFileSync(CREDS, `${JSON.stringify(c, null, 2)}\n`, { mode: 0o600 });
+  fs.chmodSync(CREDS, 0o600);
+}
+
+export function forget(team) {
+  const c = readCreds();
+  if (team) delete c.teams[team];
+  else c.teams = {};
+  if (fs.existsSync(CREDS)) fs.writeFileSync(CREDS, `${JSON.stringify(c, null, 2)}\n`, { mode: 0o600 });
+}
+
+// An admin token from before team tokens existed: publishes for any team.
+export function legacyToken() {
+  try { return fs.readFileSync(LEGACY, 'utf8').trim() || null; } catch { return null; }
+}
+
+export const credsPath = CREDS;
+
+async function api(pathname, { token, method = 'GET', body } = {}) {
+  const res = await fetch(`${CLOUD}${pathname}`, {
+    method,
+    headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...(body ? { 'Content-Type': 'application/json' } : {}) },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const json = await res.json().catch(() => ({}));
+  return { status: res.status, ok: res.ok, json };
+}
+
+// Is the saved token still good? -> { team } or null.
+export async function whoami(token) {
+  const r = await api('/api/cli/whoami', { token }).catch(() => null);
+  return r?.ok ? r.json : null;
+}
+
+export async function slugAvailable(token, slug) {
+  const r = await api(`/api/cli/slug/${slug}`, { token });
+  return r.ok ? r.json : { available: false, reason: r.json.error || `HTTP ${r.status}` };
+}
+
+export function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref();
+  } catch { /* no browser: the URL is printed anyway */ }
+}
+
+// Browser sign-in. onCode(user_code, url) is called once, to show the code;
+// resolves { team, token } once a team member approves it at sl-ide.com/cli.
+export async function deviceLogin({ onCode, open = true }) {
+  const start = await api('/api/cli/login/start', { method: 'POST', body: { client: os.hostname().replace(/\.local$/, '') } });
+  if (!start.ok) throw new Error(`could not reach ${CLOUD} (${start.status})`);
+  const { device_code: device, user_code: code, verification_uri_complete: url, interval = 2, expires_in: ttl = 600 } = start.json;
+  onCode(code, url);
+  if (open) openBrowser(url);
+  const until = Date.now() + ttl * 1000;
+  while (Date.now() < until) {
+    await new Promise((r) => setTimeout(r, interval * 1000));
+    const r = await api('/api/cli/login/poll', { method: 'POST', body: { device_code: device } }).catch(() => null);
+    if (!r || r.status === 202) continue;
+    if (r.ok && r.json.token) return { team: r.json.team, token: r.json.token };
+    throw new Error('the sign-in code expired; run the command again');
+  }
+  throw new Error('the sign-in code expired; run the command again');
+}

package/lib/run.mjs

@@ -0,0 +1,23 @@
+import { spawn, spawnSync } from 'node:child_process';
+
+// Run a command; resolve its stdout, reject with its stderr.
+export function run(cmd, args, { cwd, input, quiet = true } = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(cmd, args, { cwd, stdio: [input == null ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    p.stdout.on('data', (d) => { out += d; if (!quiet) process.stdout.write(d); });
+    p.stderr.on('data', (d) => { err += d; });
+    if (input != null) { p.stdin.write(input); p.stdin.end(); }
+    p.on('error', reject);
+    p.on('close', (code) => (code === 0 ? resolve(out.trim()) : reject(new Error(`${cmd} ${args.join(' ')}: ${err.trim() || `exit ${code}`}`))));
+  });
+}
+
+export function has(cmd) {
+  return spawnSync(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' }).status === 0;
+}
+
+export function ghReady() {
+  return has('gh') && spawnSync('gh', ['auth', 'status'], { stdio: 'ignore' }).status === 0;
+}

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "create-sl-ide",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Start a slide deck with sl-ide: pnpm create sl-ide",
+  "type": "module",
+  "bin": {
+    "create-sl-ide": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=20.12"
+  },
+  "keywords": [
+    "sl-ide",
+    "slides",
+    "deck",
+    "presentation",
+    "claude-code",
+    "codex",
+    "create"
+  ],
+  "homepage": "https://sl-ide.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dberm312/create-sl-ide.git"
+  },
+  "author": "David Berman",
+  "packageManager": "pnpm@12.11.2",
+  "dependencies": {
+    "@clack/prompts": "^1.8.1"
+  }
+}