@linzumi/cli 1.0.86 → 1.0.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.86",
+  "version": "1.0.88",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/compute-node-demo-server.mjs

@@ -0,0 +1,186 @@
+// Demo/evidence stand-in for the compute-nodes GraphQL surface (spec
+// kandan/plans/2026-07-11-m0.1-compute-nodes-schema-protocol-spec.md,
+// sections 3-4): an in-memory /api/v2/graphql that answers the CLI's
+// ComputeNodeCliList / ComputeNodeCliCommand documents with the frozen
+// result-union shapes, including the reset retire+successor semantics
+// (generation + 1, one active generation per identity) and rename.
+//
+// PURPOSE: terminal recordings + local demos of the REAL CLI code paths
+// before M1.3 is deployed (D29 gates the merge on the real mutation; this
+// stand-in never ships and is not a test double for correctness claims -
+// the live acceptance run is scripts/compute-node-reset-e2e.mjs against a
+// real server).
+//
+// RUN: node scripts/compute-node-demo-server.mjs [port]   (default 4123)
+// Then: linzumi node list --linzumi-url ws://127.0.0.1:4123 --token demo
+import { createServer } from 'node:http';
+import { hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+const port = Number(process.argv[2] ?? 4123);
+
+// One pre-adopted active node for this machine, like a real first connect
+// (adoption names the node after the hello hostname).
+const nodes = [
+  {
+    id: `ComputeNode:${randomUUID()}`,
+    name: hostname(),
+    identityKey: 'mfp2-demo',
+    identityQuality: 'FULL',
+    resetGeneration: 0,
+    firstSeenAt: new Date(Date.now() - 86_400_000).toISOString(),
+    lastSeenAt: new Date().toISOString(),
+    retiredAt: null,
+  },
+  {
+    id: `ComputeNode:${randomUUID()}`,
+    name: 'basement-linux',
+    identityKey: 'demo-degraded-machine-id',
+    identityQuality: 'DEGRADED',
+    resetGeneration: 2,
+    firstSeenAt: new Date(Date.now() - 30 * 86_400_000).toISOString(),
+    lastSeenAt: new Date(Date.now() - 3 * 86_400_000).toISOString(),
+    retiredAt: null,
+  },
+];
+
+function activeNodes() {
+  return nodes.filter((node) => node.retiredAt === null);
+}
+
+function summary(node) {
+  return {
+    id: node.id,
+    name: node.name,
+    identityQuality: node.identityQuality,
+    onlineStatus: node.retiredAt === null ? 'OFFLINE' : 'UNKNOWN',
+    resetGeneration: node.resetGeneration,
+    firstSeenAt: node.firstSeenAt,
+    lastSeenAt: node.lastSeenAt,
+  };
+}
+
+// Spec section 4: retire + insert successor in one step; retry-idempotent.
+function resetNode(nodeId) {
+  const target = nodes.find((node) => node.id === nodeId);
+  if (target === undefined) {
+    return {
+      __typename: 'ComputeNodeNotFoundError',
+      message: 'no such compute node',
+      nodeId,
+    };
+  }
+  if (target.retiredAt !== null) {
+    const successor = nodes.find(
+      (node) =>
+        node.identityKey === target.identityKey &&
+        node.resetGeneration === target.resetGeneration + 1
+    );
+    if (successor === undefined) {
+      return {
+        __typename: 'ComputeNodeNotFoundError',
+        message: 'retired without successor (admin-retired lineage)',
+        nodeId,
+      };
+    }
+    return {
+      __typename: 'ResetComputeNodeSuccess',
+      computeNode: summary(successor),
+    };
+  }
+  target.retiredAt = new Date().toISOString();
+  const successor = {
+    ...target,
+    id: `ComputeNode:${randomUUID()}`,
+    resetGeneration: target.resetGeneration + 1,
+    firstSeenAt: null,
+    lastSeenAt: null,
+    retiredAt: null,
+  };
+  nodes.push(successor);
+  return {
+    __typename: 'ResetComputeNodeSuccess',
+    computeNode: summary(successor),
+  };
+}
+
+function renameNode(nodeId, name) {
+  const target = nodes.find(
+    (node) => node.id === nodeId && node.retiredAt === null
+  );
+  if (target === undefined) {
+    return {
+      __typename: 'ComputeNodeNotFoundError',
+      message: 'no such compute node',
+      nodeId,
+    };
+  }
+  const trimmed = name.trim();
+  if (trimmed.length === 0 || trimmed.length > 255) {
+    return {
+      __typename: 'ComputeNodeInvalidNameError',
+      message: 'name must be 1-255 characters',
+    };
+  }
+  target.name = trimmed;
+  return {
+    __typename: 'RenameComputeNodeSuccess',
+    computeNode: summary(target),
+  };
+}
+
+const server = createServer((request, response) => {
+  if (request.method !== 'POST' || request.url !== '/api/v2/graphql') {
+    response.writeHead(404).end();
+    return;
+  }
+  let body = '';
+  request.on('data', (chunk) => (body += chunk));
+  request.on('end', () => {
+    const { query, variables } = JSON.parse(body);
+    let data;
+    if (query.includes('ComputeNodeCliList')) {
+      data = {
+        viewer: {
+          computeNodes: {
+            edges: activeNodes().map((node) => ({ node: summary(node) })),
+          },
+        },
+      };
+    } else if (query.includes('ComputeNodeCliCommand')) {
+      const input = variables.input ?? {};
+      const members = Object.keys(input);
+      if (members.length !== 1) {
+        // OneOf violation (D32) - a real server rejects this in validation.
+        response.writeHead(200, { 'content-type': 'application/json' }).end(
+          JSON.stringify({
+            errors: [{ message: 'OneOf input must have exactly one member' }],
+          })
+        );
+        return;
+      }
+      data = {
+        executeComputeNodeCommand:
+          members[0] === 'reset'
+            ? resetNode(input.reset.nodeId)
+            : renameNode(input.rename.nodeId, input.rename.name),
+      };
+    } else {
+      response.writeHead(200, { 'content-type': 'application/json' }).end(
+        JSON.stringify({
+          errors: [{ message: 'Cannot query field (demo server)' }],
+        })
+      );
+      return;
+    }
+    response
+      .writeHead(200, { 'content-type': 'application/json' })
+      .end(JSON.stringify({ data }));
+  });
+});
+
+server.listen(port, '127.0.0.1', () => {
+  console.log(
+    `compute-node demo server on http://127.0.0.1:${port}/api/v2/graphql`
+  );
+});

package/scripts/compute-node-hello-witness.mjs

@@ -0,0 +1,92 @@
+// Hello witness (evidence tooling for M1.5): a minimal Phoenix-protocol WS
+// endpoint that PRINTS the machine-identity fields of the real CLI's join
+// hello (proving fingerprint v2 rides the wire next to v1, hashed only - D5)
+// and replies with an M1.1-shaped `compute_node` adoption receipt so the
+// runner's `runner.compute_node` log line fires.
+//
+// Evidence-only, like compute-node-demo-server.mjs: never a correctness
+// oracle (the live acceptance run is compute-node-reset-e2e.mjs against a
+// real server).
+//
+// RUN: node scripts/compute-node-hello-witness.mjs [port]   (default 4124)
+// Then: linzumi connect --linzumi-url ws://127.0.0.1:4124 --token demo --cwd .
+import { createRequire } from 'node:module';
+import { createServer } from 'node:http';
+
+const require = createRequire(import.meta.url);
+const { WebSocketServer } = require('ws');
+
+const port = Number(process.argv[2] ?? 4124);
+
+// The CLI's connect flow makes HTTP preflight calls against the same host
+// (token/config probes). Answer them all with an empty-ok JSON so the flow
+// proceeds to the websocket join - the part this witness exists to print.
+const httpServer = createServer((request, response) => {
+  console.log(`[http] ${request.method} ${request.url}`);
+  response
+    .writeHead(200, { 'content-type': 'application/json' })
+    .end(JSON.stringify({ ok: true }));
+});
+const server = new WebSocketServer({ server: httpServer });
+httpServer.listen(port, '127.0.0.1');
+
+server.on('connection', (socket) => {
+  socket.on('message', (rawMessage) => {
+    const frame = JSON.parse(String(rawMessage));
+    const [, ref, topic, event, payload] = frame;
+
+    if (event === 'phx_join' && payload?.clientName !== undefined) {
+      console.log(`\n=== join hello received on ${topic} ===`);
+      console.log(`  machineFingerprint   (v1): ${payload.machineFingerprint}`);
+      console.log(
+        `  machineFingerprintV2 (v2): ${
+          'machineFingerprintV2' in payload
+            ? payload.machineFingerprintV2
+            : '<ABSENT - degraded path>'
+        }`
+      );
+      console.log(
+        `  hostname: ${payload.hostname}  version: ${payload.version}`
+      );
+      console.log('=== replying with compute_node adoption receipt ===\n');
+
+      socket.send(
+        JSON.stringify([
+          null,
+          ref,
+          topic,
+          'phx_reply',
+          {
+            status: 'ok',
+            response: {
+              ok: true,
+              protocol: 'kandan-local-runner.v1',
+              compute_node: {
+                id: 'Q29tcHV0ZU5vZGU6ZGVtbw==',
+                name: payload.hostname,
+                identity_quality:
+                  'machineFingerprintV2' in payload ? 'full' : 'degraded',
+                reset_generation: 0,
+              },
+            },
+          },
+        ])
+      );
+      return;
+    }
+
+    if (ref !== null && ref !== undefined) {
+      socket.send(
+        JSON.stringify([
+          null,
+          ref,
+          topic,
+          'phx_reply',
+          { status: 'ok', response: { ok: true, event } },
+        ])
+      );
+    }
+  });
+});
+
+console.log(`hello witness listening on ws://127.0.0.1:${port}`);

package/scripts/compute-node-reset-e2e.mjs

@@ -0,0 +1,250 @@
+// Compute-nodes plan M1 acceptance (a), CLI legs - LIVE e2e against a REAL
+// server (compute-nodes program; spec
+// kandan/plans/2026-07-11-m0.1-compute-nodes-schema-protocol-spec.md
+// section 4 join-time selection + section 7 acceptance commands):
+//
+//   P1 adoption:   a fresh connect adopts ONE active compute node for this
+//                  (machine, OS user); on a v2-capable host its identity
+//                  quality is FULL (fingerprint v2 rode the hello).
+//   P2 reset:      `linzumi node reset` retires the generation and the
+//                  server returns the successor (generation + 1).
+//   P3 config wipe: rm -rf of the CLI's local config/state, then reconnect,
+//                  SELECTS THE SUCCESSOR - never a revived generation 0,
+//                  never a second active row (D21: lineage lives server-side,
+//                  so there is nothing local whose loss could fork identity).
+//   P4 rename:     `linzumi node rename` renames the node and the list
+//                  read-back shows the new name (M1.8).
+//
+// REQUIREMENTS: a server running M1.1 (join adoption) + M1.3 (the
+// executeComputeNodeCommand mutation) - D29 gates the CLI merge on M1.3
+// being deployed. Run against a LOCAL dev server or a preview with a TEST
+// account; never a real user.
+//
+// RUN (from packages/linzumi-cli, after `npm run build`):
+//
+//   LINZUMI_E2E_URL=ws://127.0.0.1:4000 \
+//   LINZUMI_E2E_TOKEN=<local-runner token for the test user> \
+//   node scripts/compute-node-reset-e2e.mjs
+//
+// The script never touches the real ~/.linzumi: all CLI state is scoped into
+// a temp dir via LINZUMI_CONFIG_FILE, and the "config wipe" leg wipes THAT.
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = dirname(here);
+const cliBin = join(pkgRoot, 'bin', 'linzumi.js');
+
+const serverUrl = process.env.LINZUMI_E2E_URL ?? 'ws://127.0.0.1:4000';
+const token = process.env.LINZUMI_E2E_TOKEN;
+// Extra args appended to `linzumi connect` (space-separated), e.g.
+// `--code-server-bin /tmp/stub` on hosts without the editor runtime.
+const extraConnectArgs = (process.env.LINZUMI_E2E_CONNECT_ARGS ?? '')
+  .split(' ')
+  .filter((arg) => arg !== '');
+
+if (token === undefined || token === '') {
+  console.error(
+    'LINZUMI_E2E_TOKEN is required (a local-runner token for a TEST account).'
+  );
+  process.exit(2);
+}
+
+let stateRoot = mkdtempSync(join(tmpdir(), 'linzumi-node-e2e-'));
+const workDir = mkdtempSync(join(tmpdir(), 'linzumi-node-e2e-cwd-'));
+
+function cliEnv() {
+  return {
+    ...process.env,
+    // Scope EVERY piece of CLI state into the wipeable temp root.
+    LINZUMI_CONFIG_FILE: join(stateRoot, 'config.json'),
+  };
+}
+
+function runCli(args, options = {}) {
+  const result = spawnSync('node', [cliBin, ...args], {
+    env: cliEnv(),
+    encoding: 'utf8',
+    timeout: options.timeoutMs ?? 60_000,
+  });
+  return {
+    code: result.status,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}
+
+function nodeList() {
+  const result = runCli([
+    'node',
+    'list',
+    '--json',
+    '--linzumi-url',
+    serverUrl,
+    '--token',
+    token,
+  ]);
+  if (result.code !== 0) {
+    throw new Error(`node list failed: ${result.stderr}`);
+  }
+  return JSON.parse(result.stdout);
+}
+
+// Connect a runner long enough for join-time adoption to commit, then stop
+// it. Adoption happens ON JOIN (spec section 4), so we poll the list read
+// until the node appears rather than parsing runner logs.
+async function connectAndAdopt(label) {
+  const child = spawn(
+    'node',
+    [
+      cliBin,
+      'connect',
+      '--linzumi-url',
+      serverUrl,
+      '--token',
+      token,
+      '--cwd',
+      workDir,
+      ...extraConnectArgs,
+    ],
+    { env: cliEnv(), stdio: ['ignore', 'pipe', 'pipe'] }
+  );
+  let output = '';
+  child.stdout.on('data', (chunk) => (output += chunk));
+  child.stderr.on('data', (chunk) => (output += chunk));
+
+  try {
+    const deadline = Date.now() + 60_000;
+    for (;;) {
+      const nodes = nodeList();
+      if (nodes.length > 0) {
+        return nodes;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(
+          `${label}: no compute node adopted within 60s. runner output:\n${output}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1_000));
+    }
+  } finally {
+    child.kill('SIGTERM');
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    child.kill('SIGKILL');
+  }
+}
+
+const failures = [];
+function check(name, condition, detail) {
+  if (condition) {
+    console.log(`PASS ${name}`);
+  } else {
+    console.error(`FAIL ${name}: ${detail}`);
+    failures.push(name);
+  }
+}
+
+try {
+  // P1: fresh adoption.
+  const adopted = await connectAndAdopt('P1');
+  check(
+    'P1 exactly one active node adopted',
+    adopted.length === 1,
+    JSON.stringify(adopted)
+  );
+  const original = adopted[0];
+  check(
+    'P1 identity quality is FULL on a v2-capable host',
+    original.identityQuality === 'FULL',
+    `identityQuality=${original.identityQuality} (expected FULL on macOS/Linux; DEGRADED means the v2 fingerprint did not ride the hello)`
+  );
+  const originalGeneration = original.resetGeneration;
+
+  // P2: reset returns the successor generation.
+  const reset = runCli([
+    'node',
+    'reset',
+    '--node',
+    original.id,
+    '--yes',
+    '--linzumi-url',
+    serverUrl,
+    '--token',
+    token,
+  ]);
+  check('P2 reset exits 0', reset.code === 0, reset.stderr);
+  check(
+    'P2 reset prints the successor generation',
+    reset.stdout.includes(`generation ${originalGeneration + 1}`),
+    reset.stdout
+  );
+
+  const afterReset = nodeList();
+  check(
+    'P2 exactly one active node after reset',
+    afterReset.length === 1,
+    JSON.stringify(afterReset)
+  );
+  const successor = afterReset[0];
+  check(
+    'P2 successor generation is original + 1',
+    successor.resetGeneration === originalGeneration + 1,
+    `generation=${successor.resetGeneration}`
+  );
+  check(
+    'P2 successor is a NEW row (fresh id)',
+    successor.id !== original.id,
+    `id unchanged: ${successor.id}`
+  );
+
+  // P3: config wipe + reconnect selects the successor (the D21 property:
+  // nothing local can revive the retired generation).
+  rmSync(stateRoot, { recursive: true, force: true });
+  stateRoot = mkdtempSync(join(tmpdir(), 'linzumi-node-e2e-rewiped-'));
+
+  const rejoined = await connectAndAdopt('P3');
+  check(
+    'P3 still exactly one active node after wipe + reconnect',
+    rejoined.length === 1,
+    JSON.stringify(rejoined)
+  );
+  check(
+    'P3 reconnect selected the successor (no generation-0 revival, no new row)',
+    rejoined[0].id === successor.id &&
+      rejoined[0].resetGeneration === originalGeneration + 1,
+    JSON.stringify(rejoined[0])
+  );
+
+  // P4: rename (M1.8) + read-back.
+  const newName = `e2e renamed ${Date.now()}`;
+  const rename = runCli([
+    'node',
+    'rename',
+    newName,
+    '--node',
+    successor.id,
+    '--linzumi-url',
+    serverUrl,
+    '--token',
+    token,
+  ]);
+  check('P4 rename exits 0', rename.code === 0, rename.stderr);
+  const renamed = nodeList().find((node) => node.id === successor.id);
+  check(
+    'P4 list read-back shows the new name',
+    renamed?.name === newName,
+    JSON.stringify(renamed)
+  );
+} finally {
+  rmSync(stateRoot, { recursive: true, force: true });
+  rmSync(workDir, { recursive: true, force: true });
+}
+
+if (failures.length > 0) {
+  console.error(`\n${failures.length} property(ies) FAILED`);
+  process.exit(1);
+}
+console.log('\nAll compute-node CLI acceptance properties PASSED');