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

package/format.js

@@ -0,0 +1,73 @@
+/**
+ * How a size, a time and a video are said, in one place.
+ *
+ * Small, and imported by nearly everything that renders — which is exactly why it is not left
+ * in the middle of the server.
+ */
+
+// What counts as a video, in one place: the listing, the play fragment and the row icon all have
+// to agree, or a file gets a Play button that 404s.
+const VIDEO_RE = /\.(mp4|m4v|webm|ogv|mov)$/i;
+// Sound the browser plays in an <audio> element; the listing, the player and the file route share it.
+const AUDIO_RE = /\.(mp3|wav|ogg|oga|opus|m4a|aac|flac|weba)$/i;
+// Rendered document formats a docs row can carry beside its markdown.
+const DOC_ARTIFACT_RE = /\.(pdf|html?|docx?|xlsx?|pptx?|odt|ods|odp|rtf|csv)$/i;
+
+function humanTime(d) {
+  if (!(d instanceof Date) || !d.getTime()) return '';
+  const p = new Intl.DateTimeFormat('en-GB', { day: '2-digit', month: 'short', year: 'numeric',
+    hour: '2-digit', minute: '2-digit', hour12: false }).formatToParts(d)
+    .reduce((o, x) => (o[x.type] = x.value, o), {});
+  const off = -d.getTimezoneOffset();
+  const sign = off < 0 ? '-' : '+';
+  const oh = String(Math.floor(Math.abs(off) / 60)).padStart(2, '0');
+  const om = String(Math.abs(off) % 60).padStart(2, '0');
+  return `${p.day} ${p.month} ${p.year} ${p.hour}:${p.minute} ${sign}${oh}:${om}`;
+}
+
+function humanSize(bytes) {
+  if (bytes > 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024)).toFixed(1) + ' GB';
+  if (bytes > 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+  return Math.max(1, Math.round(bytes / 1024)) + ' KB';
+}
+
+
+/**
+ * A path as a person writes it: `~/workspace/dev/site1`, not
+ * `/home/rajab/workspace/dev/site1`. Every path the dashboard SHOWS goes
+ * through this — the home prefix is noise in a UI, and it is the one part of a
+ * path that differs between machines, so a command someone copies from here
+ * should paste cleanly on theirs.
+ */
+function tildePath(p) {
+  const home = process.env.HOME || '';
+  const s = String(p || '');
+  if (!home || !s.startsWith(home)) return s;
+  const rest = s.slice(home.length);
+  return rest === '' ? '~' : (rest.startsWith('/') ? `~${rest}` : s);
+}
+
+// A CLI's error, trimmed for a person to read.
+//
+// Tail-slicing is right for a build log — the end is where the failure is — and wrong
+// for a command's error: these CLIs print the REASON first and then a usage synopsis,
+// so `.slice(-300)` showed a list of flags and threw the reason away. An unreadable
+// error is worse than a long one: the Upsun token failure read as a syntax problem for
+// as long as it was displayed that way.
+function cliError(text, max = 400) {
+  const raw = String(text || '').replace(/\r/g, '');
+  const kept = raw.split('\n').filter((l) => {
+    const t = l.trim();
+    if (!t) return false;
+    // the usage synopsis: "upsun environments [-I|--no-inactive] … [--] <command>"
+    if (/\[-{1,2}[A-Za-z]/.test(t) && /\[--\]|\[-h\|--help\]/.test(t)) return false;
+    if (/^Usage:$/i.test(t) || /^\s*[a-z][\w:.-]*( \[[^\]]+\])+\s*$/.test(t)) return false;
+    return true;
+  }).join('\n').trim();
+  const out = kept || raw.trim();
+  return out.length > max ? out.slice(0, max) + '…' : out;
+}
+
+module.exports = {
+  tildePath, cliError,
+  DOC_ARTIFACT_RE, VIDEO_RE, AUDIO_RE, humanTime, humanSize };

package/git-info.js

