groove-dev 0.27.198 → 0.27.199

package/node_modules/@groove-dev/daemon/src/routes/innerchat.js

@@ -1,9 +1,12 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { MAX_EXCHANGES } from '../innerchat.js';
+import { readFileSync } from 'fs';
 import { validatePeer, parsePeerRef } from '../innerchat-relay.js';
 import { saveConfig } from '../firstrun.js';
 
+const pkgVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+
 // Agents know each other by name, not id. Exact matches win first so
 // `fullstack-1` never resolves to `fullstack-14`; only if nothing matches
 // exactly do we accept a single unambiguous partial, since agents routinely
@@ -73,7 +76,101 @@ function verifyRelayCaller(daemon, body, res) {
   return peer;
 }
 
+// A peer relay is accepted only when the sender is BOTH a configured peer
+// (in innerchatPeers — the human's decision) AND signature-verifies against a
+// stored federation public key. Those are independent gates, which is what
+// makes automatic key exchange safe: holding someone's public key grants
+// nothing on its own. So adding a peer can fetch and store its key without a
+// separate manual pairing step.
+async function exchangeKeys(daemon, url, alias) {
+  const base = url.replace(/\/+$/, '');
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 8000);
+  try {
+    const res = await fetch(`${base}/api/innerchat/identity`, { signal: controller.signal });
+    if (!res.ok) throw new Error(`peer returned HTTP ${res.status}`);
+    const id = await res.json();
+    if (!id?.daemonId || !id?.publicKey) throw new Error('peer did not return an identity');
+
+    // Store their key so we can verify what they send us.
+    daemon.federation._savePeer({
+      id: id.daemonId,
+      name: alias,
+      host: new URL(base).hostname,
+      port: Number(new URL(base).port) || 80,
+      publicKey: id.publicKey,
+      pairedAt: new Date().toISOString(),
+    });
+
+    // Push ours so they can verify what WE send — this is the half that
+    // otherwise required a manual step on the other machine.
+    let pushed = false;
+    try {
+      const push = await fetch(`${base}/api/innerchat/identity`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          daemonId: daemon.federation.getDaemonId(),
+          publicKey: daemon.federation.getPublicKeyPem(),
+          name: daemon.config?.daemonName || 'groove',
+        }),
+        signal: controller.signal,
+      });
+      pushed = push.ok;
+    } catch { /* reachable for GET but not POST — report partial */ }
+
+    return { ok: true, peerDaemonId: id.daemonId, peerVersion: id.version, pushed };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export function registerInnerChatRoutes(app, daemon) {
+  /**
+   * This daemon's federation identity. Read-only and non-secret (a public key
+   * plus an id); the peer needs it to verify signed relays from us.
+   */
+  app.get('/api/innerchat/identity', (req, res) => {
+    res.json({
+      daemonId: daemon.federation.getDaemonId(),
+      publicKey: daemon.federation.getPublicKeyPem(),
+      version: pkgVersion,
+      port: daemon.port,
+      agents: daemon.registry.getAll().map((a) => a.name),
+    });
+  });
+
+  /**
+   * Accept a peer's public key so we can verify its signed relays. Storing a
+   * key authorizes nothing by itself — a relay ALSO requires that daemon to be
+   * listed in innerchatPeers, which only the user can do. That second gate is
+   * what keeps this endpoint safe to accept without a pairing dance.
+   */
+  app.post('/api/innerchat/identity', (req, res) => {
+    const { daemonId, publicKey, name } = req.body || {};
+    if (!daemonId || !/^[a-f0-9]{6,64}$/.test(String(daemonId))) {
+      return res.status(400).json({ error: 'valid daemonId required' });
+    }
+    if (!publicKey || typeof publicKey !== 'string' || !publicKey.includes('PUBLIC KEY')) {
+      return res.status(400).json({ error: 'publicKey (PEM) required' });
+    }
+    daemon.federation._savePeer({
+      id: daemonId,
+      name: typeof name === 'string' && name.trim() ? name.trim().slice(0, 40) : daemonId,
+      host: (req.ip || '').replace('::ffff:', '') || '127.0.0.1',
+      port: 0,
+      publicKey,
+      pairedAt: new Date().toISOString(),
+    });
+    daemon.audit.log('innerchat.key.received', { daemonId });
+    res.json({
+      ok: true,
+      // Hand back ours so a single call completes the exchange either way.
+      daemonId: daemon.federation.getDaemonId(),
+      publicKey: daemon.federation.getPublicKeyPem(),
+    });
+  });
+
   /**
    * Ask another agent a question and BLOCK until it answers.
    *
@@ -223,19 +320,104 @@ export function registerInnerChatRoutes(app, daemon) {
     res.json({ peers: daemon.innerchat._peers() });
   });
 
-  app.post('/api/innerchat/peers', (req, res) => {
-    const entry = { alias: req.body?.alias, url: req.body?.url, daemonId: req.body?.daemonId };
-    const err = validatePeer(entry);
-    if (err) return res.status(400).json({ error: err });
-    entry.url = entry.url.replace(/\/+$/, '');
+  /**
+   * Add a peer. The daemonId is discovered from the peer itself rather than
+   * typed, and public keys are exchanged automatically, so the user only has
+   * to supply a name and a reachable URL.
+   */
+  app.post('/api/innerchat/peers', async (req, res) => {
+    const alias = req.body?.alias;
+    const rawUrl = req.body?.url;
+    if (!alias || typeof alias !== 'string' || !/^[a-zA-Z0-9_-]{1,40}$/.test(alias)) {
+      return res.status(400).json({ error: 'peer name must be 1-40 chars (letters, digits, dash, underscore)' });
+    }
+    if (!rawUrl || typeof rawUrl !== 'string') return res.status(400).json({ error: 'peer url is required' });
+
+    let url;
+    try {
+      const parsed = new URL(rawUrl.trim());
+      if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        return res.status(400).json({ error: 'peer url must be http(s)' });
+      }
+      if (parsed.username || parsed.password) return res.status(400).json({ error: 'credentials in the url are not allowed' });
+      url = rawUrl.trim().replace(/\/+$/, '');
+    } catch { return res.status(400).json({ error: `invalid url: ${rawUrl}` }); }
+
+    // Reach the peer, learn its id, and trade keys. This is the step that used
+    // to be a manual federation pairing.
+    let exchange;
+    try {
+      exchange = await exchangeKeys(daemon, url, alias);
+    } catch (err) {
+      return res.status(502).json({
+        error: `Could not reach a Groove daemon at ${url} — ${err.message}. `
+          + 'Check the URL (for a tunnelled peer this is the forwarded local port, not 31415) and that the peer daemon is running the current version.',
+      });
+    }
+
+    if (exchange.peerDaemonId === daemon.federation.getDaemonId()) {
+      return res.status(400).json({
+        error: `That URL points at THIS daemon, not a peer. For a tunnelled machine use the forwarded local port (e.g. http://127.0.0.1:31416), not ${url}.`,
+      });
+    }
+
+    const entry = { alias, url, daemonId: exchange.peerDaemonId };
+    const check = validatePeer(entry);
+    if (check) return res.status(400).json({ error: check });
 
     const peers = Array.isArray(daemon.config.innerchatPeers) ? daemon.config.innerchatPeers : [];
-    const next = peers.filter((p) => p.alias !== entry.alias);
+    const next = peers.filter((p) => p.alias !== alias);
     next.push(entry);
     daemon.config.innerchatPeers = next;
     saveConfig(daemon.grooveDir, daemon.config);
-    daemon.audit.log('innerchat.peer.set', { alias: entry.alias, url: entry.url });
-    res.json({ peers: next });
+    daemon.audit.log('innerchat.peer.set', { alias, url, daemonId: entry.daemonId });
+    // Registry files carry the @peer instructions + alias list — refresh now so
+    // running agents see the new peer without waiting for a spawn or restart.
+    try { daemon.introducer?.writeRegistryFile?.(daemon.projectDir); } catch { /* best effort */ }
+
+    res.json({
+      peers: next,
+      exchanged: true,
+      keyPushed: exchange.pushed,
+      peerDaemonId: exchange.peerDaemonId,
+      note: exchange.pushed
+        ? `Keys exchanged with ${alias}. Add this machine as a peer there too if you want its agents to start conversations.`
+        : `Stored ${alias}'s key, but could not send ours — ${alias} may be running an older version. Update it, then re-add.`,
+    });
+  });
+
+  /**
+   * Verify a configured peer end to end: reachable, identity matches what we
+   * stored, and keys are present on both sides.
+   */
+  app.get('/api/innerchat/peers/:alias/test', async (req, res) => {
+    const peer = daemon.innerchat._peerByAlias(req.params.alias);
+    if (!peer) return res.status(404).json({ error: `No peer named "${req.params.alias}"` });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 8000);
+    try {
+      const r = await fetch(`${peer.url}/api/innerchat/identity`, { signal: controller.signal });
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      const id = await r.json();
+      const idMatches = id.daemonId === peer.daemonId;
+      const weHaveTheirKey = daemon.federation.peers.has(peer.daemonId);
+      res.json({
+        ok: idMatches && weHaveTheirKey,
+        reachable: true,
+        idMatches,
+        weHaveTheirKey,
+        peerDaemonId: id.daemonId,
+        peerVersion: id.version,
+        agents: Array.isArray(id.agents) ? id.agents : [],
+        error: !idMatches
+          ? `The daemon at ${peer.url} reports id ${id.daemonId}, but this peer is configured as ${peer.daemonId}. Re-add the peer.`
+          : !weHaveTheirKey ? 'Missing this peer\'s public key — re-add the peer to exchange keys.' : null,
+      });
+    } catch (err) {
+      res.json({ ok: false, reachable: false, error: `Could not reach ${peer.url} — ${err.message}` });
+    } finally {
+      clearTimeout(timer);
+    }
   });
 
   app.delete('/api/innerchat/peers/:alias', (req, res) => {

package/node_modules/@groove-dev/daemon/test/axom-connector.test.js

@@ -31,6 +31,8 @@ class MockBridge {
     this.sessions = sessions || { 's-test0001': { started: 1753000000, live: true, events: [] } };
     this.interrupts = [];
     this.stops = [];
+    this.shutdowns = [];
+    this.messages = [];
     this.sinceSeen = []; // ?since values observed on WS connects
     this.sockets = new Set();
   }
@@ -95,6 +97,18 @@ class MockBridge {
     const interrupt = url.pathname.match(/^\/session\/([^/]+)\/interrupt$/);
     const stop = url.pathname.match(/^\/session\/([^/]+)\/stop$/);
     const message = url.pathname.match(/^\/session\/([^/]+)\/message$/);
+    if (req.method === 'POST' && url.pathname === '/shutdown') {
+      let body = '';
+      req.on('data', (c) => { body += c; });
+      req.on('end', () => {
+        const { force } = JSON.parse(body || '{}');
+        const busy = Object.values(this.sessions).some((s) => s.live);
+        if (busy && !force) return json(409, { error: 'turn in flight' });
+        this.shutdowns.push({ force: !!force });
+        return json(202, { stopping: true });
+      });
+      return;
+    }
     if (req.method === 'POST' && (interrupt || stop || message)) {
       let body = '';
       req.on('data', (c) => { body += c; });
@@ -108,7 +122,11 @@ class MockBridge {
           // §12 semantics: caller-chosen id, first message creates; one turn
           // at a time; hard max with 413, never truncation.
           const id = decodeURIComponent(message[1]);
-          const { text } = JSON.parse(body || '{}');
+          const parsed = JSON.parse(body || '{}');
+          const { text } = parsed;
+          // Store the parsed body verbatim so tests can assert on key
+          // PRESENCE (a destructured undefined would fabricate the key).
+          this.messages.push({ session: id, body: parsed });
           if (text.length > 32768) return json(413, { error: 'too_long', max: 32768 });
           let session = this.sessions[id];
           if (!session) { session = this.sessions[id] = { started: Date.now() / 1000, live: false, events: [] }; }
@@ -380,6 +398,31 @@ describe('AxomConnector', () => {
     assert.equal(s.watching, true);
   });
 
+  it('sends client_ref only when given, and omits it otherwise (§15)', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    await connector.message('local', 's-ref', 'with a ref', 'g-abc123');
+    await connector.message('local', 's-noref', 'without one');
+    assert.equal(bridge.messages[0].body.client_ref, 'g-abc123');
+    // Pre-§15 runtimes must see exactly today's payload — no null key.
+    assert.equal('client_ref' in bridge.messages[1].body, false);
+  });
+
+  it('shuts the runtime down, refusing mid-turn unless forced (§14)', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    // s-test0001 starts live: a turn is in flight.
+    const refused = await connector.shutdown('local');
+    assert.equal(refused.status, 409);
+    assert.equal(refused.body.error, 'turn in flight');
+    assert.equal(bridge.shutdowns.length, 0);
+
+    const forced = await connector.shutdown('local', { force: true });
+    assert.equal(forced.status, 202);
+    assert.deepEqual(forced.body, { stopping: true });
+    assert.deepEqual(bridge.shutdowns, [{ force: true }]);
+  });
+
   it('reports an unreachable endpoint honestly and recovers by retry', async () => {
     const deadUrl = bridge.url;
     const port = Number(new URL(deadUrl).port);

package/node_modules/@groove-dev/daemon/test/axom-remote.test.js

@@ -0,0 +1,115 @@
+// GROOVE — Axom Remote Control Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// SSH is injected, so these assert the COMMANDS we would run and the honesty
+// of what we report — never that ssh itself works.
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { AxomRemote, validateRemote } from '../src/axom-remote.js';
+
+function harness({ responses = {}, remote = { host: 'spark.local', user: 'axom' } } = {}) {
+  const calls = [];
+  const daemon = {
+    config: { axom: { remote } },
+    broadcast() {},
+    audit: { log() {} },
+  };
+  const exec = (bin, args, opts, cb) => {
+    const command = args[args.length - 1];
+    calls.push({ bin, target: args[args.length - 2], command });
+    const match = Object.keys(responses).find((k) => command.includes(k));
+    const out = match ? responses[match] : '';
+    if (out instanceof Error) return cb(out, '', out.message);
+    cb(null, out, '');
+  };
+  return { remote: new AxomRemote(daemon, { exec }), calls, daemon };
+}
+
+describe('AxomRemote', () => {
+  it('reports running/not-running from a probe on the remote host', async () => {
+    const up = harness({ responses: { '/about': 'UP\n' } });
+    assert.deepEqual(await up.remote.status(), {
+      configured: true, host: 'spark.local', user: 'axom', port: 8737, running: true, error: null,
+    });
+    const down = harness({ responses: { '/about': 'DOWN\n' } });
+    assert.equal((await down.remote.status()).running, false);
+  });
+
+  it('reports UNKNOWN (not "stopped") when the host is unreachable', async () => {
+    const h = harness({ responses: { '/about': new Error('ssh: connect to host spark.local port 22: No route to host') } });
+    const s = await h.remote.status();
+    // A host we cannot reach tells us nothing about the runtime. Saying
+    // "stopped" would be a guess presented as fact.
+    assert.equal(s.running, null);
+    assert.match(s.error, /No route to host/);
+  });
+
+  it('starts detached with no supervisor and confirms it actually came up', async () => {
+    let probes = 0;
+    const h = harness({
+      responses: {
+        get '/about'() { probes += 1; return probes === 1 ? 'DOWN\n' : 'UP\n'; },
+        'nohup': 'STARTED\n',
+      },
+    });
+    const result = await h.remote.start();
+    assert.equal(result.started, true);
+    const startCmd = h.calls.find((c) => c.command.includes('nohup')).command;
+    assert.match(startCmd, /axom serve --port 8737/);
+    assert.match(startCmd, /disown/);           // survives the ssh session
+    assert.equal(/while|until|restart|systemctl/.test(startCmd), false); // never supervised
+  });
+
+  it('does not start a second runtime when one is already up', async () => {
+    const h = harness({ responses: { '/about': 'UP\n' } });
+    assert.deepEqual(await h.remote.start(), { started: false, alreadyRunning: true, port: 8737 });
+    assert.equal(h.calls.some((c) => c.command.includes('nohup')), false);
+  });
+
+  it('stops via the §14 shutdown verb when the runtime supports it', async () => {
+    const h = harness({ responses: { '/shutdown': '202', '/about': 'DOWN\n' } });
+    const result = await h.remote.stop();
+    assert.deepEqual(result, { stopped: true, via: 'shutdown' });
+    assert.equal(h.calls.some((c) => c.command.includes('kill')), false); // no signal needed
+  });
+
+  it('refuses to stop mid-turn unless forced, and passes force through', async () => {
+    const busy = harness({ responses: { '/shutdown': '409', '/about': 'UP\n' } });
+    assert.deepEqual(await busy.remote.stop(), { stopped: false, turnInFlight: true });
+
+    const forced = harness({ responses: { '/shutdown': '202', '/about': 'UP\n' } });
+    await forced.remote.stop({ force: true });
+    assert.match(forced.calls.find((c) => c.command.includes('/shutdown')).command, /"force":true/);
+  });
+
+  it('falls back to a signal only for runtimes predating §14', async () => {
+    const h = harness({ responses: { '/shutdown': '404', '/about': 'UP\n' } });
+    const result = await h.remote.stop();
+    assert.deepEqual(result, { stopped: true, via: 'signal' });
+    assert.match(h.calls.find((c) => c.command.includes('kill')).command, /lsof -t -i:8737/);
+  });
+
+  it('reports unconfigured rather than pretending', async () => {
+    const h = harness({ remote: null });
+    assert.deepEqual(await h.remote.status(), { configured: false, running: null });
+    await assert.rejects(() => h.remote.start(), /no remote Axom host configured/);
+  });
+});
+
+describe('validateRemote', () => {
+  it('accepts a clean config', () => {
+    assert.equal(validateRemote({ host: 'spark.local', user: 'axom', sshPort: 22, port: 8737 }), null);
+  });
+
+  it('rejects shell metacharacters and malformed values', () => {
+    // host/user reach execFile as single argv entries, but a permissive
+    // validator would still invite injection attempts through config.
+    assert.ok(validateRemote({ host: 'spark.local; rm -rf /', user: 'axom' }));
+    assert.ok(validateRemote({ host: 'spark.local', user: 'axom$(id)' }));
+    assert.ok(validateRemote({ host: 'a'.repeat(300), user: 'axom' }));
+    assert.ok(validateRemote({ host: 'spark.local', user: 'axom', sshPort: 99999 }));
+    assert.ok(validateRemote({ host: 'spark.local', user: 'axom', command: 'x'.repeat(600) }));
+    assert.ok(validateRemote(null));
+  });
+});

package/node_modules/@groove-dev/daemon/test/axom-server.test.js

@@ -58,7 +58,7 @@ describe('AxomServerManager', () => {
     daemon = fakeDaemon(dir);
     // Lifecycle tests inject ample RAM — the floor guard has its own test
     // (and CI boxes/the 8GB dev Mac must not trip it on unrelated tests).
-    manager = new AxomServerManager(daemon, { command: stubPath, totalRamGb: 32 });
+    manager = new AxomServerManager(daemon, { command: stubPath, totalRamGb: 32, portBase: 18737 });
   });
 
   afterEach(async () => {
@@ -68,7 +68,7 @@ describe('AxomServerManager', () => {
   it('starts an instance with its own port and sovereign data-dir, and registers the endpoint', async () => {
     const instance = await manager.start('proj-a');
     assert.equal(instance.status, 'running');
-    assert.equal(instance.port, 8737);
+    assert.equal(instance.port, 18737);
     assert.ok(instance.dataDir.endsWith(join('axom', 'instances', 'proj-a')));
     assert.ok(existsSync(instance.dataDir));
 
@@ -76,15 +76,15 @@ describe('AxomServerManager', () => {
     assert.equal(about.instance.data_dir, instance.dataDir);
 
     const ep = daemon.config.axom.endpoints.find((e) => e.name === 'local-proj-a');
-    assert.equal(ep.url, 'http://127.0.0.1:8737');
+    assert.equal(ep.url, 'http://127.0.0.1:18737');
     assert.deepEqual(daemon.axom.lastConfigured, daemon.config.axom.endpoints);
   });
 
   it('allocates distinct ports for concurrent instances', async () => {
     const a = await manager.start('a');
     const b = await manager.start('b');
-    assert.equal(a.port, 8737);
-    assert.equal(b.port, 8738);
+    assert.equal(a.port, 18737);
+    assert.equal(b.port, 18738);
     assert.notEqual(a.dataDir, b.dataDir); // ledgers never shared
   });
 
@@ -97,7 +97,7 @@ describe('AxomServerManager', () => {
   });
 
   it('refuses non-mock start below the RAM floor — the host stays up', async () => {
-    manager = new AxomServerManager(daemon, { command: stubPath, totalRamGb: 8 });
+    manager = new AxomServerManager(daemon, { command: stubPath, totalRamGb: 8, portBase: 18737 });
     await assert.rejects(() => manager.start('x'), /below Axom's 12GB floor/);
     // Mock mode is weightless and exempt.
     daemon.config.axom.mock = true;
@@ -105,8 +105,29 @@ describe('AxomServerManager', () => {
     assert.equal(instance.status, 'running');
   });
 
+  it('refuses to adopt a foreign runtime already holding the port', async () => {
+    // A tunnel to a remote Axom (or any other runtime) can already own the
+    // port. Claiming it would let GROOVE offer to shut down a process it
+    // never launched — found live when an SSH tunnel occupied 8737.
+    const foreign = createServer((req, res) => {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({
+        name: 'axom', version: 'someone-elses',
+        instance: { port: 18737, data_dir: '/somewhere/else', pid: 999999 },
+      }));
+    });
+    await new Promise((r) => foreign.listen(18737, '127.0.0.1', r));
+    try {
+      await assert.rejects(() => manager.start('hijack'), /already served by another Axom runtime/);
+      assert.equal(manager.list().find((i) => i.id === 'hijack').status, 'error');
+    } finally {
+      foreign.closeAllConnections?.();
+      await new Promise((r) => foreign.close(r));
+    }
+  });
+
   it('reports a missing runtime binary honestly', async () => {
-    manager = new AxomServerManager(daemon, { command: '/nonexistent/axom', totalRamGb: 32 });
+    manager = new AxomServerManager(daemon, { command: '/nonexistent/axom', totalRamGb: 32, portBase: 18737 });
     await assert.rejects(() => manager.start('x'), /not found — install the Axom runtime/);
     assert.equal(manager.list().find((i) => i.id === 'x').status, 'error');
   });
@@ -176,8 +197,28 @@ describe('AxomInstaller', () => {
     }
   });
 
-  it('errors without a configured manifest url — no hardcoded source exists', async () => {
-    await assert.rejects(() => installer.install(undefined), /no install manifest configured/);
+  it('reports unavailable (not an error) when no distribution is configured', async () => {
+    // A public GROOVE build ships with no manifest: the UI must render
+    // "Coming soon" rather than offering an action that fails on click.
+    const status = installer.getStatus();
+    assert.equal(status.available, false);
+    assert.equal(status.unavailableReason, 'Coming soon');
+    assert.equal(status.manifestUrl, null);
+  });
+
+  it('gates install server-side too — a hand-crafted POST cannot bypass it', async () => {
+    await assert.rejects(() => installer.install(undefined), /Coming soon/);
+  });
+
+  it('explains a gated private distribution instead of leaking HTTP codes', async () => {
+    const gated = createServer((req, res) => { res.statusCode = 403; res.end('{}'); });
+    await new Promise((r) => gated.listen(0, '127.0.0.1', r));
+    const url = `http://127.0.0.1:${gated.address().port}/manifest.json`;
+    try {
+      await assert.rejects(() => installer.install(url), /private — your account does not have access/);
+    } finally {
+      await new Promise((r) => gated.close(r));
+    }
   });
 
   it('refuses to download weights below the RAM floor', async () => {