clickroom 0.3.4 → 0.3.5

package/cli/push.js

@@ -7,6 +7,7 @@ import { BACKUP_DIR, copyBuild, cloudUrl, buildPages, baseUrl, localUrl, isTeamm
 import { call } from './client.js';
 import { dim } from './dev.js';
 import { rememberFolder } from './changes.js';
+import { serversInProject, probe } from './detect.js';
 
 const OUT_DIRS = ['dist', 'build', 'out', '.output/public'];
 
@@ -98,11 +99,16 @@ export async function push(name, local, { note, live = false, build, out, quiet
   } else {
     const pkgDir = packageDir(dir, local.cwd);
     const cmd = command || buildScript(pkgDir);
-    if (!cmd) throw new NoSnapshot(`No build script in ${path.join(pkgDir || dir, 'package.json')}, so there's nothing to snapshot.`);
-    const started = Date.now();
-    if (!quiet) console.log(dim(`  Building v${next}: ${cmd}`));
-    await run(cmd, pkgDir || dir);
-    source = out || local.out ? path.resolve(pkgDir || dir, out || local.out) : findOutput(pkgDir || dir, started);
+    // No build step: a folder of plain web files (served by any little server) is its own snapshot.
+    const plain = !cmd && [pkgDir || dir, ...OUT_DIRS.map((d) => path.join(pkgDir || dir, d))].find((d) => fs.existsSync(path.join(d, 'index.html')));
+    if (plain) source = plain;
+    else if (!cmd) throw new NoSnapshot(`No build script in ${path.join(pkgDir || dir, 'package.json')}, so there's nothing to snapshot.`);
+    else {
+      const started = Date.now();
+      if (!quiet) console.log(dim(`  Building v${next}: ${cmd}`));
+      await run(cmd, pkgDir || dir);
+      source = out || local.out ? path.resolve(pkgDir || dir, out || local.out) : findOutput(pkgDir || dir, started);
+    }
     if (!source) throw new NoSnapshot(`The build finished, but no folder with an index.html was produced (looked in ${OUT_DIRS.join(', ')}).`);
   }
   if (!fs.existsSync(path.join(source, 'index.html'))) throw new NoSnapshot(`${source} has no index.html.`);
@@ -213,6 +219,59 @@ export async function backup(name) {
 }
 
 // Nearest folder with a package.json, from where clickroom was run up to the project root.
+// No dev server running (the owner's Live view): start the project's own (`npm run dev`, else
+// `start`) for as long as the session runs. { target, how, stop } once it answers in this project,
+// null without such a script.
+export async function startDevServer(root, { exclude = [] } = {}) {
+  const dir = packageDir(root, root);
+  if (!dir) return null;
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+  } catch {
+    return null;
+  }
+  const script = ['dev', 'start'].find((s) => pkg.scripts?.[s]);
+  if (!script) return null;
+  const pm = packageManager(dir);
+  const cmd = `${pm} run ${script}`;
+  if (Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).length && !fs.existsSync(path.join(dir, 'node_modules'))) {
+    console.log(dim(`  Installing the project's packages (${pm} install; the first time only, this can take a minute)…`));
+    await run(`${pm} install`, dir).catch((err) => {
+      throw new FolderProblem(`Installing the project's packages failed.\n${err.message.replace(/^.*\n/, '')}`, `${pm} install fails in this project; please fix it, then run npx clickroom again.`);
+    });
+  }
+  console.log(dim(`  No dev server running, so clickroom starts it: ${cmd}`));
+  // Its own process group, so stopping it also stops what it started (vite, next, …).
+  const child = spawn(cmd, { cwd: dir, shell: true, detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, BROWSER: 'none', FORCE_COLOR: '0' } });
+  let log = '';
+  const keep = (d) => (log = (log + d).slice(-4000));
+  child.stdout.on('data', keep);
+  child.stderr.on('data', keep);
+  let exited = false;
+  child.on('exit', () => (exited = true));
+  child.on('error', () => (exited = true));
+  const stop = () => {
+    try {
+      if (process.platform === 'win32') child.kill();
+      else process.kill(-child.pid, 'SIGTERM');
+    } catch {}
+  };
+  for (let i = 0; i < 90 && !exited; i++) {
+    await new Promise((r) => setTimeout(r, 1000));
+    const own = await serversInProject(root, { exclude });
+    for (const s of own) {
+      const p = await probe(s.port);
+      if (p.ok && p.html) return { target: `http://localhost:${s.port}`, how: `${cmd}, started by clickroom`, stop };
+    }
+  }
+  stop();
+  throw new FolderProblem(
+    `${exited ? `\`${cmd}\` stopped` : `\`${cmd}\` didn't start a web server within 90 seconds`}:\n${log.trim().split('\n').slice(-8).map((l) => '    ' + l).join('\n')}`,
+    `\`${cmd}\` doesn't start the dev server in this project; please fix it, then run npx clickroom again.`,
+  );
+}
+
 function packageDir(dir, root) {
   let d = path.resolve(dir);
   const stop = path.resolve(root || dir);

package/cli/share.js

@@ -6,7 +6,7 @@ import { readLocal, writeLocal, copyBuild, cloudUrl, baseUrl, isTeammate, adminT
 import { call, isUp, signinLink } from './client.js';
 import { projectRoot, projectName, parseTarget, detectTarget } from './detect.js';
 import { startServer, bold, dim } from './dev.js';
-import { push, pushHint, backup, NoSnapshot, FolderProblem, prepareFolder, projectFolder } from './push.js';
+import { push, pushHint, backup, NoSnapshot, FolderProblem, prepareFolder, projectFolder, startDevServer } from './push.js';
 import { folderChanges } from './changes.js';
 import { connectAgents, agentsReport } from './agents.js';
 import { autoNote } from './note.js';
@@ -57,6 +57,17 @@ export async function share(arg, opts) {
     const what = await prepareFolder(cwd, root).catch(explain);
     target = what.kind === 'static' ? { kind: 'static', target: null, source: what.source, how: 'the files as they are' } : { kind: 'build', target: null, source: null, how: 'each push runs its build' };
   }
+  // Nothing running in this project: clickroom starts the project's own dev server (until q), and
+  // a folder of plain web files needs none: its files are the versions.
+  let dev = null;
+  if (!teammate && !arg && (!target || target.uncertain)) {
+    dev = await startDevServer(root, { exclude: [port, 9229, 9230] }).catch(explain);
+    if (dev) {
+      target = { kind: 'url', target: dev.target, how: dev.how };
+      process.on('exit', dev.stop); // also when the session ends with an error
+    }
+    else if (fs.existsSync(path.join(root, 'index.html'))) target = { kind: 'static', target: null, source: root, how: 'the files as they are' };
+  }
   if (!target) {
     throw new Error(
       'No running dev server found for this project.\n' +
@@ -79,8 +90,17 @@ export async function share(arg, opts) {
     console.log(dim(`  Sharing through ${cloud} as you`));
   } else if (cloud) {
     console.log(dim(`  Sharing through ${cloud}`));
+    // The Live view reaches this Mac through the local clickroom server (the relay). Not running
+    // (no `clickroom service`): this session runs it, until q.
     const relay = await fetch(`http://localhost:${port}/__ps/api/health`).then((r) => r.ok, () => false);
-    if (!relay) console.log(dim('  The local clickroom server is not running, so the Live view and app API calls are offline.\n  Start it in the background with `clickroom service install`.'));
+    if (!relay && target.kind === 'url') {
+      console.log(dim('  Starting the local clickroom server for the Live view…'));
+      server = await startServer({ ...opts, port, tunnel: true }).catch((e) => {
+        console.log(dim(`  Couldn't start it (${e.message}), so the Live view is offline; pushed versions work.`));
+        return null;
+      });
+      delete process.env.CLICKROOM_URL; // startServer points the CLI at it; this session talks to the cloud
+    }
   } else if (await isUp()) {
     console.log(dim(`  Attaching to the clickroom server already running on :${port}`));
   } else {
@@ -253,10 +273,11 @@ export async function share(arg, opts) {
   watcher?.close();
   await call('DELETE', `/__ps/api/projects/${encodeURIComponent(name)}/session`).catch(() => {});
   await backup(name);
+  dev?.stop();
   if (server) {
     server.stop();
     await Promise.race([server.exited, new Promise((r) => setTimeout(r, 3000))]);
-    console.log(dim('\n  Tunnel closed.'));
+    console.log(dim(cloud ? '\n  Live view stopped (pushed versions stay online).' : '\n  Tunnel closed.'));
   }
   process.exit(0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clickroom",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Share prototype builds for review: pins, region comments, threads, versions, and agent hand-off (MCP). Teammates push builds to their team’s clickroom with `clickroom login`.",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
     "test": "node --test test/*.test.js",
     "screens": "node examples/screens/build.js",
     "demo:seed": "node examples/demo/seed.js",
+    "release": "npm version patch --no-git-tag-version && npm publish && git commit -am \"$(node -p 'require(\"./package.json\").version')\"",
     "prepublishOnly": "node --test test/detect.test.js test/changes.test.js test/webpush.test.js"
   },
   "engines": {