@webship.co/workspace 0.0.0-stage → 1.0.0-beta1

package/actions/project-make.js

@@ -0,0 +1,28 @@
+/**
+ * Make a video or an audio recording about a project: the form of the row's More menu posts here.
+ * It starts a Claude Code session in the project through the same handler New screen uses, briefed by
+ * `project-make.js`, so it shows on Screens like every other session.
+ */
+
+const { esc } = require('../html');
+const make = require('../project-make');
+
+async function project_make({ form, send, res }) {
+  const brief = make.brief(form);
+  if (brief.error) return send(`<div class="msg error">${esc(brief.error)}</div>`, 400);
+  let out = null;
+  await require('./screens')['/actions/screen-new']({
+    form: { target: brief.target, kind: 'claude', session: brief.session, command: brief.prompt },
+    send: (html, status = 200) => { out = { html, status }; },
+    res,
+  });
+  if (!out || out.status >= 400) return send((out && out.html) || '<div class="msg error">The session did not start.</div>', (out && out.status) || 500);
+  const name = `${brief.project ? `${brief.ws}--${brief.project}` : brief.ws}--${brief.session}`.toLowerCase();
+  const dest = make.KIND[brief.kind].dest;
+  return send(`<div class="msg assistant">
+      <p>The AI (Claude Code) is working${brief.project ? ` in <strong>${esc(brief.ws)}/${esc(brief.project)}</strong>` : ''}, in the session <code>${esc(name)}</code>.</p>
+      <p class="uk-text-meta">It writes the words first and waits for your yes. Watch and answer it on <a href="/screens">Screens</a>, or
+        <code>screen -r ${esc(name)}</code> in your terminal. The result lands in <a href="https://${esc(dest)}.${esc(require('../workspaces').hubDomain())}">${esc(dest)}</a>.</p></div>`);
+}
+
+module.exports = { '/actions/project-make': project_make };

package/actions/rag.js

