@webship.co/workspace 1.0.0-alpha1 → 1.0.0-beta2

package/core/workspace-app/tests/unit/video-transcript.test.js

@@ -0,0 +1,237 @@
+/**
+ * A recording's card: a default picture when it has none, and its voiceover script one click away.
+ *
+ * The script is found by name in docs/ (`<video>-voiceover-script.md`). The pure parts are tested
+ * directly; the rows, the player and the transcript route run on the real server and a temp tree.
+ */
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const net = require('net');
+const { spawn } = require('child_process');
+
+const APP = path.join(__dirname, '../..');
+const REPO = path.join(APP, '../..');
+const { copyConfig } = require('./_isolated-config');
+const tr = require('../../transcripts');
+
+const SCRIPT = `# Demo: voiceover script (draft 1)
+
+- **Version:** Draft 1
+
+## Section timings
+
+| # | Section |
+|---|---|
+| E01 | Opening |
+
+## E01 Opening (00:00.0 to 00:20.0)
+
+**On screen:** the home page.
+
+> This is **Webship 11**, running on [Drupal](https://drupal.org) 11.
+> *(optional)* A spare sentence.
+
+## E02 Close (00:20.0 to 01:05.5)
+
+> Thank you for <watching> & goodbye.
+`;
+
+test('a script is found by the video\'s name, in the order of its suffixes', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-tr-'));
+  for (const n of ['a-voiceover-script.md', 'b-transcript.md', 'c-script.md', 'd.md', 'a-script.md']) fs.writeFileSync(path.join(dir, n), 'x');
+  assert.strictEqual(tr.findScript(dir, 'a'), 'a-voiceover-script.md');
+  assert.strictEqual(tr.findScript(dir, 'b'), 'b-transcript.md');
+  assert.strictEqual(tr.findScript(dir, 'c'), 'c-script.md');
+  assert.strictEqual(tr.findScript(dir, 'd'), null, 'a bare name is not a script');
+  assert.strictEqual(tr.findScript(path.join(dir, 'missing'), 'a'), null);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('a timed script gives sections with only the words spoken', () => {
+  const p = tr.parseTranscript(SCRIPT);
+  assert.strictEqual(p.timed, true);
+  assert.strictEqual(p.title, 'Demo: voiceover script (draft 1)');
+  assert.deepStrictEqual(p.sections.map((s) => [s.id, s.title, s.start, s.end]), [['E01', 'Opening', 0, 20], ['E02', 'Close', 20, 65.5]]);
+  assert.deepStrictEqual(p.sections[0].lines, [
+    { text: 'This is Webship 11, running on Drupal 11.', optional: false },
+    { text: 'A spare sentence.', optional: true },
+  ]);
+  assert.ok(!JSON.stringify(p).includes('On screen'));
+});
+
+test('a plain script gives its paragraphs, without lists, tables or headings', () => {
+  const p = tr.parseTranscript('# Title\n\n- a note\n\nFirst paragraph\nstill first.\n\n| a | b |\n\nSecond paragraph.\n');
+  assert.deepStrictEqual([p.timed, p.paragraphs], [false, ['First paragraph still first.', 'Second paragraph.']]);
+});
+
+test('the transcript is escaped, and a section time seeks only when asked to', () => {
+  const html = tr.transcriptHtml(tr.parseTranscript(SCRIPT), { file: 'd.md', href: '/files/docs/d.md', seek: true });
+  assert.match(html, /Thank you for &lt;watching&gt; &amp; goodbye\./);
+  assert.ok(!/<watching>/.test(html));
+  assert.match(html, /<button type="button" class="transcript-seek" data-seek="20"[^>]*>00:20<\/button>/);
+  assert.match(html, /class="is-optional"/);
+  assert.ok(!/data-seek/.test(tr.transcriptHtml(tr.parseTranscript(SCRIPT), {})), 'no seek buttons without a player');
+  assert.strictEqual(tr.stamp(65.5), '01:06');
+  assert.strictEqual(tr.stamp(3725), '1:02:05');
+});
+
+// ---- the running server ------------------------------------------------------------------------
+
+let proc; let base; const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-tr-root-'));
+
+const free = () => new Promise((resolve) => {
+  const s = net.createServer().listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => resolve(p)); });
+});
+
+before(async () => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  fs.symlinkSync(path.join(REPO, 'core/scripts'), path.join(root, 'core/scripts'));
+  fs.symlinkSync(APP, path.join(root, 'core/workspace-app'));
+  for (const d of ['videos', 'docs', 'audio']) fs.mkdirSync(path.join(root, d), { recursive: true });
+  fs.writeFileSync(path.join(root, 'videos/demo-draft-1.mp4'), Buffer.alloc(200, 1));
+  fs.writeFileSync(path.join(root, 'videos/posted.mp4'), Buffer.alloc(200, 2));
+  fs.writeFileSync(path.join(root, 'videos/posted-poster.jpg'), Buffer.alloc(50, 3));
+  fs.writeFileSync(path.join(root, 'audio/hello.mp3'), Buffer.alloc(200, 4));
+  fs.mkdirSync(path.join(root, 'audio/sounds'), { recursive: true });
+  const put = (name, body) => fs.writeFileSync(path.join(root, 'audio', name), body);
+  put('sounds/rain.mp3', Buffer.alloc(300, 5));
+  put('sounds/rain.txt', 'Rain on a tin roof\n');
+  put('sounds/rain.json', JSON.stringify({ kind: 'sound', engine: 'elevenlabs', duration: 4, loop: true, created_utc: '2026-10-07T12:00:00Z' }));
+  put('sounds/rain.jpg', Buffer.alloc(60, 6));
+  put('sounds/stray.bin', 'not a sound');
+  put('sounds/loose.txt', 'a text with no sound');
+  put('sounds/chime-cover.png', Buffer.alloc(60, 8));
+  put('sounds/chime.wav', Buffer.alloc(300, 9));
+  put('sounds/chime-transcript.md', 'A single chime.\n');
+  fs.mkdirSync(path.join(root, 'videos/older-takes'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'docs/notes-folder'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'docs/loose-note.md'), 'x');
+  fs.writeFileSync(path.join(root, 'docs/demo-draft-1-voiceover-script.md'), SCRIPT);
+  const port = await free();
+  base = `http://127.0.0.1:${port}`;
+  proc = spawn(process.execPath, ['server.js'], { cwd: APP, env: { ...process.env, PORT: String(port), WORKSPACE_ROOT: root }, stdio: ['ignore', 'pipe', 'pipe'] });
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error('server did not start')), 15000);
+    proc.stdout.on('data', (d) => { if (/listening/.test(String(d))) { clearTimeout(t); resolve(); } });
+    proc.on('exit', (c) => { clearTimeout(t); reject(new Error(`server exited ${c}`)); });
+  });
+});
+
+after(() => {
+  if (proc) proc.kill();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+const get = (p) => fetch(base + p);
+
+test('a recording with no poster gets the default picture, one with a poster keeps its own', async () => {
+  const html = await (await get('/fragments/videos/items')).text();
+  const row = (name) => html.slice(html.indexOf(`title="${name}.mp4`) - 1500, html.indexOf(`title="${name}.mp4`) + 1500);
+  assert.match(row('demo-draft-1'), /fx-thumb is-default/);
+  assert.match(html, /<span class="fx-thumb is-video"[^>]*>\s*<img src="[^"]*posted-poster\.jpg/);
+  const posted = html.slice(html.indexOf('posted-poster.jpg') - 200, html.indexOf('posted-poster.jpg') + 600);
+  assert.ok(!/is-default/.test(posted));
+  assert.match(await (await get('/fragments/audio/items')).text(), /fx-thumb is-default/);
+});
+
+test('pressing the picture of a recording or a sound plays it, like its Play button', async () => {
+  const videos = await (await get('/fragments/videos/items')).text();
+  assert.match(videos, /<span class="fx-thumb is-default" role="button" tabindex="0" title="Play demo-draft-1\.mp4"\s+hx-get="\/fragments\/videos\/play\/demo-draft-1\.mp4"/);
+  assert.match(videos, /<span class="fx-thumb is-video" role="button" tabindex="0" title="Play posted\.mp4"\s+hx-get="\/fragments\/videos\/play\/posted\.mp4"/);
+  assert.match(videos, /hx-trigger="click, keyup\[key=='Enter'\]" hx-target="#editor-modal-body"/);
+  assert.match(await (await get('/fragments/audio/items')).text(), /fx-thumb is-default" role="button"[^>]*hx-get="\/fragments\/audio\/play\/hello\.mp3"/);
+  // The same address the button uses, and it answers.
+  assert.strictEqual((await get('/fragments/videos/play/posted.mp4')).status, 200);
+});
+
+test('only a recording that has a script shows the Transcript button', async () => {
+  const html = await (await get('/fragments/videos/items')).text();
+  assert.strictEqual((html.match(/fx-transcript/g) || []).length, 1);
+  assert.match(html, /hx-get="\/fragments\/videos\/transcript\/demo-draft-1\.mp4"/);
+  assert.match(html, /Read the voiceover script: demo-draft-1-voiceover-script\.md/);
+});
+
+test('the player shows the words under the video, with times that seek', async () => {
+  const withScript = await (await get('/fragments/videos/play/demo-draft-1.mp4')).text();
+  assert.match(withScript, /<details class="transcript-details" open><summary>Transcript<\/summary>/);
+  assert.match(withScript, /data-seek="20"/);
+  assert.ok(!/<h4[^>]*>Transcript/.test(withScript), 'the summary says it, the body does not repeat it');
+  assert.match(withScript, /This is Webship 11, running on Drupal 11\./);
+  const without = await (await get('/fragments/videos/play/posted.mp4')).text();
+  assert.ok(!/transcript/.test(without));
+});
+
+test('the transcript opens on its own, and says nothing it should not', async () => {
+  const r = await get('/fragments/videos/transcript/demo-draft-1.mp4');
+  assert.strictEqual(r.status, 200);
+  const html = await r.text();
+  assert.match(html, /from <a href="\/files\/docs\/demo-draft-1-voiceover-script\.md"/);
+  assert.ok(!/data-seek|<video|On screen/.test(html));
+  assert.strictEqual((await get('/fragments/videos/transcript/posted.mp4')).status, 404, 'no script');
+  assert.strictEqual((await get('/fragments/videos/transcript/nothing.mp4')).status, 404, 'no video');
+  assert.strictEqual((await get('/fragments/videos/transcript/..%2Fdocs%2Fdemo-draft-1-voiceover-script.md')).status, 404);
+  assert.strictEqual((await get('/fragments/videos/transcript/demo-draft-1.mp4.txt')).status, 404);
+});
+
+test('the seek buttons and the card styles are in the front end', () => {
+  assert.match(fs.readFileSync(path.join(APP, 'public/media-player.js'), 'utf8'), /\[data-seek\][\s\S]*media\.currentTime = /);
+  assert.match(fs.readFileSync(path.join(APP, 'public/css/components/project-rows.css'), 'utf8'), /\.fx-thumb\.is-default/);
+});
+
+test('the audio workspace lists sounds and what belongs to them, nothing else', async () => {
+  const html = await (await get('/fragments/audio/items?path=sounds')).text();
+  assert.match(html, /title="Play rain\.mp3/);
+  assert.match(html, /title="Play chime\.wav/);
+  for (const hidden of ['rain.txt', 'rain.json', 'rain.jpg', 'stray.bin', 'loose.txt', 'chime-cover.png', 'chime-transcript.md']) {
+    assert.ok(!html.includes(`title="${hidden}`) && !html.includes(`/${hidden}"`) || /fx-thumb[^>]*>\s*<img src="[^"]*(rain\.jpg|chime-cover\.png)/.test(html) && !/title="[^"]*(rain\.txt|stray)/.test(html), hidden);
+  }
+  assert.ok(!/stray\.bin|loose/.test(html), 'a file that is not a sound is not listed');
+  assert.match(html, /<span class="fx-thumb is-video"[^>]*>\s*<img src="[^"]*rain\.jpg/, 'the cover is the picture');
+  assert.match(html, /<span class="fx-thumb is-video"[^>]*>\s*<img src="[^"]*chime-cover\.png/, 'a -cover picture too');
+  assert.strictEqual((html.match(/fx-transcript/g) || []).length, 2, 'both have text');
+  assert.match(html, /hx-get="\/fragments\/audio\/transcript\/sounds\/rain\.mp3"/);
+  assert.match(html, /See how it was made, and the text/);
+});
+
+test('a sound shows how it was made, and the text, in the player and on its own', async () => {
+  const play = await (await get('/fragments/audio/play/sounds/rain.mp3')).text();
+  assert.match(play, /<summary>How it was made<\/summary>/);
+  assert.match(play, /Made as<\/span> sound/);
+  assert.match(play, /With<\/span> elevenlabs/);
+  assert.match(play, /Loop<\/span> yes/);
+  assert.match(play, /<h4 class="uk-margin-small-bottom">Description /);
+  assert.match(play, /Rain on a tin roof/);
+  assert.match(play, /data-sound-speed="5"/);
+  const own = await get('/fragments/audio/transcript/sounds/rain.mp3');
+  assert.strictEqual(own.status, 200);
+  assert.match(await own.text(), /sound-record[\s\S]*Rain on a tin roof/);
+  const plain = await (await get('/fragments/audio/transcript/sounds/chime.wav')).text();
+  assert.match(plain, /A single chime\./);
+  assert.ok(!/sound-record/.test(plain), 'no record, so no facts line');
+  assert.strictEqual((await get('/fragments/audio/transcript/hello.mp3')).status, 404, 'nothing belongs to it');
+  assert.strictEqual((await get('/fragments/audio/transcript/sounds/rain.txt')).status, 404, 'only a sound opens one');
+});
+
+test('videos and audio list the newest files first, then the folders; other workspaces keep folders first', async () => {
+  const order = (html, ...names) => names.map((n) => html.indexOf(n));
+  const videos = await (await get('/fragments/videos/items')).text();
+  const [file, folder] = order(videos, 'title="Play demo-draft-1.mp4', 'older-takes');
+  assert.ok(file > 0 && folder > 0 && file < folder, 'a recording comes before the folder');
+  assert.match(videos, /<option value="files-first" selected>Files first<\/option>/);
+  const folders = await (await get('/fragments/videos/items?kind=all')).text();
+  const [f2, d2] = order(folders, 'title="Play demo-draft-1.mp4', 'older-takes');
+  assert.ok(d2 > 0 && f2 > 0 && d2 < f2, 'choosing Folders first puts the folder first');
+  assert.match(folders, /<option value="all" selected>Folders first<\/option>/);
+  assert.match(folders, /kind=all/, 'the choice travels with the pager and the search');
+  const sounds = await (await get('/fragments/audio/items')).text();
+  assert.match(sounds, /<option value="files-first" selected>/);
+  assert.ok(sounds.indexOf('title="Play hello.mp3') < sounds.indexOf('items?path=sounds'));
+  const docs = await (await get('/fragments/docs/items')).text();
+  assert.match(docs, /<option value="all" selected>Folders first<\/option>/);
+  assert.ok(docs.indexOf('notes-folder') < docs.indexOf('loose-note'), 'docs still lists folders first');
+});

