k0-board 0.1.2 → 0.3.0

package/server/index.js

@@ -3,8 +3,9 @@ import fs from 'node:fs'
 import path from 'node:path'
 import crypto from 'node:crypto'
 import * as db from './db.js'
+import { allowed } from './guard.js'
 import { ROOT } from './paths.js'
-import { readLiveSessions, deriveStatus, forgetSession, renameSession } from './watcher.js'
+import { readLiveSessions, deriveStatus, forgetSession, renameSession, busy } from './watcher.js'
 import {
   launch,
   focusWindow,
@@ -15,12 +16,17 @@ import {
   relayoutWindows,
 } from './launcher.js'
 import * as mode from './mode.js'
+import * as settings from './settings.js'
+import { dueForClose } from './idle.js'
 import { listProjects, onDisk, projectName } from './projects.js'
 import { scanSessions } from './sessions.js'
 import * as git from './git.js'
+import * as changelog from './changelog.js'
+import * as writer from './writer.js'
 import * as files from './files.js'
 import * as pdf from './pdf.js'
 import * as machine from './machine.js'
+import * as servers from './servers.js'
 import { report as platformReport } from '../platform/index.js'
 // The same front-matter reader the viewer uses: the PDF has to be called what the page is
 // called, and two different readings of the same header would give two different names.
@@ -61,44 +67,56 @@ function tick() {
   // The power levers are checked once a minute rather than every round: reading the power
   // state costs processes, and the things it has to follow — the mains plugged in or out, the
   // battery going down — do not change from one second to the next.
-  if (rounds++ % 60 === 0) mode.guard()
+  if (rounds % 60 === 0) mode.guard()
+  // The forgotten terminals, on the same cadence but half a minute off it, so the two jobs that
+  // only run once a minute never land in the same second as each other.
+  if (rounds % 60 === 30) sweepIdle(live)
+  rounds++
+}
+
+/**
+ * Gives back the memory of the windows you have stopped using.
+ *
+ * It does exactly what the `Close` link on a card does, and on purpose the same three moves and
+ * not a path of its own: stop the session, shut the window, forget the window. The card stays
+ * where it is with the status it had, `session_id` is untouched, and `Resume` picks the
+ * conversation up where it was — a closed terminal is not a lost session.
+ *
+ * Deliberately not awaited by `tick`: closing a terminal waits up to two seconds for the process
+ * to go, and the watching loop must not be held up by it. Hence the latch, the same one
+ * `machine.js` and `servers.js` keep for their own sampling — `setInterval` will happily start a
+ * second round on top of the first.
+ */
+let sweeping = false
+async function sweepIdle(live) {
+  if (sweeping) return
+  const hours = settings.read().closeIdleTerminalsAfterHours
+  const due = dueForClose({ cards: db.listCards(), live, hours })
+  if (!due.length) return
+  sweeping = true
+  try {
+    for (const card of due) {
+      try {
+        await closeTerminal({ winId: card.terminal_window_id, pid: live.get(card.session_id)?.pid })
+        db.setTerminalWindow(card.id, null) // that window is gone; Resume opens a new one
+        db.setAutoClosed(card.id, true)
+        console.log(`k0 — "${card.title}" sat still for ${hours}h: its terminal is closed, Resume picks it up`)
+      } catch (err) {
+        // One window that refuses to go must not take the others with it, and must certainly not
+        // take the server: nothing is awaiting this, so a rejection escaping here would end the
+        // process outright. It runs unattended — the next round is the retry.
+        console.error(`k0 — could not close the terminal of "${card.title}": ${String(err?.message || err)}`)
+      }
+    }
+  } finally {
+    sweeping = false
+  }
 }
 
 /** When somebody last looked at the board. */
 let lastBoard = 0
 setInterval(tick, 1000)
 
-// ── Who is allowed to talk to this server ────────────────────────────────────
-// k0 listens on the loopback interface only, which keeps the rest of the network out. What it
-// does not keep out is a web page open in your browser: any site can make requests to
-// 127.0.0.1, and this API opens terminals and starts sessions.
-//
-// Two checks close that door.
-//
-// The `Host` header must be one we recognise. A page cannot forge it, and requiring it stops
-// DNS rebinding — the trick where a hostile domain resolves to 127.0.0.1 so the browser thinks
-// it is talking to its own site.
-//
-// The `Origin` header, when there is one, must be ours. Browsers attach it to every
-// cross-origin request and to every same-origin POST, so a hostile page is always identified.
-// Things that are not browsers — the menu bar icon, curl, the import skill — send none, and
-// they are let through: they are already running as you, on your machine, and a header would
-// not tell us anything a hostile process could not also write.
-const ALLOWED_HOSTS = new Set(
-  ['127.0.0.1', 'localhost', 'k0.localhost', '[::1]'].map((h) => `${h}:${PORT}`)
-)
-const ALLOWED_ORIGINS = new Set(
-  ['127.0.0.1', 'localhost', 'k0.localhost', '[::1]'].map((h) => `http://${h}:${PORT}`)
-)
-
-function allowed(req) {
-  const host = String(req.headers.host || '')
-  if (!ALLOWED_HOSTS.has(host)) return false
-  const origin = req.headers.origin
-  if (origin && !ALLOWED_ORIGINS.has(origin)) return false
-  return true
-}
-
 // ── API ──────────────────────────────────────────────────────────────────────
 const MIME = {
   '.html': 'text/html; charset=utf-8',
@@ -170,6 +188,9 @@ function board() {
     load: machine.loadOf(live.get(c.session_id)?.pid),
   }))
   const paths = [...new Set(cards.map((c) => c.project_path))]