@@ -0,0 +1,202 @@
+/**
+ * Indexing a project into Milvus, searching it, and choosing which server holds it.
+ *
+ * One module per area of the dashboard, each exporting the handlers it owns keyed by the path that
+ * reaches them. server.js merges the maps and dispatches; nothing here knows about routing, and
+ * adding an action is adding an entry rather than another branch in a 1,250-line function.
+ *
+ * Every handler takes the same context: the parsed form, the response, a `send` that writes an HTML
+ * fragment, and the workspace the request named.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('../html');
+const { humanSize, humanTime } = require('../format');
+const { ROOT, loadWorkspaces, workspaceDir } = require('../workspaces');
+const {
+  run, jobFragment, runningJobKey, startJob, ddevProjectName, listProjects,
+  startInScreen, screenStartedHtml, screenAction,
+} = require('../jobs');
+const { graphStoreDir } = require('../graphs');
+const {
+  milvusProjectName, ragInstances, ragBindings, ragInstanceFor, ragWriteBinding,
+  ragCollectionName, milvusPost, ragCollections, ragInvalidate,
+} = require('../rag');
+const {
+  findTestReports, testReportFor, invalidateTestReports, testMediaHtml, testingStackOf,
+} = require('../test-reports');
+const { NAME_RE, SCRIPT_RE } = require('../validate');
+const { commandBlock } = require('../command-block');
+const { wsUrl } = require('../urls');
+const { findGraphifyScript, findRagifyScript } = require('../workspaces');
+const { DDEV_ACTIONS } = require('../ddev');
+
+async function rag_mcp_command({ form, res, send, workspace, pathname }) {
+    const projectName = String(form.projectName || '');
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    const instance = ragInstanceFor(workspace, projectName);
+    const collection = ragCollectionName(workspace, projectName);
+    return send(commandBlock(
+      `Serve the ${instance} RAG server to the Claude Code CLI`,
+      [`cd ${ROOT}/rag && bash cmd-milvus-mcp.sh ${instance} -a register`,
+        `claude mcp add --scope user rag-${instance} -- uvx --from mcp-server-milvus==0.1.1.dev9 --with "mcp<2" mcp-server-milvus --milvus-uri http://127.0.0.1:19530`],
+      `Run either one <strong>on the host</strong>, in a terminal. One registration covers the whole `
+      + `server, so every collection on it — including <code>${esc(collection)}</code> — is searchable `
+      + `from the same 13 tools, and a new index needs no new registration. The workspace command is `
+      + `the safer of the two: it resolves the published port for you and proves the server starts `
+      + `before registering it.`));
+}
+
+  // Bind a project to a RAG server, or unbind it back to the shared default.
+async function rag_bind({ form, res, send, workspace, pathname }) {
+    const projectName = String(form.projectName || '');
+    const instance = String(form.instance || '');
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    if (instance && !ragInstances().includes(instance)) {
+      return send('<div class="msg error">No such RAG server in the rag workspace.</div>', 400);
+    }
+    ragWriteBinding(workspace, projectName, instance);
+    ragInvalidate();
+    res.setHeader('HX-Trigger', 'refresh-projects');
+    const where = instance || `${milvusProjectName()} (the shared default)`;
+    return send(`<div class="msg assistant">🔗 <strong>${esc(projectName)}</strong> now indexes into <strong>${esc(where)}</strong>.
+      Re-index it to fill that server — the old collection stays where it was, so drop it first if it is stale.</div>`);
+}
+
+  // Build a new RAG server, and bind this project to it. Two steps deliberately kept in one
+  // action: a server built and then not bound is a 2 GB stack nothing uses.
+async function rag_server_new({ form, res, send, workspace, pathname }) {
+    const projectName = String(form.projectName || '');
+    const name = String(form.name || '').trim();
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    if (!NAME_RE.test(name)) return send('<div class="msg error">A server name is letters, digits, dashes and underscores.</div>', 400);
+    if (ragInstances().includes(name)) return send(`<div class="msg error">A RAG server called ${esc(name)} already exists — pick it from the list instead.</div>`, 409);
+    const ragDir = workspaceDir('rag');
+    const script = 'cmd-milvus-project.sh';
+    if (!fs.existsSync(path.join(ragDir, script))) return send('<div class="msg error">No Milvus builder in the rag workspace.</div>', 400);
+    const jobKey = `milvus-build:${name}`;
+    if (runningJobKey(jobKey)) return send('<div class="msg error">That server is already being built.</div>', 409);
+    // Bound first: the build takes minutes, and the binding is what makes the row point at the new
+    // server the moment it answers.
+    ragWriteBinding(workspace, projectName, name);
+    ragInvalidate();
+    return screenAction(send, { workspace: 'rag', project: name, projectDir: ragDir, verb: 'milvus-build',
+      cmdLine: `bash ${JSON.stringify(script)} ${JSON.stringify(name)}`, label: `build the RAG server ${name}` });
+}
+
+  // Build or rebuild a project's RAG index. The script does the work — this only guards the
+  // arguments and keeps two runs off one collection, since a re-index drops and recreates it and
+  // two of those racing would leave half of each.
+async function ragify({ form, res, send, workspace, pathname }) {
+    const dir = workspaceDir(workspace);
+    const script = findRagifyScript(dir);
+    const projectName = String(form.projectName || '');
+    if (!script) return send('<div class="msg error">No ragify script in this workspace.</div>', 400);
+    if (!NAME_RE.test(projectName) || !listProjects(dir).includes(projectName)) {
+      return send('<div class="msg error">Unknown project.</div>', 400);
+    }
+    const instance = ragInstanceFor(workspace, projectName);
+    const { up } = await ragCollections(instance);
+    if (!up) {
+      return send(`<div class="msg error">The ${esc(instance)} RAG server is not running — start it from the <a href="${wsUrl('rag')}">RAG workspace</a> first.</div>`, 409);
+    }
+    const jobKey = `ragify:${workspace}/${projectName}`;
+    if (runningJobKey(jobKey)) {
+      return send('<div class="msg error">This project is already being indexed.</div>', 409);
+    }
+    // BM25 inside the database: no embedding model, no API key, nothing leaves the machine. Long
+    // timeout because a large tree is thousands of chunks.
+    const started = await startInScreen({ workspace, project: projectName, projectDir: dir, ownerDir: path.join(dir, projectName), verb: 'ragify',
+      cmdLine: `bash ${JSON.stringify(script)} ${JSON.stringify(projectName)}`, label: 'ragify' });
+    return send(screenStartedHtml(started, 'ragify', projectName), started.ok ? 200 : (started.already ? 409 : 500));
+}
+
+async function rag_info({ form, res, send, workspace, pathname }) {
+    const projectName = String(form.projectName || '');
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    const collection = ragCollectionName(workspace, projectName);
+    const instance = ragInstanceFor(workspace, projectName);
+    const described = await milvusPost('/v2/vectordb/collections/describe', { collectionName: collection }, 4000, instance);
+    const stats = await milvusPost('/v2/vectordb/collections/get_stats', { collectionName: collection }, 4000, instance);
+    if (!described || described.code !== 0) {
+      return send('<div class="msg error">Milvus did not answer for this collection — is the instance running?</div>', 409);
+    }
+    const fields = (described.data.fields || []).map((f) => f.name);
+    const functions = (described.data.functions || []).map((f) => `${f.name} (${f.type || 'function'})`);
+    const rows = stats && stats.code === 0 ? stats.data.rowCount : '?';
+    return send(`<div class="msg assistant">
+      <strong>${esc(collection)}</strong><br>
+      Chunks: <strong>${esc(String(rows))}</strong><br>
+      Fields: <code>${esc(fields.join(', '))}</code><br>
+      Functions: <code>${esc(functions.join(', ') || '—')}</code><br>
+      <span class="uk-text-meta">Retrieval is BM25, built inside Milvus — no embedding model and no API key.</span>
+    </div>`);
+}
+
+  // Search one index. Straight over Milvus's REST API rather than through the Python worker: the
+  // dashboard container has no pymilvus, and full-text search on a BM25 function field takes the
+  // query as plain text in `data`.
+async function rag_search({ form, res, send, workspace, pathname }) {
+    const projectName = String(form.projectName || '');
+    const query = String(form.query || '').trim();
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    if (!query) return send('<p class="uk-text-meta">Type a question first.</p>');
+    const collection = ragCollectionName(workspace, projectName);
+    const body = await milvusPost('/v2/vectordb/entities/search', {
+      collectionName: collection,
+      data: [query],
+      annsField: 'sparse',
+      limit: 8,
+      outputFields: ['path', 'start_line', 'end_line', 'text'],
+    }, 20000, ragInstanceFor(workspace, projectName));
+    if (!body || body.code !== 0) {
+      return send(`<div class="msg error">Milvus refused the search${body && body.message ? `: ${esc(body.message)}` : ''}.</div>`);
+    }
+    const hits = body.data || [];
+    if (!hits.length) return send(`<p class="uk-text-meta">No passage in <code>${esc(collection)}</code> matches ${esc(query)}.</p>`);
+    const cards = hits.map((h) => {
+      // The path is indexed as the first line of the chunk (so a filename matches even when the
+      // words are not in the file) — show the body, not that duplicate.
+      const text = String(h.text || '');
+      const nl = text.indexOf('\n');
+      const bodyText = nl === -1 ? text : text.slice(nl + 1);
+      return `<div class="uk-card uk-card-default uk-card-small uk-card-body uk-margin-small">
+        <div class="uk-text-bold">${esc(h.path)}<span class="uk-text-meta">:${esc(String(h.start_line))}-${esc(String(h.end_line))}</span>
+          <span class="uk-label">score ${esc(String(Math.round((h.distance || 0) * 100) / 100))}</span></div>
+        <pre class="uk-margin-small-top" style="max-height:16rem;overflow:auto"><code>${esc(bodyText.split('\n').slice(0, 24).join('\n'))}</code></pre>
+      </div>`;
+    }).join('');
+    return send(`<p class="uk-text-meta">${hits.length} passages for ${esc(query)} in <code>${esc(collection)}</code>, best first.</p>${cards}`);
+}
+
+  // Drop one index. Regenerable by definition — a re-index rebuilds it from the tree — and the
+  // project itself is never touched: nothing of the index lives in it.
+async function rag_remove({ form, res, send, workspace, pathname }) {
+    if (form.confirm !== 'yes') return send('<div class="msg error">Deleting requires confirmation.</div>', 400);
+    const projectName = String(form.projectName || '');
+    if (!NAME_RE.test(projectName)) return send('<div class="msg error">Unknown project.</div>', 400);
+    if (runningJobKey(`ragify:${workspace}/${projectName}`)) {
+      return send('<div class="msg error">An index run is in progress for this project — wait for it to finish.</div>', 409);
+    }
+    const collection = ragCollectionName(workspace, projectName);
+    const body = await milvusPost('/v2/vectordb/collections/drop', { collectionName: collection }, 4000,
+      ragInstanceFor(workspace, projectName));
+    if (!body || body.code !== 0) {
+      return send('<div class="msg error">Milvus did not drop the collection — is the instance running?</div>', 409);
+    }
+    ragInvalidate();
+    res.setHeader('HX-Trigger', 'refresh-projects');
+    return send(`<div class="msg assistant">🗑️ Deleted the index <strong>${esc(collection)}</strong>. Rebuild it any time from the RAG menu.</div>`);
+}
+
+module.exports = {
+  '/actions/rag-mcp-command': rag_mcp_command,
+  '/actions/rag-bind': rag_bind,
+  '/actions/rag-server-new': rag_server_new,
+  '/actions/ragify': ragify,
+  '/actions/rag-info': rag_info,
+  '/actions/rag-search': rag_search,
+  '/actions/rag-remove': rag_remove,
+};

package/actions/row-actions.js

@@ -0,0 +1,262 @@
+/**
+ * Commands → Buttons (rows management), and running the actions it lets someone add.
+ *
+ * Every change answers with the editor re-rendered, on the tab it came from. Each form carries the file's
+ * mtime from when it was drawn, and a write refuses with 409 when the file changed since — another tab,
+ * or a hand edit — rather than silently writing over it. An action change made from the Rows tab carries
+ * the rest of that form, so a drag not yet saved is not lost by adding, editing or deleting an action.
+ *
+ * An action is run by id only. Its steps come from the file, never from the request; the only things a
+ * request carries into a run are option values, each checked against its option and single-quoted.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('../html');
+const { workspaceDir } = require('../workspaces');
+const { screenStartedHtml, screenSessionName } = require('../jobs');
+const { NAME_RE } = require('../validate');
+const { lingerTail } = require('../linger');
+const { hasOwnGit } = require('../git-info');
+const { startUnlessRunning, terminalLink, isDdevProject, hasComposerJson, SAFE_PATH_RE } = require('./composer');
+const { hasPackageJson } = require('./node');
+const rowLayout = require('../row-layout');
+const catalog = require('../commands');
+
+const paneOf = (form) => (['0', '1', '2'].includes(String(form.pane)) ? Number(form.pane) : 0);
+// The card someone was working in stays open when the editor comes back.
+const editor = (send, form, message, code = 200) => send(rowLayout.rowActionsEditorHtml(message, paneOf(form),
+  { openButton: String(form.open_button || '') }), code);
+const ok = (text) => `<div class="msg assistant">✅ ${text}</div>`;
+const bad = (text) => `<div class="msg error">${text}</div>`;
+
+/** Write, or answer with why not. True when it was written. */
+function write(send, form, fn) {
+  try {
+    fn();
+    return true;
+  } catch (err) {
+    if (err && err.code === 'CHANGED') {
+      editor(send, form, bad('Row actions changed since this page was loaded (another tab, or a hand edit), so nothing was saved. This is the current state.'), 409);
+    } else {
+      editor(send, form, bad(`Could not save: ${esc(String(err && err.message || err))}`), 500);
+    }
+    return false;
+  }
+}
+
+/** The layout with whatever the Rows form carried applied to it (unchanged when the request had no form). */
+function arranged(form) {
+  const layout = rowLayout.loadRowLayoutFresh();
+  return rowLayout.arrangementFromForm(layout, form);
+}
+
+// One step a line. A line `use: <command id>` runs that command of the catalog; any other line is a command line.
+const stepsFrom = (text) => String(text || '').split(/\r?\n/).map((l) => l.trim()).filter(Boolean)
+  .map((l) => { const m = /^use:\s*(\S+)$/.exec(l); return m ? { use: m[1] } : l; });
+
+async function arrange_save({ form, send }) {
+  const next = rowLayout.normalizeLayout(arranged(form));
+  if (!write(send, form, () => rowLayout.saveRowLayout(next, form.mtime))) return undefined;
+  return editor(send, form, ok('Rows saved. Reload a workspace page to see them.'));
+}
+
+async function rows_op({ form, send }) {
+  const doc = arranged(form);
+  const i = Number(form.index);
+  const op = String(form.op || '');
+  if (op === 'add') {
+    if (doc.rows.length >= rowLayout.MAX_ROWS) return editor(send, form, bad(`Up to ${rowLayout.MAX_ROWS} rows.`), 400);
+    doc.rows.push([]);
+  } else if (!Number.isInteger(i) || i < 0 || i >= doc.rows.length) {
+    return editor(send, form, bad('No such row.'), 400);
+  } else if (op === 'remove') {
+    if (doc.rows.length === 1) return editor(send, form, bad('A project row keeps at least one row.'), 400);
+    const [gone] = doc.rows.splice(i, 1);
+    doc.rows[Math.max(0, i - 1)].push(...gone);
+  } else if (op === 'up' || op === 'down') {
+    const j = op === 'up' ? i - 1 : i + 1;
+    if (j < 0 || j >= doc.rows.length) return editor(send, form, bad('That row cannot move further.'), 400);
+    [doc.rows[i], doc.rows[j]] = [doc.rows[j], doc.rows[i]];
+  } else {
+    return editor(send, form, bad('Unknown row operation.'), 400);
+  }
+  if (!write(send, form, () => rowLayout.saveRowLayout(rowLayout.normalizeLayout(doc), form.mtime))) return undefined;
+  const said = { add: 'Row added', remove: 'Row removed — its buttons moved to the row above', up: 'Row moved up', down: 'Row moved down' }[op];
+  return editor(send, form, ok(`${said}. Reload a workspace page to see it.`));
+}
+
+async function custom_add({ form, send }) {
+  const doc = arranged(form);
+  const key = form.for_button === '__new__' ? 'new' : String(form.for_button || '');
+  const field = (n) => (form[`add_${n}_${key}`] === undefined ? '' : String(form[`add_${n}_${key}`]));
+  // A command picked with nothing typed is the whole action: it takes that command's label, group and node filter.
+  const typed = stepsFrom(field('steps'));
+  const use = field('use').trim();
+  const alone = use && !typed.length ? catalog.findCommand(use) : null;
+  const label = field('label').trim() || (alone ? alone.label : '');
+  const taken = new Set(doc.custom.map((c) => c.id));
+  const base = rowLayout.slug(label);
+  let id = base;
+  for (let n = 2; taken.has(id); n += 1) id = `${base}-${n}`;
+  const entry = rowLayout.cleanCustom({
+    id, label,
+    button: key === 'new' ? field('button') : key,
+    group: field('group').trim() || (alone ? alone.group : 'Custom'),
+    when: alone && (!field('when') || field('when') === 'any') ? alone.when : (field('when') || 'any'),
+    steps: use ? [...typed, { use }] : typed,
+    keepgoing: field('keepgoing') === '1',
+    confirm: field('confirm') === '1',
+    open: field('open'),
+  });
+  const why = rowLayout.customRefusal(entry) || rowLayout.useRefusal(entry);
+  if (why) return editor(send, form, bad(`Not added: ${esc(why)}.`), 400);
+  doc.custom.push(rowLayout.customToDoc(entry));
+  if (!write(send, form, () => rowLayout.saveRowLayout(rowLayout.normalizeLayout(doc), form.mtime))) return undefined;
+  return editor(send, form, ok(`Added ${esc(entry.label)} to ${esc(rowLayout.buttonLabel(entry.button))}. Reload a workspace page to see it.`));
+}
+
+async function custom_save({ form, send }) {
+  const doc = arranged(form);
+  const id = String(form.id || '');
+  const at = doc.custom.findIndex((c) => c.id === id);
+  if (at < 0) return editor(send, form, bad('No such action — it may have been deleted.'), 404);
+  const old = rowLayout.cleanCustom(doc.custom[at]);
+  const field = (n) => (form[`edit_${n}_${id}`] === undefined ? '' : String(form[`edit_${n}_${id}`]));
+  // A step whose text did not change keeps its on_error; options are kept whole (Definition edits those).
+  const steps = stepsFrom(field('steps')).map((step, i) => {
+    const was = old.steps[i];
+    const text = typeof step === 'string' ? step : `use: ${step.use}`;
+    if (!was || !was.onError || rowLayout.stepText(was) !== text) return step;
+    return typeof step === 'string' ? { command: step, on_error: was.onError } : { use: step.use, on_error: was.onError };
+  });
+  const entry = rowLayout.cleanCustom({
+    ...rowLayout.customToDoc(old),
+    command: undefined,
+    label: field('label').trim(),
+    group: field('group').trim() || 'Custom',
+    when: field('when').trim().split(/\s+/).filter(Boolean),
+    steps,
+    keepgoing: field('keepgoing') === '1',
+    confirm: field('confirm') === '1',
+    open: field('open'),
+  });
+  const why = rowLayout.customRefusal(entry) || rowLayout.useRefusal(entry);
+  if (why) return editor(send, form, bad(`Not saved: ${esc(why)}.`), 400);
+  doc.custom[at] = rowLayout.customToDoc(entry);
+  if (!write(send, form, () => rowLayout.saveRowLayout(rowLayout.normalizeLayout(doc), form.mtime))) return undefined;
+  return editor(send, form, ok(`Saved ${esc(entry.label)}. Reload a workspace page to see it.`));
+}
+
+async function custom_remove({ form, send }) {
+  const doc = arranged(form);
+  const id = String(form.id || '');
+  if (!doc.custom.some((c) => c.id === id)) return editor(send, form, bad('No such action — only actions you added can be deleted.'), 404);
+  doc.custom = doc.custom.filter((c) => c.id !== id);
+  if (!write(send, form, () => rowLayout.saveRowLayout(rowLayout.normalizeLayout(doc), form.mtime))) return undefined;
+  return editor(send, form, ok('Action deleted.'));
+}
+
+async function layout_reset({ form, send }) {
+  if (!write(send, form, () => rowLayout.resetRowLayout(form.mtime))) return undefined;
+  return editor(send, form, ok('Back to the defaults.'));
+}
+
+function reportHtml(report) {
+  return `${report.errors.map((e) => bad(esc(e))).join('')}${report.notes.length
+    ? `<div class="msg assistant">${report.errors.length ? '' : '✅ '}${report.notes.map(esc).join(' ')}</div>` : ''}`;
+}
+
+async function definition_check({ form, send }) {
+  const report = rowLayout.checkDefinition(form.definition, String(form.mode || 'replace'), rowLayout.loadRowLayoutFresh());
+  if (!report.errors.length) report.notes.unshift('It loads cleanly.');
+  return send(reportHtml(report), report.errors.length ? 400 : 200);
+}
+
+async function definition_save({ form, send }) {
+  const report = rowLayout.checkDefinition(form.definition, String(form.mode || 'replace'), rowLayout.loadRowLayoutFresh());
+  if (report.errors.length) return editor(send, { ...form, pane: '2' }, `${bad('Nothing was saved:')}${reportHtml(report)}`, 400);
+  if (!write(send, { ...form, pane: '2' }, () => rowLayout.saveRowLayout(report.next, form.mtime))) return undefined;
+  return editor(send, { ...form, pane: '2' }, ok(`Loaded. ${report.notes.map(esc).join(' ')}`));
+}
+
+/** The action and the folder it would run in, or an answer saying why not. */
+function actionTarget({ form, send, workspace }) {
+  const projectName = String(form.projectName || '');
+  if (!NAME_RE.test(projectName)) { send(bad('Invalid project name.'), 400); return { done: true }; }
+  const entry = rowLayout.loadRowLayout().custom.find((c) => c.id === String(form.id || ''));
+  if (!entry) { send(bad('No such action — it may have been deleted in Commands → Buttons.'), 404); return { done: true }; }
+  const why = rowLayout.customRefusal(entry);
+  if (why) { send(bad(`Not running ${esc(entry.label)}: ${esc(why)}.`), 400); return { done: true }; }
+  const projectDir = path.join(workspaceDir(workspace), projectName);
+  let isDir = false;
+  try { isDir = fs.statSync(projectDir).isDirectory(); } catch (_) { /* not there */ }
+  if (!isDir) { send(bad(`No folder called ${esc(projectName)} here.`), 400); return { done: true }; }
+  if (!SAFE_PATH_RE.test(projectDir)) { send(bad('Not running it: the folder path has characters a shell line cannot carry safely.'), 400); return { done: true }; }
+  const ctx = { key: workspace, isDdev: isDdevProject(projectDir), hasComposer: hasComposerJson(projectDir), hasNode: hasPackageJson(projectDir), hasGit: hasOwnGit(projectDir) };
+  if (!rowLayout.whenMatches(entry.when, ctx)) { send(bad(`${esc(entry.label)} is only for ${esc(rowLayout.describeWhen(entry.when))}.`), 400); return { done: true }; }
+  const used = rowLayout.useRefusal(entry);
+  if (used) { send(bad(`Not running ${esc(entry.label)}: ${esc(used)}.`), 400); return { done: true }; }
+  // A command a step uses keeps its own node filter: the action's filter does not widen it.
+  for (const { cmd } of rowLayout.usedCommands(entry)) {
+    if (!rowLayout.whenMatches(cmd.when, ctx)) {
+      send(bad(`${esc(entry.label)} uses ${esc(cmd.label)}, which is only for ${esc(rowLayout.describeWhen(cmd.when))}.`), 400);
+      return { done: true };
+    }
+  }
+  return { entry, projectName, projectDir };
+}
+
+async function custom_options(args) {
+  const t = actionTarget(args);
+  if (t.done) return undefined;
+  return args.send(rowLayout.actionOptionsFormHtml(t.entry, { workspace: args.workspace, project: t.projectName }));
+}
+
+async function custom_run(args) {
+  const { form, send, workspace } = args;
+  const t = actionTarget(args);
+  if (t.done) return undefined;
+  const { entry, projectName, projectDir } = t;
+  const options = rowLayout.effectiveOptions(entry);
+  if (options.length && form.submitted !== '1') {
+    return send(bad(`${esc(entry.label)} asks for ${options.length === 1 ? 'an option' : 'options'} — run it from its menu, which opens the form.`), 400);
+  }
+  const { values, error } = rowLayout.resolveOptions({ ...entry, options }, form);
+  if (error) return send(bad(`Not running ${esc(entry.label)}: ${esc(error)}.`), 400);
+  const expanded = catalog.expandSteps(entry, { workspace, project: projectName, projectDir });
+  if (expanded.error) return send(bad(`Not running ${esc(entry.label)}: ${esc(expanded.error)}.`), 400);
+
+  const verb = `custom-${entry.id}`;
+  // The last run of this action here is about to have its log truncated: write down how it ended first.
+  rowLayout.settleRun(screenSessionName(projectName, verb, workspace));
+  const started = await startUnlessRunning({ workspace, project: projectName, projectDir, verb,
+    cmdLine: `${rowLayout.actionCommandLine(expanded.entry, values)}; ${lingerTail(entry.label)}`, label: entry.label });
+  if (started.stillRunning) {
+    return send(bad(`<code>${esc(entry.label)}</code> is still running on <strong>${esc(projectName)}</strong> — ${terminalLink(started.session, 'open it')}. Left alone.`), 409);
+  }
+  if (!started.ok) return send(screenStartedHtml(started, entry.label, projectName), started.already ? 409 : 500);
+  rowLayout.recordRun({ at: new Date().toISOString(), id: entry.id, label: entry.label, workspace, project: projectName, session: started.session });
+
+  if (entry.open === 'screen') {
+    // Its terminal, at once, in the dashboard's one modal — the same terminal the SCREENS menu opens.
+    // Nothing visible lands in the page: this only fetches the terminal into the modal and shows it.
+    return send(`<div hidden hx-get="/fragments/screen-term/${encodeURIComponent(started.session)}" hx-trigger="load" hx-target="#editor-modal-body" hx-swap="innerHTML"
+      hx-on::after:request="UIkit.modal('#editor-modal').show()"></div>`);
+  }
+  return send(`<div class="msg assistant flash-now"><code>${esc(entry.label)}</code> on <strong>${esc(projectName)}</strong> — ${terminalLink(started.session, 'open the output')}</div>`);
+}
+
+module.exports = {
+  '/actions/row-arrange-save': arrange_save,
+  '/actions/row-rows': rows_op,
+  '/actions/row-custom-add': custom_add,
+  '/actions/row-custom-save': custom_save,
+  '/actions/row-custom-remove': custom_remove,
+  '/actions/row-layout-reset': layout_reset,
+  '/actions/row-definition-check': definition_check,
+  '/actions/row-definition-save': definition_save,
+  '/actions/row-custom-options': custom_options,
+  '/actions/row-custom-run': custom_run,
+};