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

package/waiting.js

@@ -0,0 +1,85 @@
+/**
+ * Whether a screen session is working or waiting for a person.
+ *
+ * Its own module, with NO requires, because two processes need the same answer: the
+ * dashboard (in its container) and the host screen runner (a standalone script that must
+ * not pull the app's dependency tree in). One copy of the rules, so the badge on the page
+ * and the flag on the host can never disagree.
+ */
+
+/**
+ * Is this session WORKING, or WAITING FOR A PERSON?
+ *
+ * From the outside the two are identical — a detached session with a live process — so a
+ * long agent run that has stopped to ask "which of these do you want?" sits there until
+ * somebody thinks to look. That is the whole point of this: the Screens page can say it.
+ *
+ * The decision is made on the TAIL of the visible screen, because a question is drawn at
+ * the bottom of a window, never at the top.
+ *
+ * The strongest signal is a NEGATIVE one, and it is checked first: Claude Code prints
+ * `esc to interrupt` in its footer only while it is busy. Observed on a real run —
+ *
+ *   6 Thinking… (6m 16s · 23.9k tokens)
+ *   ⏵⏵ bypass permissions on (shift+tab to cycle) · esc to interrupt
+ *
+ * — so its presence means working, whatever else is on screen. Without it, the footer has
+ * changed, and only then do the positive patterns get a say.
+ *
+ * Conservative on purpose. A badge that cries "waiting" on every row is worse than no
+ * badge: it trains you to ignore it. Anything unrecognised is reported as neither.
+ */
+function waitingState(tail) {
+  const text = String(tail || '');
+  if (!text.trim()) return { waiting: false, why: '' };
+
+  // Busy: the interrupt hint, or a spinner line with an elapsed timer.
+  if (/esc to interrupt/i.test(text)) return { waiting: false, why: '' };
+  if (/\b(Thinking|Working|Running|Compacting)…\s*\(/i.test(text)) return { waiting: false, why: '' };
+
+  // A choice: a numbered list with a selection caret is what Claude Code draws for a
+  // permission question or a plan decision. `❯` is its own marker; `>` is the fallback
+  // some terminals get.
+  if (/(^|\n)\s*[❯▶>]\s*\d+[.)]\s+\S/.test(text)) return { waiting: true, why: 'waiting on a choice' };
+  if (/\b(1[.)]\s+Yes|Yes,\s+and\b|No,\s+and tell)/i.test(text)) return { waiting: true, why: 'waiting on a choice' };
+
+  // A plain question — but only in the LAST FEW LINES, and only on a line that is
+  // shaped like a prompt. An agent's own report says things like "the ticket asks: do
+  // you want the picker? I implemented it", and matching that would put a pulsing
+  // "waiting for you" badge on a session that is busy writing prose. A prompt is the
+  // last thing on the screen and the line ENDS at the question; a mention is followed
+  // by more sentence.
+  const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
+  const last = lines.slice(-3);
+  const asksHere = (re) => last.some((l) => re.test(l));
+  // A question that has been ANSWERED is not a question. The two yes/no rules allow a few characters
+  // after the bracket because a cursor sits there — and a typed `y` is one character, so
+  //
+  //   Do you want to continue? (y/n) y
+  //   rajab@host:~/workspace/test/ruverify1$
+  //
+  // went on matching once the shell had moved on, and the hand never went down. A badge that cries
+  // "waiting" on a session nobody is blocking is worse than no badge: it trains you to ignore it.
+  // So those two ask the LAST line only — an answered prompt always has something after it, if only
+  // the shell's own. The rules below keep the three-line window: a numbered choice list and a
+  // "press Enter" are drawn with a footer under them.
+  const asksLast = (re) => re.test(lines[lines.length - 1] || '');
+
+  if (asksLast(/\((y\/n|y\/N|Y\/n|yes\/no)\)\s*\S{0,3}$/i)) return { waiting: true, why: 'waiting on yes/no' };
+  if (asksLast(/\[(y\/N|Y\/n)\]\s*\S{0,3}$/)) return { waiting: true, why: 'waiting on yes/no' };
+  if (asksHere(/^(Do you want|Would you like)\b[^?]{0,80}\?$/i)) return { waiting: true, why: 'waiting on an answer' };
+  if (asksHere(/^(Proceed|Continue|Overwrite|Are you sure)\b[^?]{0,40}\?$/i)) return { waiting: true, why: 'waiting on an answer' };
+  if (asksHere(/Press (Enter|any key) to (continue|proceed)/i)) return { waiting: true, why: 'waiting for Enter' };
+  if (asksHere(/^(Enter (a |the )?(value|name|password|token)|Please enter)\b/i)) return { waiting: true, why: 'waiting for input' };
+
+  // Claude Code sitting at its own prompt with nothing running: its footer hints are
+  // there, the interrupt hint is not. That is a finished agent waiting to be told what
+  // is next — worth flagging, more gently than an unanswered question.
+  if (/(\? for shortcuts|bypass permissions on|shift\+tab to cycle)/i.test(text)) {
+    return { waiting: true, why: 'idle at its prompt' };
+  }
+
+  return { waiting: false, why: '' };
+}
+
+module.exports = { waitingState };