+  // And the same for the dev servers: looking at the board is what makes k0 ask the machine
+  // who is listening, and it asks only about the repositories in front of you.
+  servers.touch(paths)
 
   // Live sessions no card claims: they weigh the same, and if the computer is struggling it is
   // fair to know there are three of them open outside here.
@@ -180,7 +201,14 @@ function board() {
     // The columns are the projects with at least one card — and that still exist: a card is
     // kept alive by its directory (see `onDisk` in projects.js).
     columns: paths
-      .map((p) => ({ path: p, name: projectName(p), git: publicGit(git.stateOf(p)) }))
+      .map((p) => ({
+        path: p,
+        name: projectName(p),
+        git: publicGit(git.stateOf(p)),
+        // Null where the repository has no way to start a server: then there is no globe at
+        // all, rather than one that would do nothing.
+        server: servers.stateOf(p),
+      }))
       .sort((a, b) => a.name.localeCompare(b.name)),
     cards,
     // The repositories for the last column, the one you go through to reach the files of a
@@ -203,6 +231,10 @@ function board() {
     mode: mode.current(),
     lid: mode.lid(),
     reason: mode.reason(),
+    // After how long a forgotten terminal is closed, so the machine chip can say that it is
+    // watching and after how long. Zero means it is switched off, and then the chip says nothing
+    // rather than saying "0h" — a number that would read as "closes immediately".
+    closeIdleAfterHours: settings.read().closeIdleTerminalsAfterHours,
     // What this machine can and cannot do, so the board greys out the rest and says why
     // instead of offering a button that quietly does nothing.
     platform: platformReport(),
@@ -309,6 +341,50 @@ function site(req, res, seg) {
 // is a much smaller loss than that, so the header is gone.
 const SANDBOX = 'sandbox'
 
+// ── The recap of a window ────────────────────────────────────────────────────
+// Held for a minute, and not as a saved result: the page asks for the facts, then asks for the
+// write-up to start, then asks every second whether it is done. Reading every repository's git
+// history once a second to answer "not yet" would be absurd. Nothing is written down, and a
+// minute later the same question is asked of git again from scratch.
+const RECAP_TTL = 60000
+let recap = null
+
+async function recapFor(raw, { fresh = true } = {}) {
+  const period = changelog.PERIODS.includes(raw) ? raw : 'last'
+  // The page asks about the write-up once a second until it is done, and a model can take
+  // longer than a minute: those questions must reuse whatever window is already open, or a
+  // slow answer would mean a full sweep of every repository's git, every second, while waiting.
+  if (recap && recap.period === period && (!fresh || Date.now() - recap.at < RECAP_TTL)) return recap
+  const data = await changelog.facts(period)
+  recap = {
+    period,
+    at: Date.now(),
+    // The window is part of the name: at midnight "yesterday" becomes a different day, and a
+    // summary written for the old one must not be handed over as if it were the new one.
+    key: `${data.period}:${data.from}:${data.to}`,
+    public: data,
+    payload: JSON.stringify(
+      {
+        period: data.period,
+        from: new Date(data.from).toISOString(),
+        to: new Date(data.to).toISOString(),
+        totals: data.totals,
+        repositories: data.repos.map((r) => ({
+          name: r.name,
+          commits: r.commits.map(({ at, subject, body, online }) => ({ at, subject, body, online })),
+          unpushed_total: r.unpushedTotal,
+          uncommitted_files: r.dirty.map((f) => f.path),
+          unreleased_changelog: r.unreleased,
+          cards: r.cards,
+        })),
+      },
+      null,
+      2
+    ),
+  }
+  return recap
+}
+
 async function api(req, res, url) {
   const seg = url.pathname.split('/').filter(Boolean) // ['api', 'card', '3', 'start']
   const [, resource, idRaw, action] = seg
@@ -318,6 +394,20 @@ async function api(req, res, url) {
   if (resource === 'status' && req.method === 'GET') return send(res, 200, status())
   if (resource === 'projects' && req.method === 'GET') return send(res, 200, listProjects())
 
+  // ── What you have been doing ───────────────────────────────────────────────
+  // Two halves, deliberately apart. The facts come back straight away and the page can already
+  // show them; the write-up takes a model half a minute, so it is started and then asked
+  // about, the same once-a-second poll the board and the viewer already live on.
+  if (resource === 'changelog' && !idRaw && req.method === 'GET') {
+    const data = await recapFor(url.searchParams.get('period'))
+    return send(res, 200, { ...data.public, writer: writer.capability() })
+  }
+  if (resource === 'changelog' && idRaw === 'write') {
+    const data = await recapFor(url.searchParams.get('period'), { fresh: false })
+    if (req.method === 'POST') return send(res, 200, writer.write(data.key, data.payload))
+    if (req.method === 'GET') return send(res, 200, writer.state(data.key))
+  }
+
   // ── The four modes ─────────────────────────────────────────────────────────
   // One control, with two handles: the row of buttons on the board and the four entries in the
   // menu bar. The text in terminals that are already open changes STRAIGHT AWAY, not only in
@@ -333,6 +423,25 @@ async function api(req, res, url) {
     return send(res, 200, { mode: mode.current(), lid: mode.lid(), reason: mode.reason() })
   }
 
+  // ── The dev server of a repository ─────────────────────────────────────────
+  // The globe in the column heading. One address for the three gestures, because they are the
+  // same gesture with different endings — and `restart` really is stop-then-start, not a third
+  // path through the same code.
+  //
+  // The repository is not taken on trust. It arrives from the page as a plain path and it is a
+  // path k0 is about to RUN something in, so it goes through the same allowlist the file viewer
+  // uses: a directory k0 already knows as a project, or nothing at all.
+  if (resource === 'server' && req.method === 'POST') {
+    const b = await readBody(req)
+    const repo = rootOf(b.path)
+    if (!repo) return send(res, 404, { error: 'k0 does not know that repository.' })
+    const action = b.action
+    if (action === 'start') return send(res, 200, await servers.start(repo))
+    if (action === 'stop') return send(res, 200, await servers.stop(repo))
+    if (action === 'restart') return send(res, 200, await servers.restart(repo))
+    return send(res, 400, { error: 'That is not something a server can be asked to do.' })
+  }
+
   // The screen changed under the windows: a monitor plugged in or unplugged, a different
   // resolution. This puts them all back in the middle of what is there now, as they were the
   // day they were born. The menu bar icon calls it, being the one piece of k0 that sees that
@@ -552,6 +661,22 @@ async function api(req, res, url) {
       return send(res, 200, await focusWindow(card.terminal_window_id))
     }
 
+    // Closing the terminal without closing the work: the same two moves as Done — stop the
+    // session, shut its window — and none of the marking. The card stays where it is, with the
+    // status it had, and Resume picks the conversation up where it was.
+    if (req.method === 'POST' && action === 'close') {
+      if (!card.session_id) return send(res, 400, { error: 'This card has no session' })
+      // The board is up to a second behind, so a card that was idle when it was clicked may have
+      // started thinking since. Nothing that is working gets stopped from here.
+      if (busy(card.status)) return send(res, 409, { error: 'It is working: let it finish' })
+      const pid = readLiveSessions().get(card.session_id)?.pid
+      const out = await closeTerminal({ winId: card.terminal_window_id, pid })
+      db.setTerminalWindow(id, null) // that window is gone; Resume opens a new one
+      db.setAutoClosed(id, false) // this one was you: the card must not say otherwise
+      tick() // so the answer already carries the closed card, without waiting for the loop
+      return send(res, 200, { ...out, card: db.getCard(id) })
+    }
+
     if (req.method === 'POST' && (action === 'start' || action === 'resume')) {
       const resuming = action === 'resume' && card.session_id
       const sessionId = resuming ? card.session_id : crypto.randomUUID()
@@ -567,6 +692,7 @@ async function api(req, res, url) {
       try {
         const out = await launch({ card: db.getCard(id), sessionId, mode: resuming ? 'resume' : 'start' })
         db.setTerminalWindow(id, out.winId)
+        db.setAutoClosed(id, false) // there is a window again: whoever shut the last one is history
         tick()
         return send(res, 200, { ...out, card: db.getCard(id) })
       } catch (err) {
@@ -589,13 +715,23 @@ function serveStatic(res, pathname) {
     res.writeHead(404).end('Not found')
     return
   }
-  res.writeHead(200, { 'content-type': MIME[path.extname(file)] || 'application/octet-stream' })
+  // Nothing here is cached, and that is deliberate. These files have no version in their names
+  // and nothing rebuilds them, so with no instruction at all the browser decides for itself how
+  // long to keep them — and a tab left open all day keeps the stylesheet it loaded that morning.
+  // That turns "change a file, reload the page" into a promise k0 does not keep, and it does the
+  // same after an update: the new app on disk, the old interface on screen. They are a few
+  // kilobytes over loopback; there is nothing to save here and a whole class of confusion to
+  // avoid.
+  res.writeHead(200, {
+    'content-type': MIME[path.extname(file)] || 'application/octet-stream',
+    'cache-control': 'no-cache, no-store, must-revalidate',
+  })
   fs.createReadStream(file).pipe(res)
 }
 
 http
   .createServer(async (req, res) => {
-    if (!allowed(req)) {
+    if (!allowed(req.headers, PORT)) {
       res.writeHead(403, { 'content-type': 'text/plain; charset=utf-8' })
       res.end('k0 only answers to its own address on this machine.')
       return
@@ -609,6 +745,9 @@ http
     }
   })
   .listen(PORT, '127.0.0.1', () => {
+    // The settings file, written out with everything in it the first time k0 runs: it is the only
+    // list of what can be changed, so it has to exist before anybody goes looking for it.
+    settings.ensure()
     tick()
     // The mode is remembered, and at startup it puts the machine back as it was: the sleep
     // levers and, where needed, the font size of terminals left open. The server restarts often
@@ -631,6 +770,8 @@ process.on('exit', mode.stopNow)
 for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
   process.on(signal, () => {
     mode.stopNow()
+    // A summary being written when the server goes down has nobody left to give it to.
+    writer.stop()
     process.exit(0)
   })
 }

package/server/launcher.js

@@ -105,7 +105,11 @@ export async function launch({ card, sessionId, mode = 'start' }) {
   const up = await waitForSession(sessionId)
 
   if (autoSend) return { name, up, winId, pasted: true, autoSent: true }
-  if (!up || !card.prompt?.trim()) return { name, up, winId, pasted: false }
+  // The prompt belongs to the beginning. Resuming picks up a conversation that answered it hours
+  // ago, and putting it back under the cursor is at best a stale instruction in the way — at
+  // worst it is sent, because where pasting is unavailable the fallback below types it. This
+  // matters more now that k0 closes forgotten terminals by itself: a Resume is no longer rare.
+  if (resume || !up || !card.prompt?.trim()) return { name, up, winId, pasted: false }
 
   await waitForPrompt(winId)
 

package/server/machine.js

@@ -123,6 +123,15 @@ async function cycle() {
 setInterval(cycle, TTL).unref()
 
 // ── What is known right now ───────────────────────────────────────────────────
+/**
+ * The process table as it was last sampled, for whoever needs to walk it rather than weigh it —
+ * today that is `servers.js`, which follows a dev server down to whichever of its children is
+ * actually holding the port. Null until the first cycle has run: the caller decides what a
+ * missing sample means, and re-reading the table here to fill the gap would undo the whole
+ * point of only sampling while somebody is looking.
+ */
+export const tree = () => (snap ? { procs: snap.procs, kids: snap.kids } : null)
+
 /**
  * What a session weighs: its whole subtree. `top` is the three biggest processes inside it,
  * and that is the answer to "why is this terminal eating so much".

package/server/paths.js

@@ -12,10 +12,11 @@ import { fileURLToPath } from 'node:url'
  * there is on borrowed time. Data now lives in a directory owned by the user, and the
  * installed copy of the app is disposable.
  *
- *   ~/.k0/k0.db      the board
- *   ~/.k0/app/       the installed copy of k0 (written by `k0-board install`)
- *   ~/.k0/logs/      service stdout/stderr
- *   ~/.k0/cache/     pasted images, the Chrome profile used for PDF export
+ *   ~/.k0/k0.db        the board
+ *   ~/.k0/config.json  the settings, written out with everything in it on the first run
+ *   ~/.k0/app/         the installed copy of k0 (written by `k0-board install`)
+ *   ~/.k0/logs/        service stdout/stderr
+ *   ~/.k0/cache/       pasted images, the Chrome profile used for PDF export
  *
  * On Windows the same tree goes under %LOCALAPPDATA%\k0, which is the local-only,
  * not-roamed location Windows expects for this kind of state.