design-share 0.1.0

package/src/detect.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { git, tryGit } from './git.js';
+
+const CONFIG_FILE = '.design-share.json';
+
+export async function detectRepo(cwd) {
+  let root;
+  try {
+    root = await git(cwd, ['rev-parse', '--show-toplevel']);
+  } catch {
+    throw new Error('not inside a git repository. cd into your project repo and run npx design-share again.');
+  }
+  const remote = await tryGit(root, ['remote', 'get-url', 'origin']);
+  return { root, name: path.basename(root), remote };
+}
+
+export async function detectIdentity(repoRoot) {
+  const name = (await tryGit(repoRoot, ['config', 'user.name'])) || '';
+  const email = (await tryGit(repoRoot, ['config', 'user.email'])) || '';
+  let slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '');
+  if (!slug && email) slug = email.split('@')[0].toLowerCase().replace(/[^a-z0-9]+/g, '');
+  if (!slug) slug = 'designer';
+  return { name: name.trim() || slug, email: email.trim(), slug };
+}
+
+export async function currentBranch(repoRoot) {
+  const b = await tryGit(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  return b === 'HEAD' ? null : b;
+}
+
+export function readRepoConfig(repoRoot) {
+  const p = path.join(repoRoot, CONFIG_FILE);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeRepoConfig(repoRoot, config) {
+  const p = path.join(repoRoot, CONFIG_FILE);
+  fs.writeFileSync(p, JSON.stringify(config, null, 2) + '\n');
+  return p;
+}
+
+// Returns { type: 'command'|'static', command?, dir?, source, label }
+export function detectPreview(repoRoot) {
+  const saved = readRepoConfig(repoRoot);
+  if (saved && saved.preview && saved.preview.type) {
+    return { ...saved.preview, source: 'config' };
+  }
+
+  const pkgPath = path.join(repoRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    let pkg;
+    try { pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8')); } catch { pkg = null; }
+    const scripts = (pkg && pkg.scripts) || {};
+    const deps = { ...(pkg && pkg.dependencies), ...(pkg && pkg.devDependencies) };
+    const pick = ['dev', 'start', 'storybook', 'serve'].find((s) => scripts[s]);
+    if (pick) {
+      let label = `npm run ${pick}`;
+      if (deps.vite) label += ' (vite)';
+      else if (deps.next) label += ' (next)';
+      else if (deps['@storybook/cli'] || pick === 'storybook') label += ' (storybook)';
+      return { type: 'command', command: `npm run ${pick}`, source: 'package.json', label };
+    }
+  }
+
+  if (fs.existsSync(path.join(repoRoot, 'index.html'))) {
+    return { type: 'static', dir: '.', source: 'index.html', label: 'static folder' };
+  }
+
+  return null;
+}

package/src/git.js

@@ -0,0 +1,47 @@
+import { execFile } from 'node:child_process';
+
+export function git(repoRoot, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    execFile('git', args, {
+      cwd: repoRoot,
+      maxBuffer: 16 * 1024 * 1024,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0', ...opts.env },
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const e = new Error((stderr || err.message).trim());
+        e.code = err.code;
+        e.stderr = stderr;
+        reject(e);
+      } else {
+        resolve(stdout.replace(/\n$/, ''));
+      }
+    });
+  });
+}
+
+export function gitInput(repoRoot, args, input, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = execFile('git', args, {
+      cwd: repoRoot,
+      maxBuffer: 16 * 1024 * 1024,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0', ...opts.env },
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const e = new Error((stderr || err.message).trim());
+        e.stderr = stderr;
+        reject(e);
+      } else {
+        resolve(stdout.replace(/\n$/, ''));
+      }
+    });
+    child.stdin.end(input);
+  });
+}
+
+export async function tryGit(repoRoot, args, opts = {}) {
+  try {
+    return await git(repoRoot, args, opts);
+  } catch {
+    return null;
+  }
+}

