agent-office-studio 0.7.0 → 0.9.1

package/server/tunnel.js

@@ -0,0 +1,136 @@
+// A public address for the office, so a phone can reach it from anywhere: a
+// Cloudflare quick tunnel. `cloudflared` dials out from this machine and gives
+// back a random https://….trycloudflare.com name that forwards to the office,
+// so nothing listens on the network and no router is touched. No account.
+//
+// It is only ever started by an explicit click, never at boot, and it dies
+// with the office. The address is new every time. Whoever has the link with
+// the key can run Claude here, so the key stays the one thing that matters.
+//
+// It is only called on once the address works from outside: a phone that
+// looks a name up too early caches "no such name" for minutes, and a tunnel
+// can connect yet route nowhere (see emptyConfig). Either way the phone would
+// show a blank page, so the QR waits.
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import https from 'node:https';
+import { Resolver } from 'node:dns/promises';
+
+// cloudflared reads ~/.cloudflared/config.yml even for a quick tunnel, and a
+// named tunnel's ingress there (ending, as they do, in http_status:404) then
+// answers every request to our address with an empty 404: a blank page on the
+// phone. So it gets a config of its own, with nothing in it.
+function emptyConfig() {
+  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'office-tunnel-')), 'config.yml');
+  fs.writeFileSync(file, '');
+  return file;
+}
+
+// Does https://host/ reach this office from the internet? Looked up on public
+// resolvers, not this machine's, which may have cached the name as missing.
+// The office answers a keyless visit with 401, which Cloudflare never sends.
+const resolver = new Resolver({ timeout: 3000, tries: 1 });
+resolver.setServers(['1.1.1.1', '8.8.8.8']);
+export async function reachable(host) {
+  let ip;
+  try { [ip] = await resolver.resolve4(host); } catch { return false; }
+  if (!ip) return false;
+  return new Promise((resolve) => {
+    const req = https.get({ host: ip, servername: host, headers: { host }, path: '/', timeout: 8000 }, (res) => { res.resume(); resolve(res.statusCode === 401); });
+    req.on('timeout', () => req.destroy());
+    req.on('error', () => resolve(false));
+  });
+}
+
+const URL_RE = /https:\/\/([a-z0-9-]+\.trycloudflare\.com)/i;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export class Tunnel {
+  // findBin() gives the cloudflared to run (it may download it, calling
+  // onStep('download')); allow(host) lets the office accept that Host and
+  // forget(host) takes it back; check(host) is the outside check.
+  constructor({ port, allow, forget, findBin, check = reachable, onChange = () => {} }) {
+    Object.assign(this, { port, allow, forget, findBin, check, onChange });
+    this.state = 'off'; // off | starting | on | error
+    this.step = null; // while starting: download | connect | check
+    this.host = null;
+    this.error = null;
+    this.child = null;
+    this.run = 0; // bumped by every start and stop, so a stale run stands down
+  }
+
+  status() {
+    return { state: this.state, step: this.state === 'starting' ? this.step : null, url: this.state === 'on' ? `https://${this.host}` : null, error: this.error };
+  }
+
+  set(state, extra = {}) {
+    Object.assign(this, { state, error: null, ...extra });
+    this.onChange(this.status());
+  }
+
+  start() {
+    if (this.state === 'starting' || this.state === 'on') return this.status();
+    const run = ++this.run;
+    this.set('starting', { host: null, step: 'connect' });
+    this.boot(run).catch((err) => { if (run === this.run) this.fail(err.message); });
+    return this.status();
+  }
+
+  async boot(run) {
+    const bin = await this.findBin((step) => { if (run === this.run) this.set('starting', { step }); });
+    if (run !== this.run) return;
+    this.set('starting', { step: 'connect' });
+    const host = await new Promise((resolve, reject) => {
+      const child = spawn(bin, ['tunnel', '--config', emptyConfig(), '--no-autoupdate', '--url', `http://127.0.0.1:${this.port}`], { stdio: ['ignore', 'ignore', 'pipe'] });
+      this.child = child;
+      let tail = '', name = null;
+      const timer = setTimeout(() => reject(new Error('Timed out waiting for Cloudflare. Check your connection and try again.')), 45000);
+      const done = (fn, v) => { clearTimeout(timer); fn(v); };
+      // The name is printed a second before the connection is up.
+      child.stderr.on('data', (d) => {
+        tail = (tail + d).slice(-4000);
+        const m = !name && URL_RE.exec(tail);
+        if (m && m[1] !== 'api.trycloudflare.com') name = m[1];
+        if (name && /Registered tunnel connection/.test(tail)) done(resolve, name);
+      });
+      child.on('error', (err) => done(reject, new Error(err.code === 'ENOENT' ? 'cloudflared couldn’t be started.' : err.message)));
+      child.on('exit', (code) => {
+        if (this.child !== child) return; // stopped on purpose
+        done(reject, new Error(this.state === 'on' ? 'The public address closed. Make a new one.' : `cloudflared stopped (${code}).`));
+        if (this.state === 'on' && run === this.run) this.fail('The public address closed. Make a new one.');
+      });
+    });
+    if (run !== this.run) return;
+    this.allow(host);
+    this.host = host;
+    this.set('starting', { step: 'check' });
+    for (const end = Date.now() + 90000; Date.now() < end; await sleep(2000)) {
+      if (run !== this.run) return;
+      if (await this.check(host)) { if (run === this.run) this.set('on', { host }); return; }
+    }
+    throw new Error('Cloudflare connected, but the address doesn’t reach this office from outside. Try again in a minute.');
+  }
+
+  fail(message) {
+    this.run++;
+    this.drop();
+    this.set('error', { error: message, host: null });
+  }
+
+  drop() {
+    const child = this.child;
+    this.child = null;
+    if (this.host) this.forget(this.host);
+    if (child) { try { child.kill('SIGTERM'); } catch {} }
+  }
+
+  stop() {
+    this.run++;
+    this.drop();
+    this.set('off', { host: null });
+    return this.status();
+  }
+}