package/workspace-card-tools.js

@@ -0,0 +1,41 @@
+/**
+ * Edit and Settings on a home page workspace card, as the project and folder cards carry their tools.
+ *
+ * The corner holds the backups count too, so the three never overlap. It sits beside the card's link, not in it:
+ * a card is one <a>, and a button inside a link is not a button.
+ */
+
+const { esc } = require('./html');
+const { iconHtml } = require('./icons');
+
+const settingsFile = (key) => `workspace.${key}.settings.yml`;
+
+/** The corner of one card: its backups count, Edit (the card's icon and description) and Settings (its own file). */
+function cornerHtml(w, { backupCount = 0, backupsUrl = '' } = {}) {
+  const file = settingsFile(w.key);
+  const backups = backupCount
+    ? `<a class="ws-backups" href="${esc(backupsUrl)}" title="View the ${backupCount} backup${backupCount === 1 ? '' : 's'} for ${esc(w.label)}"><span uk-icon="icon: album; ratio: .65"></span> ${backupCount}</a>`
+    : '';
+  return `<div class="ws-card-corner" role="toolbar" aria-label="${esc(w.label)}">
+      ${backups}
+      <button type="button" class="ws-card-tool" hx-get="/fragments/workspace-edit/${encodeURIComponent(w.key)}"
+              hx-target="#editor-modal-body" hx-swap="innerHTML"
+              title="Edit the ${esc(w.label)} card: its icon and description" aria-label="Edit ${esc(w.label)}">${iconHtml('tabler:pencil', 0.75)}</button>
+      <a class="ws-card-tool" href="/settings/${encodeURIComponent(file)}"
+         data-tabmodal-open="/fragments/settings/modal?tab=${encodeURIComponent(file)}"
+         title="${esc(w.label)} settings: ${esc(file)}" aria-label="${esc(w.label)} settings">${iconHtml('tabler:settings', 0.75)}</a>
+    </div>`;
+}
+
+/** The Edit modal: the same presentation editor the workspace's settings tab shows, on its own. */
+function editModalHtml(w, presentationHtml) {
+  return `<div class="editor-card ws-card-edit">
+      <h3 class="uk-h4 uk-margin-small-bottom">${iconHtml(w.icon, 1)} Edit the ${esc(w.label)} card</h3>
+      <p class="uk-text-meta uk-margin-remove-top">The icon and description on its card and in the rail.
+        Everything else is in <a href="/settings/${encodeURIComponent(settingsFile(w.key))}"
+        data-tabmodal-open="/fragments/settings/modal?tab=${encodeURIComponent(settingsFile(w.key))}">its settings</a>.</p>
+      ${presentationHtml}
+    </div>`;
+}
+
+module.exports = { cornerHtml, editModalHtml, settingsFile };

package/workspace-delete.js

