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

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

@@ -0,0 +1,254 @@
+/**
+ * Commands → Navigation: the sidebar and the top bar, arranged.
+ *
+ * What must never drift: with no file the navigation is exactly what the code built; hiding, reordering
+ * and adding are presentation only; an entry lives in exactly ONE place, so moving it to the top bar
+ * takes it out of its sidebar group; a workspace's own settings are applied after the global ones; an
+ * added link can only be an https address or a path of this dashboard; and the reserved lists (the three
+ * top-bar regions and Hidden) are never written back as sidebar groups.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'navigation-'));
+process.env.NAVIGATION_FILE = path.join(tmp, 'navigation.yml');
+process.env.NAVIGATION_SEEN_FILE = path.join(tmp, 'navigation.seen.json');
+process.on('exit', () => fs.rmSync(tmp, { recursive: true, force: true }));
+
+const nav = require('../../navigation');
+
+const entry = (id, label = id) => ({ id, label, html: `<a class="action-btn" href="/${id}"><span class="action-label">${label}</span></a>` });
+const built = () => ([
+  { id: 'create', label: 'Create', items: [entry('new-project', 'New project')] },
+  { id: 'go', label: 'Go', items: [entry('all-workspaces', 'All workspaces'), entry('commands', 'Commands'), entry('help', 'Help')] },
+]);
+const write = (raw) => nav.saveLayout(raw);
+const reset = () => { try { fs.unlinkSync(process.env.NAVIGATION_FILE); } catch (_) { /* already gone */ } };
+
+test('with no file the navigation is what the code built, and the top bar is empty', () => {
+  reset();
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.groups.map((g) => g.id), ['create', 'go']);
+  assert.deepStrictEqual(out.groups[1].items.map((i) => i.id), ['all-workspaces', 'commands', 'help']);
+  assert.deepStrictEqual(nav.REGIONS.map((r) => out.topbar[r].length), [0, 0, 0]);
+});
+
+test('an id slugs from the label with any count stripped, so a backup does not forget the layout', () => {
+  assert.strictEqual(nav.slugId('Backups (2)'), 'backups');
+  assert.strictEqual(nav.slugId('Run a tool (13)'), 'run-a-tool');
+  assert.strictEqual(nav.slugId('All workspaces'), 'all-workspaces');
+});
+
+test('hidden is presentation only: the entry goes, the group survives its last entry leaving', () => {
+  write({ global: { hidden: ['commands'] } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.groups[1].items.map((i) => i.id), ['all-workspaces', 'help']);
+
+  write({ global: { hidden: ['new-project'] } });
+  const only = nav.arrange(built(), 'global');
+  assert.ok(!only.groups.some((g) => g.id === 'create'), 'a group with nothing left in it is not drawn');
+});
+
+test('order names what it names; anything unlisted keeps its place AFTER it', () => {
+  write({ global: { groups: ['go', 'create'], order: { go: ['help', 'commands'] } } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.groups.map((g) => g.id), ['go', 'create'], 'the group order is the one named');
+  assert.deepStrictEqual(out.groups[0].items.map((i) => i.id), ['help', 'commands', 'all-workspaces'],
+    'an entry the layout has never seen must not vanish into the middle of it');
+});
+
+test('an entry moved to the top bar leaves its sidebar group: it is in one place, not two', () => {
+  write({ global: { topbar: { end: ['commands'] } } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.topbar.end.map((i) => i.id), ['commands']);
+  assert.deepStrictEqual(out.groups.find((g) => g.id === 'go').items.map((i) => i.id), ['all-workspaces', 'help']);
+  assert.deepStrictEqual(out.topbar.start, []);
+  assert.deepStrictEqual(out.topbar.center, []);
+});
+
+test('the three regions are kept apart, and each is in the order the layout names', () => {
+  write({ global: { topbar: { start: ['help'], center: ['commands'], end: ['all-workspaces', 'new-project'] } } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.topbar.start.map((i) => i.id), ['help']);
+  assert.deepStrictEqual(out.topbar.center.map((i) => i.id), ['commands']);
+  assert.deepStrictEqual(out.topbar.end.map((i) => i.id), ['all-workspaces', 'new-project'],
+    'the order inside a region is the order it was saved in');
+  assert.deepStrictEqual(out.groups, [], 'everything moved up leaves nothing behind');
+});
+
+test('an entry the dashboard ships in the top bar stays there until someone says otherwise', () => {
+  reset();
+  const groups = [{ id: 'screens', label: 'Screens', items: [{ ...entry('open-screens', 'Screens'), topbar: 'end' }] }];
+  const shipped = nav.arrange(groups, 'global');
+  assert.deepStrictEqual(shipped.topbar.end.map((i) => i.id), ['open-screens'],
+    'a live count is a status, glanced at rather than gone to');
+  assert.deepStrictEqual(shipped.groups, [], 'and it is not also down the side');
+
+  write({ global: { order: { screens: ['open-screens'] } } });
+  const moved = nav.arrange(groups, 'global');
+  assert.deepStrictEqual(moved.topbar.end, [], 'naming it anywhere is saying otherwise');
+  assert.deepStrictEqual(moved.groups.map((g) => g.id), ['screens']);
+
+  write({ global: { topbar: { start: ['open-screens'] } } });
+  assert.deepStrictEqual(nav.arrange(groups, 'global').topbar.start.map((i) => i.id), ['open-screens'],
+    'and so is moving it to another region');
+
+  write({ global: { hidden: ['open-screens'] } });
+  const gone = nav.arrange(groups, 'global');
+  assert.deepStrictEqual(gone.topbar.end, []);
+  assert.deepStrictEqual(gone.groups, [], 'hiding it takes it out of the default placement too');
+});
+
+test('what the dashboard ships in the top bar: the assistant and the version, then the screens count', () => {
+  reset();
+  const groups = [
+    { id: 'screens', label: 'Screens', items: [{ ...entry('open-screens', 'Screens'), topbar: 'end' }] },
+    { id: 'go', label: 'Go', items: [
+      entry('commands', 'Commands'),
+      { ...entry('ai-assistant', 'AI Assistant'), topbar: 'start' },
+      { ...entry('version', '1.0.12'), topbar: 'start' },
+    ] },
+  ];
+  const out = nav.arrange(groups, 'global');
+  assert.deepStrictEqual(out.topbar.start.map((i) => i.id), ['ai-assistant', 'version'],
+    'in the order the page built them, so a default placement does not need an order of its own');
+  assert.deepStrictEqual(out.topbar.end.map((i) => i.id), ['open-screens']);
+  assert.deepStrictEqual(out.groups.map((g) => g.id), ['go'], 'and neither is also down the side');
+  assert.deepStrictEqual(out.groups[0].items.map((i) => i.id), ['commands']);
+});
+
+test('hidden beats the top bar: an entry hidden is nowhere at all', () => {
+  write({ global: { hidden: ['commands'], topbar: { end: ['commands'] } } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.topbar.end, []);
+  assert.ok(!out.groups.some((g) => g.items.some((i) => i.id === 'commands')));
+});
+
+test("a workspace's own settings are applied after the global ones", () => {
+  write({ global: { hidden: ['help'] }, workspaces: { dev: { topbar: { start: ['commands'] } } } });
+  const onDev = nav.arrange(built(), 'dev');
+  assert.deepStrictEqual(onDev.topbar.start.map((i) => i.id), ['commands'], "the workspace's own move applies");
+  assert.ok(!onDev.groups.some((g) => g.items.some((i) => i.id === 'help')), 'and the global hide still applies');
+
+  const elsewhere = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(elsewhere.topbar.start, [], "a workspace's move is that workspace's alone");
+});
+
+test('scopeFor reads the page context, and anything else is the global scope', () => {
+  assert.strictEqual(nav.scopeFor('workspace:dev'), 'dev');
+  assert.strictEqual(nav.scopeFor('backups:dev'), 'dev');
+  assert.strictEqual(nav.scopeFor('commands:navigation'), 'global');
+  assert.strictEqual(nav.scopeFor('home'), 'global');
+  assert.strictEqual(nav.scopeFor(undefined), 'global');
+});
+
+test('an added entry joins the group it names, or a group of its own at the end', () => {
+  write({ global: { items: [{ id: 'jira', label: 'Jira', href: 'https://CHANGE_ME.atlassian.net', group: 'go' }] } });
+  const inGo = nav.arrange(built(), 'global').groups.find((g) => g.id === 'go');
+  assert.deepStrictEqual(inGo.items.map((i) => i.id), ['all-workspaces', 'commands', 'help', 'jira']);
+
+  write({ global: { items: [{ id: 'jira', label: 'Jira', href: 'https://CHANGE_ME.atlassian.net' }] } });
+  const own = nav.arrange(built(), 'global').groups;
+  assert.strictEqual(own[own.length - 1].id, 'yours', 'with no group named it is Yours, at the end');
+});
+
+test('an added entry can name a top-bar region as its group and land there', () => {
+  write({ global: { items: [{ id: 'jira', label: 'Jira', href: 'https://x.example', group: 'topbar-center' }] } });
+  const out = nav.arrange(built(), 'global');
+  assert.deepStrictEqual(out.topbar.center.map((i) => i.id), ['jira']);
+  assert.ok(!out.groups.some((g) => g.id === 'topbar-center'), 'a region is never a sidebar group');
+});
+
+test('an added entry that is a link off this dashboard opens in a new tab, and one inside it does not', () => {
+  const away = nav.customItemHtml({ id: 'jira', label: 'Jira', href: 'https://CHANGE_ME.atlassian.net' });
+  assert.match(away, /target="_blank"/);
+  assert.match(away, /rel="noopener"/);
+  const here = nav.customItemHtml({ id: 'dev', label: 'Dev', href: '/dev' });
+  assert.ok(!here.includes('target="_blank"'), 'replacing the page you are working on is not what a link here does');
+});
+
+test('an added entry that runs a command goes through the same runner and the same confirm dialog', () => {
+  const plain = nav.customItemHtml({ id: 'cr', label: 'Rebuild', use: 'drush-cr' });
+  assert.match(plain, /hx-post="\/actions\/nav-run"/);
+  assert.ok(!plain.includes('arm-step'), 'a command that does not ask is not armed');
+  const asks = nav.customItemHtml({ id: 'cr', label: 'Rebuild', use: 'drush-cr', confirm: true });
+  assert.match(asks, /arm-step/);
+  assert.match(asks, /hx-trigger="confirmed-remove"/, 'the request fires on the dialog alone');
+});
+
+test('an icon that is not a name we know falls back rather than reaching the markup', () => {
+  const html = nav.customItemHtml({ id: 'x', label: 'X', href: '/x', icon: '"><script>alert(1)</script>' });
+  assert.ok(!html.includes('<script>'), 'nothing a person types becomes markup');
+  assert.match(html, /icon: link;/, 'and it draws the fallback icon');
+});
+
+test('withScope drops what is empty, so the file stays a record of what someone changed', () => {
+  const raw = nav.withScope({}, 'global', { hidden: [], groups: [], order: {}, topbar: nav.emptyTopbar(), items: [] });
+  assert.deepStrictEqual(raw, {}, 'a scope with nothing in it is not written at all');
+
+  const one = nav.withScope({}, 'dev', { hidden: ['help'], topbar: { start: ['commands'], center: [], end: [] } });
+  assert.deepStrictEqual(one, { workspaces: { dev: { hidden: ['help'], topbar: { start: ['commands'] } } } },
+    'and an empty region is not written either');
+});
+
+test('an id is a slug, and anything else is refused rather than escaped into unreadability', () => {
+  assert.ok(nav.isId('all-workspaces'));
+  assert.ok(!nav.isId('Go To'));
+  assert.ok(!nav.isId('../etc'));
+  assert.ok(!nav.isId(''));
+  assert.strictEqual(nav.regionOf('topbar-end'), 'end');
+  assert.strictEqual(nav.regionOf('go'), null);
+  assert.ok(nav.RESERVED.has('hidden'), 'Hidden is a place, not a group someone can name');
+});
+
+test('the saved file can be read back exactly, and reading it is what a later render sees', () => {
+  const raw = { global: { hidden: ['help'], topbar: { end: ['commands'] }, items: [{ id: 'jira', label: 'Jira', href: '/x' }] } };
+  write(raw);
+  const back = nav.scopeLayout(nav.rawLayout().raw, 'global');
+  assert.deepStrictEqual(back.hidden, ['help']);
+  assert.deepStrictEqual(back.topbar.end, ['commands']);
+  assert.deepStrictEqual(back.items.map((i) => i.id), ['jira']);
+  assert.deepStrictEqual(back.topbar.start, [], 'every key is present, so no caller has to test for undefined');
+});
+
+test('an entry shows its icon, its text, or both — wherever it sits', () => {
+  reset();
+  const groups = [{ id: 'go', label: 'Go', items: [entry('commands', 'Commands'), entry('help', 'Help'), entry('settings', 'Settings')] }];
+  assert.deepStrictEqual(nav.arrange(groups, 'global').groups[0].items.map((i) => i.show), ['', '', ''],
+    'both is what every entry is until somebody says otherwise');
+
+  write({ global: { show: { commands: 'icon', help: 'text' } } });
+  const out = nav.arrange(groups, 'global').groups[0].items;
+  assert.deepStrictEqual(out.map((i) => `${i.id}:${i.show || 'both'}`), ['commands:icon', 'help:text', 'settings:both']);
+});
+
+test('it applies in the top bar as much as in the sidebar: it is about room, not about which strip', () => {
+  write({ global: { show: { commands: 'icon' }, topbar: { end: ['commands'] } } });
+  const out = nav.arrange([{ id: 'go', label: 'Go', items: [entry('commands', 'Commands')] }], 'global');
+  assert.deepStrictEqual(out.topbar.end.map((i) => i.show), ['icon']);
+});
+
+test('an entry the dashboard ships one way keeps it, and an explicit both is what puts it back', () => {
+  reset();
+  const shipped = [{ id: 'go', label: 'Go', items: [{ ...entry('ai-assistant', 'AI Assistant'), show: 'icon' }] }];
+  assert.strictEqual(nav.arrange(shipped, 'global').groups[0].items[0].show, 'icon',
+    'the assistant is its mark and nothing else until the layout says otherwise');
+
+  write({ global: { show: { 'ai-assistant': 'both' } } });
+  const back = nav.arrange(shipped, 'global').groups[0].items[0];
+  assert.strictEqual(back.show, '', 'both, written down, is what overrides a shipped default');
+  assert.strictEqual(back.ships, 'icon', 'and the shipped value is still reported, so the editor can offer it');
+
+  write({ global: { show: { 'ai-assistant': 'text' } } });
+  assert.strictEqual(nav.arrange(shipped, 'global').groups[0].items[0].show, 'text');
+});
+
+test('a value that is not one of the three is not a value', () => {
+  write({ global: { show: { commands: 'sideways', help: 'icon' } } });
+  const layout = nav.scopeLayout(nav.rawLayout().raw, 'global');
+  assert.deepStrictEqual(layout.show, { help: 'icon' });
+});

package/core/workspace-app/tests/unit/new-folder.test.js

@@ -0,0 +1,121 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const folders = require('../../folders');
+const { typeActions } = require('../../workspace-types');
+
+const root = path.join(__dirname, '..', '..');
+const server = fs.readFileSync(path.join(root, 'server.js'), 'utf8');
+
+test('a folder name is lowercase letters, digits, - and _', () => {
+  for (const ok of ['folder1', 'my-app', 'a_b', '9lives']) assert.equal(folders.nameProblem(ok), '', ok);
+  for (const bad of ['', 'My App', '../x', '.hidden', '-x', 'a/b', 'x.y', 'A1', 'a'.repeat(64)]) {
+    assert.notEqual(folders.nameProblem(bad), '', bad);
+  }
+  assert.match(folders.nameProblem('node_modules'), /reserved/);
+});
+
+test('createFolder makes the folder once, inside the workspace, and refuses the rest', () => {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-'));
+  try {
+    const made = folders.createFolder(ws, 'demo1');
+    assert.equal(made.ok, true);
+    assert.ok(fs.statSync(path.join(ws, 'demo1')).isDirectory());
+    assert.equal(folders.createFolder(ws, 'demo1').status, 409);
+    assert.equal(folders.createFolder(ws, '../out').status, 400);
+    assert.equal(folders.createFolder(path.join(ws, 'missing'), 'x').status, 404);
+    assert.equal(folders.suggestName(ws, 'demo'), 'demo2');
+  } finally {
+    fs.rmSync(ws, { recursive: true, force: true });
+  }
+});
+
+test('the form posts the name, the note and what to start, and shows the Claude message only for Claude', () => {
+  const html = folders.folderFormHtml('dev', { label: 'Dev', suggestion: 'folder1' });
+  assert.match(html, /hx-post="\/actions\/folder-new"/);
+  assert.match(html, /name="workspace" value="dev"/);
+  assert.match(html, /name="name"[^>]*value="folder1"/s);
+  for (const v of ['none', 'shell', 'claude']) assert.match(html, new RegExp(`name="then" value="${v}"`));
+  const css = fs.readFileSync(path.join(root, 'public/css/components/folders.css'), 'utf8');
+  assert.match(css, /:has\(input\[name="then"\]\[value="claude"\]:checked\) \.folder-prompt \{ display: block; \}/);
+});
+
+test('every workspace type takes new folders except the AI items, where a folder is a skill', () => {
+  for (const t of ['sites', 'code', 'files', 'media']) assert.ok(typeActions(t).has('folder'), t);
+  assert.ok(!typeActions('ai-items').has('folder'));
+});
+
+test('a files workspace makes the folder inside the one being viewed, with readable names and nothing to set up', () => {
+  assert.equal(folders.nameProblem('Webship Demo Guide 2.0', { files: true }), '');
+  assert.notEqual(folders.nameProblem('Webship Demo Guide', {}), '');
+  for (const bad of ['..', '.x', 'a/b', 'ends.', 'ends ']) assert.notEqual(folders.nameProblem(bad, { files: true }), '', bad);
+  const html = folders.filesFolderFormHtml('docs', { label: 'Docs', sub: 'guides', suggestion: 'new-folder-1' });
+  assert.match(html, /New folder in Docs \/ guides/);
+  assert.match(html, /name="sub" value="guides"/);
+  assert.doesNotMatch(html, /name="ddev"|name="then"/);
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-'));
+  try {
+    assert.equal(folders.createFolder(ws, 'My Guide', { files: true }).ok, true);
+    assert.equal(folders.createFolder(ws, 'My Guide').status, 400);
+  } finally { fs.rmSync(ws, { recursive: true, force: true }); }
+});
+
+test('the files workspaces offer New folder in their Create group, and the form reads the folder being viewed', () => {
+  assert.match(server, /create\.push\(btn\('default', 'tabler:folder-plus', 'New folder', `hx-get="\/fragments\/\$\{esc\(key\)\}\/folder-new" \$\{modal\}`/);
+  assert.match(server, /meta\.kind !== 'files' && require\('\.\/actions\/folders'\)\.canMakeFolder\(key\)/);
+  assert.match(server, /require\('\.\/actions\/folders'\)\.folderFormFor\(fm\[1\], req, \{ readPageState \}\)/);
+  const src = fs.readFileSync(path.join(root, 'actions/folders.js'), 'utf8');
+  assert.match(src, /req\.headers\['hx-current-url'\]/);
+  assert.match(src, /if \(isFilesWorkspace\(ws\)\) return filesFolderNew/);
+  assert.match(src, /safeSub\(ws, String\(form\.sub \|\| ''\)\)/);
+});
+
+test('the Create group, the form route and the action are wired in', () => {
+  assert.match(server, /btn\('default', 'tabler:folder-plus', 'New folder'/);
+  assert.match(server, /\\\/fragments\\\/\(\[a-z0-9_-\]\+\)\\\/folder-new\$/);
+  assert.match(server, /\.\.\.require\('\.\/actions\/folders'\)/);
+  const action = require('../../actions/folders');
+  assert.equal(typeof action['/actions/folder-new'], 'function');
+});
+
+test('the form offers Configure DDEV, and webship-js only where the workspace can test', () => {
+  const types = require('../../actions/folders').projectTypes();
+  assert.ok(types.includes('php') && types.includes('drupal11'));
+  const withTests = folders.folderFormHtml('dev', { projectTypes: types, canTest: true });
+  assert.match(withTests, /name="ddev" value="1"/);
+  assert.match(withTests, /name="e2e" value="1"/);
+  assert.match(withTests, /<option value="php" selected>/);
+  assert.doesNotMatch(folders.folderFormHtml('modules', { projectTypes: types, canTest: false }), /name="e2e"/);
+  const css = fs.readFileSync(path.join(root, 'public/css/components/folders.css'), 'utf8');
+  assert.match(css, /:has\(\.folder-setup input:checked\) \.folder-ddev-type \{ display: block; \}/);
+});
+
+test('the setup line chains DDEV, the webship-js setup and what the plugins add, in that order', () => {
+  const fa = require('../../actions/folders');
+  const line = fa.setupLine('dev', 'demo1', { ddev: '1', e2e: '1', project_type: 'php' });
+  assert.ok(line.startsWith("( cd 'demo1' && ddev 'config' '--auto=false' '--project-name=demo1' '--project-type=php' '--docroot=' )"), line);
+  assert.ok(line.indexOf("bash cmd-tools-testing.sh 'demo1'") > line.indexOf("'config'"));
+  // webship-js alone still configures DDEV first, and an unknown type falls back to php.
+  assert.match(fa.setupLine('dev', 'demo1', { e2e: '1', project_type: 'nope' }), /'--project-type=php'/);
+  assert.equal(fa.setupLine('dev', 'demo1', {}), '');
+});
+
+test('the AI tasks go to one Claude Code prompt, and the form is checked before anything is made', () => {
+  const fa = require('../../actions/folders');
+  const p = fa.claudePrompt('dev', 'demo1', { note: 'Try search', prompt: 'Then say hello' });
+  assert.ok(p.endsWith('Then say hello'));
+  assert.equal(fa.claudePrompt('dev', 'demo1', {}), '');
+  assert.equal(fa.formProblem('dev', {}), '');
+});
+
+test('the form offers the sections plugins hand it, under Connect it', () => {
+  const html = folders.folderFormHtml('dev', { pluginSetups: '<div class="x-plugin-setup">cloud</div>' });
+  assert.match(html, /Connect it/, 'the section opens when a plugin hands something in');
+  assert.match(html, /x-plugin-setup/, 'a plugin section is under Connect it');
+  const bare = folders.folderFormHtml('modules', {});
+  assert.doesNotMatch(bare, /Connect it/);
+  const css = fs.readFileSync(path.join(root, 'public/css/components/folders.css'), 'utf8');
+});

package/core/workspace-app/tests/unit/new-screen-form.test.js

@@ -0,0 +1,149 @@
+/**
+ * The New screen form.
+ *
+ * It asked four questions in one row of controls, and one of them was a select of 309 entries — every
+ * workspace folder and every project in the tree, flat. Now it asks them in the order they are answered:
+ * where it runs (the workspace, then what is inside it), what it starts, its arguments, and the prompt.
+ *
+ * Three things must not drift. The place is picked in TWO lists, so neither is long. The session name is
+ * pre-filled with where it runs, because that is what `screen -ls` shows and what `screen -r` takes —
+ * but a name typed by hand is never overwritten. And the Claude arguments come from `claude --help`,
+ * so a free-text box of flags nobody checks is not the way back in.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const path = require('path');
+
+const read = (f) => fs.readFileSync(path.join(__dirname, '..', '..', f), 'utf8');
+const screens = require('../../screens');
+const src = read('screens.js');
+const ui = read('public/ui.js');
+const action = read('actions/screens.js');
+const server = read('server.js');
+
+test('the place is two lists, not one of three hundred', () => {
+  // One list of the workspaces, then one of what is inside the chosen one. The workspace list is short
+  // whatever the tree holds; the long one only ever shows a single workspace's projects.
+  const workspaces = screens.workspaceOptionsHtml('root');
+  assert.ok((workspaces.match(/<option/g) || []).length < 40, 'the workspace list is short enough to read');
+  assert.match(workspaces, /value="root"/, 'the workspace root is one of them');
+  assert.match(src, /const inside = screenTargets\(\)\.filter\(\(t\) => t\.value === `ws:\$\{key\}` \|\| t\.value\.startsWith\(`p:\$\{key\}:`\)\);/,
+    'and the second list is scoped to that workspace, not the whole tree');
+});
+
+test('a workspace folder is a place in its own right, listed first', () => {
+  assert.match(src, /const folder = t\.value === `ws:\$\{key\}`;/);
+  assert.match(src, /folder \? `the \$\{key\}\/ folder itself`/,
+    'the folder itself is an option that says what it is, not something to notice is missing');
+});
+
+test('every place carries where it is, so the path follows the choice with no request', () => {
+  assert.match(src, /data-path="\$\{esc\(tildePath\(t\.dir\)\)\}"/);
+  assert.match(ui, /line\.textContent = path\.path;/);
+});
+
+test('reopening the form lands on the list the target was picked from', () => {
+  assert.strictEqual(screens.workspaceOfTarget('p:dev:ha1x00b1'), 'dev');
+  assert.strictEqual(screens.workspaceOfTarget('ws:modules'), 'modules');
+  assert.strictEqual(screens.workspaceOfTarget('root'), 'root');
+  assert.strictEqual(screens.workspaceOfTarget(''), 'root');
+});
+
+test('the session name is pre-filled with where it runs, and a short id of its own', () => {
+  assert.strictEqual(screens.defaultSessionName('p:dev:ha1x00b1', '7f3a'), 'dev--ha1x00b1--7f3a');
+  assert.strictEqual(screens.defaultSessionName('ws:modules', '7f3a'), 'modules--7f3a');
+  assert.strictEqual(screens.defaultSessionName('root', '7f3a'), 'workspace-7f3a',
+    "not 'root': in screen -ls that reads as the user it runs as, which it is not");
+  assert.match(screens.defaultSessionName('p:dev:Weird Name!'), /^[a-z0-9][a-z0-9._-]*$/,
+    'and it is a name screen(1) accepts');
+});
+
+test('the id makes it startable twice: two names for one place are not the same name', () => {
+  const a = screens.defaultSessionName('p:dev:ha1x00b1');
+  const b = screens.defaultSessionName('p:dev:ha1x00b1');
+  assert.notStrictEqual(a, b, 'a second session in one project was refused as a name that already exists');
+  assert.match(a, /^dev--ha1x00b1--[0-9a-f]{4}$/);
+});
+
+test('the pre-filled name already says where it runs, so the endpoint does not say it again', () => {
+  const name = screens.defaultSessionName('p:dev:ha1x00b1', '7f3a');
+  assert.ok(name.startsWith('dev--ha1x00b1--'), 'which is exactly what the endpoint checks for');
+});
+
+test('a name typed by hand is never overwritten by the place changing', () => {
+  assert.match(ui, /if \(field\.value && field\.value !== field\.dataset\.derived\) return;/);
+  assert.match(src, /data-derived="\$\{esc\(prefilled\)\}"/,
+    'the rendered default says it was derived, or the first change would look hand-typed');
+  assert.match(src, /data-tail="\$\{esc\(prefilled\.slice\(-4\)\)\}"/,
+    'and carries its id, so changing the place does not roll a new one every time');
+});
+
+test('a name that already says where it runs is not made to say it twice', () => {
+  assert.match(action, /const said = prefix && \(`\$\{session\}--` === prefix \|\| session\.startsWith\(prefix\)\);/,
+    'dev--ha1x00b1 must not become dev--ha1x00b1--dev--ha1x00b1');
+});
+
+test('the free-text flags box is gone, and nothing reads it any more', () => {
+  assert.ok(!/name="options"/.test(src), 'the box that meant knowing every flag by heart is not rendered');
+  assert.ok(!action.includes("form.options"), 'and the endpoint no longer takes a string of flags');
+  assert.match(action, /claudeArgs\.flagsFromForm\(options, form\)/);
+  assert.match(action, /if \(problems\.length\)/, 'a value it will not pass on is said out loud');
+});
+
+test('the arguments are the installed CLI own, not a list kept here by hand', () => {
+  assert.match(src, /await claudeArgs\.claudeOptions\(\)/);
+  assert.match(src, /Read from <code>claude --help<\/code> on this machine/);
+  assert.match(src, /The Claude Code options could not be read from/,
+    'a machine with no claude still gets a form, and is told why it is shorter');
+});
+
+test('each argument gets the control its own shape asks for', () => {
+  assert.match(src, /if \(opt\.takes === 'none'\) \{[\s\S]{0,200}type="checkbox"/);
+  assert.match(src, /opt\.choices\.length[\s\S]{0,80}<select/);
+  assert.match(src, /opt\.repeatable \? ' — space separated' : ''/);
+});
+
+test('the four reached for every time are in front of the other thirty', () => {
+  assert.match(src, /claudeArgs\.COMMON\.map/);
+  assert.match(src, /<summary>All Claude Code options \(\$\{rest\.length\}\)<\/summary>/);
+});
+
+test('a prompt template puts its flags on the controls that own them', () => {
+  assert.match(ui, /window\.screenPromptTemplate = function screenPromptTemplate/);
+  assert.match(ui, /if \(field\.type === 'checkbox'\) \{ field\.checked = true; continue; \}/);
+  assert.ok(!src.includes('f.options.value = fl'), 'not into a text box that no longer exists');
+});
+
+test('the kind is three named choices, and it decides what the rest of the form asks', () => {
+  assert.match(src, /type="radio" name="kind" value="\$\{value\}"/);
+  assert.match(ui, /for \(const el of form\.querySelectorAll\('\[data-claude-only\]'\)\) el\.hidden = kind !== 'claude';/);
+  assert.match(ui, /for \(const el of form\.querySelectorAll\('\[data-not-claude\]'\)\) el\.hidden = kind === 'claude';/);
+});
+
+test('the form arrives in a modal, so its state is settled on the swap rather than on load', () => {
+  assert.match(ui, /document\.body\.addEventListener\('htmx:after:settle'/);
+  assert.match(ui, /el\.id === 'screen-where' \? el : el\.querySelector\('#screen-where'\)/);
+});
+
+test('changing the workspace or the place does not close the modal', () => {
+  const where = src.slice(src.indexOf('function screenWhereHtml'), src.indexOf('function claudeArgFieldHtml'));
+  assert.match(where, /hx-on::after:request="event\.stopPropagation\(\)"/,
+    "the form's own after:request hides the modal — these requests must not reach it");
+  assert.match(src, /hx-get="\/fragments\/screen-where"/);
+  assert.match(server, /pathname === '\/fragments\/screen-where'/);
+});
+
+test('the resume row is per DIRECTORY, so a workspace folder has one exactly as a project does', () => {
+  assert.match(src, /a workspace folder has its own sessions exactly\s*\n?\s*\*? ?as a project does|folder has its own sessions exactly as a project does/,
+    'stated where somebody would look for it');
+  assert.match(src, /<div id="claude-resume-row">\$\{claudeResumeHtml\(p\.target\)\}<\/div>/);
+  assert.match(src, /hx-target="#claude-resume-row"/, 'and it reloads when the place changes');
+});
+
+test('an empty session name is filled in, not refused', () => {
+  assert.match(action, /String\(form\.session \|\| ''\)\.trim\(\) \|\| defaultSessionName\(form\.target\)/,
+    'refusing it made the one field nobody wants to think about the one that fails');
+  assert.ok(!/name="session" id="screen-session" required/.test(src), 'so the field is not required either');
+});