@celilo/core 0.7.0 → 0.8.1

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@celilo/core",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Lightweight shared core for Celilo CLI tools — command registry, NDJSON API protocol, and remote SSH client. No Ink/React/drizzle/aws-sdk transitive deps, so an MCP server can reach the transport without installing the full CLI.",
   "type": "module",
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts"
   },
+  "scripts": {
+    "test": "bun test"
+  },
   "files": [
     "src/",
     "README.md"

package/src/command-registry.ts

@@ -715,6 +715,14 @@ export const COMMANDS: CommandDef[] = [
               { name: 'key', description: 'Config key', completion: 'config_keys' },
             ],
           },
+          {
+            name: 'unset',
+            description: "Remove an override so the key follows the module's manifest again",
+            args: [
+              { name: 'id', description: 'Module ID', completion: 'module_ids' },
+              { name: 'key', description: 'Config key', completion: 'config_keys' },
+            ],
+          },
         ],
       },
       {
@@ -1086,6 +1094,29 @@ export const COMMANDS: CommandDef[] = [
       },
     ],
   },
+  {
+    name: 'firewall',
+    description: "Inspect a firewall's interfaces",
+    subcommands: [
+      {
+        name: 'interface',
+        description: 'Interface classification for a firewall',
+        subcommands: [
+          {
+            name: 'list',
+            description:
+              'Show how celilo classifies each interface (zone, external, or unaccounted for)',
+            args: [
+              {
+                name: 'hostname',
+                description: 'Firewall hostname (default: every machine celilo calls a router)',
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
   {
     name: 'machine',
     description: 'Manage existing machines (Raspberry Pi, VPS, bare metal)',
@@ -1198,6 +1229,11 @@ export const COMMANDS: CommandDef[] = [
           },
         ],
       },
+      {
+        name: 'discover-network',
+        description:
+          "Record the network this box sits on, read from its own routing table. celilo's own write: `apply-config` refuses network.* keys",
+      },
       {
         name: 'config',
         description: 'Get or set system configuration',
@@ -1672,15 +1708,24 @@ export const COMMANDS: CommandDef[] = [
         description: 'Run a monitor now',
         args: [{ name: 'target', description: 'Module id or built-in check name' }],
       },
+      {
+        name: 'set-interval',
+        description:
+          "Change a built-in check's cadence (a module's comes from `module config set <m> health_check_interval`)",
+        args: [
+          { name: 'check', description: 'Built-in check name' },
+          { name: 'cadence', description: 'Cadence, e.g. 15m, 1h, daily' },
+        ],
+      },
       {
         name: 'enable',
-        description: 'Enable a monitor',
-        args: [{ name: 'target', description: 'Module id or built-in check name' }],
+        description: 'Enable a built-in check monitor',
+        args: [{ name: 'target', description: 'Built-in check name' }],
       },
       {
         name: 'disable',
-        description: 'Disable a monitor and resolve its alerts',
-        args: [{ name: 'target', description: 'Module id or built-in check name' }],
+        description: 'Disable a built-in check monitor and resolve its alerts',
+        args: [{ name: 'target', description: 'Built-in check name' }],
       },
     ],
   },

package/src/remote-client.test.ts

@@ -0,0 +1,179 @@
+/**
+ * celilo#606 — the interview path must never read the process stdin that
+ * carries JSON-RPC.
+ *
+ * An MCP server's stdin IS its JSON-RPC transport. `defaultRenderInterview`
+ * used to prompt with clack, and clack reads keypresses off stdin whether or
+ * not stdin is a TTY — so raising an interview consumed bytes off the wire.
+ * That desynchronises the framing, which is why the reported symptom was not a
+ * failed call but a session that never answered again: every later call hung,
+ * a fresh session was clean, and cancelling the stuck call could not help,
+ * because you cannot re-synchronise a corrupted stream by cancelling.
+ *
+ * Two independent fixes now close it — the non-TTY guard in
+ * `defaultRenderInterview`, and the MCP always supplying `answersRenderer`,
+ * which touches no stdin at all. This asserts the first, and asserts the
+ * PROPERTY rather than either implementation: a raised interview must leave
+ * stdin byte-for-byte intact.
+ *
+ * ⚠️ These are the first tests in `@celilo/core`. The package had no `test`
+ * script, so `bun run --filter '@celilo/*' test` silently skipped it — the only
+ * `@celilo/*` package that was skipped, while holding the SSH/NDJSON transport,
+ * the wire protocol, and the command registry the MCP builds its whole tool
+ * surface from. That absence is why this mechanism could ship unnoticed.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import type { RemoteTransport } from './remote-client';
+import { InterviewUnanswerableError, interviewKey, runRemoteClient } from './remote-client';
+
+/** A transport that replays canned server lines and records what we wrote. */
+function fakeTransport(serverLines: string[]): RemoteTransport & { written: string[] } {
+  const written: string[] = [];
+  return {
+    written,
+    stdin: {
+      write: (chunk: string) => {
+        written.push(chunk);
+      },
+      end: () => {},
+    },
+    stdout: new ReadableStream<Uint8Array>({
+      start(controller) {
+        for (const line of serverLines) {
+          controller.enqueue(new TextEncoder().encode(`${line}\n`));
+        }
+        controller.close();
+      },
+    }),
+    kill: () => {},
+    exited: Promise.resolve(0),
+  };
+}
+
+const INTERVIEW = JSON.stringify({
+  type: 'interview',
+  id: 'iv-1',
+  scope: 'module.deploy',
+  key: 'confirm_breaking',
+  kind: 'confirm',
+  message: 'This is a breaking change. Continue?',
+});
+
+describe('interviewKey', () => {
+  test('joins scope and key into the pre-staging identity', () => {
+    expect(
+      interviewKey({
+        type: 'interview',
+        id: 'x',
+        scope: 'module.deploy',
+        key: 'confirm_breaking',
+        kind: 'confirm',
+        message: 'go?',
+      }),
+    ).toBe('module.deploy.confirm_breaking');
+  });
+
+  test('is null when the server sent no scope/key (older server)', () => {
+    expect(
+      interviewKey({ type: 'interview', id: 'x', kind: 'confirm', message: 'go?' }),
+    ).toBeNull();
+  });
+});
+
+describe('an interview on a non-TTY stdin (celilo#606)', () => {
+  test('a supplied renderer is used and its answer goes back to the server', async () => {
+    const transport = fakeTransport([INTERVIEW, JSON.stringify({ type: 'result', exitCode: 0 })]);
+
+    await runRemoteClient('host', ['module', 'deploy', 'caddy'], {
+      openTransport: () => transport,
+      renderInterview: async () => true,
+      out: { write: () => {} },
+    });
+
+    const answer = transport.written.find((w) => w.includes('"answer"'));
+    expect(answer).toBeTruthy();
+    expect(answer).toContain('iv-1');
+  });
+
+  /**
+   * The default renderer must REFUSE rather than prompt. Refusing is what keeps
+   * the prompt away from stdin; a renderer that prompts on a non-TTY is the
+   * defect, whatever it does with the answer afterwards.
+   */
+  test('the DEFAULT renderer refuses instead of prompting', async () => {
+    const transport = fakeTransport([INTERVIEW, JSON.stringify({ type: 'result', exitCode: 0 })]);
+
+    // No `renderInterview` — exercises defaultRenderInterview, and this suite
+    // runs with stdin not a TTY, exactly like an MCP server.
+    expect(process.stdin.isTTY).toBeFalsy();
+
+    let threw: unknown;
+    try {
+      await runRemoteClient('host', ['module', 'deploy', 'caddy'], {
+        openTransport: () => transport,
+        out: { write: () => {} },
+      });
+    } catch (error) {
+      threw = error;
+    }
+
+    // Either it throws unanswerable, or it reports the command as unable to
+    // proceed — what it must NOT do is silently succeed by reading a keypress.
+    const answered = transport.written.some((w) => w.includes('"answer"'));
+    expect(answered).toBe(false);
+    if (threw) expect(threw).toBeInstanceOf(InterviewUnanswerableError);
+  });
+});
+
+/**
+ * The property, proven the only way it can be: in a child process whose stdin
+ * is a pipe carrying JSON-RPC, assert the bytes are still there afterwards.
+ *
+ * An in-process assertion cannot show this — the harness's own stdin is shared,
+ * and "nothing read it" is not observable from inside. The issue's original
+ * reproduction was `echo '{...}' | bun run clacktest.ts`; this is that,
+ * inverted into an assertion.
+ */
+describe('stdin carrying JSON-RPC survives a raised interview', () => {
+  test('the JSON-RPC line is still readable after the interview is refused', async () => {
+    const script = `
+      const { runRemoteClient } = await import('${import.meta.dir}/remote-client.ts');
+      const transport = {
+        stdin: { write() {}, end() {} },
+        stdout: new ReadableStream({
+          start(c) {
+            c.enqueue(new TextEncoder().encode(${JSON.stringify(INTERVIEW)} + '\\n'));
+            c.enqueue(new TextEncoder().encode('{"type":"result","exitCode":0}\\n'));
+            c.close();
+          },
+        }),
+        kill() {}, exited: Promise.resolve(0),
+      };
+      try {
+        await runRemoteClient('host', ['module','deploy','caddy'], {
+          openTransport: () => transport, out: { write() {} },
+        });
+      } catch {}
+      // Whatever happened above, OUR stdin must be untouched.
+      const survived = await new Response(Bun.stdin.stream()).text();
+      process.stdout.write('SURVIVED:' + survived.trim());
+    `;
+
+    const proc = Bun.spawn(['bun', '-e', script], {
+      stdin: 'pipe',
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+    const rpc = '{"jsonrpc":"2.0","id":7,"method":"tools/call"}';
+    proc.stdin.write(`${rpc}\n`);
+    await proc.stdin.end();
+    await proc.exited;
+
+    const out = await new Response(proc.stdout).text();
+    // The exact bytes we piped in, still unread by anything in the interview
+    // path. Before celilo#607 a clack prompt consumed this line and answered
+    // itself with it.
+    expect(out).toContain(`SURVIVED:${rpc}`);
+  }, 30_000);
+});