@linzumi/cli 1.0.241 → 1.0.243

package/dist/impl-ts/native/darwin/manifest.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "sourceSha256": "7c168456109138578f8fa5fd3bc380f9fa3a6befdffde5ecc534d2ed8ab16a87",
+  "buildScriptSha256": "52eaf6b1a76cb6df19d572f939f712ea582915c8172989914b9b9febdd64012a",
+  "binarySha256": "ae41488f097db1fec1714ecb6399107d0b8d0c9281544364ae93efd927ed4d4f",
+  "architectures": ["arm64", "x86_64"],
+  "flags": [
+    "-std=c11",
+    "-Wall",
+    "-Wextra",
+    "-Werror",
+    "-Os",
+    "-arch",
+    "arm64",
+    "-arch",
+    "x86_64",
+    "-mmacosx-version-min=11.0"
+  ],
+  "compiler": "Apple clang version 21.0.0 (clang-2100.1.1.101)",
+  "sdkVersion": "26.5"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.241",
+  "version": "1.0.243",
   "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/build.mjs

@@ -8,13 +8,114 @@ import {
   readFile,
   rm,
   writeFile,
+  mkdtemp,
+  stat,
+  chmod,
 } from 'node:fs/promises';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { build } from 'esbuild';
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 
+// Spec: plans/2026-09-06-preview-cold-watcher-reproduction.md.
+// Native source changes use the existing Darwin build host, not an end-user
+// compiler or Linux cross-build. Normal builds verify/copy the immutable asset.
+const identitySource = join(packageRoot, 'scripts/preview-process-identity.c');
+const identityAsset = join(
+  packageRoot,
+  'native/darwin/preview-process-identity'
+);
+const identityManifestPath = join(packageRoot, 'native/darwin/manifest.json');
+const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const nativeFlags = [
+  '-std=c11',
+  '-Wall',
+  '-Wextra',
+  '-Werror',
+  '-Os',
+  '-arch',
+  'arm64',
+  '-arch',
+  'x86_64',
+  '-mmacosx-version-min=11.0',
+];
+const nativeInputs = {
+  sourceSha256: digest(await readFile(identitySource)),
+  buildScriptSha256: digest(await readFile(fileURLToPath(import.meta.url))),
+};
+if (
+  process.argv.includes('--build-preview-identity') ||
+  process.argv.includes('--check-preview-identity')
+) {
+  if (process.platform !== 'darwin')
+    throw new Error('preview_identity_build_requires_darwin');
+  const dir = await mkdtemp(join(tmpdir(), 'linzumi-preview-identity-'));
+  const output = join(dir, 'preview-process-identity');
+  execFileSync(
+    'xcrun',
+    ['clang', ...nativeFlags, identitySource, '-o', output],
+    { stdio: 'inherit' }
+  );
+  const architectures = execFileSync('lipo', ['-archs', output], {
+    encoding: 'utf8',
+  })
+    .trim()
+    .split(/\s+/)
+    .sort();
+  if (JSON.stringify(architectures) !== '["arm64","x86_64"]')
+    throw new Error('preview_identity_architectures_invalid');
+  const manifest = {
+    version: 1,
+    ...nativeInputs,
+    binarySha256: digest(await readFile(output)),
+    architectures,
+    flags: nativeFlags,
+    compiler: execFileSync('xcrun', ['clang', '--version'], {
+      encoding: 'utf8',
+    }).split('\n')[0],
+    sdkVersion: execFileSync('xcrun', ['--show-sdk-version'], {
+      encoding: 'utf8',
+    }).trim(),
+  };
+  if (process.argv.includes('--check-preview-identity')) {
+    const prior = JSON.parse(await readFile(identityManifestPath, 'utf8'));
+    if (
+      JSON.stringify(prior) !== JSON.stringify(manifest) ||
+      digest(await readFile(identityAsset)) !== manifest.binarySha256 ||
+      ((await stat(identityAsset)).mode & 0o777) !== 0o755
+    )
+      throw new Error('preview_identity_rebuild_mismatch');
+  } else {
+    await mkdir(dirname(identityAsset), { recursive: true });
+    await copyFile(output, identityAsset);
+    await chmod(identityAsset, 0o755);
+    await writeFile(
+      identityManifestPath,
+      `${JSON.stringify(manifest, null, 2)}\n`
+    );
+  }
+  console.log(JSON.stringify({ ...manifest, buildDirectory: dir }));
+  process.exit(0);
+}
+const nativeManifest = JSON.parse(await readFile(identityManifestPath, 'utf8'));
+if (
+  nativeManifest.version !== 1 ||
+  nativeManifest.sourceSha256 !== nativeInputs.sourceSha256 ||
+  nativeManifest.buildScriptSha256 !== nativeInputs.buildScriptSha256 ||
+  nativeManifest.binarySha256 !== digest(await readFile(identityAsset)) ||
+  JSON.stringify(nativeManifest.architectures) !== '["arm64","x86_64"]' ||
+  JSON.stringify(nativeManifest.flags) !== JSON.stringify(nativeFlags) ||
+  typeof nativeManifest.compiler !== 'string' ||
+  typeof nativeManifest.sdkVersion !== 'string' ||
+  ((await stat(identityAsset)).mode & 0o777) !== 0o755
+)
+  throw new Error('preview_identity_packaged_asset_invalid');
+
+const { build } = await import('esbuild');
+
 // Spec: plans/2026-08-17-tcp-tunnel-cli.spec.md. The zero-TS tunnel command
 // is a mandatory ReScript build input, not a fail-soft optional rung.
 const tcpTunnelCliEntry = join(
@@ -32,6 +133,18 @@ const packageVersion = JSON.parse(
 ).version;
 
 await rm(join(packageRoot, 'dist'), { recursive: true, force: true });
+for (const implementation of ['impl-ts', 'impl-res']) {
+  const destination = join(
+    packageRoot,
+    'dist',
+    implementation,
+    'native/darwin'
+  );
+  await mkdir(destination, { recursive: true });
+  await copyFile(identityAsset, join(destination, 'preview-process-identity'));
+  await chmod(join(destination, 'preview-process-identity'), 0o755);
+  await copyFile(identityManifestPath, join(destination, 'manifest.json'));
+}
 
 // Renamed banner import (the build-auth-parity-oracle.mjs convention, made
 // load-bearing by prod RCA 2026-07-20): esbuild injects banners VERBATIM -

package/scripts/preview-process-identity.c

@@ -0,0 +1,45 @@
+/* Spec: plans/2026-05-20-commander-port-watchers-worker-descendants.md.
+ * Recovery operator 2026-09-06: read only the requested process incarnation.
+ * No arguments, environment, signal, attachment, or privileged operations. */
+#include <errno.h>
+#include <inttypes.h>
+#include <libproc.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  if (argc != 2) { fputs("preview_identity_pid_required\n", stderr); return 2; }
+  errno = 0;
+  char *end = NULL;
+  long parsed = strtol(argv[1], &end, 10);
+  if (errno || !end || *end || parsed <= 1 || parsed > INT32_MAX) {
+    fputs("preview_identity_pid_invalid\n", stderr); return 2;
+  }
+  struct proc_bsdinfo info = {0};
+  int size = proc_pidinfo((int)parsed, PROC_PIDTBSDINFO, 0, &info, sizeof(info));
+  if (size != sizeof(info) || info.pbi_pid != (uint32_t)parsed) {
+    fputs("preview_identity_process_unavailable\n", stderr); return 3;
+  }
+  if (info.pbi_uid != getuid()) {
+    fputs("preview_identity_foreign_uid\n", stderr); return 4;
+  }
+  char boot[64] = {0};
+  size_t boot_size = sizeof(boot);
+  if (sysctlbyname("kern.bootsessionuuid", boot, &boot_size, NULL, 0) != 0 || boot_size < 2 || boot_size > sizeof(boot)) {
+    fputs("preview_identity_boot_unavailable\n", stderr); return 5;
+  }
+  for (size_t i = 0; i < boot_size - 1; i++) {
+    char ch = boot[i];
+    if (!((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f') || ch == '-')) {
+      fputs("preview_identity_boot_invalid\n", stderr); return 5;
+    }
+  }
+  if (boot[boot_size - 1] != '\0') { fputs("preview_identity_boot_invalid\n", stderr); return 5; }
+  printf("{\"pid\":%u,\"uid\":%u,\"birth\":\"%" PRIu64 ":%" PRIu64 "\",\"boot\":\"%s\"}\n",
+         info.pbi_pid, info.pbi_uid, info.pbi_start_tvsec, info.pbi_start_tvusec,
+         boot);
+  return 0;
+}