package/core/workspace-app/tests/unit/waiting.test.js

@@ -0,0 +1,48 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const { waitingState } = require('../../waiting');
+
+// The real footer of a working Claude Code session, captured from a live run.
+const BUSY = ['  Ran 1 shell command',
+  '6 Thinking… (6m 16s · 23.9k tokens)',
+  '  ⏵⏵ bypass permissions on (shift+tab to cycle) · esc to interrupt'].join('\n');
+
+test('the interrupt hint means working, whatever else is on screen', () => {
+  assert.equal(waitingState(BUSY).waiting, false);
+  // Even with a question ABOVE it: the footer is the authority.
+  assert.equal(waitingState(`Do you want to proceed?\n❯ 1. Yes\n${BUSY}`).waiting, false);
+});
+
+test('a numbered choice with a caret is waiting', () => {
+  const s = waitingState('Do you want to proceed?\n❯ 1. Yes\n  2. No');
+  assert.equal(s.waiting, true);
+  assert.match(s.why, /choice/);
+});
+
+test('yes/no in the shapes CLIs actually ask', () => {
+  assert.equal(waitingState('Overwrite the file? (y/N)').waiting, true);
+  assert.equal(waitingState('Continue [Y/n]').waiting, true);
+});
+
+test('an idle Claude prompt is flagged, more gently', () => {
+  const s = waitingState('⏵⏵ bypass permissions on (shift+tab to cycle)\n? for shortcuts');
+  assert.equal(s.waiting, true);
+  assert.match(s.why, /idle/);
+});
+
+test('ordinary output is not a question', () => {
+  assert.equal(waitingState('Ran 3 shell commands\nAll five components verified.').waiting, false);
+  assert.equal(waitingState('').waiting, false);
+  assert.equal(waitingState(null).waiting, false);
+});
+
+test('a report that merely mentions a question is not waiting', () => {
+  // An agent writing prose about a question must not raise the flag.
+  assert.equal(waitingState('The ticket asks: do you want the picker? I implemented it.\nRan 2 commands').waiting, false);
+  assert.equal(waitingState('I asked whether to continue? and decided yes.\nMoving on.').waiting, false);
+});
+
+test('the question has to be the last thing on screen, not buried above', () => {
+  const buried = ['Do you want to proceed?', 'yes', 'Ran 4 commands', 'Wrote 2 files', 'Done.'].join('\n');
+  assert.equal(waitingState(buried).waiting, false);
+});