@@ -0,0 +1,139 @@
+/**
+ * Deleting a workspace that holds nothing: the reverse of addWorkspace in server.js.
+ *
+ * Only a workspace with no content can go. Its folder may hold the tooling a workspace ships
+ * (cmd-*.sh, README.md, AGENTS.md, CLAUDE.md, *.code-workspace) and nothing else; it has no backups
+ * and no screen session running. The dashboard asks three times before it deletes one.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('./html');
+const { ROOT, CONFIG_DIR, loadWorkspaces } = require('./workspaces');
+const { readListBlock, writeListBlock } = require('./settings-file');
+
+const TOOLING_RE = /^(cmd-.+\.sh|README\.md|AGENTS\.md|CLAUDE\.md|.+\.code-workspace)$/;
+const NAME_RE = /^[a-z][a-z0-9-]*$/;
+const DDEV_CONFIG = path.join(__dirname, '.ddev', 'config.yaml');
+
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+
+function liveSessionNames() {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(ROOT, '.screens', 'host-sessions.json'), 'utf8'));
+    return (j.sessions || []).map((s) => String(s.session || ''));
+  } catch (_) { return []; }
+}
+
+function filesIn(dir) {
+  try { return fs.readdirSync(dir); } catch (_) { return []; }
+}
+
+/** What keeps a workspace in use. Deletable when `reasons` is empty; `tooling` is what deleting removes. */
+function usage(name, { sessions = liveSessionNames() } = {}) {
+  const meta = loadWorkspaces()[name];
+  if (!meta) return { reasons: ['not a workspace'], tooling: [] };
+  const reasons = [];
+  const dir = path.join(ROOT, name);
+  if (path.resolve(meta.dir) !== dir) reasons.push('its folder is set outside the tree');
+  const entries = filesIn(dir);
+  const content = entries.filter((f) => !TOOLING_RE.test(f));
+  if (content.length) {
+    reasons.push(`${plural(content.length, 'item')} in its folder (${content.slice(0, 3).join(', ')}${content.length > 3 ? ', …' : ''})`);
+  }
+  const backups = filesIn(meta.backupsDir);
+  if (backups.length) reasons.push(plural(backups.length, 'backup file'));
+  const live = sessions.filter((s) => s.startsWith(`${name}--`));
+  if (live.length) reasons.push(`${plural(live.length, 'screen session')} running`);
+  const list = readListBlock('settings.yml', 'workspaces');
+  if (list && list.items.length < 2) reasons.push('it is the only workspace');
+  return { reasons, tooling: entries.filter((f) => TOOLING_RE.test(f)), dir, backupsDir: meta.backupsDir };
+}
+
+/** The three answers the last step must carry: the dialog's Yes, the name typed back, and YES. */
+function confirmed(name, form) {
+  return String(form.confirmName || '').trim() === name && String(form.confirmYes || '').trim() === 'YES';
+}
+
+/** Remove the list entry, the settings file, the folder and the hostname. Checked again here, not trusted from the page. */
+function deleteWorkspace(name) {
+  if (!NAME_RE.test(name)) return { error: 'Not a workspace name.' };
+  const use = usage(name);
+  if (use.reasons.length) return { error: `${name} is in use: ${use.reasons.join('; ')}.` };
+
+  const notes = [];
+  const list = readListBlock('settings.yml', 'workspaces');
+  writeListBlock('settings.yml', 'workspaces', list.items.filter((k) => k !== name));
+  notes.push('took it out of <code>workspaces:</code>');
+
+  const settingsFile = path.join(CONFIG_DIR, `workspace.${name}.settings.yml`);
+  if (fs.existsSync(settingsFile)) {
+    fs.unlinkSync(settingsFile);
+    notes.push(`deleted <code>core/config/workspace.${esc(name)}.settings.yml</code>`);
+  }
+  if (fs.existsSync(use.dir)) {
+    use.tooling.forEach((f) => fs.unlinkSync(path.join(use.dir, f)));
+    fs.rmdirSync(use.dir);
+    notes.push(`deleted the <code>${esc(name)}/</code> folder${use.tooling.length ? ` and its ${plural(use.tooling.length, 'command file')}` : ''}`);
+  }
+  try { fs.rmdirSync(use.backupsDir); } catch (_) { /* none, or not empty */ }
+
+  try {
+    const cfg = fs.readFileSync(DDEV_CONFIG, 'utf8');
+    const next = cfg.split('\n').filter((l) => l.trim() !== `- "*.${name}.workspace"`).join('\n');
+    if (next !== cfg) {
+      fs.writeFileSync(DDEV_CONFIG, next);
+      notes.push(`removed <code>*.${esc(name)}.workspace</code> from the dashboard's DDEV hostnames`);
+    }
+  } catch (_) { /* no DDEV config here */ }
+  return { notes };
+}
+
+/** The row's delete control: a button for an unused workspace, a quiet "in use" with the reasons otherwise. */
+function rowControlHtml(name, use) {
+  if (use.reasons.length) {
+    return `<span class="ws-in-use uk-text-meta" title="Cannot be deleted: ${esc(use.reasons.join('; '))}">in use</span>`;
+  }
+  return `<button type="button" form="ws-delete-form" class="uk-button uk-button-default uk-button-small ws-delete arm-step"
+      hx-post="/actions/workspace-delete" hx-trigger="confirmed-remove"
+      hx-vals='{"workspace":"${esc(name)}","step":"name"}' hx-target="#list-editor" hx-swap="outerHTML"
+      title="Delete the ${esc(name)} workspace"><span uk-icon="icon: trash; ratio: .7"></span></button>`;
+}
+
+/** Steps 2 and 3, shown under the row: type the name, then type YES. The buttons post through the empty
+ *  #ws-delete-form, so the settings form they sit in is not sent with them. */
+function stepHtml(name, step, use, error) {
+  const vals = (s, extra = '') => `hx-post="/actions/workspace-delete" hx-target="#list-editor" hx-swap="outerHTML"
+      hx-vals='{"workspace":"${esc(name)}","step":"${s}"${extra}}'`;
+  const id = `ws-del-${esc(name)}`;
+  const removes = [
+    `the <code>${esc(name)}/</code> folder${use.tooling.length ? ` (${plural(use.tooling.length, 'command file')})` : ''}`,
+    `<code>core/config/workspace.${esc(name)}.settings.yml</code>`,
+    `its line in <code>workspaces:</code>`,
+    `the <code>*.${esc(name)}.workspace</code> hostname`,
+  ];
+  const cancel = `<button type="button" form="ws-delete-form" class="uk-button uk-button-default uk-button-small" ${vals('cancel')}>Cancel</button>`;
+  const body = step === 'yes'
+    ? `<p><strong>Step 3 of 3.</strong> Type <code>YES</code> to delete the <strong>${esc(name)}</strong> workspace. This cannot be undone.</p>
+      <div class="ws-delete-fields">
+        <input class="uk-input uk-form-small" id="${id}-yes" name="confirmYes" autocomplete="off" spellcheck="false"
+               placeholder="YES" aria-label="Type YES to delete ${esc(name)}">
+        <button type="button" form="ws-delete-form" class="uk-button uk-button-danger uk-button-small ws-delete-go"
+                ${vals('delete', `,"confirmName":"${esc(name)}"`)} hx-include="#${id}-yes">Delete workspace</button>
+        ${cancel}
+      </div>`
+    : `<p><strong>Step 2 of 3.</strong> Type the workspace name, <code>${esc(name)}</code>, to continue.</p>
+      <p class="uk-text-meta">Deleting it removes ${removes.join(', ')}.</p>
+      <div class="ws-delete-fields">
+        <input class="uk-input uk-form-small" id="${id}-name" name="confirmName" autocomplete="off" spellcheck="false"
+               placeholder="${esc(name)}" aria-label="Type the workspace name">
+        <button type="button" form="ws-delete-form" class="uk-button uk-button-primary uk-button-small ws-delete-go"
+                ${vals('yes')} hx-include="#${id}-name">Continue</button>
+        ${cancel}
+      </div>`;
+  return `<div class="ws-delete-step" role="group" aria-label="Delete the ${esc(name)} workspace">
+      ${error ? `<p class="ws-delete-error" role="alert">${esc(error)}</p>` : ''}${body}</div>`;
+}
+
+module.exports = { usage, confirmed, deleteWorkspace, rowControlHtml, stepHtml, TOOLING_RE };