package/server/visits.js

@@ -19,10 +19,11 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFile, spawn } from 'node:child_process';
-import { snapshotTree, summarize, fileDiff } from './changes.js';
+import { snapshotTree, summarize, fileDiff, noFilters } from './changes.js';
 
 export const ACCESS = ['off', 'read', 'edit'];
 const MAX_OPEN = 3; // working visits per guest link
+const MAX_COPIES = 6; // copies on disk per guest link, working or waiting for review
 const MAX_READ = 24 * 1024; // what one answer carries, under the relay's 64 KB a frame
 const MAX_WRITE = 40 * 1024; // what one write may carry, likewise
 const MAX_FILE = 2 * 1024 * 1024; // the most a file may grow to
@@ -112,6 +113,11 @@ export class Visits {
       this.push(v);
       return { sid: v.sid, access };
     }
+    // Each new job of theirs is a whole copy of the project, so they can't
+    // leave more than a few lying about.
+    if (this.list.filter((x) => x.guest.link === link.id && !x.applied && !x.discarded && fs.existsSync(x.dir)).length >= MAX_COPIES) {
+      throw fail(429, `You have ${MAX_COPIES} copies of this office’s projects open or waiting for review. Ask the owner to apply or discard some first.`);
+    }
     const src = this.office.repoPath(repo);
     if (!src) throw fail(404, 'That project folder is gone.');
     const base = await snapshotTree(src);