package/src/menubar.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const APP_SOURCE = path.join(PKG_ROOT, 'dist', 'DesignShare.app');
+const APP_TARGET = path.join(os.homedir(), 'Applications', 'DesignShare.app');
+
+function run(cmd, args) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, (err, stdout, stderr) => {
+      if (err) reject(new Error((stderr || err.message).trim()));
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+export function appAvailable() {
+  return process.platform === 'darwin' && fs.existsSync(APP_SOURCE);
+}
+
+export function appInstalled() {
+  return fs.existsSync(APP_TARGET);
+}
+
+export async function installApp() {
+  if (process.platform !== 'darwin') throw new Error('the menu bar app is macOS only.');
+  if (!fs.existsSync(APP_SOURCE)) {
+    throw new Error('the menu bar app is not bundled in this package build. run scripts/build-app.sh first.');
+  }
+  fs.mkdirSync(path.dirname(APP_TARGET), { recursive: true });
+  fs.rmSync(APP_TARGET, { recursive: true, force: true });
+  // ditto preserves the bundle structure and extended attributes, including the signature.
+  await run('ditto', [APP_SOURCE, APP_TARGET]);
+  return APP_TARGET;
+}
+
+export async function launchApp() {
+  await run('open', ['-g', APP_TARGET]);
+}
+
+export async function quitApp() {
+  try {
+    await run('osascript', ['-e', 'tell application "DesignShare" to quit']);
+  } catch { /* not running */ }
+}

package/src/previews.js

@@ -0,0 +1,240 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { git, tryGit } from './git.js';
+
+const URL_RE = /(https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d+[^\s'"]*)/;
+const START_TIMEOUT_MS = 90_000;
+const MIME = {
+  '.html': 'text/html', '.js': 'text/javascript', '.mjs': 'text/javascript',
+  '.css': 'text/css', '.json': 'application/json', '.svg': 'image/svg+xml',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+  '.ico': 'image/x-icon', '.woff': 'font/woff', '.woff2': 'font/woff2', '.webp': 'image/webp',
+  '.mp4': 'video/mp4', '.txt': 'text/plain',
+};
+
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function portFree(port) {
+  return new Promise((resolve) => {
+    const probe = net.createServer();
+    probe.once('error', () => resolve(false));
+    probe.listen(port, '127.0.0.1', () => probe.close(() => resolve(true)));
+  });
+}
+
+async function findFreePort(start) {
+  let port = start;
+  while (!(await portFree(port))) port++;
+  return port;
+}
+
+export class PreviewManager {
+  constructor(repoRoot, previewConfig, identity) {
+    this.repoRoot = repoRoot;
+    this.previewConfig = previewConfig;
+    this.identity = identity;
+    this.previews = new Map(); // key user/branch -> record
+    this.nextPort = 4501;
+    this.worktreeBase = path.join(repoRoot, '.design-share', 'worktrees');
+  }
+
+  ensureExcluded() {
+    // Keeps the hidden worktree area out of git status for everyone,
+    // without touching the repo's committed .gitignore.
+    try {
+      const exclude = path.join(this.repoRoot, '.git', 'info', 'exclude');
+      const line = '.design-share/';
+      const cur = fs.existsSync(exclude) ? fs.readFileSync(exclude, 'utf8') : '';
+      if (!cur.split('\n').includes(line)) {
+        fs.mkdirSync(path.dirname(exclude), { recursive: true });
+        fs.writeFileSync(exclude, cur + (cur.endsWith('\n') || cur === '' ? '' : '\n') + line + '\n');
+      }
+    } catch { /* non fatal */ }
+  }
+
+  get(key) {
+    return this.previews.get(key);
+  }
+
+  statuses() {
+    const out = {};
+    for (const [key, p] of this.previews) {
+      out[key] = {
+        status: p.status, url: p.url, commit: p.commit || null,
+        error: p.error || null, logTail: p.log.slice(-1600),
+      };
+    }
+    return out;
+  }
+
+  async ensureOwn(branch) {
+    const key = `${this.identity.slug}/${branch}`;
+    const existing = this.previews.get(key);
+    if (existing && existing.status !== 'error' && existing.status !== 'stopped') return existing;
+    const commit = await tryGit(this.repoRoot, ['rev-parse', 'HEAD']);
+    return this.start(key, { cwd: this.repoRoot, commit, own: true });
+  }
+
+  async ensureBranch(user, branch, ownBranch) {
+    if (user === this.identity.slug && branch === ownBranch) {
+      return this.ensureOwn(branch);
+    }
+    const key = `${user}/${branch}`;
+    await tryGit(this.repoRoot, ['fetch', '--quiet', 'origin', branch]);
+    const commit = await tryGit(this.repoRoot, ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`])
+      || await tryGit(this.repoRoot, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]);
+    if (!commit) {
+      const rec = this.record(key);
+      rec.status = 'error';
+      rec.error = `branch ${branch} was not found on origin. the author may not have pushed yet.`;
+      return rec;
+    }
+
+    const existing = this.previews.get(key);
+    if (existing && existing.status !== 'error' && existing.status !== 'stopped') {
+      if (existing.commit !== commit && existing.worktree) {
+        await tryGit(existing.worktree, ['checkout', '--quiet', '--detach', commit]);
+        existing.commit = commit;
+      }
+      return existing;
+    }
+
+    this.ensureExcluded();
+    const safe = `${user}__${branch}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    const wt = path.join(this.worktreeBase, safe);
+    if (fs.existsSync(path.join(wt, '.git'))) {
+      await tryGit(wt, ['checkout', '--quiet', '--detach', commit]);
+    } else {
+      fs.mkdirSync(this.worktreeBase, { recursive: true });
+      await tryGit(this.repoRoot, ['worktree', 'prune']);
+      await git(this.repoRoot, ['worktree', 'add', '--quiet', '--detach', wt, commit]);
+    }
+
+    // Dev servers need dependencies. Borrow the root install when present.
+    const rootModules = path.join(this.repoRoot, 'node_modules');
+    const wtModules = path.join(wt, 'node_modules');
+    if (fs.existsSync(rootModules) && !fs.existsSync(wtModules) && fs.existsSync(path.join(wt, 'package.json'))) {
+      try { fs.symlinkSync(rootModules, wtModules, 'dir'); } catch { /* non fatal */ }
+    }
+
+    return this.start(key, { cwd: wt, commit, worktree: wt });
+  }
+
+  record(key) {
+    let rec = this.previews.get(key);
+    if (!rec) {
+      rec = { status: 'idle', url: null, log: '', proc: null };
+      this.previews.set(key, rec);
+    }
+    return rec;
+  }
+
+  async start(key, { cwd, commit, worktree, own }) {
+    const rec = this.record(key);
+    rec.status = 'starting';
+    rec.url = null;
+    rec.error = null;
+    rec.log = '';
+    rec.commit = commit;
+    rec.worktree = worktree || null;
+    rec.own = !!own;
+    rec.startedAt = Date.now();
+
+    const cfg = this.previewConfig;
+    if (!cfg) {
+      rec.status = 'error';
+      rec.error = 'no preview command configured for this repo.';
+      return rec;
+    }
+
+    if (cfg.type === 'static') {
+      const dir = path.resolve(cwd, cfg.dir || '.');
+      const server = http.createServer((req, res) => serveStatic(dir, req, res));
+      server.listen(0, '127.0.0.1', () => {
+        rec.url = `http://localhost:${server.address().port}/`;
+        rec.status = 'ready';
+      });
+      rec.server = server;
+      return rec;
+    }
+
+    const port = await findFreePort(this.nextPort);
+    this.nextPort = port + 1;
+    const proc = spawn(cfg.command, {
+      cwd,
+      shell: true,
+      detached: true,
+      env: { ...process.env, PORT: String(port), BROWSER: 'none' },
+    });
+    rec.proc = proc;
+
+    const onData = (buf) => {
+      const text = stripAnsi(buf.toString());
+      rec.log = (rec.log + text).slice(-8000);
+      if (!rec.url) {
+        const m = text.match(URL_RE);
+        if (m) {
+          rec.url = m[1].replace('0.0.0.0', 'localhost').replace('127.0.0.1', 'localhost');
+          rec.status = 'ready';
+        }
+      }
+    };
+    proc.stdout.on('data', onData);
+    proc.stderr.on('data', onData);
+    proc.on('exit', (code) => {
+      if (rec.status !== 'ready' || code !== 0) {
+        rec.status = rec.status === 'ready' ? 'stopped' : 'error';
+        if (rec.status === 'error') rec.error = `preview command exited with code ${code}.`;
+      } else {
+        rec.status = 'stopped';
+      }
+      rec.proc = null;
+    });
+
+    setTimeout(() => {
+      if (rec.status === 'starting') {
+        rec.status = 'error';
+        rec.error = 'could not detect a preview URL from the command output.';
+      }
+    }, START_TIMEOUT_MS).unref();
+
+    return rec;
+  }
+
+  stopAll() {
+    for (const [, rec] of this.previews) {
+      if (rec.proc && rec.proc.pid) {
+        try { process.kill(-rec.proc.pid, 'SIGTERM'); } catch { /* gone */ }
+      }
+      if (rec.server) {
+        try { rec.server.close(); } catch { /* gone */ }
+      }
+    }
+  }
+}
+
+export function serveStatic(root, req, res) {
+  try {
+    const urlPath = decodeURIComponent(new URL(req.url, 'http://x').pathname);
+    let filePath = path.normalize(path.join(root, urlPath));
+    if (!filePath.startsWith(root)) {
+      res.writeHead(403); res.end('forbidden'); return;
+    }
+    if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+      filePath = path.join(filePath, 'index.html');
+    }
+    if (!fs.existsSync(filePath)) {
+      res.writeHead(404); res.end('not found'); return;
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+    fs.createReadStream(filePath).pipe(res);
+  } catch {
+    res.writeHead(500); res.end('error');
+  }
+}

package/src/registry.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// The menu bar app reads this registry to know which repos have daemons,
+// where they listen, and how to respawn one that died with the terminal.
+const DIR = path.join(os.homedir(), '.design-share');
+const FILE = path.join(DIR, 'daemons.json');
+const CONFIG = path.join(DIR, 'config.json');
+
+function readJson(file, fallback) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+
+function writeJson(file, data) {
+  fs.mkdirSync(DIR, { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
+}
+
+export function readRegistry() {
+  return readJson(FILE, { repos: {} });
+}
+
+export function upsertDaemon(repoRoot, entry) {
+  const reg = readRegistry();
+  reg.repos[repoRoot] = { ...reg.repos[repoRoot], ...entry, updatedAt: Date.now() };
+  writeJson(FILE, reg);
+}
+
+export function removeDaemon(repoRoot) {
+  const reg = readRegistry();
+  delete reg.repos[repoRoot];
+  writeJson(FILE, reg);
+}
+
+export function readUserConfig() {
+  return readJson(CONFIG, {});
+}
+
+export function writeUserConfig(patch) {
+  writeJson(CONFIG, { ...readUserConfig(), ...patch });
+}

package/src/server.js

@@ -0,0 +1,214 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import http from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { tryGit } from './git.js';
+import { currentBranch } from './detect.js';
+import { serveStatic } from './previews.js';
+
+const PUBLIC_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'public');
+const SYNC_INTERVAL_MS = 15_000;
+const FETCH_INTERVAL_MS = 60_000;
+
+function json(res, code, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+  res.end(body);
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', (c) => { data += c; if (data.length > 1_000_000) req.destroy(); });
+    req.on('end', () => {
+      try { resolve(data ? JSON.parse(data) : {}); } catch (e) { reject(e); }
+    });
+    req.on('error', reject);
+  });
+}
+
+export class DesignShareServer {
+  constructor({ repo, identity, store, previews, port }) {
+    this.repo = repo;
+    this.identity = identity;
+    this.store = store;
+    this.previews = previews;
+    this.port = port;
+    this.server = null;
+    this.timers = [];
+  }
+
+  async branchHeads() {
+    const heads = {};
+    const raw = await tryGit(this.repo.root, [
+      'for-each-ref', '--format=%(refname)%09%(objectname)%09%(committerdate:unix)%09%(authorname)',
+      'refs/heads', 'refs/remotes/origin',
+    ]);
+    if (raw) {
+      for (const line of raw.split('\n')) {
+        const [ref, sha, time, author] = line.split('\t');
+        if (!ref || ref.endsWith('/HEAD')) continue;
+        const branch = ref.replace(/^refs\/heads\//, '').replace(/^refs\/remotes\/origin\//, '');
+        const isRemote = ref.startsWith('refs/remotes/');
+        // Remote tip wins as the shared truth; local tip fills gaps.
+        if (!heads[branch] || isRemote) {
+          heads[branch] = { sha, time: Number(time) || 0, author: author || '' };
+        }
+      }
+    }
+    return heads;
+  }
+
+  async board() {
+    const ownBranch = await currentBranch(this.repo.root);
+    const ownHead = await tryGit(this.repo.root, ['rev-parse', 'HEAD']);
+    const heads = await this.branchHeads();
+    const state = this.store.state;
+    const shares = Object.values(state.shares || {}).filter((s) => s.active);
+    const sharedBranchSet = new Set(shares.map((s) => s.branch));
+    const defaultish = new Set(['main', 'master', 'develop', 'dev']);
+    const others = Object.entries(heads)
+      .filter(([b]) => !sharedBranchSet.has(b) && !defaultish.has(b) && b !== ownBranch)
+      .map(([branch, h]) => ({ branch, ...h }))
+      .sort((a, b) => b.time - a.time)
+      .slice(0, 30);
+
+    return {
+      repo: { name: this.repo.name, remote: this.repo.remote, root: this.repo.root },
+      me: this.identity,
+      ownBranch,
+      ownHead,
+      port: this.port,
+      shares,
+      heads,
+      otherBranches: others,
+      comments: Object.values(state.comments || {}),
+      previews: this.previews.statuses(),
+      sync: {
+        hasRemote: this.store.hasRemote,
+        lastSync: this.store.lastSync,
+        lastSyncError: this.store.lastSyncError,
+      },
+    };
+  }
+
+  async handle(req, res) {
+    const url = new URL(req.url, `http://localhost:${this.port}`);
+    const p = url.pathname;
+
+    try {
+      if (p.startsWith('/api/')) {
+        if (req.method === 'GET' && p === '/api/board') {
+          return json(res, 200, await this.board());
+        }
+        if (req.method === 'POST' && p === '/api/share') {
+          const body = await readBody(req);
+          const branch = body.branch || (await currentBranch(this.repo.root));
+          this.store.share({ branch, title: body.title });
+          this.syncSoon();
+          return json(res, 200, { ok: true, branch });
+        }
+        if (req.method === 'POST' && p === '/api/unshare') {
+          const body = await readBody(req);
+          this.store.unshare(body.branch);
+          this.syncSoon();
+          return json(res, 200, { ok: true });
+        }
+        if (req.method === 'POST' && p === '/api/comments') {
+          const body = await readBody(req);
+          const heads = await this.branchHeads();
+          const ownBranch = await currentBranch(this.repo.root);
+          let commit = heads[body.branch] ? heads[body.branch].sha : null;
+          if (body.branch === ownBranch) {
+            commit = await tryGit(this.repo.root, ['rev-parse', 'HEAD']);
+          }
+          const id = this.store.addComment({
+            targetUser: body.targetUser,
+            branch: body.branch,
+            route: body.route || '/',
+            xPct: body.xPct,
+            yPct: body.yPct,
+            viewportLabel: body.viewportLabel || 'desktop',
+            viewportW: body.viewportW,
+            viewportH: body.viewportH,
+            commit,
+            text: String(body.text || '').slice(0, 4000),
+          });
+          this.syncSoon();
+          return json(res, 200, { ok: true, id });
+        }
+        const replyMatch = p.match(/^\/api\/comments\/([a-z0-9]+)\/replies$/);
+        if (req.method === 'POST' && replyMatch) {
+          const body = await readBody(req);
+          this.store.reply(replyMatch[1], String(body.text || '').slice(0, 4000));
+          this.syncSoon();
+          return json(res, 200, { ok: true });
+        }
+        const resolveMatch = p.match(/^\/api\/comments\/([a-z0-9]+)\/resolve$/);
+        if (req.method === 'POST' && resolveMatch) {
+          const body = await readBody(req);
+          this.store.setResolved(resolveMatch[1], body.resolved !== false);
+          this.syncSoon();
+          return json(res, 200, { ok: true });
+        }
+        if (req.method === 'POST' && p === '/api/preview/start') {
+          const body = await readBody(req);
+          const ownBranch = await currentBranch(this.repo.root);
+          const rec = await this.previews.ensureBranch(body.user, body.branch, ownBranch);
+          return json(res, 200, {
+            ok: true,
+            status: rec.status, url: rec.url, error: rec.error || null, logTail: rec.log ? rec.log.slice(-1600) : '',
+          });
+        }
+        return json(res, 404, { error: 'not found' });
+      }
+
+      // Dashboard static files
+      if (p === '/' || p === '/index.html') {
+        res.writeHead(200, { 'Content-Type': 'text/html', 'Cache-Control': 'no-store' });
+        return res.end(fs.readFileSync(path.join(PUBLIC_DIR, 'index.html')));
+      }
+      return serveStatic(PUBLIC_DIR, req, res);
+    } catch (err) {
+      return json(res, 500, { error: err.message });
+    }
+  }
+
+  syncSoon() {
+    clearTimeout(this._syncSoonTimer);
+    this._syncSoonTimer = setTimeout(() => this.store.sync(), 800);
+  }
+
+  listen() {
+    return new Promise((resolve, reject) => {
+      const attempt = (port, remaining) => {
+        const server = http.createServer((req, res) => this.handle(req, res));
+        server.once('error', (err) => {
+          if (err.code === 'EADDRINUSE' && remaining > 0) {
+            attempt(port + 1, remaining - 1);
+          } else {
+            reject(err);
+          }
+        });
+        server.listen(port, '127.0.0.1', () => {
+          this.port = port;
+          this.server = server;
+          this.timers.push(setInterval(() => this.store.sync(), SYNC_INTERVAL_MS));
+          this.timers.push(setInterval(
+            () => tryGit(this.repo.root, ['fetch', '--quiet', 'origin']),
+            FETCH_INTERVAL_MS,
+          ));
+          resolve(port);
+        });
+      };
+      attempt(this.port, 20);
+    });
+  }
+
+  close() {
+    this.timers.forEach(clearInterval);
+    clearTimeout(this._syncSoonTimer);
+    if (this.server) this.server.close();
+    this.previews.stopAll();
+  }
+}