package/workspace-types.js

@@ -0,0 +1,85 @@
+/**
+ * Workspace types: what a folder's projects are FOR, and therefore which actions
+ * their rows offer.
+ *
+ * Two layers decide whether a control appears, and they answer different questions:
+ *
+ *   capability  does this folder ship the script?   (findBackupScript, cmd-tools-testing.sh …)
+ *   policy      does this KIND of folder want it?   (this file)
+ *
+ * Discovery alone was the whole story until now, which meant a folder got every
+ * control its scripts could serve — a code-packages folder with a backup script
+ * showed DDEV/Upsun surface the moment someone copied the wrong cmd file in.
+ * The type is chosen per workspace in workspace.<name>.settings.yml (`type:`),
+ * editable from the Settings page; these defaults cover the shipped folders so
+ * an unset file behaves exactly as it always did.
+ *
+ * `kind` (projects/files page layout) is presentation and stays in
+ * workspaces.js — a type never changes how a page is laid out, only which
+ * actions its project rows carry.
+ */
+
+const TYPES = {
+  sites: {
+    label: 'Sites — DDEV projects',
+    description: 'Built Drupal sites: DDEV controls, tests, users, the full toolbelt.',
+    actions: ['build', 'folder', 'ddev', 'backup', 'clone', 'remove', 'graphify', 'ragify', 'tests', 'checks', 'users'],
+  },
+  code: {
+    label: 'Code — packages and repositories',
+    description: 'Modules, themes, libraries, recipes: quality checks and knowledge tools, no site controls.',
+    actions: ['build', 'folder', 'backup', 'remove', 'graphify', 'ragify', 'checks'],
+  },
+  files: {
+    label: 'Files — documents and drafts',
+    description: 'Markdown and documents; the page is an item list, projects carry no actions.',
+    actions: ['folder'],
+  },
+  media: {
+    label: 'Media — recordings',
+    description: 'Videos and other media; the page is an item list, projects carry no actions.',
+    actions: ['folder'],
+  },
+  'ai-items': {
+    label: 'AI items — agents, skills, prompts',
+    description: 'Claude Code items with their own install/fetch/propose surface.',
+    actions: [],
+  },
+};
+
+// What each shipped folder is, so nothing changes until somebody edits a `type:`.
+// A folder absent here (a new workspace) defaults by its kind: projects → sites.
+const DEFAULT_TYPE_BY_KEY = {
+  products: 'sites', dev: 'sites', test: 'sites', demos: 'sites', sandboxes: 'sites',
+  projects: 'sites', profiles: 'sites', 'site-templates': 'sites', rag: 'sites', designs: 'sites',
+  recipes: 'code', components: 'code', themes: 'code', modules: 'code', libraries: 'code',
+  forked: 'code', graphs: 'code',
+  docs: 'files', worklogs: 'files', specs: 'files',
+  images: 'media', videos: 'media', audio: 'media',
+  'ai-agents': 'ai-items', 'ai-skills': 'ai-items',
+  'ai-commands': 'ai-items', 'ai-prompts': 'ai-items',
+};
+
+function isType(name) {
+  return Object.prototype.hasOwnProperty.call(TYPES, name);
+}
+
+/** The type a workspace resolves to: its own `type:`, the shipped default, or by kind. */
+function resolveType(key, declaredType, kind) {
+  if (declaredType && isType(declaredType)) return declaredType;
+  if (DEFAULT_TYPE_BY_KEY[key]) return DEFAULT_TYPE_BY_KEY[key];
+  return kind === 'files' ? 'files' : 'sites';
+}
+
+function typeActions(type) {
+  return new Set((TYPES[type] || TYPES.sites).actions);
+}
+
+/** An action a plugin brings ('upsun' on sites): allowed on the types it names from now on. */
+function addTypeAction(action, types) {
+  for (const type of types || []) {
+    if (TYPES[type] && !TYPES[type].actions.includes(action)) TYPES[type].actions.push(action);
+  }
+}
+
+module.exports = { TYPES, DEFAULT_TYPE_BY_KEY, isType, resolveType, typeActions, addTypeAction };