cawdev-cli 1.0.5-beta → 1.0.7-beta

package/runner/cawdev.mjs

@@ -29,8 +29,8 @@ import { attach, urlFrom, valueOf } from './attach.mjs';
 import { asker, askOne, mintForThisMachine, setUpThisMachine } from './bootstrap.mjs';
 import { liveSockets, probeSocket, socketPathFor } from './control.mjs';
 import {
-  addProject, addWorkspace, readConfigFile, reloadIfRunning, setAcceptsRulesFromConsole, setQuality,
-  setAgentEnabled,
+  addProject, addWorkspace, readConfigFile, reloadIfRunning, removeProject, setAcceptsRulesFromConsole,
+  setQuality, setAgentEnabled,
 } from './configure.mjs';
 import { restartNeededFor } from '../lib/runner-config.mjs';
 import { Select } from './select.mjs';
@@ -63,6 +63,8 @@ const USAGE = `
   cawdev config add-project              serve one more project you can write to
   cawdev config add-workspace            another checkout for a project you
                                           already serve — R47's concurrency
+  cawdev config remove-project <slug>    stop serving a project (its checkouts
+                                          stay on disk)
   cawdev config agent enable|disable <claude|agy|codex>
   cawdev config rules on|off             accept permission rules from the console
   cawdev config quality on|off <slug>    scan that project's branches with
@@ -422,6 +424,7 @@ async function runVersion(url, ink) {
 /**
  * `cawdev config` — R283's granular half of the setup walk, on a machine
  * already configured. A direct subcommand (`add-project`, `add-workspace`,
+ * `remove-project <slug>`,
  * `agent enable|disable <command>`, `rules on|off`, `quality on|off <slug>`,
  * `show`) or, with none, a
  * menu — the same `Select` widget everything that offers a choice uses.
@@ -463,6 +466,7 @@ export async function pickAction(ask, say, pick = askOne) {
     rows: [
       { id: 'add-project', label: 'Add a project' },
       { id: 'add-workspace', label: 'Add a workspace to a project' },
+      { id: 'remove-project', label: 'Stop serving a project' },
       { id: 'agent-enable', label: `Enable an agent (${KNOWN_AGENTS.join(' / ')})` },
       { id: 'agent-disable', label: 'Disable an agent' },
       { id: 'rules-on', label: 'Accept permission rules from the console' },
@@ -477,6 +481,9 @@ export async function pickAction(ask, say, pick = askOne) {
     const command = (await ask.line(`  Which agent — ${KNOWN_AGENTS.join(', ')}? `)).trim();
     return ['agent', id === 'agent-enable' ? 'enable' : 'disable', command];
   }
+  if (id === 'remove-project') {
+    return ['remove-project', (await ask.line('  Which project (slug)? ')).trim()];
+  }
   if (id === 'rules-on') return ['rules', 'on'];
   if (id === 'rules-off') return ['rules', 'off'];
   if (id === 'quality-on' || id === 'quality-off') {
@@ -507,6 +514,14 @@ export async function runAction([verb, ...rest], { configPath, file, url, sessio
     await reload(await addWorkspace({ configPath, file, url, session, ask, say, ink }));
     return;
   }
+  if (verb === 'remove-project') {
+    const [slug] = rest;
+    if (!slug) {
+      throw new Error('Name a project: cawdev config remove-project <slug>');
+    }
+    await reload(await removeProject({ file, configPath, ask, say, ink, slug }));
+    return;
+  }
   if (verb === 'agent') {
     const [sub, command] = rest;
     if (!KNOWN_AGENTS.includes(command)) {

package/runner/configure.mjs

@@ -345,6 +345,40 @@ export async function setAgentEnabled({
   return next;
 }
 
+/**
+ * Stop serving a project: its entry leaves the config, and nothing else moves.
+ * The checkouts stay on disk — they are somebody's working copies, and
+ * deleting a directory is not a config change — and the machine's token keeps
+ * its grant, which reaches nothing once the project is gone and reaches it
+ * again if it is added back. `projects` is read at boot, so the daemon serves
+ * it until a restart; the reload after this says so.
+ *
+ * The case it exists for: a project deleted in the console is still in this
+ * file, so the terminal kept offering it and the daemon kept polling for it.
+ */
+export async function removeProject({
+  file, configPath, slug,
+  ask, say, ink = painter(3),
+  write = writeRunnerConfig,
+} = {}) {
+  const projects = file.projects ?? {};
+  if (!slug || !(slug in projects)) {
+    throw new Error(`This machine does not serve ${slug || 'that project'}. `
+      + `It serves: ${Object.keys(projects).join(', ') || 'nothing yet'}.`);
+  }
+  const paths = pathsOf(projects[slug]);
+  const kept = paths.length ? ` Its checkout${paths.length === 1 ? '' : 's'} stay${paths.length === 1 ? 's' : ''} on disk: ${paths.join(', ')}.` : '';
+  if (!await confirm(ask, `Stop serving ${slug} on this machine?${kept}`)) {
+    throw new Error('Nothing changed.');
+  }
+  const { [slug]: _removed, ...rest } = projects;
+  const next = { ...file, projects: rest };
+  await write(configPath, next);
+  say(`  ${ink.success('✓')} ${ink.muted(`This machine no longer serves ${slug}.`)}`
+    + (paths.length ? ` ${ink.muted(`Delete ${paths.length === 1 ? 'its checkout' : 'its checkouts'} yourself if you no longer want ${paths.length === 1 ? 'it' : 'them'}.`)}` : ''));
+  return next;
+}
+
 /** Turn `acceptsRulesFromConsole` on or off — R126. */
 export async function setAcceptsRulesFromConsole({
   file, configPath, enabled,

package/runner/input.mjs

@@ -136,25 +136,38 @@ export class History {
     this.draft = '';
   }
 
-  /** Older. Returns null when there is nothing older, so the line is left alone. */
-  back(current = '') {
+  /**
+   * Older. Returns null when there is nothing older, so the line is left alone.
+   *
+   * @param keep which entries this line walks — a command line walks the
+   *   commands and skips the prompts sent to sessions, which it cannot send
+   */
+  back(current = '', keep = () => true) {
     if (this.at === this.entries.length) {
       this.draft = current;
     }
-    if (this.at === 0) {
+    let at = this.at;
+    do {
+      at -= 1;
+    } while (at >= 0 && !keep(this.entries[at]));
+    if (at < 0) {
       return null;
     }
-    this.at -= 1;
-    return this.entries[this.at];
+    this.at = at;
+    return this.entries[at];
   }
 
   /** Newer, ending at the draft you were writing. */
-  forward() {
+  forward(keep = () => true) {
     if (this.at >= this.entries.length) {
       return null;
     }
-    this.at += 1;
-    return this.at === this.entries.length ? this.draft : this.entries[this.at];
+    let at = this.at;
+    do {
+      at += 1;
+    } while (at < this.entries.length && !keep(this.entries[at]));
+    this.at = at;
+    return at === this.entries.length ? this.draft : this.entries[at];
   }
 
   reset() {
@@ -179,7 +192,11 @@ export function completions(text, commands) {
     return [];
   }
   const word = typed.slice(1).toLowerCase();
-  return commands.filter(([name]) => name.slice(1).toLowerCase().startsWith(word));
+  const found = commands.filter(([name]) => name.slice(1).toLowerCase().startsWith(word));
+  // A name typed in full comes first, so enter runs `/log` and not `/login`,
+  // the first longer one in the list.
+  const exact = found.filter(([name]) => name.slice(1).toLowerCase() === word);
+  return [...exact, ...found.filter((row) => !exact.includes(row))];
 }
 
 /**

package/runner/prefs.mjs

@@ -0,0 +1,52 @@
+/**
+ * What this terminal remembers about how you like to work — beside history.mjs
+ * and in its shape: one file under ~/.cawdev, keyed by the platform's URL, 0600.
+ *
+ * One preference so far: the agent `/new` asks for when a command names none
+ * (`/agent codex`). Kept here and not on the platform, because it is a choice
+ * about THIS terminal — the project's default and your account's live in the
+ * console, and this sits in front of them without changing either.
+ *
+ * @author Claude Opus 5.5 (Claude Code)
+ * @author Moez Ben MBarka
+ */
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+export function prefsFile() {
+  return process.env.CAWDEV_PREFS_FILE ?? join(homedir(), '.cawdev', 'terminal.json');
+}
+
+function key(url) {
+  return String(url).replace(/\/+$/, '');
+}
+
+async function readAll() {
+  try {
+    const parsed = JSON.parse(await readFile(prefsFile(), 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** This platform's preferences, `{}` when there are none or the file is unreadable. */
+export async function loadPrefs(url) {
+  const mine = (await readAll())[key(url)];
+  return mine && typeof mine === 'object' ? mine : {};
+}
+
+/** Merges `changes` into this platform's preferences; a null value removes the key. */
+export async function savePrefs(url, changes) {
+  const all = await readAll();
+  const mine = { ...(all[key(url)] ?? {}) };
+  for (const [name, value] of Object.entries(changes)) {
+    if (value === null || value === undefined) delete mine[name];
+    else mine[name] = value;
+  }
+  all[key(url)] = mine;
+  await mkdir(dirname(prefsFile()), { recursive: true, mode: 0o700 });
+  await writeFile(prefsFile(), `${JSON.stringify(all, null, 2)}\n`, { mode: 0o600 });
+  await chmod(prefsFile(), 0o600).catch(() => undefined);
+}

package/runner/restart.mjs

@@ -0,0 +1,191 @@
+// What a daemon that restarted under its sessions does about them — R339.
+//
+// A daemon killed mid-run (most often for memory, by the kernel, while the
+// session ran a test suite) comes back healthy with an empty `running` map.
+// The platform could only infer what happened: five minutes later
+// StaleRunSweeper failed the run as "its runner is alive but stopped driving
+// it", a sentence that names no cause and arrives after somebody has already
+// gone looking. The one process that KNOWS is the new daemon, so the old one
+// leaves a note: the runs it is driving, written beside the socket every time
+// that set changes. On boot the new one reads it and reports each run it no
+// longer holds as DAEMON_RESTARTED, at once.
+//
+// And so it happens less: `sessionMemoryMax` spawns each agent in a systemd
+// scope with a memory ceiling, so a runaway test suite takes down its own
+// session — the ordinary "agent was terminated" path — and not the daemon.
+//
+// Pure where it can be. The file, the scope probe and the kill are the only
+// side effects, and each takes what it touches as an argument.
+
+import { spawn } from 'node:child_process';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+/**
+ * Where a runner's note lives — one per runner id, because one machine may
+ * run two configs. NOT in the run directory, which holds sockets and nothing
+ * else (the terminal lists it to find daemons): beside it, so a test that
+ * points CAWDEV_RUN_DIR at a temporary directory keeps its notes there too.
+ */
+export function drivingPath(runnerId, env = process.env) {
+  const dir = env.CAWDEV_DRIVING_DIR
+    ?? (env.CAWDEV_RUN_DIR ? `${env.CAWDEV_RUN_DIR}-driving` : join(homedir(), '.cawdev', 'driving'));
+  return join(dir, `${runnerId}.json`);
+}
+
+/**
+ * The note: who wrote it and what it was driving. `command` is the child's
+ * command's base name, so the next daemon can tell its own orphan from an
+ * unrelated process that was handed the same pid after a reboot.
+ */
+export function snapshotOf(pid, running) {
+  const runs = [];
+  for (const [id, child] of running) {
+    runs.push({
+      id,
+      projectSlug: child?.cawdevProjectSlug ?? null,
+      childPid: Number.isInteger(child?.pid) ? child.pid : null,
+      command: child?.cawdevCommand ? basename(child.cawdevCommand) : null,
+    });
+  }
+  return { pid, runs };
+}
+
+/** Atomic: a daemon killed mid-write must not leave half a note for the next one. */
+export async function writeDriving(path, snapshot) {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(snapshot), { mode: 0o600 });
+  await rename(temporary, path);
+}
+
+/** The previous note, or null — a missing or unreadable one is "nothing was being driven". */
+export async function readDriving(path) {
+  try {
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    return parsed && Number.isInteger(parsed.pid) && Array.isArray(parsed.runs) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The runs a previous daemon left behind, or none.
+ *
+ * None when the note is this process's own, and none when its writer is
+ * still alive: that is a second daemon on the same runner id, and its runs
+ * are its own business.
+ */
+export function leftBehind(previous, myPid, isAlive) {
+  if (!previous || previous.pid === myPid || isAlive(previous.pid)) {
+    return [];
+  }
+  return previous.runs.filter((run) => typeof run.id === 'string' && run.projectSlug);
+}
+
+/** Whether a pid is a live process. Signal 0 tests without sending. */
+export function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (failure) {
+    return failure.code === 'EPERM';
+  }
+}
+
+/** Live states a restart does not concern: they hold no process. */
+const NOT_DRIVEN = new Set(['QUEUED', 'PAUSED', 'USAGE_LIMITED']);
+
+/**
+ * Whether the platform's view of a run means a restart killed it: live,
+ * holding a process, and still this runner's. A run carried on elsewhere in
+ * the meantime is not ours to fail.
+ */
+export function killedByRestart(run, runnerId) {
+  return Boolean(run?.live)
+    && !NOT_DRIVEN.has(run.state)
+    && (!run.runnerId || run.runnerId === runnerId);
+}
+
+/**
+ * What the run says — the cause, the evidence to look for, and the way out.
+ * `stopped` is the signal a daemon that stopped ON PURPOSE wrote into its
+ * note; without one it was killed, and memory is the usual reason.
+ */
+export function restartSummary({ name, previousPid, pid, orphanStopped, stopped = null }) {
+  const why = stopped
+    ? `It was stopped (${stopped}) — by somebody, or by the service manager restarting it.`
+    : 'Most often the machine ran out of memory — `journalctl -k | grep -i "killed process"` '
+      + 'says so on Linux; `sessionMemoryMax` in the runner config keeps a session from taking '
+      + 'the daemon with it.';
+  return `The cawdev daemon on ${name} restarted while driving this run (it was pid `
+    + `${previousPid}; it is pid ${pid} now), and the agent session went with it. ${why}`
+    + (orphanStopped ? ' The session it left running unattended has been stopped.' : '')
+    + ' The workspace is kept with whatever the session had written: carry it on there, or '
+    + 'discard it.';
+}
+
+// --- the memory ceiling ----------------------------------------------------
+
+/**
+ * `sessionMemoryMax` as systemd reads it — `6G`, `512M`, `75%` — or null.
+ * Anything else is null, and the daemon says so rather than guessing.
+ */
+export function memoryMaxOf(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const text = String(value).trim();
+  return /^\d+(\.\d+)?[KMGT]?$|^\d+(\.\d+)?%$/i.test(text) ? text.toUpperCase() : null;
+}
+
+/**
+ * The command line that runs `command args` under the ceiling — or the same
+ * command line, when there is no ceiling to apply. `systemd-run --scope` execs
+ * the command in place, so the pid, the process group and the pipes are the
+ * agent's own: cancelling (`kill(-pid)`) and the stream readers do not change.
+ */
+export function scoped(command, args, scope) {
+  if (!scope?.memoryMax) {
+    return { command, args };
+  }
+  return {
+    command: 'systemd-run',
+    args: [`--${scope.manager}`, '--scope', '--quiet', '--collect', '--no-ask-password',
+      '-p', `MemoryMax=${scope.memoryMax}`, '--', command, ...args],
+  };
+}
+
+/**
+ * Whether this machine can apply the ceiling: Linux, and a systemd that will
+ * make a scope for this user. Tried with `true` once at boot, because a
+ * daemon run as a system service has no user manager and every spawn would
+ * otherwise fail on a command that cannot work here.
+ */
+export async function probeScope(memoryMax, { platform = process.platform, run = runQuietly } = {}) {
+  if (!memoryMax) return { scope: null, why: null };
+  if (platform !== 'linux') {
+    return { scope: null, why: `sessionMemoryMax needs Linux and systemd; this is ${platform}` };
+  }
+  for (const manager of ['user', 'system']) {
+    const code = await run('systemd-run',
+      [`--${manager}`, '--scope', '--quiet', '--collect', '--no-ask-password',
+        '-p', `MemoryMax=${memoryMax}`, 'true']);
+    if (code === 0) {
+      return { scope: { manager, memoryMax }, why: null };
+    }
+  }
+  return {
+    scope: null,
+    why: 'systemd-run could not make a scope here (no user manager — `loginctl enable-linger` '
+      + 'for this user, or run the daemon as root)',
+  };
+}
+
+function runQuietly(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: 'ignore' });
+    child.on('error', () => resolve(-1));
+    child.on('close', (code) => resolve(code));
+  });
+}