@@ -0,0 +1,81 @@
+/**
+ * What the dashboard asks git about a folder: whether it is a repository, which worktree role it has,
+ * what a remove would destroy, which branch it is on. Used by the clone and remove forms, the IDE
+ * caption and the row context, and handed to plugins through api.lib (the GIT plugin draws its menu
+ * from these answers).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/**
+ * Is this project directory a git checkout?
+ *
+ * `rev-parse --git-dir` rather than a test for a `.git` directory, because a
+ * project that is ITSELF a worktree carries `.git` as a FILE pointing at the real
+ * one — and a worktree of a worktree is both legal and useful. Asking git is the
+ * only answer that is right for every shape, including a submodule.
+ */
+function projectHasGit(dir) {
+  try {
+    return spawnSync('git', ['-C', dir, 'rev-parse', '--git-dir'],
+      { stdio: ['ignore', 'ignore', 'ignore'], timeout: 5000 }).status === 0;
+  } catch (_) { return false; }
+}
+
+/** Does this folder have its own `.git`? A directory for a clone, a file for a worktree. */
+function hasOwnGit(dir) {
+  try { return fs.existsSync(path.join(dir, '.git')); } catch (_) { return false; }
+}
+
+/**
+ * What a project folder IS to git: 'none', 'plain', 'primary' (other worktrees
+ * live off its .git) or 'linked' (it is a worktree). The destructive difference:
+ * deleting a PRIMARY takes the only copy of the repository with it and leaves
+ * every linked worktree a folder of files git can say nothing about.
+ *
+ * Deliberately the same questions fun-git-worktrees.sh asks, so the dashboard and
+ * the command cannot disagree about what is safe.
+ */
+function gitWorktreeInfo(dir) {
+  const out = {
+    role: 'none', branch: '', others: [], primary: '', unpushed: 0, dirty: 0,
+  };
+  if (!projectHasGit(dir)) return out;
+  const git = (args) => {
+    const r = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8', timeout: 5000 });
+    return r.status === 0 ? String(r.stdout || '').trim() : '';
+  };
+  const gitdir = git(['rev-parse', '--absolute-git-dir']);
+  const common = git(['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  const list = git(['worktree', 'list', '--porcelain'])
+    .split('\n').filter((l) => l.startsWith('worktree ')).map((l) => l.slice(9));
+  const self = fs.realpathSync.native ? (() => { try { return fs.realpathSync(dir); } catch (_) { return dir; } })() : dir;
+  out.primary = list[0] || '';
+  out.others = list.filter((p) => { try { return fs.realpathSync(p) !== self; } catch (_) { return p !== self; } });
+  // A repository with no commits yet has a branch that EXISTS but points at nothing, so
+  // `rev-parse --abbrev-ref HEAD` fails and the menus read "detached HEAD" for a folder that was
+  // `git init`-ed a moment ago. `symbolic-ref` still names the branch; only when that fails too is
+  // HEAD really detached.
+  const b = git(['rev-parse', '--abbrev-ref', 'HEAD']);
+  const named = git(['symbolic-ref', '--short', '-q', 'HEAD']);
+  out.branch = (b && b !== 'HEAD') ? b : named;
+  out.unborn = !git(['rev-parse', '--verify', '-q', 'HEAD']) && !!named;
+  out.unpushed = parseInt(git(['rev-list', '--count', 'HEAD', '--not', '--remotes']) || '0', 10) || 0;
+  out.dirty = git(['status', '--porcelain', '--untracked-files=normal']).split('\n').filter(Boolean).length;
+  if (gitdir && common && gitdir !== common) out.role = 'linked';
+  else out.role = out.others.length ? 'primary' : 'plain';
+  return out;
+}
+
+/** The branch a checkout is on, or '' — used only to label the worktree control. */
+function gitBranchOf(dir) {
+  try {
+    const r = spawnSync('git', ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD'],
+      { encoding: 'utf8', timeout: 5000 });
+    return r.status === 0 ? String(r.stdout || '').trim() : '';
+  } catch (_) { return ''; }
+}
+
+module.exports = { projectHasGit, hasOwnGit, gitWorktreeInfo, gitBranchOf };

package/github-auth.js

@@ -0,0 +1,62 @@
+/**
+ * How this app authenticates GitHub work: gh's own login when it stands on its
+ * own, otherwise the token from settings.yml's git.github block — probed once
+ * and cached, never logged.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { run } = require('./jobs');
+const { loadSettings } = require('./workspaces');
+
+// Whether the `gh` CLI can authenticate on its own, and as whom. Cached for 5 minutes: the
+// probe is a network call. `hosts.yml` names the account even when the token is unreachable —
+// that is exactly the container's situation — so the name alone proves nothing and the probe
+// is what decides.
+let _ghAuth = null;
+let _ghAuthAt = 0;
+async function ghCliAuth() {
+  if (_ghAuth && Date.now() - _ghAuthAt < 5 * 60 * 1000) return _ghAuth;
+  const out = { binary: null, named: '', login: '' };
+  for (const dir of (process.env.PATH || '').split(':')) {
+    const candidate = path.join(dir, 'gh');
+    try { fs.accessSync(candidate, fs.constants.X_OK); out.binary = candidate; break; } catch (_) { /* keep looking */ }
+  }
+  try {
+    const hosts = fs.readFileSync(path.join(process.env.HOME, '.config', 'gh', 'hosts.yml'), 'utf8');
+    out.named = (hosts.match(/^\s*user:\s*(\S+)/m) || [])[1] || '';
+  } catch (_) { /* gh never signed in here */ }
+  if (out.binary) {
+    // No settings token in this environment: the question is whether gh stands on its own.
+    const env = { ...process.env };
+    delete env.GH_TOKEN; delete env.GITHUB_TOKEN;
+    const res = await run('gh', ['api', 'user', '--jq', '.login'], process.env.HOME, { timeoutMs: 20000, env });
+    if (res.ok) out.login = res.stdout.trim();
+  }
+  _ghAuth = out; _ghAuthAt = Date.now();
+  return out;
+}
+
+
+// GitHub auth for the child processes that need it. The token comes from settings.yml's
+// `git.github_token`, which is how this container authenticates at all: its gh config is
+// mounted from the host but the token lives in the host keyring, which it cannot read. Passed
+// per child rather than assigned into process.env, so it is not handed to every job the
+// dashboard runs. Never logged.
+function githubEnv() {
+  if (process.env.GH_TOKEN || process.env.GITHUB_TOKEN) return process.env;
+  // A forge plugin (@webship.co/workspace-github) owns the credential when it is active.
+  try {
+    const forge = require('./plugin-loader').pluginForge('github.com');
+    if (forge && typeof forge.env === 'function') return forge.env() || process.env;
+  } catch (_) { /* the loader is not up yet: the legacy block below answers */ }
+  const github = (() => { try { return (loadSettings().git || {}).github || {}; } catch (_) { return {}; } })();
+  // gh's own login is preferred when it works; the cached probe answers without waiting.
+  if (String(github.use_gh_cli) !== 'false' && _ghAuth && _ghAuth.login) return process.env;
+  const token = github.token || '';
+  if (!token || token === 'CHANGE_ME') return process.env;
+  return { ...process.env, GH_TOKEN: token };
+}
+
+module.exports = { ghCliAuth, githubEnv };

