feat(org): project remote set and checked, repository editable on Settings (#1873 P1-6, P1-7)
Remote mode sets the project checkout's origin and checks it once with git ls-remote, with no credential, no prompt, a protocol allowlist of https and ssh and a 15 second limit. The receipt reports reachable, needs-credential or unreachable with git's error summarized. Nothing is pushed. URLs are https or ssh only; ext:: and other helpers, file://, local paths, option-like values and credential-bearing URLs are refused. `mosaic org project repo set` changes a project's repository later, both ways between remote and local only, through the same rules and check, with a revision guard and an org.project.repo.set receipt. The Console's organization project Settings tab edits it through /api/orgs/ID/repo/project/PROJECT; Quick Setup accepts ssh and shows the check.
This commit is contained in:
1 parent
0b8fe202bc
commit
f5df067304
18 files changed
+997
-28
No files matched your search
@@ -1279,8 +1279,12 @@ its checkout; `mosaic org project repo init ID PROJECT --local-only
|
||||
URL` selects remote mode instead. These commands never push or overwrite an
|
||||
existing repository. Local-only acceptance records the risk of losing the only
|
||||
copy. Read back with `mosaic org queue show ID [--json]` or `mosaic org project
|
||||
repo show ID PROJECT [--json]`. See `packages/organization/README.md` for the
|
||||
layout and scope. On existing CLI commands, `--org ID` is an alias for `--business ID`;
|
||||
repo show ID PROJECT [--json]`. `mosaic org project repo set ID PROJECT
|
||||
(--local-only --accept-local-loss-risk | --remote URL) --if-revision N [--json]`
|
||||
changes a project's repository later. A remote is https or ssh; its checkout's
|
||||
`origin` is set and checked once with `git ls-remote`, without credentials, and
|
||||
the receipt says `reachable`, `needs-credential` or `unreachable`. See
|
||||
`packages/organization/README.md` for the URL rules, layout and scope. On existing CLI commands, `--org ID` is an alias for `--business ID`;
|
||||
if both are supplied they must name the same ID.
|
||||
|
||||
`mosaic org delete ID --confirm ID --if-revision N [--json]` stops the
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import { readFile, writeFile } from 'node:fs/promises';
|
||||
import { configDir } from '../../organization/src/organization-config.mjs';
|
||||
import { listOrgs, orgLock } from '../../organization/src/org-registry.mjs';
|
||||
import { templateRender, validateOrg, createOrg, showOrg, updateOrg, queueInit, queueShow, projectRepoInit, projectRepoShow, deleteOrg, archiveOrg, restoreOrg } from '../../organization/src/org-service.mjs';
|
||||
import { templateRender, validateOrg, createOrg, showOrg, updateOrg, queueInit, queueShow, projectRepoInit, projectRepoShow, projectRepoSet, deleteOrg, archiveOrg, restoreOrg } from '../../organization/src/org-service.mjs';
|
||||
import { installedSystemTypes } from '../../plugins/src/system-types.mjs';
|
||||
import { DEV_OWNER, devOwnerInstance } from './dev-local-owner.mjs';
|
||||
import { loadSystem } from './config.mjs';
|
||||
@@ -12,7 +12,7 @@ import { consoleBusRestart } from './org-console.mjs';
|
||||
import { refuseInsideAgent } from './transport.mjs';
|
||||
import { definitionsCommand, DEFINITIONS_USAGE } from './org-definitions.mjs';
|
||||
import { orgOwnerCommand, ORG_OWNER_USAGE, ORG_OWNER_VERBS } from './org-owner.mjs';
|
||||
export const ORG_USAGE = 'mosaic org system-types installed | system-types enabled ID | lock show|clear ID | reload ID | archive ID --if-revision N [--json] | restore ID --if-revision N [--no-bus] [--json] | delete ID --confirm ID [--if-revision N] [--json] | template render ID [--fixture local] --output FILE | validate FILE | create ID --from FILE | show ID [--json] | list [--json] | update ID --from FILE --if-revision N | queue init ID (--local-only --accept-local-loss-risk | --remote URL) | queue show ID [--json] | project repo init ID PROJECT (--local-only --accept-local-loss-risk | --remote URL) | project repo show ID PROJECT [--json] | ' + DEFINITIONS_USAGE.slice('mosaic org '.length) + ' | ' + ORG_OWNER_USAGE.slice('mosaic org '.length) + ' | config validate ID | config resolve ID INSTANCE [--project ID]';
|
||||
export const ORG_USAGE = 'mosaic org system-types installed | system-types enabled ID | lock show|clear ID | reload ID | archive ID --if-revision N [--json] | restore ID --if-revision N [--no-bus] [--json] | delete ID --confirm ID [--if-revision N] [--json] | template render ID [--fixture local] --output FILE | validate FILE | create ID --from FILE | show ID [--json] | list [--json] | update ID --from FILE --if-revision N | queue init ID (--local-only --accept-local-loss-risk | --remote URL) | queue show ID [--json] | project repo init ID PROJECT (--local-only --accept-local-loss-risk | --remote URL) | project repo show ID PROJECT [--json] | project repo set ID PROJECT (--local-only --accept-local-loss-risk | --remote URL) --if-revision N [--json] | ' + DEFINITIONS_USAGE.slice('mosaic org '.length) + ' | ' + ORG_OWNER_USAGE.slice('mosaic org '.length) + ' | config validate ID | config resolve ID INSTANCE [--project ID]';
|
||||
function parse(args) { const pos = [], values = {}, flags = new Set(); for (let i = 0; i < args.length; i++) { const a = args[i]; if (['--json', '--local-only', '--accept-local-loss-risk', '--no-bus'].includes(a)) { if (flags.has(a)) throw new CliError(`duplicate ${a}`, 4); flags.add(a); } else if (['--fixture', '--output', '--from', '--if-revision', '--remote', '--confirm'].includes(a)) { if (values[a] !== undefined || !args[i+1] || args[i+1].startsWith('--')) throw new CliError(`${a} needs one value`, 4); values[a] = args[++i]; } else if (a.startsWith('--')) throw new CliError(`unknown option ${a}`, 4); else pos.push(a); } return { pos, values, flags }; }
|
||||
// A refusal names the document by label and the error by its code, never by host path or bytes (PR #1916).
|
||||
const errorCode = e => typeof e?.code === 'string' && /^E[A-Z0-9]+$/.test(e.code) ? e.code : 'unreadable';
|
||||
@@ -80,6 +80,9 @@ export async function orgCommand(args, io, deps = {}) {
|
||||
const project = words[0] === 'project', op = words[project ? 2 : 1], id = words[project ? 3 : 2], name = project ? words[4] : null;
|
||||
if (op === 'show') { allowed(['--json'], []); result = project ? await projectRepoShow(ctx, id, name) : await queueShow(ctx, id); }
|
||||
else if (op === 'init') { allowed(['--local-only', '--accept-local-loss-risk'], ['--remote']); if (p.flags.has('--local-only') === Boolean(p.values['--remote'])) throw new CliError('select exactly one of --local-only or --remote', 4); const opts = { mode: p.flags.has('--local-only') ? 'local-only' : 'remote', remote: p.values['--remote'], acceptLocalLossRisk: p.flags.has('--accept-local-loss-risk') }; result = project ? await projectRepoInit(ctx, id, name, opts) : await queueInit(ctx, id, opts); }
|
||||
// #1873 P1-7: change the project's repository (remote URL, or remote to local-only and back).
|
||||
// The same URL rules and check as init; origin follows; nothing is pushed.
|
||||
else if (op === 'set' && project) { allowed(['--json', '--local-only', '--accept-local-loss-risk'], ['--remote', '--if-revision']); if (p.flags.has('--local-only') === Boolean(p.values['--remote'])) throw new CliError('select exactly one of --local-only or --remote', 4); const ifRevision = revision(p.values['--if-revision'], true); result = await projectRepoSet(ctx, id, name, { mode: p.flags.has('--local-only') ? 'local-only' : 'remote', remote: p.values['--remote'], acceptLocalLossRisk: p.flags.has('--accept-local-loss-risk'), ifRevision }); }
|
||||
else throw new CliError(ORG_USAGE, 4);
|
||||
} else throw new CliError(ORG_USAGE, 4);
|
||||
io.stdout.write(JSON.stringify(result, null, 2) + '\n');
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
// #1873 P1-6 and P1-7: `org project repo init --remote` sets and checks origin; `org project repo
|
||||
// set` changes the repository both ways. The remotes point at 127.0.0.1 port 1, which refuses at
|
||||
// once, so the check runs for real and answers "unreachable" without leaving the host.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { mkdtempSync } from 'node:fs';
|
||||
import { join, resolve } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { execFileSync, spawnSync } from 'node:child_process';
|
||||
const repo = resolve(import.meta.dirname, '../../..');
|
||||
const run = (env, ...args) => spawnSync(join(repo, 'scripts/mosaic'), args, { cwd: repo, env, encoding: 'utf8' });
|
||||
const git = (cwd, ...args) => execFileSync('git', ['-C', cwd, ...args], { env: { PATH: process.env.PATH, HOME: '/nonexistent', GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null' }, encoding: 'utf8' }).trim();
|
||||
|
||||
test('org project repo init --remote and repo set: origin follows, the check is reported, refusals are plain', () => {
|
||||
const home = mkdtempSync(join(tmpdir(), 'org-repo-')); const env = { ...process.env, HOME: home, MOSAIC_CONFIG: join(home, '.config/mosaic-orgtest/config.json') };
|
||||
const boot = spawnSync(join(repo, 'scripts/bootstrap.sh'), ['--instance', 'orgtest'], { cwd: repo, env, encoding: 'utf8' }); assert.equal(boot.status, 0, boot.stderr);
|
||||
const ok = (...args) => { const r = run(env, ...args); assert.equal(r.status, 0, r.stderr); return JSON.parse(r.stdout); };
|
||||
const file = join(home, 'alpha.json');
|
||||
run(env, 'org', 'template', 'render', 'alpha', '--fixture', 'local', '--output', file); ok('org', 'create', 'alpha', '--from', file);
|
||||
|
||||
const ssh = 'ssh://[email protected]:1/team/work.git';
|
||||
const init = ok('org', 'project', 'repo', 'init', 'alpha', 'work', '--remote', ssh);
|
||||
assert.equal(init.origin, ssh); assert.equal(init.check.result, 'unreachable'); assert.match(init.check.message, /port 1|refused/i);
|
||||
assert.equal(git(init.root, 'remote', '-v'), `origin\t${ssh} (fetch)\norigin\t${ssh} (push)`);
|
||||
|
||||
// Usage errors come first and change nothing.
|
||||
for (const args of [['--local-only', '--accept-local-loss-risk'], ['--remote', ssh, '--local-only', '--if-revision', '9'], ['--if-revision', '9'], ['--remote', ssh, '--if-revision', '0']]) {
|
||||
const r = run(env, 'org', 'project', 'repo', 'set', 'alpha', 'work', ...args); assert.equal(r.status, 4, `${args}: ${r.stderr}`);
|
||||
}
|
||||
assert.equal(run(env, 'org', 'queue', 'set', 'alpha', '--local-only', '--accept-local-loss-risk', '--if-revision', '1').status, 4);
|
||||
let rev = ok('org', 'show', 'alpha', '--json').revision;
|
||||
for (const bad of ['ext::sh -c id', 'file:///etc', '/srv/repo', 'https://user:[email protected]:1/o/r', 'http://127.0.0.1:1/o/r']) {
|
||||
const r = run(env, 'org', 'project', 'repo', 'set', 'alpha', 'work', '--remote', bad, '--if-revision', String(rev));
|
||||
assert.equal(r.status, 2, bad); assert.match(r.stderr, /org-invalid/, bad);
|
||||
}
|
||||
const stale = run(env, 'org', 'project', 'repo', 'set', 'alpha', 'work', '--local-only', '--accept-local-loss-risk', '--if-revision', String(rev + 5));
|
||||
assert.equal(stale.status, 2); assert.match(stale.stderr, /revision-conflict/);
|
||||
assert.equal(git(init.root, 'remote', 'get-url', 'origin'), ssh);
|
||||
|
||||
const local = ok('org', 'project', 'repo', 'set', 'alpha', 'work', '--local-only', '--accept-local-loss-risk', '--if-revision', String(rev));
|
||||
assert.equal(local.op, 'org.project.repo.set'); assert.equal(local.revision, rev + 1); assert.equal(local.origin, null); assert.equal(git(init.root, 'remote', '-v'), '');
|
||||
rev = local.revision;
|
||||
const https = 'https://127.0.0.1:1/team/work.git';
|
||||
const back = ok('org', 'project', 'repo', 'set', 'alpha', 'work', '--remote', https, '--if-revision', String(rev), '--json');
|
||||
assert.equal(back.revision, rev + 1); assert.equal(back.check.result, 'unreachable'); assert.match(back.check.message, /Failed to connect|Could not connect/);
|
||||
assert.equal(git(init.root, 'remote', 'get-url', 'origin'), https);
|
||||
assert.deepEqual(ok('org', 'project', 'repo', 'show', 'alpha', 'work', '--json').current, { mode: 'remote', remote: https, origin: https, revision: back.revision, check: back.check, changedAt: back.at });
|
||||
});
|
||||
@@ -569,10 +569,31 @@ Initialize an organization checkout with `mosaic org queue init ID --local-only
|
||||
--accept-local-loss-risk` and a project repository with `mosaic org project repo
|
||||
init ID PROJECT --local-only --accept-local-loss-risk`. The explicit acceptance
|
||||
records that this machine may hold the only copy. Alternatively use `--remote
|
||||
https://HOST/OWNER/REPO` in place of both local-only flags. Both modes create a
|
||||
local repository and genesis commit; remote mode records the URL without a
|
||||
push. Existing paths are never overwritten. `mosaic org queue show ID --json`
|
||||
and `mosaic org project repo show ID PROJECT --json` read the receipts back.
|
||||
URL` in place of both local-only flags. Both modes create a local repository and
|
||||
genesis commit. Existing paths are never overwritten. `mosaic org queue show ID
|
||||
--json` and `mosaic org project repo show ID PROJECT --json` read the receipts
|
||||
back; the project form also reports the binding as it is now (`current`).
|
||||
|
||||
Remote mode (#1873 P1-6) accepts `https://HOST/OWNER/REPO` and ssh
|
||||
(`ssh://[USER@]HOST[:PORT]/PATH` or `USER@HOST:PATH`) only. It refuses
|
||||
`ext::` and other transport helpers, `file://`, local paths, values that begin
|
||||
with `-`, and any URL that carries a user password or token
|
||||
(`src/vocabulary.mjs` `parseRepoRemote`). The checkout's `origin` is set to the
|
||||
URL and checked once with `git ls-remote` (`src/repo-remote.mjs`): no
|
||||
credential helper, no askpass, no terminal prompt, no redirects,
|
||||
`GIT_ALLOW_PROTOCOL=https:ssh`, no git or ssh config files, no ssh agent or key,
|
||||
and a 15 second limit. The receipt's `check.result` is `reachable`,
|
||||
`needs-credential` (the credential binding will supply it) or `unreachable`
|
||||
with git's error summarized. The check never refuses the setup, and nothing is
|
||||
pushed. Tests reach a local bare repository only through `repoRemoteTestSeam`,
|
||||
which no source module may import.
|
||||
|
||||
`mosaic org project repo set ID PROJECT (--local-only --accept-local-loss-risk |
|
||||
--remote URL) --if-revision N [--json]` (#1873 P1-7) changes an initialized
|
||||
project's repository: a new URL, or remote to local only and back. It runs the
|
||||
same URL rules and check, sets or removes `origin`, records the binding in the
|
||||
organization file's `projects.PROJECT.git`, and writes an
|
||||
`org.project.repo.set` receipt. A stale `--if-revision` is `revision-conflict`.
|
||||
Queue review transports and transitions are not provided by this setup.
|
||||
|
||||
The local development owner is accepted only through the existing named-instance
|
||||
|
||||
@@ -4,7 +4,8 @@ import { spawn } from 'node:child_process';
|
||||
import { createHash, randomBytes } from 'node:crypto';
|
||||
import { dirname, join, resolve } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { validateBusinessDocument, httpsUrl } from './organization-config.mjs';
|
||||
import { validateBusinessDocument } from './organization-config.mjs';
|
||||
import { checkRemote, parseRepoRemote } from './repo-remote.mjs';
|
||||
import { ID_PATTERN } from './vocabulary.mjs';
|
||||
import { OrgError, orgRoot, quiet, readRegistry, reserveOrg, resolveOrg, withRegistry, withOrgLifecycle } from './org-registry.mjs';
|
||||
import { loadInstalled } from '../../plugins/src/loader.mjs';
|
||||
@@ -198,7 +199,8 @@ export async function updateOrg(ctx, id, input, { ifRevision } = {}) {
|
||||
}
|
||||
function options({ mode, remote, acceptLocalLossRisk }) {
|
||||
if (mode === 'local-only') { if (acceptLocalLossRisk !== true || remote !== undefined) fail('org-risk', 'local-only requires explicit loss-risk acceptance and no remote'); return { mode, riskAccepted: true }; }
|
||||
if (mode === 'remote') { if (acceptLocalLossRisk || typeof remote !== 'string') fail('org-invalid', 'remote mode requires a remote URL'); try { httpsUrl(remote, 'remote', { repo: true }); } catch (e) { fail('org-invalid', e.message); } return { mode, remote }; }
|
||||
// #1873 P1-6: https or ssh, and nothing that git could read as an option, a helper or a path.
|
||||
if (mode === 'remote') { if (acceptLocalLossRisk || typeof remote !== 'string') fail('org-invalid', 'remote mode requires a remote URL'); const parsed = parseRepoRemote(remote); if (!parsed.ok) fail('org-invalid', parsed.message, '$.remote'); return { mode, remote: parsed.url }; }
|
||||
fail('org-invalid', 'select local-only or remote');
|
||||
}
|
||||
async function git(root, args) {
|
||||
@@ -206,8 +208,21 @@ async function git(root, args) {
|
||||
return new Promise((resolve, reject) => { const p = spawn('git', ['-c', 'user.name=Mosaic Local', '-c', '[email protected]', '-c', 'core.hooksPath=/dev/null', '-C', root, ...args], { env, stdio: ['ignore', 'pipe', 'pipe'] }); let out = '', err = ''; p.stdout.on('data', d => out += d); p.stderr.on('data', d => err += d); p.on('error', reject); p.on('close', code => code === 0 ? resolve(out.trim()) : reject(new OrgError('org-git', `git ${args[0]} failed (exit ${code})`))); });
|
||||
}
|
||||
async function initGit(root) { await fs.mkdir(root, { mode: 0o700 }); await git(root, ['init', '--quiet', '--template=']); await git(root, ['commit', '--quiet', '--allow-empty', '-m', 'Genesis']); return git(root, ['rev-parse', 'HEAD']); }
|
||||
// The checkout's origin, or null when it has none.
|
||||
async function originOf(root) { try { return await git(root, ['config', '--get', 'remote.origin.url']); } catch (e) { if (e?.code === 'org-git') return null; throw e; } }
|
||||
// #1873 P1-6: point origin at the remote (or remove it for local-only). Never pushes or fetches.
|
||||
async function setOrigin(root, selection) {
|
||||
const origin = await originOf(root);
|
||||
if (selection.mode === 'remote') { if (origin === null) await git(root, ['remote', 'add', 'origin', selection.remote]); else if (origin !== selection.remote) await git(root, ['remote', 'set-url', 'origin', selection.remote]); }
|
||||
else if (origin !== null) await git(root, ['remote', 'remove', 'origin']);
|
||||
return originOf(root);
|
||||
}
|
||||
const checkFields = (check) => check ? { check: { result: check.result, message: check.message } } : {};
|
||||
async function setup(ctx, id, project, opts) {
|
||||
authorize(ctx); const selection = options(opts); if (project !== null) checkId(project);
|
||||
// The check talks to the network, so it runs before any lock is taken. Its result is reported,
|
||||
// never a refusal: a repository that needs a credential is the usual case before binding.
|
||||
const check = selection.mode === 'remote' ? await checkRemote(selection.remote) : null;
|
||||
return withOrgLifecycle(ctx, id, async () => {
|
||||
const current = await withRegistry(ctx, async () => {
|
||||
const current = await readCurrentUnlocked(ctx, id); if (project !== null && !Object.hasOwn(current.doc.projects, project)) fail('org-unknown', 'unknown project');
|
||||
@@ -217,7 +232,7 @@ async function setup(ctx, id, project, opts) {
|
||||
}, { write: false });
|
||||
const parent = project === null ? current.root : join(current.root, 'projects'); if (project !== null) await ensurePrivateDir(parent);
|
||||
const root = project === null ? join(current.root, 'checkout') : projectPath(current.root, project);
|
||||
const commit = await initGit(root); const fields = { ...selection, root, commit, ...(project === null ? {} : { project }) };
|
||||
const commit = await initGit(root); const origin = await setOrigin(root, selection); const fields = { ...selection, root, commit, ...(project === null ? {} : { project }), origin, ...checkFields(check) };
|
||||
return withRegistry(ctx, async registry => {
|
||||
const latest = await readCurrentUnlocked(ctx, id);
|
||||
if (latest.revision !== current.revision) fail('revision-conflict', 'organization changed during setup; inspect the initialized repository before retrying');
|
||||
@@ -236,7 +251,42 @@ async function showSetup(ctx, id, project) {
|
||||
if (!item || item.root !== root || !same(item.subject, current.principal)) fail('org-unavailable', 'setup receipt unavailable');
|
||||
if (project !== null) { const parent = await fs.lstat(join(current.root, 'projects')); if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== process.getuid() || (parent.mode & 0o077)) fail('org-mismatch', 'unsafe projects directory'); }
|
||||
const st = await fs.lstat(root); const dotgit = await fs.lstat(join(root, '.git')); if (!st.isDirectory() || st.isSymbolicLink() || !dotgit.isDirectory() || dotgit.isSymbolicLink()) fail('org-mismatch', 'unsafe git repository');
|
||||
await git(root, ['rev-parse', '--verify', 'HEAD']); return item;
|
||||
await git(root, ['rev-parse', '--verify', 'HEAD']);
|
||||
if (project === null) return item;
|
||||
// #1873 P1-7: the binding as it is now, which a later repo set may have changed since init.
|
||||
const binding = current.doc.projects[project].git ?? { mode: item.mode, ...(item.remote ? { remote: item.remote } : {}) };
|
||||
const last = records.findLast(r => r.op === 'org.project.repo.set' && r.project === project && same(r.subject, current.principal)) ?? null;
|
||||
return { ...item, current: { mode: binding.mode, ...(binding.mode === 'remote' ? { remote: binding.remote } : {}), origin: await originOf(root), revision: current.revision, ...((last ?? item).check ? { check: (last ?? item).check } : {}), ...(last ? { changedAt: last.at } : {}) } };
|
||||
}
|
||||
// #1873 P1-7: change an initialized project's repository between remote and local-only, or to a
|
||||
// new URL. The same URL rules and check as init; origin follows; nothing is pushed. A receipt
|
||||
// records it. Setting the same URL again re-runs the check and repairs origin.
|
||||
export async function projectRepoSet(ctx, id, project, opts = {}) {
|
||||
authorize(ctx); checkId(id); checkId(project); const selection = options(opts); const { ifRevision } = opts;
|
||||
if (!Number.isSafeInteger(ifRevision)) fail('org-invalid', 'repo set needs --if-revision');
|
||||
// Fail fast on the cheap checks before the network check, then again under the lock.
|
||||
await projectRepoShow(ctx, id, project).then(r => { if (r.current.revision !== ifRevision) fail('revision-conflict', 'organization revision changed'); });
|
||||
const check = selection.mode === 'remote' ? await checkRemote(selection.remote) : null;
|
||||
return withOrgLifecycle(ctx, id, () => withRegistry(ctx, async registry => {
|
||||
const latest = await readCurrentUnlocked(ctx, id); if (!Object.hasOwn(latest.doc.projects, project)) fail('org-unknown', 'unknown project');
|
||||
if (latest.revision !== ifRevision) fail('revision-conflict', 'organization revision changed');
|
||||
const root = projectPath(latest.root, project);
|
||||
const init = (await receipts(latest.root)).findLast(r => r.op === 'org.project.repo.init' && r.project === project);
|
||||
if (!init || init.root !== root || !same(init.subject, latest.principal)) fail('org-unavailable', 'setup receipt unavailable');
|
||||
const st = await fs.lstat(root); const dotgit = await fs.lstat(join(root, '.git')); if (!st.isDirectory() || st.isSymbolicLink() || !dotgit.isDirectory() || dotgit.isSymbolicLink()) fail('org-mismatch', 'unsafe git repository');
|
||||
const previous = latest.doc.projects[project].git ?? { mode: init.mode, ...(init.remote ? { remote: init.remote } : {}) };
|
||||
const next = selection.mode === 'remote' ? { mode: 'remote', remote: selection.remote } : { mode: 'local-only' };
|
||||
// origin first: a failure after it leaves the recorded binding as it was, and repeating the
|
||||
// same set repairs origin.
|
||||
const origin = await setOrigin(root, selection);
|
||||
let revision = latest.revision;
|
||||
if (canonicalJson(previous) !== canonicalJson(next)) {
|
||||
if (!Number.isSafeInteger(revision + 1)) fail('org-mismatch', 'organization revision cannot be incremented');
|
||||
latest.doc.projects[project].git = next; await checked(latest.doc); const raw = encode(latest.doc);
|
||||
await atomic(join(ctx.configDir, 'businesses', `${id}.json`), raw); registry.orgs[id].digest = digest(raw); registry.orgs[id].revision = revision = latest.revision + 1;
|
||||
}
|
||||
return receipt(latest.root, 'org.project.repo.set', id, ctx.principal, { ...selection, root, project, previous, revision, origin, ...checkFields(check) });
|
||||
}));
|
||||
}
|
||||
export async function queueShow(ctx, id) { return showSetup(ctx, id, null); }
|
||||
export async function projectRepoShow(ctx, id, project) { return showSetup(ctx, id, project); }
|
||||
|
||||
@@ -12,7 +12,7 @@ import { checkVars } from "./vars.mjs";
|
||||
import { parseCredentialRef } from "./credentials.mjs";
|
||||
import { loadRole } from "./role.mjs";
|
||||
import { checkDefinitions, checkDefinitionName, orgDefinitionName, ORG_PREFIX } from "./definitions.mjs";
|
||||
import { END_PROTECTED } from "./vocabulary.mjs";
|
||||
import { END_PROTECTED, parseRepoRemote } from "./vocabulary.mjs";
|
||||
import { checkPlugins, checkUsageSettings } from "../../plugins/src/kinds.mjs";
|
||||
import { hasModule } from "../../plugins/src/loader.mjs";
|
||||
import { readPluginLock } from "../../plugins/src/pinned.mjs";
|
||||
@@ -320,7 +320,9 @@ export function validateOrganizationDocument(document, file, { rolesDir, dataRoo
|
||||
requireObject(entry.git, `${file} projects.${id}.git`);
|
||||
rejectUnknownKeys(entry.git, ["mode", "remote"], `${file} projects.${id}.git`);
|
||||
if (!['local-only', 'remote'].includes(entry.git.mode)) refuse(`${file} projects.${id}.git.mode must be local-only or remote`);
|
||||
if (entry.git.mode === 'remote') httpsUrl(entry.git.remote, `${file} projects.${id}.git.remote`, { repo: true });
|
||||
// #1873 P1-6: the checkout's origin may be https or ssh (repo-remote.mjs's rules). The Row 199
|
||||
// upstream, projects.<p>.remote, stays https only.
|
||||
if (entry.git.mode === 'remote') { const remote = parseRepoRemote(entry.git.remote); if (!remote.ok) refuse(`${file} projects.${id}.git.remote: ${remote.message}`); }
|
||||
else if (Object.hasOwn(entry.git, 'remote')) refuse(`${file} projects.${id}.git.remote is not allowed for local-only`);
|
||||
}
|
||||
projects[id] = { root: entry.root, ...(Object.hasOwn(entry, "repo") ? { repo: entry.repo } : {}),
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
// #1873 P1-6 and P1-7: the project repository's remote URL, and the one check it gets.
|
||||
//
|
||||
// parseRepoRemote decides which URLs may become a checkout's origin: https (the Gitea form the
|
||||
// loader already uses) and ssh, nothing else. checkRemote runs `git ls-remote` against that URL with
|
||||
// no credential of any kind and a hard timeout, and says plainly whether the repository answered,
|
||||
// wants a credential, or could not be reached. Nothing here pushes, fetches objects or writes.
|
||||
import { spawn } from 'node:child_process';
|
||||
import { parseRepoRemote } from './vocabulary.mjs';
|
||||
|
||||
export { parseRepoRemote };
|
||||
|
||||
// The ssh client for the check: no user or system config file, no agent, no key, no password, no
|
||||
// proxy or jump host, no multiplexing, no forwarding, no local command, and an unknown host key is
|
||||
// accepted for this one connection without being remembered (nothing secret is sent to it).
|
||||
export const CHECK_SSH_COMMAND = [
|
||||
'ssh', '-F', '/dev/null',
|
||||
...['BatchMode=yes', 'ConnectTimeout=5', 'StrictHostKeyChecking=no', 'UserKnownHostsFile=/dev/null',
|
||||
'GlobalKnownHostsFile=/dev/null', 'LogLevel=ERROR', 'IdentityFile=none', 'IdentitiesOnly=yes',
|
||||
'IdentityAgent=none', 'PasswordAuthentication=no', 'KbdInteractiveAuthentication=no',
|
||||
'HostbasedAuthentication=no', 'GSSAPIAuthentication=no', 'ProxyCommand=none', 'ProxyJump=none',
|
||||
'ControlMaster=no', 'ControlPath=none', 'PermitLocalCommand=no', 'ForwardAgent=no',
|
||||
'ClearAllForwardings=yes'].flatMap((o) => ['-o', o]),
|
||||
].join(' ');
|
||||
|
||||
const PRODUCTION = Object.freeze({ protocols: 'https:ssh', timeoutMs: 15000 });
|
||||
const OUTPUT_CAP = 64 * 1024;
|
||||
|
||||
// git's own message for "this needs a credential": a prompt it could not show, a 401 or 403, or
|
||||
// ssh refusing every (absent) key.
|
||||
const NEEDS_CREDENTIAL = [
|
||||
/terminal prompts disabled/i, /could not read (username|password)/i, /authentication failed/i,
|
||||
/returned error: 40[13]\b/, /permission denied \(/i,
|
||||
];
|
||||
|
||||
// One plain line from git's stderr: the first line that says what went wrong, without "fatal: ",
|
||||
// control characters or more than 200 characters.
|
||||
export function summarizeGitError(stderr) {
|
||||
const lines = String(stderr).split('\n').map((l) => l.replace(/[\0-\x1f\x7f]/g, '').trim()).filter(Boolean);
|
||||
const line = lines.find((l) => /^(fatal|ssh|error):/i.test(l)) ?? lines[0] ?? '';
|
||||
const text = line.replace(/^(fatal|error):\s*/i, '');
|
||||
return text.length > 200 ? `${text.slice(0, 199)}…` : text || 'git gave no reason';
|
||||
}
|
||||
|
||||
export function classifyCheck({ code, timedOut, spawnError, stderr }) {
|
||||
if (spawnError) return { result: 'unreachable', message: 'git could not be started' };
|
||||
if (timedOut) return { result: 'unreachable', message: 'no answer before the check timed out' };
|
||||
if (code === 0) return { result: 'reachable', message: 'the repository answered' };
|
||||
if (NEEDS_CREDENTIAL.some((p) => p.test(stderr))) return { result: 'needs-credential', message: 'the repository needs a credential; the credential binding will supply it' };
|
||||
return { result: 'unreachable', message: summarizeGitError(stderr) };
|
||||
}
|
||||
|
||||
function lsRemote(url, { protocols, timeoutMs }) {
|
||||
const env = {
|
||||
PATH: process.env.PATH ?? '/usr/bin:/bin', HOME: '/nonexistent', LC_ALL: 'C',
|
||||
GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CEILING_DIRECTORIES: '/',
|
||||
GIT_TERMINAL_PROMPT: '0', GIT_ALLOW_PROTOCOL: protocols,
|
||||
GIT_SSH_COMMAND: CHECK_SSH_COMMAND, GIT_SSH_VARIANT: 'ssh', GIT_PROTOCOL_FROM_USER: '0',
|
||||
};
|
||||
const args = [
|
||||
'-c', 'credential.helper=', '-c', 'core.askPass=', '-c', 'http.followRedirects=false',
|
||||
'-c', 'protocol.allow=never', ...protocols.split(':').flatMap((p) => ['-c', `protocol.${p}.allow=always`]),
|
||||
'ls-remote', '--', url, 'HEAD',
|
||||
];
|
||||
return new Promise((resolve) => {
|
||||
let child;
|
||||
try { child = spawn('git', args, { cwd: '/', env, stdio: ['ignore', 'pipe', 'pipe'], detached: true }); }
|
||||
catch { resolve(classifyCheck({ spawnError: true })); return; }
|
||||
let stderr = '', timedOut = false, done = false;
|
||||
const kill = () => { try { process.kill(-child.pid, 'SIGKILL'); } catch { /* already gone */ } };
|
||||
const timer = setTimeout(() => { timedOut = true; kill(); }, timeoutMs);
|
||||
child.stdout.on('data', () => {});
|
||||
child.stderr.on('data', (d) => { if (stderr.length < OUTPUT_CAP) stderr += d; });
|
||||
const finish = (outcome) => { if (done) return; done = true; clearTimeout(timer); kill(); resolve(classifyCheck({ ...outcome, timedOut, stderr })); };
|
||||
child.on('error', () => finish({ spawnError: true }));
|
||||
child.on('close', (code) => finish({ code }));
|
||||
});
|
||||
}
|
||||
|
||||
let override = null;
|
||||
|
||||
// The check for a URL parseRepoRemote accepted: https and ssh only, 15 second limit. Returns
|
||||
// {result: 'reachable'|'needs-credential'|'unreachable', message, url}. A URL that does not parse
|
||||
// is refused by the caller first; here it is reported unreachable without running git.
|
||||
export async function checkRemote(url) {
|
||||
const parsed = parseRepoRemote(url);
|
||||
if (!parsed.ok) return { result: 'unreachable', message: parsed.message, url };
|
||||
const outcome = override ? await override(parsed.url) : await lsRemote(parsed.url, PRODUCTION);
|
||||
return { result: outcome.result, message: outcome.message, url: parsed.url };
|
||||
}
|
||||
|
||||
// TEST SEAM. Tests reach a local bare repository through this and nothing else: lsRemote with a
|
||||
// widened protocol list, and a stand-in for checkRemote's git call. No module under packages/*/src
|
||||
// may import or name it; tests/repo-remote.test.mjs enforces that by scanning the sources.
|
||||
export const repoRemoteTestSeam = Object.freeze({
|
||||
lsRemote: (url, { protocols, timeoutMs = 5000 }) => lsRemote(url, { protocols, timeoutMs }),
|
||||
useCheck(fn) { override = typeof fn === 'function' ? fn : null; },
|
||||
});
|
||||
@@ -236,6 +236,62 @@ export function parseGiteaUrl(value, { repo = false } = {}) {
|
||||
return { url, owner: segments[0], repo: name };
|
||||
}
|
||||
|
||||
// #1873 P1-6: a project repository's remote, https or ssh. It lives here, beside parseGiteaUrl,
|
||||
// because the loader validates projects.<p>.git.remote with it and this file imports nothing.
|
||||
const REPO_REMOTE_MAX = 512;
|
||||
// A host name or IPv4 address: labels of letters, digits and "-", starting with a letter or digit.
|
||||
const REMOTE_HOST = '[A-Za-z0-9](?:[A-Za-z0-9-]{0,62})(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,62}))*';
|
||||
// A login name. It never starts with "-" so ssh can't read it as an option.
|
||||
const REMOTE_USER = '[A-Za-z0-9_][A-Za-z0-9_.-]{0,63}';
|
||||
// Path segments: letters, digits, "_", ".", "-" and "~", never starting with "-", never "." or "..".
|
||||
const REMOTE_SEGMENT = '[A-Za-z0-9_.~][A-Za-z0-9_.~-]{0,99}';
|
||||
const REMOTE_SSH_URL = new RegExp(`^ssh://(?:(${REMOTE_USER})@)?(${REMOTE_HOST})(?::([0-9]{1,5}))?(/${REMOTE_SEGMENT}(?:/${REMOTE_SEGMENT})*)$`);
|
||||
const REMOTE_SCP_LIKE = new RegExp(`^(${REMOTE_USER})@(${REMOTE_HOST}):(/?${REMOTE_SEGMENT}(?:/${REMOTE_SEGMENT})*)$`);
|
||||
|
||||
const REMOTE_PROBLEMS = Object.freeze({
|
||||
form: 'the repository URL must be an https or ssh URL',
|
||||
option: 'the repository URL must not start with "-"',
|
||||
transport: 'the repository URL must not name a git transport helper (such as ext::)',
|
||||
local: 'the repository URL must not be a local path or a file:// URL',
|
||||
scheme: 'the repository URL must use https or ssh',
|
||||
credentials: 'the repository URL must not carry a user password or token; credentials come from the credential binding',
|
||||
https: 'an https repository URL must be normalized and name a repository, https://HOST/OWNER/REPO',
|
||||
ssh: 'an ssh repository URL must be ssh://[USER@]HOST[:PORT]/PATH or USER@HOST:PATH, with no "." or ".." segment',
|
||||
});
|
||||
|
||||
// Returns {ok: true, kind: 'https'|'ssh', url} or {ok: false, problem, message}. The URL that is
|
||||
// checked and stored is exactly the value given; nothing is rewritten.
|
||||
export function parseRepoRemote(value) {
|
||||
const no = (problem) => ({ ok: false, problem, message: REMOTE_PROBLEMS[problem] });
|
||||
if (typeof value !== 'string' || value.length === 0 || value.length > REPO_REMOTE_MAX) return no('form');
|
||||
if (value.startsWith('-')) return no('option');
|
||||
if (value.includes('::')) return no('transport');
|
||||
if (/[\s\0-\x1f\x7f]/.test(value)) return no('form');
|
||||
if (/^file:/i.test(value) || /^[/.~\\]/.test(value)) return no('local');
|
||||
const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):\/\//.exec(value)?.[1]?.toLowerCase();
|
||||
if (scheme === 'https') {
|
||||
let url = null;
|
||||
try { url = new URL(value); } catch { return no('https'); }
|
||||
if (url.username || url.password) return no('credentials');
|
||||
return parseGiteaUrl(value, { repo: true }).url ? { ok: true, kind: 'https', url: value } : no('https');
|
||||
}
|
||||
if (scheme === 'ssh') {
|
||||
if (/^ssh:\/\/[^/@]*:[^/@]*@/.test(value)) return no('credentials');
|
||||
const m = REMOTE_SSH_URL.exec(value);
|
||||
if (!m || remoteDotSegment(m[4]) || (m[3] !== undefined && !(Number(m[3]) >= 1 && Number(m[3]) <= 65535 && !m[3].startsWith('0')))) return no('ssh');
|
||||
return { ok: true, kind: 'ssh', url: value };
|
||||
}
|
||||
if (scheme !== undefined) return no('scheme');
|
||||
// No "scheme://": git reads HOST:PATH as ssh only when the colon comes before any slash.
|
||||
const colon = value.indexOf(':'), slash = value.indexOf('/');
|
||||
if (colon < 0 || (slash >= 0 && slash < colon)) return no('local');
|
||||
if (/^[^@]*:[^@]*@/.test(value)) return no('credentials');
|
||||
const m = REMOTE_SCP_LIKE.exec(value);
|
||||
if (!m || remoteDotSegment(m[3])) return no('ssh');
|
||||
return { ok: true, kind: 'ssh', url: value };
|
||||
}
|
||||
const remoteDotSegment = (path) => path.split('/').some((s) => s === '.' || s === '..');
|
||||
|
||||
// Design D9 step 2: the agent's fork of an upstream, https://HOST[:PORT]/<user>/REPO, or null for an
|
||||
// upstream that doesn't parse. The owner is always the agent's own Gitea user; nothing else names it.
|
||||
// URL.host drops a default port, so 443 counts the same on both sides.
|
||||
|
||||
@@ -0,0 +1,217 @@
|
||||
// #1873 P1-6 and P1-7: the remote URL rules, the ls-remote check, and repo set.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createServer } from 'node:http';
|
||||
import { createServer as createTcpServer } from 'node:net';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { mkdtempSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
|
||||
import { dirname, join, resolve } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { parseRepoRemote, checkRemote, classifyCheck, summarizeGitError, CHECK_SSH_COMMAND, repoRemoteTestSeam } from '../src/repo-remote.mjs';
|
||||
import { createOrg, templateRender, projectRepoInit, projectRepoShow, projectRepoSet, queueInit, showOrg, updateOrg } from '../src/org-service.mjs';
|
||||
import { loadBusiness } from '../src/organization-config.mjs';
|
||||
import { REPO_ROLES } from './helpers.mjs';
|
||||
|
||||
const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
|
||||
const seam = repoRemoteTestSeam;
|
||||
const gitEnv = { PATH: process.env.PATH, HOME: '/nonexistent', GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', LC_ALL: 'C' };
|
||||
const git = (cwd, ...args) => execFileSync('git', ['-C', cwd, ...args], { env: gitEnv, encoding: 'utf8' }).trim();
|
||||
function bare() { const dir = mkdtempSync(join(tmpdir(), 'bare-')); git(dir, 'init', '--quiet', '--bare', '--template='); return dir; }
|
||||
function context() { const root = mkdtempSync(join(tmpdir(), 'repo-remote-')); const configDir = join(root, 'config'), dataRoot = join(root, 'data'); mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 }); return { configDir, dataRoot, instance: 'test', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } }; }
|
||||
const listen = (server) => new Promise((r) => server.listen(0, '127.0.0.1', () => r(server.address().port)));
|
||||
|
||||
test('remote URL rules: https and ssh only, nothing git could read as an option, helper, path or credential', () => {
|
||||
for (const ok of ['https://git.example.com/owner/repo', 'https://git.example.com/owner/repo.git', 'https://git.example.com:8443/o/r',
|
||||
'ssh://[email protected]/owner/repo.git', 'ssh://git.example.com:2222/srv/git/repo.git', '[email protected]:owner/repo.git', '[email protected]:/srv/repo']) {
|
||||
assert.equal(parseRepoRemote(ok).ok, true, ok);
|
||||
}
|
||||
const refused = {
|
||||
'ext::sh -c touch% /tmp/pwned': 'transport', 'fd::17': 'transport', 'file:///srv/repo.git': 'local', 'FILE:///srv/r': 'local',
|
||||
'/srv/repo.git': 'local', './repo': 'local', '../repo': 'local', '~/repo': 'local', 'repo/sub:x': 'local', 'plainword': 'local',
|
||||
'--upload-pack=touch /tmp/x': 'option', '-oProxyCommand=x': 'option',
|
||||
'https://user:[email protected]/o/r': 'credentials', 'https://[email protected]/o/r': 'credentials',
|
||||
'ssh://git:[email protected]/o/r': 'credentials', 'git:[email protected]:o/r': 'credentials',
|
||||
'http://git.example.com/o/r': 'scheme', 'git://git.example.com/o/r': 'scheme', 'ftp://x/o/r': 'scheme', 'ssh+git://x/o/r': 'scheme',
|
||||
'https://git.example.com/o/r?x=1': 'https', 'https://git.example.com/o/../r': 'https', 'https://git.example.com/o': 'https', 'HTTPS://git.example.com/o/r': 'https',
|
||||
'ssh://-oProxyCommand=x/o/r': 'ssh', 'ssh://git@-host/o/r': 'ssh', 'ssh://-user@host/o/r': 'ssh', 'ssh://host/../etc': 'ssh',
|
||||
'ssh://host:0/r': 'ssh', 'ssh://host:65536/r': 'ssh', 'ssh://host/-r': 'ssh', 'git@host:-r': 'ssh', 'git@host:a/../b': 'ssh', 'host:repo': 'ssh',
|
||||
'ssh://host/a b': 'form', 'https://x/o/r\n': 'form', '': 'form',
|
||||
};
|
||||
for (const [value, problem] of Object.entries(refused)) {
|
||||
const result = parseRepoRemote(value);
|
||||
assert.equal(result.ok, false, value); assert.equal(result.problem, problem, value); assert.ok(result.message.length > 0);
|
||||
}
|
||||
assert.equal(parseRepoRemote(42).ok, false); assert.equal(parseRepoRemote('x'.repeat(600)).ok, false);
|
||||
});
|
||||
|
||||
test('check outcomes are classified from git\'s own messages', () => {
|
||||
assert.equal(classifyCheck({ code: 0, stderr: '' }).result, 'reachable');
|
||||
assert.equal(classifyCheck({ code: 128, stderr: "fatal: could not read Username for 'https://git.example.com': terminal prompts disabled\n" }).result, 'needs-credential');
|
||||
assert.equal(classifyCheck({ code: 128, stderr: '[email protected]: Permission denied (publickey,password).\nfatal: Could not read from remote repository.\n' }).result, 'needs-credential');
|
||||
assert.equal(classifyCheck({ code: 128, stderr: "fatal: unable to access 'https://h/o/r/': The requested URL returned error: 403\n" }).result, 'needs-credential');
|
||||
const dns = classifyCheck({ code: 128, stderr: "fatal: unable to access 'https://git.example.invalid/o/r.git/': Could not resolve host: git.example.invalid\n" });
|
||||
assert.deepEqual(dns, { result: 'unreachable', message: "unable to access 'https://git.example.invalid/o/r.git/': Could not resolve host: git.example.invalid" });
|
||||
const ssh = classifyCheck({ code: 128, stderr: 'ssh: Could not resolve hostname git.example.invalid: Name or service not known\r\nfatal: Could not read from remote repository.\n\nPlease make sure you have the correct access rights\n' });
|
||||
assert.equal(ssh.message, 'ssh: Could not resolve hostname git.example.invalid: Name or service not known');
|
||||
assert.equal(classifyCheck({ timedOut: true, stderr: '' }).message, 'no answer before the check timed out');
|
||||
assert.equal(classifyCheck({ spawnError: true }).result, 'unreachable');
|
||||
assert.equal(summarizeGitError(`fatal: ${'x'.repeat(400)}\u001b[31m`).length, 200);
|
||||
assert.equal(summarizeGitError(''), 'git gave no reason');
|
||||
});
|
||||
|
||||
test('the ssh client for the check reads no config, key, agent or proxy', () => {
|
||||
for (const option of ['-F /dev/null', 'BatchMode=yes', 'IdentityFile=none', 'IdentitiesOnly=yes', 'IdentityAgent=none', 'PasswordAuthentication=no',
|
||||
'KbdInteractiveAuthentication=no', 'ProxyCommand=none', 'ProxyJump=none', 'ControlPath=none', 'PermitLocalCommand=no', 'ForwardAgent=no', 'UserKnownHostsFile=/dev/null']) {
|
||||
assert.ok(CHECK_SSH_COMMAND.includes(option), option);
|
||||
}
|
||||
});
|
||||
|
||||
test('production check refuses local and helper URLs without running git, and file is not an allowed transport', async () => {
|
||||
const repo = bare();
|
||||
for (const url of [`file://${repo}`, repo, 'ext::sh -c id', '--upload-pack=id']) assert.equal((await checkRemote(url)).result, 'unreachable', url);
|
||||
// The production protocol list, through the seam: git itself refuses the file transport.
|
||||
const refused = await seam.lsRemote(`file://${repo}`, { protocols: 'https:ssh' });
|
||||
assert.equal(refused.result, 'unreachable'); assert.match(refused.message, /transport 'file' not allowed/);
|
||||
assert.equal((await seam.lsRemote(`file://${repo}`, { protocols: 'file' })).result, 'reachable');
|
||||
});
|
||||
|
||||
test('the check ignores the caller\'s git config and environment', async () => {
|
||||
const repo = bare(); const home = mkdtempSync(join(tmpdir(), 'home-'));
|
||||
// A user config that would rewrite the URL to the local repository, and a credential helper.
|
||||
writeFileSync(join(home, '.gitconfig'), `[url "file://${repo}"]\n\tinsteadOf = https://git.example.invalid/o/r\n[credential]\n\thelper = !echo username=x; echo password=y\n`);
|
||||
const saved = { HOME: process.env.HOME, GIT_CONFIG_PARAMETERS: process.env.GIT_CONFIG_PARAMETERS, GIT_CONFIG_GLOBAL: process.env.GIT_CONFIG_GLOBAL };
|
||||
process.env.HOME = home; process.env.GIT_CONFIG_GLOBAL = join(home, '.gitconfig'); process.env.GIT_CONFIG_PARAMETERS = `'url.file://${repo}.insteadof'='https://git.example.invalid/o/r'`;
|
||||
try {
|
||||
const result = await seam.lsRemote('https://git.example.invalid/o/r', { protocols: 'https:ssh:file', timeoutMs: 10000 });
|
||||
assert.equal(result.result, 'unreachable'); assert.match(result.message, /git\.example\.invalid/);
|
||||
} finally { for (const [k, v] of Object.entries(saved)) if (v === undefined) delete process.env[k]; else process.env[k] = v; }
|
||||
});
|
||||
|
||||
test('a 401 is needs-credential and no credential is sent', async () => {
|
||||
const seen = [];
|
||||
const server = createServer((req, res) => { seen.push(req.headers.authorization ?? null); res.writeHead(401, { 'WWW-Authenticate': 'Basic realm="git"' }); res.end(); });
|
||||
const port = await listen(server);
|
||||
try {
|
||||
const result = await seam.lsRemote(`http://127.0.0.1:${port}/o/r.git`, { protocols: 'http' });
|
||||
assert.equal(result.result, 'needs-credential'); assert.match(result.message, /credential binding/);
|
||||
assert.ok(seen.length >= 1); assert.deepEqual(seen.filter(Boolean), []);
|
||||
} finally { server.close(); }
|
||||
});
|
||||
|
||||
test('a redirect is not followed, so the check reaches only the named URL', async () => {
|
||||
let elsewhere = 0;
|
||||
const other = createServer((req, res) => { elsewhere++; res.writeHead(404); res.end(); });
|
||||
const otherPort = await listen(other);
|
||||
const server = createServer((req, res) => { res.writeHead(302, { Location: `http://127.0.0.1:${otherPort}${req.url}` }); res.end(); });
|
||||
const port = await listen(server);
|
||||
try {
|
||||
const result = await seam.lsRemote(`http://127.0.0.1:${port}/o/r.git`, { protocols: 'http' });
|
||||
assert.equal(result.result, 'unreachable'); assert.match(result.message, /302/); assert.equal(elsewhere, 0);
|
||||
} finally { server.close(); other.close(); }
|
||||
});
|
||||
|
||||
test('a silent server times out and the check reports it', async () => {
|
||||
const sockets = []; const server = createTcpServer((s) => sockets.push(s)); const port = await listen(server);
|
||||
try {
|
||||
const started = Date.now();
|
||||
const result = await seam.lsRemote(`http://127.0.0.1:${port}/o/r.git`, { protocols: 'http', timeoutMs: 600 });
|
||||
assert.deepEqual(result, { result: 'unreachable', message: 'no answer before the check timed out' }); assert.ok(Date.now() - started < 5000);
|
||||
} finally { for (const s of sockets) s.destroy(); server.close(); }
|
||||
});
|
||||
|
||||
test('no production source reaches the test seam', () => {
|
||||
const offenders = [];
|
||||
for (const pkg of readdirSync(join(repoRoot, 'packages'))) {
|
||||
const walk = (dir) => { let entries; try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; } for (const e of entries) { const p = join(dir, e.name); if (e.isDirectory()) { if (e.name !== 'node_modules') walk(p); } else if (/\.(m?js|cjs)$/.test(e.name) && readFileSync(p, 'utf8').includes('repoRemoteTestSeam') && !p.endsWith(join('organization', 'src', 'repo-remote.mjs'))) offenders.push(p); } };
|
||||
walk(join(repoRoot, 'packages', pkg, 'src'));
|
||||
}
|
||||
assert.deepEqual(offenders, []);
|
||||
});
|
||||
|
||||
async function orgWithRepo(c, opts = { mode: 'local-only', acceptLocalLossRisk: true }) {
|
||||
await createOrg(c, 'alpha', await templateRender('alpha')); return projectRepoInit(c, 'alpha', 'work', opts);
|
||||
}
|
||||
|
||||
test('remote init sets origin and records the check; nothing is pushed', async () => {
|
||||
const c = context(); const repo = bare(); const url = 'https://git.example.com/team/work.git';
|
||||
seam.useCheck((u) => { assert.equal(u, url); return seam.lsRemote(`file://${repo}`, { protocols: 'file' }); });
|
||||
try {
|
||||
const r = await orgWithRepo(c, { mode: 'remote', remote: url });
|
||||
assert.equal(r.origin, url); assert.deepEqual(r.check, { result: 'reachable', message: 'the repository answered' });
|
||||
assert.equal(git(r.root, 'remote', '-v'), `origin\t${url} (fetch)\norigin\t${url} (push)`);
|
||||
assert.equal(git(repo, 'for-each-ref').length, 0, 'nothing pushed');
|
||||
const shown = await projectRepoShow(c, 'alpha', 'work');
|
||||
assert.deepEqual(shown.current, { mode: 'remote', remote: url, origin: url, revision: shown.current.revision, check: r.check });
|
||||
} finally { seam.useCheck(null); }
|
||||
});
|
||||
|
||||
test('repo set switches remote to local-only and back, with receipts and the revision fence', async () => {
|
||||
const c = context(); const r = await orgWithRepo(c);
|
||||
assert.equal(git(r.root, 'remote', '-v'), '');
|
||||
let rev = (await showOrg(c, 'alpha')).revision;
|
||||
seam.useCheck(async () => ({ result: 'needs-credential', message: 'the repository needs a credential; the credential binding will supply it' }));
|
||||
try {
|
||||
const ssh = '[email protected]:team/work.git';
|
||||
await assert.rejects(projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: ssh, ifRevision: rev + 1 }), { code: 'revision-conflict' });
|
||||
await assert.rejects(projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: ssh }), { code: 'org-invalid' });
|
||||
const set = await projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: ssh, ifRevision: rev });
|
||||
assert.equal(set.op, 'org.project.repo.set'); assert.equal(set.revision, rev + 1); assert.deepEqual(set.previous, { mode: 'local-only' });
|
||||
assert.equal(set.check.result, 'needs-credential'); assert.equal(git(r.root, 'remote', 'get-url', 'origin'), ssh);
|
||||
assert.deepEqual(loadBusiness('alpha', { dir: c.configDir, rolesDir: REPO_ROLES }).projects.work.git, { mode: 'remote', remote: ssh });
|
||||
rev = set.revision;
|
||||
const https = 'https://git.example.com/team/work';
|
||||
const moved = await projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: https, ifRevision: rev });
|
||||
assert.equal(git(r.root, 'remote', 'get-url', 'origin'), https); assert.equal(moved.revision, rev + 1); rev = moved.revision;
|
||||
// The same URL again re-checks and repairs origin without a new revision.
|
||||
git(r.root, 'remote', 'set-url', 'origin', 'https://elsewhere.example/x/y');
|
||||
const again = await projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: https, ifRevision: rev });
|
||||
assert.equal(again.revision, rev); assert.equal(git(r.root, 'remote', 'get-url', 'origin'), https);
|
||||
await assert.rejects(projectRepoSet(c, 'alpha', 'work', { mode: 'local-only', ifRevision: rev }), { code: 'org-risk' });
|
||||
const local = await projectRepoSet(c, 'alpha', 'work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev });
|
||||
assert.equal(local.revision, rev + 1); assert.equal(local.check, undefined); assert.equal(git(r.root, 'remote', '-v'), '');
|
||||
const shown = await projectRepoShow(c, 'alpha', 'work');
|
||||
assert.deepEqual(shown.current, { mode: 'local-only', origin: null, revision: local.revision, changedAt: local.at });
|
||||
const ops = readFileSync(join(r.root, '../../receipts.jsonl'), 'utf8').trim().split('\n').map((l) => JSON.parse(l).op);
|
||||
assert.deepEqual(ops.filter((o) => o.startsWith('org.project.repo')), ['org.project.repo.init', 'org.project.repo.set', 'org.project.repo.set', 'org.project.repo.set', 'org.project.repo.set']);
|
||||
// A whole-document update still can't change the binding.
|
||||
const current = await showOrg(c, 'alpha'); const doc = structuredClone(current.doc); doc.projects.work.git = { mode: 'remote', remote: https };
|
||||
await assert.rejects(updateOrg(c, 'alpha', doc, { ifRevision: current.revision }), { code: 'org-invalid' });
|
||||
} finally { seam.useCheck(null); }
|
||||
});
|
||||
|
||||
test('repo set refuses bad URLs before any check, and needs an initialized repository', async () => {
|
||||
const c = context(); await createOrg(c, 'alpha', await templateRender('alpha'));
|
||||
let checks = 0; seam.useCheck(async () => { checks++; return { result: 'reachable', message: 'x' }; });
|
||||
try {
|
||||
const rev = (await showOrg(c, 'alpha')).revision;
|
||||
await assert.rejects(projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote: 'https://git.example.com/o/r', ifRevision: rev }), { code: 'org-unavailable' });
|
||||
await projectRepoInit(c, 'alpha', 'work', { mode: 'local-only', acceptLocalLossRisk: true });
|
||||
const rev2 = (await showOrg(c, 'alpha')).revision;
|
||||
for (const remote of ['ext::sh -c id', `file://${bare()}`, '/srv/x', '--upload-pack=id', 'https://u:[email protected]/o/r', 'http://git.example.com/o/r']) {
|
||||
await assert.rejects(projectRepoSet(c, 'alpha', 'work', { mode: 'remote', remote, ifRevision: rev2 }), { code: 'org-invalid' }, remote);
|
||||
await assert.rejects(projectRepoInit(c, 'alpha', 'other', { mode: 'remote', remote }), { code: 'org-invalid' }, remote);
|
||||
}
|
||||
assert.equal(checks, 0);
|
||||
} finally { seam.useCheck(null); }
|
||||
});
|
||||
|
||||
test('queue init with a remote also sets origin', async () => {
|
||||
const c = context(); await createOrg(c, 'alpha', await templateRender('alpha'));
|
||||
seam.useCheck(async () => ({ result: 'unreachable', message: 'Could not resolve host: git.example.invalid' }));
|
||||
try {
|
||||
const q = await queueInit(c, 'alpha', { mode: 'remote', remote: 'ssh://[email protected]/team/queue.git' });
|
||||
assert.equal(git(q.root, 'remote', 'get-url', 'origin'), 'ssh://[email protected]/team/queue.git'); assert.equal(q.check.result, 'unreachable');
|
||||
} finally { seam.useCheck(null); }
|
||||
});
|
||||
|
||||
test('the loader accepts an ssh git remote and refuses a helper URL', async () => {
|
||||
const c = context(); await createOrg(c, 'alpha', await templateRender('alpha'));
|
||||
const file = join(c.configDir, 'businesses', 'alpha.json');
|
||||
const doc = JSON.parse(readFileSync(file, 'utf8'));
|
||||
const { validateOrg } = await import('../src/org-service.mjs');
|
||||
doc.projects.work.git = { mode: 'remote', remote: '[email protected]:team/work.git' };
|
||||
assert.deepEqual(await validateOrg(doc), { ok: true, errors: [] });
|
||||
doc.projects.work.git = { mode: 'remote', remote: 'ext::sh -c id' };
|
||||
assert.equal((await validateOrg(doc)).ok, false);
|
||||
});
|
||||
@@ -16,7 +16,8 @@ baseline CLI.
|
||||
| Create organization | `mosaic org create <id> --from <file>` | S6 integration hook |
|
||||
| Save organization or theme | `mosaic org update <id> --from <file> --if-revision <revision>` | S6 integration hook |
|
||||
| Initialize organization checkout | `mosaic org queue init <id> --local-only --accept-local-loss-risk` or `--remote <url>` | S6 integration hook |
|
||||
| Initialize project Git | `mosaic org project repo init <id> <project> --local-only --accept-local-loss-risk` or `--remote <url>` | S6 integration hook |
|
||||
| Initialize project Git | `mosaic org project repo init <id> <project> --local-only --accept-local-loss-risk` or `--remote <url>` | S6 integration hook; remote mode sets and checks `origin` (#1873 P1-6) |
|
||||
| Change a project's repository | `mosaic org project repo set <id> <project> (--local-only --accept-local-loss-risk \| --remote <url>) --if-revision <revision>` | Enabled (#1873 P1-7): the owner's Repository section on an organization project's Settings tab, `/api/orgs/<id>/repo/project/<project>`; needs send mode |
|
||||
| Recover a stopped bus with stale host state | `mosaic bus recover <id>` | CLI only |
|
||||
| Inspect or clear a dead lifecycle lock | `mosaic org lock show <id>` / `mosaic org lock clear <id>` | CLI only |
|
||||
| Start, stop or restart a bus | `mosaic bus start <id>` / `mosaic bus stop <id>` / `mosaic bus restart <id>` | S6 integration hook |
|
||||
|
||||
@@ -15,6 +15,8 @@
|
||||
// GET /api/orgs/ID/setup read-back of every setup step (resume)
|
||||
// POST /api/orgs/ID/setup/queue C2 queueInit mosaic org queue init
|
||||
// POST /api/orgs/ID/setup/project/P C2 projectRepoInit mosaic org project repo init
|
||||
// GET /api/orgs/ID/repo/project/P C2 projectRepoShow mosaic org project repo show (#1873 P1-7)
|
||||
// POST /api/orgs/ID/repo/project/P C2 projectRepoSet mosaic org project repo set --if-revision
|
||||
// POST /api/orgs/ID/setup/bus C3 busStart mosaic bus start --detach
|
||||
// POST /api/orgs/ID/restore C2 restoreOrg, then C3 busStart (E1: the answer's `bus`)
|
||||
// POST /api/orgs/ID/restart/bus C3 busRestart mosaic bus restart (F3; busStart when stopped;
|
||||
@@ -32,12 +34,13 @@ import { join } from 'node:path';
|
||||
import { actor } from './action-trail.mjs';
|
||||
import { DEV_OWNER } from '../../cli/src/dev-local-owner.mjs';
|
||||
import { revivePending } from './bus-revive.mjs';
|
||||
import { parseRepoRemote } from '../../organization/src/vocabulary.mjs';
|
||||
|
||||
const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
|
||||
const KEY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
|
||||
const ENV_NAME = /^[A-Z][A-Z0-9_]{0,63}$/;
|
||||
const MAX_BODY = 64 * 1024;
|
||||
const ROUTE = /^\/api\/orgs\/([^/]+)\/(admin|setup|delete|archive|restore|restart|stop)(?:\/(queue|bus|project\/([^/]+)|records\/([^/]+)))?$/;
|
||||
const ROUTE = /^\/api\/orgs\/([^/]+)\/(admin|setup|repo|delete|archive|restore|restart|stop)(?:\/(queue|bus|project\/([^/]+)|records\/([^/]+)))?$/;
|
||||
// The org-template placeholder (packages/organization/src/org-service.mjs templateRender).
|
||||
export const placeholderRoot = (id, project) => `/__mosaic_org__/${id}/projects/${project}`;
|
||||
// Project fields the server owns. The browser never sees or sends them. `agents` (#1873 A1) is
|
||||
@@ -46,11 +49,12 @@ const SERVER_PROJECT_KEYS = ['root', 'repo', 'git', 'agents'];
|
||||
|
||||
// The CLI verb each step equals (r4 section 2).
|
||||
export function verbFor(step, id, opts = {}) {
|
||||
const tail = opts.mode === 'remote' ? `--remote ${opts.remote ?? '<https-url>'}` : '--local-only --accept-local-loss-risk';
|
||||
const tail = opts.mode === 'remote' ? `--remote ${opts.remote ?? '<repository-url>'}` : '--local-only --accept-local-loss-risk';
|
||||
if (step === 'create') return `mosaic org create ${id} --from <file>`;
|
||||
if (step === 'update') return `mosaic org update ${id} --from <file> --if-revision ${opts.revision ?? '<revision>'}`;
|
||||
if (step === 'queue') return `mosaic org queue init ${id} ${tail}`;
|
||||
if (step === 'project') return `mosaic org project repo init ${id} ${opts.project} ${tail}`;
|
||||
if (step === 'repo') return `mosaic org project repo set ${id} ${opts.project} ${tail} --if-revision ${opts.revision ?? '<revision>'}`;
|
||||
if (step === 'archive' || step === 'restore') return `mosaic org ${step} ${id} --if-revision ${opts.revision}`;
|
||||
if (step === 'delete') return `mosaic org delete ${id} --confirm ${id} --if-revision ${opts.revision}`;
|
||||
if (step === 'records') return `mosaic project init ${id} ${opts.project}`;
|
||||
@@ -385,15 +389,17 @@ function unreadable(res, error, step, id, log) {
|
||||
return json(res, 409, { error: 'readback-failed', step, message: `the ${step === 'queue' ? 'checkout' : 'repository'} could not be read back${error?.code ? ` (${error.code})` : ''}, so it was not retried. Inspect it with the show verb.`, readBack: `/api/orgs/${id}/setup` });
|
||||
}
|
||||
|
||||
const gitOptions = (body, res, step) => {
|
||||
strictKeys(body, ['mode', 'remote', 'acceptLocalLossRisk']);
|
||||
const gitOptions = (body, res, step, extra = []) => {
|
||||
strictKeys(body, ['mode', 'remote', 'acceptLocalLossRisk', ...extra]);
|
||||
if (body.mode === 'local-only') {
|
||||
if (body.acceptLocalLossRisk !== true) { json(res, 422, { error: 'risk-not-accepted', step, errors: [{ path: '$.acceptLocalLossRisk', field: 'acceptLocalLossRisk', message: 'tick the box to accept that a local-only checkout has no copy anywhere else' }] }); return null; }
|
||||
if (body.remote !== undefined) { json(res, 422, { error: 'invalid', step, errors: [{ path: '$.remote', field: 'remote', message: 'local only takes no remote' }] }); return null; }
|
||||
return { mode: 'local-only', acceptLocalLossRisk: true };
|
||||
}
|
||||
if (body.mode === 'remote') {
|
||||
if (typeof body.remote !== 'string' || body.remote.length > 2048 || !/^https:\/\/[^\s/]+\/\S+$/.test(body.remote) || isShellText(body.remote)) { json(res, 422, { error: 'invalid', step, errors: [{ path: '$.remote', field: 'remote', message: 'must be an https repository URL, such as https://git.example/owner/repo' }] }); return null; }
|
||||
// #1873 P1-6: the service's own URL rules (https or ssh; no option, helper, path or credential).
|
||||
const parsed = parseRepoRemote(body.remote);
|
||||
if (!parsed.ok) { json(res, 422, { error: 'invalid', step, errors: [{ path: '$.remote', field: 'remote', message: parsed.message }] }); return null; }
|
||||
if (body.acceptLocalLossRisk !== undefined) { json(res, 422, { error: 'invalid', step, errors: [{ path: '$.acceptLocalLossRisk', field: 'acceptLocalLossRisk', message: 'applies to local only' }] }); return null; }
|
||||
return { mode: 'remote', remote: body.remote };
|
||||
}
|
||||
@@ -526,6 +532,7 @@ async function route(req, res, { path, search, org, admin, principal, write, log
|
||||
if (kind === 'setup' && !sub && !write) {
|
||||
try { return json(res, 200, await readSetup(admin, ctx, id)); } catch (e) { return refusal(res, e, { step: 'setup', id }); }
|
||||
}
|
||||
if (kind === 'repo' && sub?.startsWith('project/')) return repoSet(req, res, { project, write, id, ctx, service, log });
|
||||
if (kind === 'restart') return restartBus(req, res, { sub, write, id, ctx, service, admin, log, trail, by });
|
||||
if (kind === 'stop') return stopBus(req, res, { sub, write, id, ctx, service, admin, log, trail, by });
|
||||
if (kind !== 'setup' || !sub || !write) return json(res, 404, { error: 'not found' });
|
||||
@@ -614,6 +621,34 @@ async function restoreBus({ id, ctx, admin, log, trail, by }) {
|
||||
return { outcome: 'done', healthy, receipt: forReceipt(ctx, receipt), verb };
|
||||
}
|
||||
|
||||
// #1873 P1-7: the project Settings tab reads and changes the project's repository. GET answers the
|
||||
// binding as it is now; POST is `mosaic org project repo set`: the same URL rules and check as setup,
|
||||
// origin follows, nothing is pushed, a receipt records it. A project not set up yet answers missing.
|
||||
async function repoSet(req, res, { project, write, id, ctx, service, log }) {
|
||||
let name;
|
||||
try { name = decodeURIComponent(project); } catch { return json(res, 404, { error: 'not found' }); }
|
||||
if (!ID.test(name)) return json(res, 404, { error: 'not found' });
|
||||
let body = null, opts = null;
|
||||
if (write) { body = await readBody(req); opts = gitOptions(body, res, 'repo', ['ifRevision']); if (!opts) return; }
|
||||
if (write && (!Number.isSafeInteger(body.ifRevision) || body.ifRevision < 1)) return json(res, 422, { error: 'invalid', step: 'repo', errors: [{ path: '$.ifRevision', field: 'ifRevision', message: 'reload the project; the revision you opened is missing' }] });
|
||||
let shown;
|
||||
try { shown = await service.showOrg(ctx, id); } catch (e) { return refusal(res, e, { step: 'repo', id }); }
|
||||
if (!Object.hasOwn(shown.doc?.projects ?? {}, name) || shown.doc.projects[name]?.kind === 'library') return json(res, 404, { error: 'project-unknown', step: 'repo', message: `${id} declares no project ${name}` });
|
||||
let existing;
|
||||
try { existing = await receiptOf(() => service.projectRepoShow(ctx, id, name)); } catch (e) { return unreadable(res, e, 'project', id, log); }
|
||||
// No new refusal code: a write to a project not set up yet is the existing 'invalid'.
|
||||
if (!existing) return json(res, write ? 422 : 200, { state: 'missing', step: 'repo', project: name, revision: shown.revision, ...(write ? { error: 'invalid' } : {}), message: 'this project has no repository yet; set it up first', verb: verbFor('project', id, { project: name }) });
|
||||
if (!write) {
|
||||
const current = existing.current ?? { mode: existing.mode, ...(existing.remote ? { remote: existing.remote } : {}), revision: shown.revision };
|
||||
return json(res, 200, { state: 'done', step: 'repo', project: name, current: forReceipt(ctx, current), receipt: forReceipt(ctx, existing), verb: verbFor('repo', id, { ...current, project: name, revision: current.revision }) });
|
||||
}
|
||||
if (typeof service.projectRepoSet !== 'function') return json(res, 503, { error: 'not-configured', step: 'repo', message: 'changing a project repository is not available on this Console yet' });
|
||||
try {
|
||||
const receipt = await service.projectRepoSet(ctx, id, name, { ...opts, ifRevision: body.ifRevision });
|
||||
return json(res, 200, { outcome: 'done', step: 'repo', project: name, receipt: forReceipt(ctx, receipt), check: receipt?.check ?? null, verb: verbFor('repo', id, { ...opts, project: name, revision: body.ifRevision }) });
|
||||
} catch (e) { return refusal(res, e, { step: 'repo', id, unknownOk: true }); }
|
||||
}
|
||||
|
||||
// F3 (REQ-WEB-3): one control restarts an organization's bus and answers with a done receipt. A
|
||||
// running host restarts on the options it was started with (C3 busRestart keeps --dev-local-owner);
|
||||
// a stopped one starts as setup starts it. The trail line is written before anything changes, and
|
||||
|
||||
@@ -683,7 +683,10 @@
|
||||
refreshRequestData(c, false);
|
||||
const remote = c.container.querySelector('[data-chat-remote]');
|
||||
const project = c.projects.find(p => p.id === c.id);
|
||||
if (remote && roomOwner() && typeof window.MosaicProjectRemote?.mount === 'function') { remote.replaceChildren(); window.MosaicProjectRemote.mount({ container: remote, projectId: c.id, repositoryKey: project?.repo ?? null, projectArchived: !!c.projectArchived, preserve: true }); }
|
||||
// #1873 P1-7: an organization project's repository is editable through the organization's own route,
|
||||
// which names the project as the organization file does: the chat project's repo key.
|
||||
if (remote && roomOwner() && window.MosaicOrg && typeof window.MosaicProjectRepo?.mount === 'function') window.MosaicProjectRepo.mount({ container: remote, project: project?.repo ?? null, archived: !!c.projectArchived });
|
||||
else if (remote && roomOwner() && typeof window.MosaicProjectRemote?.mount === 'function') { remote.replaceChildren(); window.MosaicProjectRemote.mount({ container: remote, projectId: c.id, repositoryKey: project?.repo ?? null, projectArchived: !!c.projectArchived, preserve: true }); }
|
||||
// Phase P2 (#1873): the project's System types selection, the owner's, mounted like the remote.
|
||||
const types = c.container.querySelector('[data-chat-system-types]');
|
||||
if (types && roomOwner() && typeof window.MosaicSystemTypes?.mount === 'function') window.MosaicSystemTypes.mount({ container: types, projectId: c.id, archived: !!c.projectArchived });
|
||||
|
||||
@@ -4,6 +4,9 @@
|
||||
(() => {
|
||||
const $ = id => document.getElementById(id);
|
||||
const txt = v => String(v ?? '').replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' })[c]);
|
||||
// #1873 P1-6: the remote check a repository receipt records, in one plain line.
|
||||
const CHECKED = { reachable: 'reachable', 'needs-credential': 'needs a credential', unreachable: 'unreachable' };
|
||||
const checkLine = r => `Remote check: ${CHECKED[r.check.result] ?? 'unknown'}, ${r.check.message}. Origin: ${r.origin ?? 'none'}.`;
|
||||
const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
|
||||
const markup = `<div id="org-admin" class="org-admin">
|
||||
<section class="panel" aria-labelledby="org-start-title" id="org-start">
|
||||
@@ -34,7 +37,7 @@
|
||||
<section id="org-quick" class="panel" hidden aria-labelledby="org-quick-title">
|
||||
<h3 id="org-quick-title">Quick Setup</h3>
|
||||
<div class="org-field"><label for="org-project">First project name</label><input id="org-project" value="work" autocomplete="off"><span class="org-help">Lowercase letters, digits, dot, dash or underscore.</span></div>
|
||||
<div class="org-field"><label for="org-project-remote">Project remote URL (optional)</label><input id="org-project-remote" type="url" placeholder="https://git.example/team/project"><span class="org-help">Leave blank for local only. The organization checkout is local only.</span></div>
|
||||
<div class="org-field"><label for="org-project-remote">Project remote URL (optional)</label><input id="org-project-remote" type="text" inputmode="url" autocomplete="off" spellcheck="false" placeholder="https://git.example/team/project or git@git.example:team/project.git"><span class="org-help">https or ssh. The project checkout's origin is set to it and checked without a credential; nothing is pushed. Leave blank for local only. The organization checkout is local only.</span></div>
|
||||
<label class="org-quick-risk"><input id="org-risk-accept" type="checkbox"> I understand local-only repositories have no copy elsewhere and can be lost.</label>
|
||||
<div class="settings-actions"><button type="button" id="org-quick-run">Create and set up organization</button></div>
|
||||
<ol id="org-quick-steps" class="org-steps" aria-live="polite"></ol>
|
||||
@@ -302,7 +305,8 @@
|
||||
const project = $('org-project').value.trim(), remote = $('org-project-remote').value.trim();
|
||||
if (!ID.test(project)) { $('org-project').setAttribute('aria-invalid', 'true'); banner('Enter a valid project name.'); $('org-project').focus(); return; }
|
||||
$('org-project').removeAttribute('aria-invalid');
|
||||
if (remote && !/^https:\/\/[^\s/]+\/\S+$/.test(remote)) { banner('Enter an https repository URL or leave it blank.'); $('org-project-remote').focus(); return; }
|
||||
// The server applies the full URL rules (parseRepoRemote); this only catches an obvious slip.
|
||||
if (remote && (/\s/.test(remote) || !/^(https:\/\/|ssh:\/\/|[A-Za-z0-9_][A-Za-z0-9_.-]*@[^/:]+:)/.test(remote))) { banner('Enter an https or ssh repository URL, or leave it blank.'); $('org-project-remote').focus(); return; }
|
||||
if (!$('org-risk-accept').checked) { banner('Accept the risk of local-only repositories to continue.'); $('org-risk-accept').focus(); return; }
|
||||
const id = st.id, enc = encodeURIComponent, local = { mode: 'local-only', acceptLocalLossRisk: true };
|
||||
const steps = [
|
||||
@@ -340,6 +344,7 @@
|
||||
if (step === 'chat-project') quickDone = { org: id, chatProject: result.body.id, repo: project };
|
||||
card.querySelector('.org-pill').textContent = 'Done'; card.classList.add('org-step-done');
|
||||
if (result.body.verb) card.querySelector('code').textContent = result.body.verb;
|
||||
if (step === 'project' && result.body.receipt?.check) card.querySelector('.org-verb').insertAdjacentHTML('afterend', `<p class="org-help" data-remote-check>${txt(checkLine(result.body.receipt))}</p>`);
|
||||
}
|
||||
editorDirty = false; $('org-new-id').value = ''; $('org-quick-open-org').hidden = false; $('org-quick-interview').hidden = !window.MosaicOnboarding; status('Organization setup complete.');
|
||||
// E1 (P1-5): the sidebar and header list the new organization without a reload.
|
||||
@@ -451,13 +456,14 @@
|
||||
<div class="org-step-head"><h4 id="org-step-${i}-title"><span class="org-step-n">${i + 1}</span> ${txt(title)}</h4><span class="org-pill ${cls}">${txt(stateLabel)}</span></div>
|
||||
<p class="org-verb">Same as <code>${txt(s.verb || '')}</code></p>
|
||||
${s.message ? `<p class="org-help">${txt(s.message)}</p>` : ''}
|
||||
${key.startsWith('project:') && s.receipt?.check ? `<p class="org-help" data-remote-check>${txt(checkLine(s.receipt))}</p>` : ''}
|
||||
${s.lastError ? `<p class="org-field-err" role="alert">${txt(s.lastError)}</p>` : ''}
|
||||
${s.receipt ? `<details${s.state === 'done' ? '' : ' open'}><summary>${key === 'bus' ? 'Bus status' : 'Receipt'}</summary><pre class="org-pre">${txt(JSON.stringify(s.receipt, null, 2))}</pre></details>` : ''}
|
||||
${s.state === 'unknown' ? `<div class="settings-actions"><button type="button" class="org-secondary" data-readback="${txt(key)}">Read back</button><span class="org-help">Retry stays off until the step is read back.</span></div>` : ''}
|
||||
${s.state !== 'done' && s.state !== 'unknown' && git ? `<fieldset class="org-git" ${ready && canWrite ? '' : 'disabled'}><legend>Where the history lives</legend>
|
||||
<label><input type="radio" name="${name}" value="local-only"${remote ? '' : ' checked'}> Local only, on this machine</label>
|
||||
<label><input type="radio" name="${name}" value="remote"${remote ? ' checked' : ''}> Remote</label>
|
||||
<div class="org-remote"${remote ? '' : ' hidden'}><label for="${name}-remote">Remote repository URL</label><input id="${name}-remote" type="url" inputmode="url" data-remote autocomplete="off" spellcheck="false" placeholder="https://git.example/owner/repo" value="${txt(c.remote || '')}" aria-describedby="${name}-remote-help"${remote && s.lastError ? ' aria-invalid="true"' : ''}><span id="${name}-remote-help" class="org-help">An https URL. It is recorded in the receipt and the organization file; nothing is pushed.</span></div>
|
||||
<div class="org-remote"${remote ? '' : ' hidden'}><label for="${name}-remote">Remote repository URL</label><input id="${name}-remote" type="text" inputmode="url" data-remote autocomplete="off" spellcheck="false" placeholder="https://git.example/owner/repo or git@git.example:owner/repo.git" value="${txt(c.remote || '')}" aria-describedby="${name}-remote-help"${remote && s.lastError ? ' aria-invalid="true"' : ''}><span id="${name}-remote-help" class="org-help">An https or ssh URL. The checkout's origin is set to it and checked without a credential; the result is in the receipt. Nothing is pushed.</span></div>
|
||||
<label class="org-risk"${remote ? ' hidden' : ''}><input type="checkbox" data-risk${c.risk ? ' checked' : ''}${!remote && s.lastError && !c.risk ? ' aria-invalid="true"' : ''}> I accept that a local-only history has no copy anywhere else and is lost with this disk.</label>
|
||||
<div class="settings-actions"><button type="button" data-run="${txt(key)}">${busy ? 'Working… <span class="settings-spinner" aria-hidden="true"></span>' : key === 'queue' ? 'Set up checkout' : 'Set up repository'}</button></div>
|
||||
</fieldset>` : ''}
|
||||
@@ -514,7 +520,7 @@
|
||||
// The "Same as" line follows the choice in the card.
|
||||
function showVerb(card) {
|
||||
const key = card.dataset.step; if (key === 'bus') return;
|
||||
const o = stepOptions(card), tail = o.mode === 'remote' ? `--remote ${o.remote || '<https-url>'}` : '--local-only --accept-local-loss-risk';
|
||||
const o = stepOptions(card), tail = o.mode === 'remote' ? `--remote ${o.remote || '<repository-url>'}` : '--local-only --accept-local-loss-risk';
|
||||
const code = card.querySelector('.org-verb code'); if (!code) return;
|
||||
code.textContent = key === 'queue' ? `mosaic org queue init ${st.id} ${tail}` : `mosaic org project repo init ${st.id} ${key.slice(8)} ${tail}`;
|
||||
}
|
||||
|
||||
@@ -3,3 +3,16 @@
|
||||
.project-remote input { box-sizing: border-box; width: 100%; min-height: 44px; }
|
||||
.project-remote button { min-height: 44px; justify-self: start; }
|
||||
.project-remote [role="status"] { overflow-wrap: anywhere; }
|
||||
/* #1873 P1-7: an organization project's repository (project-remote.js MosaicProjectRepo). */
|
||||
.project-repo fieldset { border: 0; margin: 0; padding: 0; display: grid; gap: .5rem; }
|
||||
.project-repo legend { font-weight: 600; margin-bottom: .25rem; }
|
||||
.project-repo-option { display: flex; align-items: flex-start; gap: .5rem; min-height: 44px; }
|
||||
.project-repo-option input { margin-top: .2rem; width: 20px; height: 20px; flex: none; }
|
||||
.project-repo-option span { display: flex; flex-direction: column; min-width: 0; }
|
||||
.project-repo-option small { color: var(--muted, inherit); }
|
||||
.project-repo-facts { display: grid; grid-template-columns: max-content minmax(0, 1fr); gap: .25rem 1rem; margin: 0 0 1rem; }
|
||||
.project-repo-facts dt { font-weight: 600; }
|
||||
.project-repo-facts dd { margin: 0; overflow-wrap: anywhere; }
|
||||
.project-repo [role="status"]:empty { display: none; }
|
||||
.project-repo [role="status"]:focus { outline: none; }
|
||||
@media (max-width: 480px) { .project-repo-facts { grid-template-columns: minmax(0, 1fr); } .project-repo-facts dd { margin-bottom: .5rem; } }
|
||||
@@ -103,3 +103,138 @@
|
||||
}
|
||||
window.MosaicProjectRemote = { mount };
|
||||
})();
|
||||
|
||||
/* #1873 P1-7: an organization project's repository on its Settings tab, the owner's. It reads and
|
||||
changes the binding through /api/orgs/ORG/repo/project/P, which is `mosaic org project repo set`:
|
||||
https or ssh, the same check as setup, origin follows, nothing is pushed, a receipt records it.
|
||||
The server and the organization service recheck every write; a control shown here grants nothing. */
|
||||
(() => {
|
||||
'use strict';
|
||||
const esc = value => String(value ?? '').replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
|
||||
const enc = encodeURIComponent;
|
||||
const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
|
||||
const LINES = {
|
||||
'sign-in-required': 'Sign in again to see or change the repository.',
|
||||
'owner-only': "The repository setting is the organization owner's.",
|
||||
'read-only': 'This Console only reads. Changing the repository needs signed-in send mode.',
|
||||
'revision-conflict': 'The organization changed after this page read it. The setting was read again; your entry is kept. Check it and save again.',
|
||||
'risk-not-accepted': 'Tick the box to accept that a local-only repository has no copy anywhere else.',
|
||||
'org-risk': 'Tick the box to accept that a local-only repository has no copy anywhere else.',
|
||||
'org-inactive': 'This organization is not active, so its repository cannot be changed.',
|
||||
'org-unavailable': 'This organization is not available.',
|
||||
'project-unknown': 'This project was not found in the organization.',
|
||||
'not-configured': 'Changing the repository is not available on this Console.',
|
||||
'readback-failed': 'The repository could not be read back, so nothing was changed. Inspect it with the show command.',
|
||||
'outcome-unknown': 'The outcome is unknown. The setting was read again; check it before you retry.',
|
||||
};
|
||||
const CHECK = { reachable: 'Reachable', 'needs-credential': 'Needs a credential', unreachable: 'Unreachable' };
|
||||
const checkLine = check => check && CHECK[check.result] ? `${CHECK[check.result]}: ${check.message}.` : null;
|
||||
|
||||
async function call(path, body) {
|
||||
const init = body === undefined ? { cache: 'no-store', redirect: 'manual' }
|
||||
: { method: 'POST', cache: 'no-store', redirect: 'manual', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) };
|
||||
let response;
|
||||
try { response = await fetch(path, init); } catch { return { ok: false, code: 'outcome-unknown' }; }
|
||||
if (response.type === 'opaqueredirect') return { ok: false, code: 'sign-in-required' };
|
||||
const value = await response.json().catch(() => null);
|
||||
if (!response.ok) return { ok: false, code: typeof value?.error === 'string' ? value.error : 'outcome-unknown', message: value?.errors?.[0]?.message || value?.message || null };
|
||||
return value && typeof value === 'object' ? { ok: true, value } : { ok: false, code: 'outcome-unknown' };
|
||||
}
|
||||
// A refusal the server explained (the URL rules, a missing setup) keeps its own words.
|
||||
const refusalLine = r => (['invalid', 'org-invalid'].includes(r.code) && r.message) ? r.message : LINES[r.code] || LINES['outcome-unknown'];
|
||||
|
||||
let active = null;
|
||||
document.addEventListener('mosaic-signed-out', () => { active?.dispose(); active = null; });
|
||||
window.addEventListener('hashchange', () => { if (active) active.stale = true; });
|
||||
function mount({ container, project, archived = false }) {
|
||||
if (!(container instanceof Element)) return;
|
||||
const org = window.MosaicOrg?.id ?? null;
|
||||
if (active && active.org === org && active.project === project) {
|
||||
container.replaceChildren(active.section);
|
||||
if (active.archived !== archived) { active.archived = archived; active.paint(); }
|
||||
if (active.stale) { active.stale = false; active.refresh(); }
|
||||
return;
|
||||
}
|
||||
active?.dispose();
|
||||
const section = document.createElement('section');
|
||||
section.className = 'project-remote project-repo';
|
||||
section.setAttribute('data-project-repo', '');
|
||||
container.replaceChildren(section);
|
||||
let value = null, code = null, outcome = '', saving = false, disposed = false, generation = 0;
|
||||
let draft = null; // { mode, remote, risk } once the owner touches the form
|
||||
const state = { org, project, section, archived, stale: false, paint, refresh: () => refresh(), dispose: () => { disposed = true; generation++; section.replaceChildren(); } };
|
||||
active = state;
|
||||
const path = () => `/api/orgs/${enc(org)}/repo/project/${enc(project)}`;
|
||||
function form() {
|
||||
const cur = value.current;
|
||||
const d = draft ?? { mode: cur.mode, remote: cur.remote ?? '', risk: false };
|
||||
const off = saving ? ' disabled' : '';
|
||||
const remote = d.mode === 'remote';
|
||||
return `<form data-project-repo-form><fieldset><legend>Where the repository lives</legend>`
|
||||
+ `<label class="project-repo-option"><input type="radio" name="repo-mode" value="remote"${remote ? ' checked' : ''}${off}><span><strong>Remote</strong><small>The checkout's origin points at this URL and is checked. Nothing is pushed.</small></span></label>`
|
||||
+ `<label class="project-repo-option"><input type="radio" name="repo-mode" value="local-only"${remote ? '' : ' checked'}${off}><span><strong>Local only</strong><small>No origin. The repository has no copy anywhere else.</small></span></label></fieldset>`
|
||||
+ (remote
|
||||
? `<label for="project-repo-url">Repository URL (https or ssh)</label><input id="project-repo-url" name="repo-url" type="text" inputmode="url" autocomplete="off" spellcheck="false" maxlength="512" placeholder="https://git.example/owner/repo or [email protected]:owner/repo.git" value="${esc(d.remote)}"${off}>`
|
||||
: `<label class="project-repo-option"><input type="checkbox" name="repo-risk"${d.risk ? ' checked' : ''}${off}><span>I accept that a local-only repository has no copy anywhere else.</span></label>`)
|
||||
+ `<button type="submit" class="btn"${off}>${saving ? 'Saving…' : 'Save repository'}</button></form>`;
|
||||
}
|
||||
function paint() {
|
||||
if (disposed) return;
|
||||
const head = '<h2 tabindex="-1">Repository</h2>';
|
||||
const status = `<p role="status" tabindex="-1" data-project-repo-status>${esc(outcome)}</p>`;
|
||||
if (!org || !ID.test(project ?? '')) { section.innerHTML = `${head}<p>${org && !project ? 'This project is not linked to a repository in the organization.' : 'Repository setting unavailable.'}</p>`; return; }
|
||||
if (!value) { section.innerHTML = `${head}<p>${esc(code ? `Repository setting unavailable. ${LINES[code] || LINES['outcome-unknown']}` : 'Reading the repository setting…')}</p>${status}`; return; }
|
||||
if (value.state === 'missing') { section.innerHTML = `${head}<p>This project has no repository yet. Set it up from the organization's Quick Setup, or with <code>${esc(value.verb)}</code>.</p>${status}`; return; }
|
||||
const cur = value.current;
|
||||
const facts = `<dl class="project-repo-facts"><dt>Mode</dt><dd data-repo-mode>${cur.mode === 'remote' ? 'Remote' : 'Local only'}</dd>`
|
||||
+ `<dt>Repository URL</dt><dd data-repo-url>${cur.mode === 'remote' ? esc(cur.remote) : 'None (local only)'}</dd>`
|
||||
+ `<dt>Git origin</dt><dd data-repo-origin>${cur.origin ? esc(cur.origin) : 'None'}</dd>`
|
||||
+ `<dt>Last check</dt><dd data-repo-check>${cur.mode === 'remote' ? esc(checkLine(cur.check) ?? 'Not recorded') : 'None (local only has no remote)'}</dd></dl>`;
|
||||
const verb = `<p class="muted">Same as <code data-repo-verb>${esc(value.verb)}</code></p>`;
|
||||
const why = state.archived ? '<p class="muted">This project is archived; its repository is shown read only.</p>' : '';
|
||||
section.innerHTML = `${head}${facts}${state.archived ? '' : form()}${why}${status}${verb}`;
|
||||
}
|
||||
async function refresh() {
|
||||
if (!org || !ID.test(project ?? '')) return;
|
||||
const turn = ++generation;
|
||||
const result = await call(path());
|
||||
if (disposed || turn !== generation) return;
|
||||
if (result.ok && (result.value.state === 'missing' || (result.value.state === 'done' && result.value.current))) { value = result.value; code = null; } else { value = null; code = result.ok ? 'outcome-unknown' : result.code; }
|
||||
paint();
|
||||
}
|
||||
const focusUrl = () => section.querySelector('#project-repo-url')?.focus();
|
||||
section.addEventListener('change', e => {
|
||||
if (!value?.current) return;
|
||||
const d = draft ?? { mode: value.current.mode, remote: value.current.remote ?? '', risk: false };
|
||||
if (e.target.name === 'repo-mode') { draft = { ...d, mode: e.target.value }; paint(); section.querySelector(`input[name="repo-mode"][value="${e.target.value}"]`)?.focus(); }
|
||||
else if (e.target.name === 'repo-risk') draft = { ...d, risk: e.target.checked };
|
||||
});
|
||||
section.addEventListener('input', e => {
|
||||
if (e.target.name !== 'repo-url' || !value?.current) return;
|
||||
draft = { ...(draft ?? { mode: value.current.mode, remote: '', risk: false }), remote: e.target.value };
|
||||
});
|
||||
section.addEventListener('submit', async e => {
|
||||
e.preventDefault();
|
||||
if (saving || !value?.current || state.archived) return;
|
||||
const d = draft ?? { mode: value.current.mode, remote: value.current.remote ?? '', risk: false };
|
||||
const remote = d.mode === 'remote' ? d.remote.trim() : '';
|
||||
if (d.mode === 'remote' && !remote) { outcome = 'Enter a repository URL, or choose Local only.'; paint(); focusUrl(); return; }
|
||||
if (d.mode === 'local-only' && !d.risk) { outcome = LINES['risk-not-accepted']; paint(); section.querySelector('input[name="repo-risk"]')?.focus(); return; }
|
||||
const body = d.mode === 'remote' ? { mode: 'remote', remote, ifRevision: value.current.revision } : { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: value.current.revision };
|
||||
saving = true; outcome = ''; paint();
|
||||
const result = await call(path(), body);
|
||||
if (disposed) return;
|
||||
saving = false;
|
||||
if (result.ok && result.value.receipt) {
|
||||
const r = result.value.receipt, check = checkLine(result.value.check);
|
||||
outcome = `Saved${r.at ? ` at ${r.at}` : ''}. ${r.mode === 'remote' ? `Origin is ${r.origin ?? 'not set'}.` : 'Origin removed; local only.'}${check ? ` Check: ${check}` : ''} Nothing was pushed.`;
|
||||
draft = null;
|
||||
} else outcome = refusalLine(result);
|
||||
await refresh();
|
||||
section.querySelector('[data-project-repo-status]')?.focus({ preventScroll: true });
|
||||
});
|
||||
paint();
|
||||
if (org && ID.test(project ?? '')) refresh();
|
||||
}
|
||||
window.MosaicProjectRepo = Object.freeze({ mount });
|
||||
})();
|
||||
@@ -829,7 +829,7 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
|
||||
for (const registerRoutes of routes) registerRoutes(registered);
|
||||
registered.add('GET', '/api/themes', (req, res) => themesHTTP(req, res, { log }), { publicRead: true });
|
||||
const adminRoute = (req, res, context) => orgAdminHTTP(req, res, { ...context, admin: orgAdmin ??= defaultOrgAdmin(), log, trail });
|
||||
for (const path of ['/api/org-template', '/api/org-presets', '/api/org-validate', '/api/org-admin', /^\/api\/orgs\/[^/]+\/(?:admin|setup|delete|archive|restore|restart|stop)(?:\/(?:queue|bus|project\/[^/]+|records\/[^/]+))?$/]) {
|
||||
for (const path of ['/api/org-template', '/api/org-presets', '/api/org-validate', '/api/org-admin', /^\/api\/orgs\/[^/]+\/(?:admin|setup|repo|delete|archive|restore|restart|stop)(?:\/(?:queue|bus|project\/[^/]+|records\/[^/]+))?$/]) {
|
||||
for (const method of ['GET', 'POST']) registered.add(method, path, adminRoute);
|
||||
}
|
||||
registered.add('POST', '/api/orgs', adminRoute);
|
||||
|
||||
@@ -31,6 +31,8 @@ function fakes() {
|
||||
queueInit: async (ctx, id, opts) => { calls.push(['queueInit', id, opts]); const o = get(id); if (o.queue) throw new OrgError('org-exists', 'repository was already initialized; inspect its receipt'); if (opts.mode === 'local-only' && opts.acceptLocalLossRisk !== true) throw new OrgError('org-risk', 'local-only needs the explicit risk'); o.queue = receipt('org.queue.init', id, { mode: opts.mode }); if (fail.queue) throw new Error('lost'); return o.queue; },
|
||||
projectRepoShow: async (ctx, id, project) => { const o = get(id); if (!o.doc.projects?.[project]) throw new OrgError('org-unknown', 'unknown project'); const r = o.repos[project]; if (!r) throw new OrgError('org-unavailable', 'setup receipt unavailable'); return r; },
|
||||
projectRepoInit: async (ctx, id, project, opts) => { calls.push(['projectRepoInit', id, project, opts]); const o = get(id); if (fail.project === 'before') throw new Error('crashed'); o.repos[project] = receipt('org.project.repo.init', id, { project, mode: opts.mode }); if (fail.project === 'after') throw new Error('timeout'); return o.repos[project]; },
|
||||
// #1873 P1-7: like C2 projectRepoSet, the revision guards the change and origin follows the mode.
|
||||
projectRepoSet: async (ctx, id, project, opts) => { calls.push(['projectRepoSet', id, project, opts]); const o = get(id); if (fail.repoSet) throw new Error('timeout'); if (o.revision !== opts.ifRevision) throw new OrgError('revision-conflict'); const r = o.repos[project]; o.revision++; const remote = opts.mode === 'remote' ? opts.remote : undefined; o.repos[project] = { ...r, current: { mode: opts.mode, ...(remote ? { remote } : {}), origin: remote ?? null, revision: o.revision, ...(remote ? { check: { result: 'needs-credential', message: 'the repository needs a credential; the credential binding will supply it' } } : {}) } }; return receipt('org.project.repo.set', id, { project, mode: opts.mode, ...(remote ? { remote } : {}), root: `/data/org-runtime/${id}/projects/${project}`, revision: o.revision, origin: remote ?? null, ...(remote ? { check: o.repos[project].current.check } : {}) }); },
|
||||
};
|
||||
const registry = { listOrgs: async () => [...orgs.keys()].map(id => ({ id, state: orgs.get(id).reserved ? 'reserved' : 'active' })) };
|
||||
let running = null;
|
||||
@@ -198,10 +200,11 @@ test('setup resumes from the read-back and never overwrites a receipt', async t
|
||||
assert.equal(s.body.projects[0].verb, 'mosaic org project repo init acme work --local-only --accept-local-loss-risk');
|
||||
assert.equal(s.body.bus.verb, 'mosaic bus start acme --dev-local-owner --detach');
|
||||
|
||||
// Local only needs the explicit risk; remote needs an https URL.
|
||||
// Local only needs the explicit risk; remote needs an https or ssh URL with no option, helper,
|
||||
// path or credential in it (#1873 P1-6).
|
||||
let r = await c.call('POST', '/api/orgs/acme/setup/queue', { mode: 'local-only' });
|
||||
assert.equal(r.status, 422); assert.equal(r.body.error, 'risk-not-accepted'); assert.equal(r.body.errors[0].path, '$.acceptLocalLossRisk');
|
||||
for (const remote of ['/srv/git', 'origin', 'ssh://git@host/acme/work', 'https://host/acme/$(id)', 'https://host/a b', 'file:///srv/git']) {
|
||||
for (const remote of ['/srv/git', 'origin', 'https://host/acme/$(id)', 'https://host/a b', 'file:///srv/git', 'ext::sh -c id', '-uhost:x/y', '--upload-pack=touch /tmp/x', 'https://user:token@host/acme/work', 'ssh://git:pw@host/acme/work', 'http://host/acme/work', 'git://host/acme/work', 'ssh://-oProxyCommand=id/acme/work', 'git@host:../etc']) {
|
||||
r = await c.call('POST', '/api/orgs/acme/setup/queue', { mode: 'remote', remote });
|
||||
assert.equal(r.status, 422, remote); assert.equal(r.body.errors[0].path, '$.remote');
|
||||
}
|
||||
@@ -239,6 +242,71 @@ test('setup resumes from the read-back and never overwrites a receipt', async t
|
||||
assert.deepEqual([s.body.queue.state, s.body.projects[0].state, s.body.bus.state], ['done', 'done', 'done']);
|
||||
});
|
||||
|
||||
test('project repo set (#1873 P1-7): read, change both ways, refuse plainly, nothing before setup', async t => {
|
||||
const c = await console_(t);
|
||||
await c.call('POST', '/api/orgs', { id: 'acme', doc: browserDoc('acme') });
|
||||
// Before setup: the read says so, and a write changes nothing.
|
||||
let r = await c.call('GET', '/api/orgs/acme/repo/project/work');
|
||||
assert.equal(r.status, 200); assert.equal(r.body.state, 'missing'); assert.equal(r.body.verb, 'mosaic org project repo init acme work --local-only --accept-local-loss-risk');
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: 1 });
|
||||
assert.equal(r.status, 422); assert.equal(r.body.error, 'invalid');
|
||||
assert.equal(c.calls.filter(x => x[0] === 'projectRepoSet').length, 0);
|
||||
|
||||
assert.equal((await c.call('POST', '/api/orgs/acme/setup/project/work', { mode: 'local-only', acceptLocalLossRisk: true })).status, 201);
|
||||
r = await c.call('GET', '/api/orgs/acme/repo/project/work');
|
||||
assert.equal(r.status, 200, r.raw); assert.equal(r.body.state, 'done'); assert.equal(r.body.current.mode, 'local-only');
|
||||
const rev = r.body.current.revision;
|
||||
assert.equal(r.body.verb, `mosaic org project repo set acme work --local-only --accept-local-loss-risk --if-revision ${rev}`);
|
||||
|
||||
// The same URL rules as setup, before the service is called.
|
||||
for (const remote of ['ext::sh -c id', '-uhost:x/y', 'file:///srv/git', '/srv/git', 'https://user:token@host/acme/work', 'http://host/acme/work']) {
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'remote', remote, ifRevision: rev });
|
||||
assert.equal(r.status, 422, remote); assert.equal(r.body.errors[0].path, '$.remote', remote);
|
||||
}
|
||||
for (const ifRevision of [undefined, 0, '1', 1.5]) {
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ...(ifRevision === undefined ? {} : { ifRevision }) });
|
||||
assert.equal(r.status, 422, String(ifRevision)); assert.equal(r.body.errors[0].path, '$.ifRevision');
|
||||
}
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', ifRevision: rev });
|
||||
assert.equal(r.status, 422); assert.equal(r.body.error, 'risk-not-accepted');
|
||||
assert.equal((await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev, root: '/x' })).status, 400);
|
||||
assert.equal(c.calls.filter(x => x[0] === 'projectRepoSet').length, 0, 'no refused body reached the service');
|
||||
|
||||
// Local only to ssh remote: the receipt, origin and the check come back.
|
||||
const ssh = '[email protected]:acme/work.git';
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'remote', remote: ssh, ifRevision: rev });
|
||||
assert.equal(r.status, 200, r.raw); assert.equal(r.body.outcome, 'done'); assert.equal(r.body.receipt.op, 'org.project.repo.set');
|
||||
assert.equal(r.body.receipt.origin, ssh); assert.equal(r.body.check.result, 'needs-credential');
|
||||
assert.equal(r.body.receipt.root, '<data root>/org-runtime/acme/projects/work');
|
||||
assert.equal(r.body.verb, `mosaic org project repo set acme work --remote ${ssh} --if-revision ${rev}`);
|
||||
assert.deepEqual(c.calls.at(-1), ['projectRepoSet', 'acme', 'work', { mode: 'remote', remote: ssh, ifRevision: rev }]);
|
||||
r = await c.call('GET', '/api/orgs/acme/repo/project/work');
|
||||
assert.equal(r.body.current.mode, 'remote'); assert.equal(r.body.current.origin, ssh); assert.equal(r.body.current.revision, rev + 1);
|
||||
// A stale revision is a plain conflict; then back to local only.
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev });
|
||||
assert.equal(r.status, 409); assert.equal(r.body.error, 'revision-conflict');
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev + 1 });
|
||||
assert.equal(r.status, 200, r.raw); assert.equal(r.body.receipt.origin, null); assert.equal(r.body.check, null);
|
||||
// An unknown project or a crash: plain answers.
|
||||
assert.equal((await c.call('GET', '/api/orgs/acme/repo/project/nope')).status, 404);
|
||||
assert.equal((await c.call('POST', '/api/orgs/acme/repo/project/nope', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev + 2 })).body.error, 'project-unknown');
|
||||
c.fail.repoSet = true;
|
||||
r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev + 2 });
|
||||
assert.equal(r.status, 502); assert.equal(r.body.error, 'outcome-unknown');
|
||||
// The write fence holds: another site, or no --send, changes nothing.
|
||||
c.fail.repoSet = false; const before = c.calls.length;
|
||||
assert.equal((await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: rev + 2 }, { 'sec-fetch-site': 'cross-site' })).status, 403);
|
||||
assert.equal(c.calls.length, before);
|
||||
});
|
||||
|
||||
test('project repo set without --send or the owner is refused before the service', async t => {
|
||||
for (const opts of [{ send: null }, { sso: null, send: null }]) {
|
||||
const c = await console_(t, opts);
|
||||
const r = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: 1 });
|
||||
assert.equal(r.status, 403, JSON.stringify(opts)); assert.equal(c.calls.length, 0);
|
||||
}
|
||||
});
|
||||
|
||||
test('a step whose receipt cannot be read back is never retried', async t => {
|
||||
const c = await console_(t);
|
||||
await c.call('POST', '/api/orgs', { id: 'acme', doc: browserDoc('acme') });
|
||||
@@ -399,6 +467,11 @@ test('the Settings page ships the organization assets', async t => {
|
||||
test('against the real C2 service: create, set up, resume and refuse an overwrite', async t => {
|
||||
const service = await import('../../organization/src/org-service.mjs');
|
||||
const registry = await import('../../organization/src/org-registry.mjs');
|
||||
// #1873 P1-6: the remote check goes through the test seam, so this test never leaves the host.
|
||||
const { repoRemoteTestSeam } = await import('../../organization/src/repo-remote.mjs');
|
||||
const checked = []; repoRemoteTestSeam.useCheck(async url => { checked.push(url); return { result: 'needs-credential', message: 'the repository needs a credential; the credential binding will supply it' }; });
|
||||
t.after(() => repoRemoteTestSeam.useCheck(null));
|
||||
const { execFileSync } = await import('node:child_process');
|
||||
const { mkdtempSync, mkdirSync, existsSync } = await import('node:fs');
|
||||
const { join } = await import('node:path'); const { tmpdir } = await import('node:os');
|
||||
const root = mkdtempSync(join(tmpdir(), 'oa')); const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
@@ -419,6 +492,10 @@ test('against the real C2 service: create, set up, resume and refuse an overwrit
|
||||
assert.equal(q.status, 201, q.raw); assert.equal(q.body.receipt.op, 'org.queue.init'); assert.ok(existsSync(join(dataRoot, 'org-runtime/acme/checkout/.git')));
|
||||
const p = await c.call('POST', '/api/orgs/acme/setup/project/work', { mode: 'remote', remote: 'https://git.example.invalid/acme/work' });
|
||||
assert.equal(p.status, 201, p.raw); assert.equal(p.body.receipt.remote, 'https://git.example.invalid/acme/work');
|
||||
assert.equal(p.body.receipt.origin, 'https://git.example.invalid/acme/work'); assert.equal(p.body.receipt.check.result, 'needs-credential');
|
||||
assert.deepEqual(checked, ['https://git.example.invalid/acme/work']);
|
||||
const remotes = () => execFileSync('git', ['-C', join(dataRoot, 'org-runtime/acme/projects/work'), 'remote', '-v'], { env: { PATH: process.env.PATH, HOME: '/nonexistent', GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null' }, encoding: 'utf8' }).trim();
|
||||
assert.equal(remotes(), 'origin\thttps://git.example.invalid/acme/work (fetch)\norigin\thttps://git.example.invalid/acme/work (push)');
|
||||
s = await c.call('GET', '/api/orgs/acme/setup');
|
||||
assert.deepEqual([s.body.queue.state, s.body.projects[0].state], ['done', 'done']);
|
||||
assert.equal(s.body.queue.receipt.root, '<data root>/org-runtime/acme/checkout');
|
||||
@@ -433,6 +510,16 @@ test('against the real C2 service: create, set up, resume and refuse an overwrit
|
||||
assert.equal(stale.status, 409); assert.equal(stale.body.error, 'revision-conflict');
|
||||
const saved = await c.call('POST', '/api/orgs/acme/admin', { doc: shown.body.doc, ifRevision: shown.body.revision });
|
||||
assert.equal(saved.status, 200, saved.raw); assert.equal(saved.body.receipt.op, 'org.update');
|
||||
// #1873 P1-7: the project's repository, changed from Settings: to local only and back to ssh.
|
||||
let repo = await c.call('GET', '/api/orgs/acme/repo/project/work');
|
||||
assert.equal(repo.status, 200, repo.raw); assert.equal(repo.body.current.mode, 'remote'); assert.equal(repo.body.current.origin, 'https://git.example.invalid/acme/work'); assert.equal(repo.body.current.check.result, 'needs-credential');
|
||||
let set = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'local-only', acceptLocalLossRisk: true, ifRevision: repo.body.current.revision });
|
||||
assert.equal(set.status, 200, set.raw); assert.equal(set.body.receipt.op, 'org.project.repo.set'); assert.equal(set.body.receipt.origin, null); assert.equal(remotes(), '');
|
||||
repo = await c.call('GET', '/api/orgs/acme/repo/project/work');
|
||||
set = await c.call('POST', '/api/orgs/acme/repo/project/work', { mode: 'remote', remote: 'ssh://[email protected]/acme/work.git', ifRevision: repo.body.current.revision });
|
||||
assert.equal(set.status, 200, set.raw); assert.equal(set.body.check.result, 'needs-credential');
|
||||
assert.equal(remotes(), 'origin\tssh://[email protected]/acme/work.git (fetch)\norigin\tssh://[email protected]/acme/work.git (push)');
|
||||
assert.doesNotMatch(JSON.stringify([set.body, repo.body]), new RegExp(root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), 'no server path reaches the browser');
|
||||
assert.doesNotMatch(JSON.stringify([tpl.body, s.body, shown.body]), new RegExp(root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), 'no server path reaches the browser');
|
||||
});
|
||||
|
||||
|
||||
@@ -0,0 +1,191 @@
|
||||
// #1873 P1-7 (ruling 11): an organization project's Repository on its Settings tab is editable. The
|
||||
// Console, its per-organization routes, the org-admin route and the real organization service are
|
||||
// real; the organization's bus transports are a small fake, and the remote check goes through the
|
||||
// test seam, so nothing leaves the host. The page sets a remote, is refused a bad URL and a stale
|
||||
// revision, switches to local only and back, and `git remote -v` in the checkout follows each step.
|
||||
// MOSAIC_UX_SHOTS=<dir> also writes light and dark shots at 1440x900 and 390x844.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { mkdtempSync, mkdirSync } from 'node:fs';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { startServer } from '../src/serve.mjs';
|
||||
import { createDevOwner } from '../src/dev-owner.mjs';
|
||||
import { createOrgAdmin } from '../src/org-admin.mjs';
|
||||
import * as service from '../../organization/src/org-service.mjs';
|
||||
import * as registry from '../../organization/src/org-registry.mjs';
|
||||
import { repoRemoteTestSeam } from '../../organization/src/repo-remote.mjs';
|
||||
import { browser } from './browser.mjs';
|
||||
import { close } from './fixture.mjs';
|
||||
|
||||
const P = '10000000-0000-4000-8000-0000000000c1';
|
||||
const NEEDS = { result: 'needs-credential', message: 'the repository needs a credential; the credential binding will supply it' };
|
||||
const waitFor = b => expression => b.evaluate(`(async()=>{for(let i=0;i<300;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error(${JSON.stringify(expression)}+' | '+(document.querySelector('main')?.innerText||'').slice(0,1500))})()`);
|
||||
const text = (b, selector) => b.evaluate(`(document.querySelector(${JSON.stringify(selector)})?.innerText ?? '').replace(/\\s+/g, ' ').trim()`);
|
||||
const click = (b, selector) => b.evaluate(`(document.querySelector(${JSON.stringify(selector)}).click(), true)`);
|
||||
const fill = (b, selector, value) => b.evaluate(`(e => { e.value = ${JSON.stringify(value)}; e.dispatchEvent(new Event('input', { bubbles: true })); return true; })(document.querySelector(${JSON.stringify(selector)}))`);
|
||||
// A same-origin call from the page, so the write fence sees a real browser request.
|
||||
const api = (b, path, body) => b.evaluate(`fetch(${JSON.stringify(path)}, ${body === undefined ? '{}' : `{ method: 'POST', headers: { 'content-type': 'application/json' }, body: ${JSON.stringify(JSON.stringify(body))} }`}).then(async r => ({ status: r.status, body: await r.json() }))`);
|
||||
|
||||
// One running organization whose chat project "Work" is the organization project `work`.
|
||||
function organizations() {
|
||||
const business = { business: { id: 'acme', human: 'local-dev-owner', arbiters: [], projects: [P], vars: {}, instances: [], appearance: { theme: null } } };
|
||||
return {
|
||||
list: async () => [{ id: 'acme', label: 'Acme', theme: null, busHealthy: true }],
|
||||
resolve: async id => id !== 'acme' ? null : ({
|
||||
busHealthy: true, send: async () => ({}),
|
||||
reads: { business: async () => business, settings: async () => ({}), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
|
||||
bus: { instances: async () => ({ business: 'acme', revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }),
|
||||
messages: async () => ({ messages: [], unread: 0 }), agents: async () => [], 'thread.claims': async () => [], inbox: async () => [], tasks: async () => [] },
|
||||
chat: { projects: async () => [{ id: P, name: 'Work', repo: 'work' }], threads: async () => [] },
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
async function console_(t, { send = true, width = 1440, height = 900, root = null } = {}) {
|
||||
const fresh = root === null; root ??= mkdtempSync(join(tmpdir(), 'prb')); const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
if (fresh) { mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 }); }
|
||||
const orgAdmin = createOrgAdmin({ service, registry, bus: null, context: async () => ({ configDir, dataRoot, instance: 'test' }) });
|
||||
const server = await startServer({ port: 0, sso: createDevOwner(), ...(send ? { send: async () => ({}) } : {}), organizations: organizations(), orgAdmin, log: () => {} });
|
||||
t.after(() => close(server));
|
||||
const b = await browser({ machine: false, args: ['--disable-extensions'] }); t.after(() => b.close());
|
||||
const errors = [];
|
||||
b.on('Runtime.exceptionThrown', p => errors.push(p.exceptionDetails?.exception?.description ?? p.exceptionDetails?.text ?? 'exception'));
|
||||
await b.viewport(width, height);
|
||||
const base = `http://127.0.0.1:${server.address().port}/`;
|
||||
const checkout = join(dataRoot, 'org-runtime/acme/projects/work');
|
||||
const remotes = () => execFileSync('git', ['-C', checkout, 'remote', '-v'], { env: { PATH: process.env.PATH, HOME: '/nonexistent', GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null' }, encoding: 'utf8' }).trim();
|
||||
return { b, base, wait: waitFor(b), errors, root, remotes };
|
||||
}
|
||||
|
||||
// Create the organization and set the project up local-only, as Quick Setup does, through the routes.
|
||||
async function seed(p) {
|
||||
await p.b.navigate(`${p.base}#/orgs/acme/organization`);
|
||||
const tpl = await api(p.b, '/api/org-template?id=acme');
|
||||
assert.equal(tpl.status, 200, JSON.stringify(tpl.body));
|
||||
const made = await api(p.b, '/api/orgs', { id: 'acme', doc: tpl.body.doc });
|
||||
assert.equal(made.status, 201, JSON.stringify(made.body));
|
||||
const set = await api(p.b, '/api/orgs/acme/setup/project/work', { mode: 'local-only', acceptLocalLossRisk: true });
|
||||
assert.equal(set.status, 201, JSON.stringify(set.body));
|
||||
}
|
||||
const settings = async ({ b, base, wait }) => {
|
||||
await b.navigate(`${base}#/orgs/acme/projects/${P}/settings`);
|
||||
await wait('document.querySelector("[data-project-repo]") && !/Reading the repository/.test(document.querySelector("[data-project-repo]").textContent)');
|
||||
};
|
||||
const facts = b => b.evaluate(`['mode', 'url', 'origin', 'check'].map(k => document.querySelector('[data-repo-' + k + ']')?.textContent ?? null)`);
|
||||
const save = async ({ b, wait }, pattern) => {
|
||||
await b.evaluate(`document.querySelector('[data-project-repo-status]').textContent = '', true`);
|
||||
await click(b, '[data-project-repo-form] button[type=submit]');
|
||||
await wait(`${pattern}.test(document.querySelector('[data-project-repo-status]')?.textContent)`);
|
||||
return text(b, '[data-project-repo-status]');
|
||||
};
|
||||
|
||||
test('the owner edits the repository on Settings: remote, refusals, local only and back, origin follows', { timeout: 90000 }, async t => {
|
||||
const checked = []; repoRemoteTestSeam.useCheck(async url => { checked.push(url); return url.includes('down.invalid') ? { result: 'unreachable', message: 'Could not resolve host: down.invalid' } : NEEDS; });
|
||||
t.after(() => repoRemoteTestSeam.useCheck(null));
|
||||
const p = await console_(t); const { b } = p;
|
||||
await seed(p);
|
||||
assert.equal(p.remotes(), '');
|
||||
await settings(p);
|
||||
assert.deepEqual(await facts(b), ['Local only', 'None (local only)', 'None', 'None (local only has no remote)']);
|
||||
assert.match(await text(b, '[data-repo-verb]'), /^mosaic org project repo set acme work --local-only --accept-local-loss-risk --if-revision \d+$/);
|
||||
|
||||
// Remote, https: origin is set, the check is reported in plain words, nothing is pushed.
|
||||
await click(b, '[data-project-repo-form] input[name=repo-mode][value=remote]');
|
||||
assert.equal(await b.evaluate('document.activeElement?.value'), 'remote', 'focus stays on the radio it changed');
|
||||
const https = 'https://git.example.invalid/acme/work';
|
||||
await fill(b, '#project-repo-url', https);
|
||||
const saved = await save(p, '/Saved/');
|
||||
assert.match(saved, new RegExp(`^Saved at \\S+\\. Origin is ${https.replace(/[.]/g, '\\.')}\\. Check: Needs a credential: the repository needs a credential; the credential binding will supply it\\. Nothing was pushed\\.$`));
|
||||
assert.equal(await b.evaluate(`document.activeElement?.hasAttribute('data-project-repo-status')`), true);
|
||||
assert.deepEqual(await facts(b), ['Remote', https, https, 'Needs a credential: the repository needs a credential; the credential binding will supply it.']);
|
||||
assert.equal(p.remotes(), `origin\t${https} (fetch)\norigin\t${https} (push)`);
|
||||
assert.deepEqual(checked, [https]);
|
||||
|
||||
// URLs the rules refuse never reach git, and origin stays as it was.
|
||||
for (const [bad, why] of [['ext::sh -c id', /transport helper/], ['https://user:[email protected]/acme/work', /credential/], ['-uhost:x/y', /must not start with "-"/]]) {
|
||||
await fill(b, '#project-repo-url', bad);
|
||||
const line = await save(p, '/./');
|
||||
assert.match(line, why, bad); assert.doesNotMatch(line, /Saved/, bad);
|
||||
assert.equal(await b.evaluate(`document.querySelector('#project-repo-url').value`), bad, 'the entry is kept');
|
||||
}
|
||||
assert.deepEqual(checked, [https]);
|
||||
assert.equal(p.remotes(), `origin\t${https} (fetch)\norigin\t${https} (push)`);
|
||||
|
||||
// An unreachable remote is still saved; the git error is summarized.
|
||||
const down = 'ssh://[email protected]/acme/work.git';
|
||||
await fill(b, '#project-repo-url', down);
|
||||
assert.match(await save(p, '/Saved/'), /Check: Unreachable: Could not resolve host: down\.invalid\. Nothing was pushed\.$/);
|
||||
assert.equal(p.remotes(), `origin\t${down} (fetch)\norigin\t${down} (push)`);
|
||||
|
||||
// Another write changed the organization meanwhile: the first try is refused, the second lands.
|
||||
const shown = await api(b, '/api/orgs/acme/admin');
|
||||
assert.equal((await api(b, '/api/orgs/acme/admin', { doc: shown.body.doc, ifRevision: shown.body.revision })).status, 200);
|
||||
await click(b, '[data-project-repo-form] input[name=repo-mode][value=local-only]');
|
||||
await click(b, '[data-project-repo-form] input[name=repo-risk]');
|
||||
assert.match(await save(p, '/changed after this page read it/'), /your entry is kept/);
|
||||
assert.equal(p.remotes(), `origin\t${down} (fetch)\norigin\t${down} (push)`);
|
||||
|
||||
// Local only needs the risk box; with it, origin is removed.
|
||||
assert.equal(await b.evaluate(`document.querySelector('[data-project-repo-form] input[name=repo-risk]').checked`), true, 'the draft survived the refusal');
|
||||
await click(b, '[data-project-repo-form] input[name=repo-risk]');
|
||||
assert.equal(await save(p, '/Tick the box/'), 'Tick the box to accept that a local-only repository has no copy anywhere else.');
|
||||
await click(b, '[data-project-repo-form] input[name=repo-risk]');
|
||||
assert.match(await save(p, '/Saved/'), /^Saved at \S+\. Origin removed; local only\. Nothing was pushed\.$/);
|
||||
assert.deepEqual(await facts(b), ['Local only', 'None (local only)', 'None', 'None (local only has no remote)']);
|
||||
assert.equal(p.remotes(), '');
|
||||
|
||||
// And back to remote, scp-like ssh.
|
||||
const scp = '[email protected]:acme/work.git';
|
||||
await click(b, '[data-project-repo-form] input[name=repo-mode][value=remote]');
|
||||
await fill(b, '#project-repo-url', scp);
|
||||
assert.match(await save(p, '/Saved/'), new RegExp(`Origin is ${scp.replace(/[.]/g, '\\.')}\\.`));
|
||||
assert.equal(p.remotes(), `origin\t${scp} (fetch)\norigin\t${scp} (push)`);
|
||||
const receipts = (await api(b, '/api/orgs/acme/repo/project/work')).body;
|
||||
assert.equal(receipts.current.mode, 'remote'); assert.equal(receipts.current.origin, scp);
|
||||
assert.doesNotMatch(await b.evaluate('document.body.innerText'), new RegExp(p.root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), 'no server path reaches the page');
|
||||
assert.deepEqual(p.errors, []);
|
||||
});
|
||||
|
||||
test('a read-only Console shows the setting, refuses the change in plain words and git is untouched', { timeout: 60000 }, async t => {
|
||||
repoRemoteTestSeam.useCheck(async () => NEEDS); t.after(() => repoRemoteTestSeam.useCheck(null));
|
||||
// Seed through a send-mode Console, then open the same organization in one without send mode.
|
||||
const p = await console_(t); await seed(p);
|
||||
const q = await console_(t, { send: false, root: p.root }); const { b } = q;
|
||||
await settings(q);
|
||||
assert.deepEqual(await facts(b), ['Local only', 'None (local only)', 'None', 'None (local only has no remote)']);
|
||||
await click(b, '[data-project-repo-form] input[name=repo-mode][value=remote]');
|
||||
await fill(b, '#project-repo-url', 'https://git.example.invalid/acme/work');
|
||||
assert.equal(await save(q, '/only reads/'), 'This Console only reads. Changing the repository needs signed-in send mode.');
|
||||
assert.equal(p.remotes(), '');
|
||||
assert.deepEqual(q.errors, []);
|
||||
});
|
||||
|
||||
test('the Repository section fits 1440x900 and a phone in light and dark', { timeout: 90000 }, async t => {
|
||||
repoRemoteTestSeam.useCheck(async () => NEEDS); t.after(() => repoRemoteTestSeam.useCheck(null));
|
||||
const shots = process.env.MOSAIC_UX_SHOTS;
|
||||
if (shots) mkdirSync(shots, { recursive: true });
|
||||
for (const [width, height] of [[1440, 900], [390, 844]]) {
|
||||
const p = await console_(t, { width, height }); const { b } = p;
|
||||
await seed(p);
|
||||
await settings(p);
|
||||
await click(b, '[data-project-repo-form] input[name=repo-mode][value=remote]');
|
||||
await fill(b, '#project-repo-url', 'https://git.example.invalid/acme/work');
|
||||
await save(p, '/Saved/');
|
||||
for (const mode of ['light', 'dark']) {
|
||||
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: mode }] });
|
||||
if (await b.evaluate(`document.getElementById('theme-switch').getAttribute('aria-checked')`) !== String(mode === 'dark')) {
|
||||
await b.evaluate(`document.getElementById('theme-switch').click(), true`);
|
||||
await p.wait(`document.getElementById('theme-switch').getAttribute('aria-checked') === '${mode === 'dark'}'`);
|
||||
}
|
||||
await b.evaluate(`document.querySelector('[data-project-repo]').scrollIntoView({ block: 'start' }), true`);
|
||||
if (width === 390) assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true, `page ${width} ${mode}`);
|
||||
assert.equal(await b.evaluate(`(s => s.scrollWidth <= s.clientWidth && s.getBoundingClientRect().right <= document.documentElement.clientWidth)(document.querySelector('[data-project-repo]'))`), true, `section ${width} ${mode}`);
|
||||
assert.equal(await b.evaluate(`[...document.querySelectorAll('[data-project-repo] .project-repo-option')].every(o => o.getBoundingClientRect().height >= 44)`), true, `targets ${width} ${mode}`);
|
||||
assert.equal(await b.evaluate(`document.querySelector('#project-repo-url').getBoundingClientRect().height >= 44`), true, `url field ${width} ${mode}`);
|
||||
if (shots) await b.screenshot(join(shots, `p1-7-project-repo-${width}-${mode}.png`));
|
||||
}
|
||||
assert.deepEqual(p.errors, []);
|
||||
}
|
||||
});
|
||||
Reference in new issue
Block a user