package/core/workspace-app/tests/unit/wordpress-odoo-builders.test.js

@@ -0,0 +1,38 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const { sortWith } = require('../../build-order');
+const { suggestProjectName } = require('../../project-name');
+
+const root = path.join(__dirname, '..', '..', '..', '..');
+const BUILDERS = ['cmd-wordpress-project.sh', 'cmd-wpbedrock1-project.sh', 'cmd-odoo20-project.sh'];
+
+test('dev, test and sandboxes carry the WordPress and Odoo examples, and no other folder does', () => {
+  for (const ws of ['dev', 'test', 'sandboxes']) {
+    for (const f of BUILDERS) assert.ok(fs.existsSync(path.join(root, ws, f)), `${ws}/${f}`);
+  }
+  for (const ws of ['demos', 'projects', 'site-templates']) {
+    for (const f of BUILDERS) assert.ok(!fs.existsSync(path.join(root, ws, f)), `${ws}/${f}`);
+  }
+});
+
+test('they come last in the Build list, WordPress before Odoo', () => {
+  const dir = path.join(root, 'dev');
+  const all = fs.readdirSync(dir).filter((f) => /^cmd-.*-project\.sh$/.test(f) && !/^cmd-tools?-/.test(f)).sort();
+  assert.deepEqual(sortWith(all, []).slice(-3), BUILDERS);
+});
+
+test('each proposes a name of its own', () => {
+  const dir = path.join(root, 'dev');
+  const names = BUILDERS.map((f) => suggestProjectName(dir, f, { existing: [] }));
+  assert.deepEqual(names, ['wordpress1', 'wpbedrock1x00b1', 'odoo20x00b1']);
+});
+
+test('Odoo runs on PostgreSQL through DDEV, and WordPress never writes database settings', () => {
+  const odoo = fs.readFileSync(path.join(root, 'core/scripts/functions/fun-odoo.sh'), 'utf8');
+  const wp = fs.readFileSync(path.join(root, 'core/scripts/functions/fun-wordpress.sh'), 'utf8');
+  assert.match(odoo, /--database=postgres:16/);
+  assert.match(odoo, /proxy_pass http:\/\/odoo:8069;/);
+  assert.doesNotMatch(wp, /wp config create|define\(\s*'DB_/);
+});

package/core/workspace-app/tests/unit/workspace-bin.test.js

@@ -0,0 +1,48 @@
+/**
+ * The npm way in: `webship-workspace init` makes an EMPTY workspace from this package (the core, a
+ * settings file with no workspaces and no plugins, the dashboard's dependencies), never overwrites a
+ * settings file on a second run, and `catalog` says what can be added.
+ */
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BIN = path.join(__dirname, '..', '..', '..', 'bin', 'workspace.js');
+const run = (args, env = {}) => spawnSync(process.execPath, [BIN, ...args], { encoding: 'utf8', env: { ...process.env, WEBSHIP_WORKSPACE_SKIP_NPM: '1', WEBSHIP_WORKSPACE_SKIP_DDEV: '1', ...env } });
+
+test('init makes an empty workspace: the core, the lean settings, nothing else', () => {
+  const dir = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ws-init-')), 'workspace');
+  const r = run(['init', dir]);
+  assert.strictEqual(r.status, 0, r.stderr);
+  assert.match(r.stdout, /settings\.yml written \(empty/);
+  for (const f of ['core/scripts/plugins.sh', 'core/scripts/bootstrap.sh', 'core/workspace-app/server.js', 'core/workspace-app/plugin-loader.js', 'core/workspace-app/package.json', 'core/workspace-app/.app-version', 'core/config/settings.yml', 'README.md']) {
+    assert.ok(fs.existsSync(path.join(dir, f)), `${f} is there`);
+  }
+  assert.ok(!fs.existsSync(path.join(dir, 'core', 'workspace-app', 'node_modules')), 'no node_modules copied');
+  const settings = fs.readFileSync(path.join(dir, 'core', 'config', 'settings.yml'), 'utf8');
+  assert.match(settings, /^workspaces: \[\]$/m, 'no workspace folders yet');
+  assert.match(settings, /^plugins: \{\}$/m, 'no plugins yet');
+  assert.ok(!fs.existsSync(path.join(dir, 'dev')), 'no folders made');
+  assert.match(r.stdout, /Workspace folders — /, 'the catalogue is suggested');
+  // Again: a settings file a person may have edited is kept.
+  fs.appendFileSync(path.join(dir, 'core', 'config', 'settings.yml'), '# mine\n');
+  const r2 = run(['update', dir]);
+  assert.strictEqual(r2.status, 0, r2.stderr);
+  assert.match(r2.stdout, /settings\.yml kept/);
+  assert.match(fs.readFileSync(path.join(dir, 'core', 'config', 'settings.yml'), 'utf8'), /# mine/);
+});
+
+test('the catalogue names every family with its npm packages, and plugin refuses an unknown verb', () => {
+  const r = run(['catalog']);
+  assert.strictEqual(r.status, 0);
+  for (const f of ['Workspace folders', 'Hosting providers', 'Git forges', 'Container runtimes']) assert.match(r.stdout, new RegExp(f));
+  assert.match(r.stdout, /@webship\.co\/workspace-github/);
+  const bad = run(['plugin', 'explode', 'x']);
+  assert.strictEqual(bad.status, 1);
+  const none = run(['plugin', 'list'], { WORKSPACE_ROOT: fs.mkdtempSync(path.join(os.tmpdir(), 'ws-none-')) });
+  assert.strictEqual(none.status, 1);
+  assert.match(none.stderr, /webship-workspace init/);
+});

package/core/workspace-app/tests/unit/workspace-card-tools.test.js

@@ -0,0 +1,30 @@
+/**
+ * The tools on a home page workspace card: Edit opens the card editor, Settings opens the workspace's own file.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const tools = require('../../workspace-card-tools');
+
+const w = { key: 'dev', label: 'Dev', icon: 'tabler:code' };
+
+test('the corner offers Edit and Settings for the workspace it is on', () => {
+  const html = tools.cornerHtml(w);
+  assert.match(html, /hx-get="\/fragments\/workspace-edit\/dev"[\s\S]*hx-target="#editor-modal-body"/);
+  assert.match(html, /href="\/settings\/workspace\.dev\.settings\.yml"/);
+  assert.match(html, /data-tabmodal-open="\/fragments\/settings\/modal\?tab=workspace\.dev\.settings\.yml"/);
+  assert.doesNotMatch(html, /ws-backups/);
+});
+
+test('the backups count joins the corner when there are backups', () => {
+  const html = tools.cornerHtml(w, { backupCount: 2, backupsUrl: 'https://dev.example/backups' });
+  assert.match(html, /class="ws-backups" href="https:\/\/dev\.example\/backups" title="View the 2 backups for Dev"/);
+  assert.ok(html.indexOf('ws-backups') < html.indexOf('ws-card-tool'));
+});
+
+test('the edit modal names the card and wraps the presentation editor', () => {
+  const html = tools.editModalHtml(w, '<div id="ws-presentation"></div>');
+  assert.match(html, /Edit the Dev card/);
+  assert.match(html, /<div id="ws-presentation"><\/div>/);
+});

package/core/workspace-app/tests/unit/workspace-delete.test.js

@@ -0,0 +1,77 @@
+/**
+ * Deleting a workspace, against a temporary tree: only one with nothing in it goes, and only with both typed answers.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-delete-'));
+const CONFIG = path.join(ROOT, 'core', 'config');
+fs.mkdirSync(CONFIG, { recursive: true });
+process.env.WORKSPACE_ROOT = ROOT;
+process.env.WORKSPACE_CONFIG = CONFIG;
+
+fs.writeFileSync(path.join(CONFIG, 'settings.yml'), '# kept\nworkspaces:\n  - dev\n  - emptyws\n  - busyws\n  - docs\nother: 1\n');
+for (const name of ['dev', 'emptyws', 'busyws', 'docs']) {
+  fs.writeFileSync(path.join(CONFIG, `workspace.${name}.settings.yml`), `doc:\n  name: ${name}\n`);
+  fs.mkdirSync(path.join(ROOT, name));
+}
+fs.writeFileSync(path.join(ROOT, 'emptyws', 'cmd-tools-remove.sh'), '#!/bin/bash\n');
+fs.writeFileSync(path.join(ROOT, 'emptyws', 'README.md'), '# emptyws\n');
+fs.mkdirSync(path.join(ROOT, 'busyws', 'project1'));
+fs.mkdirSync(path.join(ROOT, 'docs', '.hidden'));
+
+const wsDelete = require('../../workspace-delete');
+
+test('a folder with only tooling is unused; content, hidden folders, backups and sessions are not', () => {
+  assert.deepStrictEqual(wsDelete.usage('emptyws', { sessions: [] }).reasons, []);
+  assert.match(wsDelete.usage('busyws', { sessions: [] }).reasons.join(), /1 item in its folder \(project1\)/);
+  assert.match(wsDelete.usage('docs', { sessions: [] }).reasons.join(), /\.hidden/);
+  assert.match(wsDelete.usage('emptyws', { sessions: ['emptyws--shell'] }).reasons.join(), /1 screen session running/);
+  assert.deepStrictEqual(wsDelete.usage('dev', { sessions: ['emptyws--shell'] }).reasons, []);
+  fs.mkdirSync(path.join(ROOT, 'backups', 'dev'), { recursive: true });
+  fs.writeFileSync(path.join(ROOT, 'backups', 'dev', 'x.tar.gz'), '');
+  assert.match(wsDelete.usage('dev', { sessions: [] }).reasons.join(), /1 backup file/);
+  assert.match(wsDelete.usage('nope').reasons.join(), /not a workspace/);
+});
+
+test('the last step needs the name typed back and YES in capitals', () => {
+  assert.strictEqual(wsDelete.confirmed('emptyws', { confirmName: 'emptyws', confirmYes: 'YES' }), true);
+  assert.strictEqual(wsDelete.confirmed('emptyws', { confirmName: 'emptyws', confirmYes: 'yes' }), false);
+  assert.strictEqual(wsDelete.confirmed('emptyws', { confirmName: 'busyws', confirmYes: 'YES' }), false);
+  assert.strictEqual(wsDelete.confirmed('emptyws', { confirmYes: 'YES' }), false);
+});
+
+test('a workspace in use is refused and left as it is', () => {
+  const r = wsDelete.deleteWorkspace('busyws');
+  assert.match(r.error, /in use/);
+  assert.ok(fs.existsSync(path.join(ROOT, 'busyws', 'project1')));
+  assert.ok(fs.existsSync(path.join(CONFIG, 'workspace.busyws.settings.yml')));
+});
+
+test('deleting an unused one removes its line, settings file and folder, and nothing else', () => {
+  const r = wsDelete.deleteWorkspace('emptyws');
+  assert.ok(!r.error, r.error);
+  assert.strictEqual(fs.readFileSync(path.join(CONFIG, 'settings.yml'), 'utf8'),
+    '# kept\nworkspaces:\n  - dev\n  - busyws\n  - docs\nother: 1\n');
+  assert.ok(!fs.existsSync(path.join(CONFIG, 'workspace.emptyws.settings.yml')));
+  assert.ok(!fs.existsSync(path.join(ROOT, 'emptyws')));
+  assert.ok(fs.existsSync(path.join(ROOT, 'dev')));
+});
+
+test('the steps ask for the name, then YES', () => {
+  const use = { reasons: [], tooling: ['cmd-a.sh'] };
+  const two = wsDelete.stepHtml('demo-x', 'name', use);
+  assert.match(two, /Step 2 of 3/);
+  assert.match(two, /name="confirmName"/);
+  assert.match(two, /"step":"yes"/);
+  const three = wsDelete.stepHtml('demo-x', 'yes', use, 'Type YES');
+  assert.match(three, /Step 3 of 3/);
+  assert.match(three, /name="confirmYes"/);
+  assert.match(three, /"step":"delete","confirmName":"demo-x"/);
+  assert.match(wsDelete.rowControlHtml('demo-x', use), /arm-step[\s\S]*hx-trigger="confirmed-remove"/);
+  assert.match(wsDelete.rowControlHtml('dev', { reasons: ['2 items'], tooling: [] }), /in use/);
+});

package/core/workspace-app/tests/unit/workspace-types.test.js

@@ -0,0 +1,68 @@
+/**
+ * The type layer: policy over which actions a workspace's project rows offer.
+ *
+ * The promise pinned here is "nothing changes until somebody edits a type" — every shipped
+ * folder must resolve to a default that carries exactly the interface it had before types
+ * existed, and an explicit `type:` must win over that default.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { TYPES, DEFAULT_TYPE_BY_KEY, isType, resolveType, typeActions } = require('../../workspace-types');
+const { loadWorkspaces, CONFIG_DIR } = require('../../workspaces');
+
+test('every default points at a real type', () => {
+  for (const [key, type] of Object.entries(DEFAULT_TYPE_BY_KEY)) {
+    assert.ok(isType(type), `${key} defaults to unknown type '${type}'`);
+  }
+});
+
+test('an explicit type wins, a bad one falls back, kind decides the rest', () => {
+  assert.equal(resolveType('dev', 'code', 'projects'), 'code');
+  assert.equal(resolveType('dev', 'not-a-type', 'projects'), 'sites');
+  assert.equal(resolveType('brand-new', undefined, 'files'), 'files');
+  assert.equal(resolveType('brand-new', undefined, 'projects'), 'sites');
+});
+
+test('sites carry the full toolbelt, code drops the site controls, lists carry none', () => {
+  const sites = typeActions('sites');
+  for (const a of ['build', 'ddev', 'backup', 'remove', 'ragify', 'tests', 'checks', 'users']) {
+    assert.ok(sites.has(a), `sites misses ${a}`);
+  }
+  const code = typeActions('code');
+  for (const a of ['ddev', 'users', 'tests']) assert.ok(!code.has(a), `code should not carry ${a}`);
+  for (const a of ['backup', 'remove', 'ragify', 'checks']) assert.ok(code.has(a), `code misses ${a}`);
+  // Lists carry no project actions; files and media take only New folder, a page action.
+  for (const t of ['files', 'media']) assert.deepEqual([...typeActions(t)], ['folder'], `${t} should carry only folder`);
+  assert.equal(typeActions('ai-items').size, 0, 'ai-items should carry no actions');
+});
+
+test('every loaded workspace resolves a type and its action set', () => {
+  for (const [key, meta] of Object.entries(loadWorkspaces())) {
+    assert.ok(isType(meta.type), `${key} resolved to unknown type '${meta.type}'`);
+    assert.ok(meta.typeActions instanceof Set, `${key} has no typeActions set`);
+    // files-kind pages have no project rows to act on — their types agree.
+    if (meta.kind === 'files' && !meta.alsoFiles) {
+      assert.equal(meta.typeActions.has('ddev'), false, `${key} is a file list but allows ddev`);
+    }
+  }
+});
+
+test('the settings dropdown and the registry cannot drift', () => {
+  const fs = require('fs');
+  const path = require('path');
+  const labels = fs.readFileSync(path.join(CONFIG_DIR, 'settings.labels.yml'), 'utf8');
+  for (const type of Object.keys(TYPES)) {
+    assert.ok(labels.includes(`    ${type}:`), `settings.labels.yml type options miss '${type}'`);
+  }
+});
+
+test('a plugin can allow its action on the types it names, and only there', () => {
+  const { addTypeAction } = require('../../workspace-types');
+  addTypeAction('x-cloud', ['sites']);
+  assert.ok(typeActions('sites').has('x-cloud'));
+  assert.ok(!typeActions('code').has('x-cloud'));
+  addTypeAction('x-cloud', ['sites']);
+  assert.strictEqual([...typeActions('sites')].filter((a) => a === 'x-cloud').length, 1, 'registered once');
+});