package/html.js

@@ -0,0 +1,10 @@
+/**
+ * The one escaper every fragment goes through.
+ *
+ * Its own module because everything that renders HTML needs it and nothing else in this file is a
+ * dependency of it — so a module can import the escaper without importing the server.
+ */
+
+const esc = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+module.exports = { esc };

package/icons.js

@@ -0,0 +1,83 @@
+/**
+ * The icon libraries a workspace card can draw from.
+ *
+ * Two of them: UIKit's own set, and Tabler's 4,700 as a vendored sprite. A name is `tabler:x` or a
+ * bare UIKit name, and an unknown one falls back rather than rendering an empty box.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PUBLIC_DIR = path.join(__dirname, 'public');
+
+const { esc } = require('./html');
+
+// Read once: the Tabler sprite is 4,736 icons, and a workspace page renders twenty of them.
+let _tablerCache = null;
+let _iconCache = null;
+// Icon and description for a workspace, stored in its own settings file so a
+// workspace added from the dashboard is not stuck with the default folder icon.
+//
+// The icon list is PARSED OUT OF the vendored uikit-icons.min.js rather than typed
+// here, so it cannot drift from what will actually render. That drift was real: the
+// commands workspace shipped with `terminal`, which UIKit has no icon for, so its
+// card and rail rendered an empty box. Anything not in this set is refused.
+// Brand and social marks. They are logos, not interface icons — a workspace card
+// showing the Facebook mark says nothing about the workspace — so they are kept out
+// of the chooser. UIKit ships about forty of them.
+const BRAND_ICONS = new Set([
+
+  '500px', 'android', 'android-robot', 'apple', 'behance', 'bluesky', 'discord', 'dribbble',
+  'etsy', 'facebook', 'flickr', 'foursquare', 'github', 'github-alt', 'gitter', 'google',
+  'instagram', 'joomla', 'linkedin', 'mastodon', 'microsoft', 'pinterest', 'reddit',
+  'soundcloud', 'telegram', 'threads', 'tiktok', 'tripadvisor', 'tumblr', 'twitch',
+  'twitter', 'uikit', 'vimeo', 'whatsapp', 'wordpress', 'x', 'xing', 'yelp', 'yootheme',
+  'youtube',
+]);
+
+function uikitIcons() {
+  if (_iconCache) return _iconCache;
+  try {
+    const src = fs.readFileSync(path.join(PUBLIC_DIR, 'vendor', 'uikit-icons.min.js'), 'utf8');
+    const names = [...src.matchAll(/(?:"([a-zA-Z0-9-]+)"|([a-zA-Z0-9-]+))\s*:\s*'<svg/g)]
+      .map((m) => m[1] || m[2]);
+    _iconCache = [...new Set(names)].filter((n) => !BRAND_ICONS.has(n)).sort();
+  } catch (_) {
+    _iconCache = ['folder'];
+  }
+  return _iconCache;
+}
+
+function tablerIcons() {
+  if (_tablerCache) return _tablerCache;
+  try {
+    const src = fs.readFileSync(path.join(PUBLIC_DIR, 'vendor', 'tabler-sprite.svg'), 'utf8');
+    _tablerCache = [...new Set([...src.matchAll(/<symbol id="([a-z0-9-]+)"/g)].map((m) => m[1]))]
+      .filter((n) => !BRAND_ICONS.has(n))
+      .sort();
+  } catch (_) {
+    _tablerCache = [];
+  }
+  return _tablerCache;
+}
+
+// One icon, from either set. A bare name is UIKit, so every icon stored before
+// Tabler existed keeps working; `tabler:<name>` comes from the sprite.
+function iconHtml(name, ratio = 1) {
+  const n = String(name || 'folder');
+  if (n.startsWith('tabler:')) {
+    const id = n.slice(7);
+    if (!tablerIcons().includes(id)) return `<span uk-icon="icon: folder; ratio: ${ratio}"></span>`;
+    const px = Math.round(20 * ratio);
+    return `<svg class="tabler-icon" width="${px}" height="${px}" aria-hidden="true">`
+      + `<use href="/vendor/tabler-sprite.svg#${esc(id)}"></use></svg>`;
+  }
+  return `<span uk-icon="icon: ${esc(n)}; ratio: ${ratio}"></span>`;
+}
+
+function isKnownIcon(name) {
+  const n = String(name || '');
+  return n.startsWith('tabler:') ? tablerIcons().includes(n.slice(7)) : uikitIcons().includes(n);
+}
+
+module.exports = { uikitIcons, tablerIcons, iconHtml, isKnownIcon };