@@ -122,7 +128,7 @@ export class Visits {
     const idx = tmpIndex();
     try {
       await git(src, ['read-tree', base], { GIT_INDEX_FILE: idx });
-      await git(src, [`--work-tree=${dir}`, 'checkout-index', '-a', '-f'], { GIT_INDEX_FILE: idx });
+      await git(src, [...await noFilters(src), `--work-tree=${dir}`, 'checkout-index', '-a', '-f'], { GIT_INDEX_FILE: idx });
     } catch (err) {
       fs.rmSync(dir, { recursive: true, force: true });
       throw fail(500, `Could not copy ${repo}: ${String(err.stderr || err.message).slice(0, 200)}`);
@@ -347,6 +353,9 @@ export class Visits {
     if (summary) this.log(v, summary, 'text');
     await this.record(v);
     const n = v.changes?.count || 0;
+    // Nothing to review, so nothing to keep: a follow-up gets a fresh copy.
+    // (If the copy couldn't be read there is no telling, so it stays.)
+    if (v.changes && !n) this.drop(v);
     const what = v.access !== 'edit' ? '' : n ? ` ${n} file${n === 1 ? '' : 's'} changed in the copy. Review them on the job and apply or discard.` : ' Nothing changed.';
     this.log(v, `${{ done: 'Finished', failed: 'Hit a wall', stopped: 'Stopped' }[status] || 'Ended'}.${what}`, 'result', { ok: status === 'done' });
     this.push(v);
@@ -369,8 +378,9 @@ export class Visits {
     const idx = tmpIndex();
     try {
       await git(src, ['read-tree', v.base], { GIT_INDEX_FILE: idx });
-      await git(src, [`--work-tree=${v.dir}`, 'add', '-A'], { GIT_INDEX_FILE: idx });
-      return (await git(src, ['write-tree'], { GIT_INDEX_FILE: idx })).trim();
+      const nf = await noFilters(src);
+      await git(src, [...nf, `--work-tree=${v.dir}`, 'add', '-A'], { GIT_INDEX_FILE: idx });
+      return (await git(src, [...nf, `--work-tree=${v.dir}`, 'write-tree'], { GIT_INDEX_FILE: idx })).trim();
     } finally {
       fs.rmSync(idx, { force: true });
     }

package/shared/shop.js

@@ -0,0 +1,134 @@
+// What the office economy pays and sells.
+//
+// Shared by the server (which pays, charges and keeps the books) and the
+// browser (which shows the shop and draws what was bought), so a price or a
+// rate can never mean one thing in the ledger and another on screen.
+
+// Pay. An agent earns by the active minute (time the model was actually
+// working, not time spent waiting on the boss or a colleague) plus a bonus
+// for finishing, and both are scaled by the model that did the work: getting
+// a job done on a lighter model is worth more than brute-forcing it on the
+// heaviest. Only finished jobs pay. A failed or stopped job pays nothing.
+// All money is naira. perMinute and finishBonus are the defaults; the boss
+// sets them in Settings and setPay() applies them, in the server and, from
+// the economy status, in the browser.
+export const PAY = {
+  perMinute: 1000,
+  finishBonus: 2500,
+  // Minutes beyond this on one job are not paid: a job that drags on is not
+  // a job done better.
+  maxMinutes: 60,
+  // The office's cut of every naira an agent earns, for the boss to spend.
+  potShare: 0.4,
+  // A boss's "great work" on a finished job pays its finish bonus again.
+  kudosOncePerJob: true,
+};
+
+export const naira = (v) => `₦${Math.round(Number(v) || 0).toLocaleString('en-NG')}`;
+export function setPay(p = {}) {
+  for (const k of ['perMinute', 'finishBonus']) if (Number.isFinite(p[k]) && p[k] >= 0) PAY[k] = p[k];
+}
+
+export const MODEL_PAY = { haiku: 3, sonnet: 1.75, opus: 1 };
+export const modelTier = (model) => Object.keys(MODEL_PAY).find((t) => String(model || '').includes(t)) || '';
+export const modelPay = (model) => MODEL_PAY[modelTier(model)] || 1;
+
+// The cut, in whole naira. The agent's share is rounded down and the pot
+// takes the rest, so the two always add up to what was earned.
+export function split(gross) {
+  const g = Math.max(0, Math.round(gross));
+  const agent = Math.floor(g * (1 - PAY.potShare));
+  return { gross: g, agent, pot: g - agent };
+}
+
+// Everything for sale. `scope` says who owns it and where it goes:
+//   desk    on one agent's desk; an agent buys it with their own pay, or the
+//           boss buys it for them out of the pot
+//   office  somewhere in the room; bought out of the pot
+//   floor / wall  the room's finish; bought out of the pot, one in use at a time
+//   layout  a different floor plan; free to switch between, one in use at a time
+export const ITEMS = [
+  // desk
+  { id: 'mug', scope: 'desk', name: 'Coffee mug', price: 2000, icon: '☕' },
+  { id: 'duck', scope: 'desk', name: 'Rubber duck', price: 3000, icon: '🦆' },
+  { id: 'cactus', scope: 'desk', name: 'Cactus', price: 3500, icon: '🌵' },
+  { id: 'photo', scope: 'desk', name: 'Photo frame', price: 5000, icon: '🖼️' },
+  { id: 'lamp', scope: 'desk', name: 'Desk lamp', price: 6000, icon: '💡' },
+  { id: 'headphones', scope: 'desk', name: 'Headphones', price: 8000, icon: '🎧' },
+  { id: 'lava', scope: 'desk', name: 'Lava lamp', price: 9000, icon: '🫧' },
+  { id: 'bonsai', scope: 'desk', name: 'Bonsai', price: 12000, icon: '🌳' },
+  { id: 'keyboard', scope: 'desk', name: 'Mechanical keyboard', price: 14000, icon: '⌨️' },
+  { id: 'trophy', scope: 'desk', name: 'Little trophy', price: 15000, icon: '🏆' },
+  { id: 'monitor', scope: 'desk', name: 'Second monitor', price: 20000, icon: '🖥️' },
+  { id: 'chair', scope: 'desk', name: 'Gaming chair', price: 30000, icon: '💺' },
+  { id: 'cat', scope: 'desk', name: 'Desk cat', price: 40000, icon: '🐈' },
+  // office
+  { id: 'neon', scope: 'office', name: 'Neon sign', price: 50000, icon: '🔆' },
+  { id: 'vending', scope: 'office', name: 'Vending machine', price: 70000, icon: '🥤' },
+  { id: 'arcade', scope: 'office', name: 'Arcade cabinet', price: 80000, icon: '🕹️' },
+  { id: 'jukebox', scope: 'office', name: 'Jukebox', price: 90000, icon: '🎵' },
+  { id: 'aquarium', scope: 'office', name: 'Aquarium', price: 120000, icon: '🐠' },
+  { id: 'pingpong', scope: 'office', name: 'Ping-pong table', price: 150000, icon: '🏓' },
+  // floor and walls
+  { id: 'floor-oak', scope: 'floor', name: 'Oak floor', price: 0, color: '#ece3d4', icon: '🟫' },
+  { id: 'floor-walnut', scope: 'floor', name: 'Walnut floor', price: 40000, color: '#b48a63', icon: '🟫' },
+  { id: 'floor-terrazzo', scope: 'floor', name: 'Terrazzo', price: 40000, color: '#e6e1da', icon: '⬜' },
+  { id: 'floor-concrete', scope: 'floor', name: 'Polished concrete', price: 40000, color: '#c9c9c4', icon: '⬛' },
+  { id: 'wall-cream', scope: 'wall', name: 'Cream walls', price: 0, color: '#f5f0e8', icon: '🧱' },
+  { id: 'wall-sage', scope: 'wall', name: 'Sage walls', price: 35000, color: '#d6e2d0', icon: '🧱' },
+  { id: 'wall-navy', scope: 'wall', name: 'Navy walls', price: 35000, color: '#3d4f6e', icon: '🧱' },
+  { id: 'wall-blush', scope: 'wall', name: 'Blush walls', price: 35000, color: '#f1d9d2', icon: '🧱' },
+  // layouts
+  { id: 'layout-classic', scope: 'layout', name: 'Classic', price: 0, icon: '🏢', blurb: 'Two rows of desks, the library and server room on the back wall.' },
+  { id: 'layout-pods', scope: 'layout', name: 'Pods', price: 0, icon: '🧩', blurb: 'Desks in two back-to-back clusters of four, a table and rug between them.' },
+  { id: 'layout-studio', scope: 'layout', name: 'Studio', price: 0, icon: '🎨', blurb: 'One long row of desks along the back, the floor left open for the table and the pool.' },
+  { id: 'layout-campus', scope: 'layout', name: 'Campus', price: 0, icon: '🏛️', blurb: 'Desks facing in round a courtyard, with the pool table at its heart.' },
+];
+
+export const itemById = (id) => ITEMS.find((i) => i.id === id);
+// What every office starts out owning and using.
+export const DEFAULTS = { floor: 'floor-oak', wall: 'wall-cream', layout: 'layout-classic' };
+// The scopes where one choice is in use at a time.
+export const SINGLE = new Set(['floor', 'wall', 'layout']);
+
+// Milestones. Each pays a one-off bonus, split like any pay.
+export const ACHIEVEMENTS = [
+  { id: 'first-job', name: 'First day', blurb: 'Finished a first job.', bonus: 2500, test: (s) => s.jobs >= 1 },
+  { id: 'ten-jobs', name: 'Regular', blurb: 'Finished 10 jobs.', bonus: 10000, test: (s) => s.jobs >= 10 },
+  { id: 'fifty-jobs', name: 'Veteran', blurb: 'Finished 50 jobs.', bonus: 40000, test: (s) => s.jobs >= 50 },
+  { id: 'haiku-hero', name: 'Haiku hero', blurb: 'Finished 5 jobs on Haiku.', bonus: 15000, test: (s) => (s.byTier.haiku || 0) >= 5 },
+  { id: 'lean', name: 'Lean machine', blurb: 'Finished a job on Haiku in under 2 active minutes.', bonus: 5000, test: (s, j) => j?.tier === 'haiku' && j.minutes < 2 },
+  { id: 'kudos', name: 'Great work', blurb: 'Got kudos from the boss.', bonus: 5000, test: (s) => s.kudos >= 1 },
+  { id: 'streak-3', name: 'On a roll', blurb: 'Finished jobs three days running.', bonus: 12000, test: (s) => s.streak >= 3 },
+  { id: 'big-earner', name: 'Big earner', blurb: 'Earned ₦200,000 in all.', bonus: 20000, test: (s) => s.earned >= 200000 },
+  // Quality over volume: none of these scale with the model, so nobody gains
+  // by picking a model for the badge.
+  { id: 'straight-through', name: 'Straight through', blurb: 'Got kudos on a job that never needed reopening.', bonus: 4000, test: (s) => s.cleanKudos >= 1 },
+  { id: 'second-wind', name: 'Second wind', blurb: 'Finished a job again after it was reopened.', bonus: 3000, test: (s) => s.comebacks >= 1 },
+  { id: 'team-player', name: 'Team player', blurb: 'Finished 3 jobs handed over by a colleague.', bonus: 8000, test: (s) => s.handed >= 3 },
+  { id: 'second-eyes', name: 'Second pair of eyes', blurb: 'Finished 3 reviews or test passes for a colleague.', bonus: 8000, test: (s) => s.reviews >= 3 },
+  { id: 'quick-study', name: 'Quick study', blurb: 'Finished a job in under half your usual time (after 5 jobs).', bonus: 5000, test: (s, j) => !!j?.quick },
+  { id: 'shopper', name: 'Treat yourself', blurb: 'Bought something for the desk.', bonus: 1500, test: (s) => s.bought >= 1 },
+];
+
+// Titles, from lifetime earnings. Shown on the name tag and in the chat.
+export const LEVELS = [
+  { at: 0, title: 'Intern' },
+  { at: 25000, title: 'Associate' },
+  { at: 100000, title: 'Specialist' },
+  { at: 300000, title: 'Senior' },
+  { at: 800000, title: 'Principal' },
+  { at: 2000000, title: 'Distinguished' },
+];
+export function levelOf(earned) {
+  let n = 0;
+  LEVELS.forEach((l, i) => { if ((Number(earned) || 0) >= l.at) n = i; });
+  return { n: n + 1, title: LEVELS[n].title, next: LEVELS[n + 1]?.at ?? null };
+}
+
+// A streak of working days lifts the wage (not the finish bonus).
+export const STREAK_BOOST = [{ days: 14, boost: 0.2 }, { days: 7, boost: 0.1 }, { days: 3, boost: 0.05 }];
+export const streakBoost = (days) => STREAK_BOOST.find((b) => days >= b.days)?.boost || 0;
+
+// What a boss may tip from the pot in one go.
+export const TIP = { min: 500, max: 50000, presets: [1000, 5000, 20000] };