@lark-codem/codem-core 0.8.9 → 0.8.11

package/LICENSE

@@ -1,6 +1,6 @@
-© Lark Technologies Pte. Ltd. All rights reserved. Use is subject to the Legal Agreements outlined here:
-
-Feishu User Terms of Service [https://www.feishu.cn/terms]
-Feishu Privacy Policy [https://www.feishu.cn/privacy]
-
-Copyright (c) 2026 Lark Technologies Pte. Ltd.
+© Lark Technologies Pte. Ltd. All rights reserved. Use is subject to the Legal Agreements outlined here:
+
+Feishu User Terms of Service [https://www.feishu.cn/terms]
+Feishu Privacy Policy [https://www.feishu.cn/privacy]
+
+Copyright (c) 2026 Lark Technologies Pte. Ltd.

package/bin/lib/control-fd.js

@@ -1,63 +1,63 @@
-"use strict";
-
-// codem-bridge launches linco with FOUR stdio slots, not three:
-//
-//   stdio: ["inherit", "inherit", "inherit", "pipe"]   (codem-bridge linco-runner.js)
-//            \______ the terminal ______/    \_ the /space control channel
-//
-// fd 3 is an out-of-band channel: on a `/space` selection linco writes one NDJSON
-// line to it so codem-bridge can persist the chosen project without polluting the
-// TUI's screen. The host announces the fd number via `CODEM_PROJECT_CHANNEL_FD`.
-//
-// This shim sits BETWEEN the two processes, and `stdio: "inherit"` is shorthand for
-// ["inherit","inherit","inherit"] — exactly three slots. It therefore dropped fd 3
-// on the floor while still forwarding the env var that advertises it, so linco kept
-// writing to a fd the exec'd process no longer held (ENXIO, not EBADF: libuv fills
-// unlisted slots with an unusable placeholder rather than leaving them closed).
-//
-// All three layers then failed quietly — linco's writer is best-effort and only
-// `tracing::warn!`s, and on the host side an idle pipe is indistinguishable from
-// "an old linco that never writes fd 3" (codem-bridge says so in a comment). Net
-// effect: `/space` reported success and the selection was silently lost.
-//
-// SCOPE — unix only. linco's writer is a `#[cfg(not(unix))]` no-op on Windows
-// (crates/linco-cli/src/space_channel.rs), so there is nothing to forward there and
-// no reason to perturb Windows process creation.
-
-/// The env var through which codem-bridge advertises the control fd.
-const CONTROL_FD_ENV = "CODEM_PROJECT_CHANNEL_FD";
-
-/// stdio for a plain interactive run: the terminal and nothing else.
-const TERMINAL_STDIO = ["inherit", "inherit", "inherit"];
-
-/// Parse the advertised fd, or null when there is nothing to forward.
-///
-/// Only fd 3 is expressible here: `stdio` slots are positional, so the 4th entry
-/// IS fd 3. A host asking for fd 4+ cannot be honoured by appending one entry, and
-/// silently forwarding the wrong fd would be worse than not forwarding at all.
-function controlFdFromEnv(env) {
-  const raw = env && env[CONTROL_FD_ENV];
-  if (typeof raw !== "string") {
-    return null;
-  }
-  const trimmed = raw.trim();
-  // Number.parseInt would accept "3x"/"3.5"; the host writes a bare integer.
-  if (!/^-?\d+$/.test(trimmed)) {
-    return null;
-  }
-  return Number.parseInt(trimmed, 10) === 3 ? 3 : null;
-}
-
-/// Build the stdio array to hand the platform binary. Returns a fresh array —
-/// `launch` mutates it when degrading after an EBADF.
-function buildStdio({ env = process.env, platform = process.platform } = {}) {
-  if (platform === "win32") {
-    return TERMINAL_STDIO.slice();
-  }
-  if (controlFdFromEnv(env) === null) {
-    return TERMINAL_STDIO.slice();
-  }
-  return [...TERMINAL_STDIO, "inherit"];
-}
-
-module.exports = { buildStdio, controlFdFromEnv, CONTROL_FD_ENV, TERMINAL_STDIO };
+"use strict";
+
+// codem-bridge launches linco with FOUR stdio slots, not three:
+//
+//   stdio: ["inherit", "inherit", "inherit", "pipe"]   (codem-bridge linco-runner.js)
+//            \______ the terminal ______/    \_ the /space control channel
+//
+// fd 3 is an out-of-band channel: on a `/space` selection linco writes one NDJSON
+// line to it so codem-bridge can persist the chosen project without polluting the
+// TUI's screen. The host announces the fd number via `CODEM_PROJECT_CHANNEL_FD`.
+//
+// This shim sits BETWEEN the two processes, and `stdio: "inherit"` is shorthand for
+// ["inherit","inherit","inherit"] — exactly three slots. It therefore dropped fd 3
+// on the floor while still forwarding the env var that advertises it, so linco kept
+// writing to a fd the exec'd process no longer held (ENXIO, not EBADF: libuv fills
+// unlisted slots with an unusable placeholder rather than leaving them closed).
+//
+// All three layers then failed quietly — linco's writer is best-effort and only
+// `tracing::warn!`s, and on the host side an idle pipe is indistinguishable from
+// "an old linco that never writes fd 3" (codem-bridge says so in a comment). Net
+// effect: `/space` reported success and the selection was silently lost.
+//
+// SCOPE — unix only. linco's writer is a `#[cfg(not(unix))]` no-op on Windows
+// (crates/linco-cli/src/space_channel.rs), so there is nothing to forward there and
+// no reason to perturb Windows process creation.
+
+/// The env var through which codem-bridge advertises the control fd.
+const CONTROL_FD_ENV = "CODEM_PROJECT_CHANNEL_FD";
+
+/// stdio for a plain interactive run: the terminal and nothing else.
+const TERMINAL_STDIO = ["inherit", "inherit", "inherit"];
+
+/// Parse the advertised fd, or null when there is nothing to forward.
+///
+/// Only fd 3 is expressible here: `stdio` slots are positional, so the 4th entry
+/// IS fd 3. A host asking for fd 4+ cannot be honoured by appending one entry, and
+/// silently forwarding the wrong fd would be worse than not forwarding at all.
+function controlFdFromEnv(env) {
+  const raw = env && env[CONTROL_FD_ENV];
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const trimmed = raw.trim();
+  // Number.parseInt would accept "3x"/"3.5"; the host writes a bare integer.
+  if (!/^-?\d+$/.test(trimmed)) {
+    return null;
+  }
+  return Number.parseInt(trimmed, 10) === 3 ? 3 : null;
+}
+
+/// Build the stdio array to hand the platform binary. Returns a fresh array —
+/// `launch` mutates it when degrading after an EBADF.
+function buildStdio({ env = process.env, platform = process.platform } = {}) {
+  if (platform === "win32") {
+    return TERMINAL_STDIO.slice();
+  }
+  if (controlFdFromEnv(env) === null) {
+    return TERMINAL_STDIO.slice();
+  }
+  return [...TERMINAL_STDIO, "inherit"];
+}
+
+module.exports = { buildStdio, controlFdFromEnv, CONTROL_FD_ENV, TERMINAL_STDIO };

package/bin/lib/detect-target.js

@@ -1,65 +1,65 @@
-"use strict";
-
-const fs = require("node:fs");
-
-function normalizeArch(arch) {
-  switch (arch) {
-    case "x64":
-    case "arm64":
-      return arch;
-    case "ia32":
-      return "ia32";
-    default:
-      throw new Error(`Unsupported architecture: ${arch}`);
-  }
-}
-
-function detectLinuxLibc() {
-  if (process.report && typeof process.report.getReport === "function") {
-    try {
-      const report = process.report.getReport();
-      if (report && report.header && report.header.glibcVersionRuntime) {
-        return "gnu";
-      }
-    } catch {
-      // fall through to fs probes
-    }
-  }
-
-  const muslProbes = [
-    "/lib/ld-musl-x86_64.so.1",
-    "/lib/ld-musl-aarch64.so.1",
-    "/lib/ld-musl-i386.so.1",
-  ];
-  for (const probe of muslProbes) {
-    if (fs.existsSync(probe)) {
-      return "musl";
-    }
-  }
-
-  return "gnu";
-}
-
-function detectTarget(host = process, env = process.env) {
-  if (env && typeof env.LINCO_NPM_TARGET === "string" && env.LINCO_NPM_TARGET.trim()) {
-    return env.LINCO_NPM_TARGET.trim();
-  }
-
-  const platform = host.platform;
-  const arch = normalizeArch(host.arch);
-
-  if (platform === "darwin") {
-    return `darwin-${arch}`;
-  }
-  if (platform === "linux") {
-    const libc = host.libc || detectLinuxLibc();
-    return `linux-${arch}-${libc}`;
-  }
-  if (platform === "win32") {
-    return `win32-${arch}-msvc`;
-  }
-
-  throw new Error(`Unsupported platform: ${platform}`);
-}
-
-module.exports = { detectTarget, normalizeArch, detectLinuxLibc };
+"use strict";
+
+const fs = require("node:fs");
+
+function normalizeArch(arch) {
+  switch (arch) {
+    case "x64":
+    case "arm64":
+      return arch;
+    case "ia32":
+      return "ia32";
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+}
+
+function detectLinuxLibc() {
+  if (process.report && typeof process.report.getReport === "function") {
+    try {
+      const report = process.report.getReport();
+      if (report && report.header && report.header.glibcVersionRuntime) {
+        return "gnu";
+      }
+    } catch {
+      // fall through to fs probes
+    }
+  }
+
+  const muslProbes = [
+    "/lib/ld-musl-x86_64.so.1",
+    "/lib/ld-musl-aarch64.so.1",
+    "/lib/ld-musl-i386.so.1",
+  ];
+  for (const probe of muslProbes) {
+    if (fs.existsSync(probe)) {
+      return "musl";
+    }
+  }
+
+  return "gnu";
+}
+
+function detectTarget(host = process, env = process.env) {
+  if (env && typeof env.LINCO_NPM_TARGET === "string" && env.LINCO_NPM_TARGET.trim()) {
+    return env.LINCO_NPM_TARGET.trim();
+  }
+
+  const platform = host.platform;
+  const arch = normalizeArch(host.arch);
+
+  if (platform === "darwin") {
+    return `darwin-${arch}`;
+  }
+  if (platform === "linux") {
+    const libc = host.libc || detectLinuxLibc();
+    return `linux-${arch}-${libc}`;
+  }
+  if (platform === "win32") {
+    return `win32-${arch}-msvc`;
+  }
+
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+
+module.exports = { detectTarget, normalizeArch, detectLinuxLibc };

package/bin/lib/launch.js

@@ -1,106 +1,106 @@
-"use strict";
-
-// Spawning the platform binary, with the two failure modes that actually reach
-// users spelled out.
-//
-// WHY THIS IS NOT JUST `spawn(...)` + `child.on("error")`:
-// `child_process.spawn` reports ENOENT asynchronously (via the "error" event) but
-// throws SYNCHRONOUSLY for every other errno — see the `throw new ErrnoException(err,
-// 'spawn')` in node:internal/child_process. An `on("error")` handler therefore cannot
-// observe an EACCES/EBADF/UNKNOWN failure, and the user gets a raw Node stack trace
-// naming an internal file instead of a sentence about their own machine. Both paths
-// must funnel into the same reporter.
-
-const { TERMINAL_STDIO } = require("./control-fd");
-
-/// Human-readable follow-up for the errnos we can actually say something useful
-/// about. Anything else falls through to the bare message.
-function hintsFor(code, platform, binary) {
-  switch (code) {
-    case "UNKNOWN":
-      // libuv's catch-all for Win32 errors it has no mapping for. The common
-      // cause in the field is CreateProcessW being denied by security software
-      // (ERROR_VIRUS_INFECTED / ERROR_VIRUS_DELETED have no libuv mapping).
-      return platform === "win32"
-        ? [
-            "On Windows this usually means antivirus or endpoint security software blocked",
-            "the executable, or the file on disk is damaged. Run it directly to see the",
-            "underlying OS error:",
-            `  & "${binary}" --version`,
-          ]
-        : null;
-    case "ENOENT":
-      return [
-        "The platform binary is missing. Reinstall it with:",
-        "  npm install --include=optional @lark-codem/codem-core",
-      ];
-    case "EACCES":
-      return [
-        "The platform binary is not executable. Check its file permissions:",
-        `  ls -l "${binary}"`,
-      ];
-    default:
-      return null;
-  }
-}
-
-function reportFatal({ error, binary, platform, stderr, exit }) {
-  stderr(`linco: failed to launch ${binary}`);
-  stderr(`  ${error && error.message ? error.message : String(error)}`);
-  const hints = hintsFor(error && error.code, platform, binary);
-  if (hints) {
-    for (const line of hints) {
-      stderr(`  ${line}`);
-    }
-  }
-  exit(1);
-}
-
-/// Spawn the platform binary. Returns the child process, or undefined when the
-/// launch failed (the caller has already been told via `exit`).
-///
-/// `stdio` may carry a 4th slot for codem-bridge's /space control fd. If the host
-/// advertised that fd but did not actually pass it, spawning fails with EBADF —
-/// degrade to the terminal-only trio and start anyway rather than refusing to run
-/// over a non-essential side channel.
-function launch({
-  binary,
-  args,
-  stdio,
-  platform = process.platform,
-  spawnImpl = require("node:child_process").spawn,
-  stderr = (line) => console.error(line),
-  exit = (code) => process.exit(code),
-}) {
-  const attempt = (stdioForAttempt) =>
-    spawnImpl(binary, args, { stdio: stdioForAttempt, windowsHide: true });
-
-  let child;
-  try {
-    child = attempt(stdio);
-  } catch (error) {
-    if (stdio.length > 3 && error && error.code === "EBADF") {
-      stderr(
-        "linco: the host advertised a /space control fd it did not pass; continuing without it"
-      );
-      try {
-        child = attempt(TERMINAL_STDIO.slice());
-      } catch (retryError) {
-        reportFatal({ error: retryError, binary, platform, stderr, exit });
-        return undefined;
-      }
-    } else {
-      reportFatal({ error, binary, platform, stderr, exit });
-      return undefined;
-    }
-  }
-
-  // ENOENT lands here instead of in the catch above.
-  child.on("error", (error) => {
-    reportFatal({ error, binary, platform, stderr, exit });
-  });
-
-  return child;
-}
-
-module.exports = { launch, hintsFor };
+"use strict";
+
+// Spawning the platform binary, with the two failure modes that actually reach
+// users spelled out.
+//
+// WHY THIS IS NOT JUST `spawn(...)` + `child.on("error")`:
+// `child_process.spawn` reports ENOENT asynchronously (via the "error" event) but
+// throws SYNCHRONOUSLY for every other errno — see the `throw new ErrnoException(err,
+// 'spawn')` in node:internal/child_process. An `on("error")` handler therefore cannot
+// observe an EACCES/EBADF/UNKNOWN failure, and the user gets a raw Node stack trace
+// naming an internal file instead of a sentence about their own machine. Both paths
+// must funnel into the same reporter.
+
+const { TERMINAL_STDIO } = require("./control-fd");
+
+/// Human-readable follow-up for the errnos we can actually say something useful
+/// about. Anything else falls through to the bare message.
+function hintsFor(code, platform, binary) {
+  switch (code) {
+    case "UNKNOWN":
+      // libuv's catch-all for Win32 errors it has no mapping for. The common
+      // cause in the field is CreateProcessW being denied by security software
+      // (ERROR_VIRUS_INFECTED / ERROR_VIRUS_DELETED have no libuv mapping).
+      return platform === "win32"
+        ? [
+            "On Windows this usually means antivirus or endpoint security software blocked",
+            "the executable, or the file on disk is damaged. Run it directly to see the",
+            "underlying OS error:",
+            `  & "${binary}" --version`,
+          ]
+        : null;
+    case "ENOENT":
+      return [
+        "The platform binary is missing. Reinstall it with:",
+        "  npm install --include=optional @lark-codem/codem-core",
+      ];
+    case "EACCES":
+      return [
+        "The platform binary is not executable. Check its file permissions:",
+        `  ls -l "${binary}"`,
+      ];
+    default:
+      return null;
+  }
+}
+
+function reportFatal({ error, binary, platform, stderr, exit }) {
+  stderr(`linco: failed to launch ${binary}`);
+  stderr(`  ${error && error.message ? error.message : String(error)}`);
+  const hints = hintsFor(error && error.code, platform, binary);
+  if (hints) {
+    for (const line of hints) {
+      stderr(`  ${line}`);
+    }
+  }
+  exit(1);
+}
+
+/// Spawn the platform binary. Returns the child process, or undefined when the
+/// launch failed (the caller has already been told via `exit`).
+///
+/// `stdio` may carry a 4th slot for codem-bridge's /space control fd. If the host
+/// advertised that fd but did not actually pass it, spawning fails with EBADF —
+/// degrade to the terminal-only trio and start anyway rather than refusing to run
+/// over a non-essential side channel.
+function launch({
+  binary,
+  args,
+  stdio,
+  platform = process.platform,
+  spawnImpl = require("node:child_process").spawn,
+  stderr = (line) => console.error(line),
+  exit = (code) => process.exit(code),
+}) {
+  const attempt = (stdioForAttempt) =>
+    spawnImpl(binary, args, { stdio: stdioForAttempt, windowsHide: true });
+
+  let child;
+  try {
+    child = attempt(stdio);
+  } catch (error) {
+    if (stdio.length > 3 && error && error.code === "EBADF") {
+      stderr(
+        "linco: the host advertised a /space control fd it did not pass; continuing without it"
+      );
+      try {
+        child = attempt(TERMINAL_STDIO.slice());
+      } catch (retryError) {
+        reportFatal({ error: retryError, binary, platform, stderr, exit });
+        return undefined;
+      }
+    } else {
+      reportFatal({ error, binary, platform, stderr, exit });
+      return undefined;
+    }
+  }
+
+  // ENOENT lands here instead of in the catch above.
+  child.on("error", (error) => {
+    reportFatal({ error, binary, platform, stderr, exit });
+  });
+
+  return child;
+}
+
+module.exports = { launch, hintsFor };

package/bin/lib/resolve-binary.js

@@ -1,64 +1,64 @@
-"use strict";
-
-// Windows release binaries are currently cross-compiled from macOS via
-// cargo-zigbuild, which can only produce *-pc-windows-gnu artifacts. The
-// canonical npm target on Windows stays win32-<arch>-msvc (preferred when a
-// Windows-host MSVC build is published); when that platform package is
-// absent we fall back to the sibling win32-<arch>-gnu package.
-const TARGET_FALLBACKS = {
-  "win32-x64-msvc": ["win32-x64-gnu"],
-  "win32-arm64-msvc": ["win32-arm64-gnu"],
-  "win32-ia32-msvc": ["win32-ia32-gnu"],
-};
-
-function packageNameForTarget(target) {
-  return `@lark-codem/codem-core-${target}`;
-}
-
-function binaryNameForTarget(target) {
-  return target.startsWith("win32-") ? "codem-core.exe" : "codem-core";
-}
-
-function resolvePlatformBinary(target, options = {}) {
-  const req = options.require || require;
-  const paths = options.paths;
-  const candidates = [target, ...(TARGET_FALLBACKS[target] || [])];
-
-  let lastNotFound;
-  for (const candidate of candidates) {
-    const request = `${packageNameForTarget(candidate)}/${binaryNameForTarget(candidate)}`;
-    try {
-      if (paths) {
-        return req.resolve(request, { paths });
-      }
-      return req.resolve(request);
-    } catch (error) {
-      if (error && error.code === "MODULE_NOT_FOUND") {
-        lastNotFound = error;
-        continue;
-      }
-      throw error;
-    }
-  }
-
-  const packageName = packageNameForTarget(target);
-  const helpLines = [
-    `linco: platform package ${packageName} is not installed.`,
-  ];
-  if (candidates.length > 1) {
-    const fallbacks = candidates.slice(1).map(packageNameForTarget).join(", ");
-    helpLines.push(`Also tried fallback package(s): ${fallbacks}.`);
-  }
-  helpLines.push(
-    "This usually means optionalDependencies were skipped during install.",
-    "Try one of:",
-    "  - reinstall with optional deps:  npm install --include=optional @lark-codem/codem-core",
-    `  - override target:               LINCO_NPM_TARGET=<other-target> (current: ${target})`
-  );
-  const wrapped = new Error(helpLines.join("\n"));
-  wrapped.code = "LINCO_PLATFORM_PACKAGE_MISSING";
-  wrapped.cause = lastNotFound;
-  throw wrapped;
-}
-
-module.exports = { resolvePlatformBinary };
+"use strict";
+
+// Windows release binaries are currently cross-compiled from macOS via
+// cargo-zigbuild, which can only produce *-pc-windows-gnu artifacts. The
+// canonical npm target on Windows stays win32-<arch>-msvc (preferred when a
+// Windows-host MSVC build is published); when that platform package is
+// absent we fall back to the sibling win32-<arch>-gnu package.
+const TARGET_FALLBACKS = {
+  "win32-x64-msvc": ["win32-x64-gnu"],
+  "win32-arm64-msvc": ["win32-arm64-gnu"],
+  "win32-ia32-msvc": ["win32-ia32-gnu"],
+};
+
+function packageNameForTarget(target) {
+  return `@lark-codem/codem-core-${target}`;
+}
+
+function binaryNameForTarget(target) {
+  return target.startsWith("win32-") ? "codem-core.exe" : "codem-core";
+}
+
+function resolvePlatformBinary(target, options = {}) {
+  const req = options.require || require;
+  const paths = options.paths;
+  const candidates = [target, ...(TARGET_FALLBACKS[target] || [])];
+
+  let lastNotFound;
+  for (const candidate of candidates) {
+    const request = `${packageNameForTarget(candidate)}/${binaryNameForTarget(candidate)}`;
+    try {
+      if (paths) {
+        return req.resolve(request, { paths });
+      }
+      return req.resolve(request);
+    } catch (error) {
+      if (error && error.code === "MODULE_NOT_FOUND") {
+        lastNotFound = error;
+        continue;
+      }
+      throw error;
+    }
+  }
+
+  const packageName = packageNameForTarget(target);
+  const helpLines = [
+    `linco: platform package ${packageName} is not installed.`,
+  ];
+  if (candidates.length > 1) {
+    const fallbacks = candidates.slice(1).map(packageNameForTarget).join(", ");
+    helpLines.push(`Also tried fallback package(s): ${fallbacks}.`);
+  }
+  helpLines.push(
+    "This usually means optionalDependencies were skipped during install.",
+    "Try one of:",
+    "  - reinstall with optional deps:  npm install --include=optional @lark-codem/codem-core",
+    `  - override target:               LINCO_NPM_TARGET=<other-target> (current: ${target})`
+  );
+  const wrapped = new Error(helpLines.join("\n"));
+  wrapped.code = "LINCO_PLATFORM_PACKAGE_MISSING";
+  wrapped.cause = lastNotFound;
+  throw wrapped;
+}
+
+module.exports = { resolvePlatformBinary };

package/bin/linco

@@ -1,74 +1,74 @@
-#!/usr/bin/env node
-"use strict";
-
-const fs = require("node:fs");
-const { detectTarget } = require("./lib/detect-target");
-const { resolvePlatformBinary } = require("./lib/resolve-binary");
-const { buildStdio } = require("./lib/control-fd");
-const { launch } = require("./lib/launch");
-
-function main() {
-  let target;
-  try {
-    target = detectTarget();
-  } catch (error) {
-    console.error(`linco: ${error.message}`);
-    console.error("Hint: set LINCO_NPM_TARGET to override platform detection.");
-    process.exit(1);
-  }
-
-  let binary;
-  try {
-    binary = resolvePlatformBinary(target);
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-
-  try {
-    fs.chmodSync(binary, 0o755);
-  } catch {
-    // best-effort
-  }
-
-  // Not a bare `stdio: "inherit"`: that is three slots and would drop the /space
-  // control fd codem-bridge passes as fd 3. See lib/control-fd.js.
-  const child = launch({
-    binary,
-    args: process.argv.slice(2),
-    stdio: buildStdio(),
-  });
-  if (!child) {
-    // launch() already reported the failure and called exit(1).
-    return;
-  }
-
-  const forwardSignal = (signal) => {
-    try {
-      child.kill(signal);
-    } catch {
-      // child may already be exiting
-    }
-  };
-  const signalHandlers = {
-    SIGINT: () => forwardSignal("SIGINT"),
-    SIGTERM: () => forwardSignal("SIGTERM"),
-    SIGHUP: () => forwardSignal("SIGHUP"),
-  };
-  for (const [name, handler] of Object.entries(signalHandlers)) {
-    process.on(name, handler);
-  }
-
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      for (const [name, handler] of Object.entries(signalHandlers)) {
-        process.off(name, handler);
-      }
-      process.kill(process.pid, signal);
-      return;
-    }
-    process.exit(code ?? 0);
-  });
-}
-
-main();
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const { detectTarget } = require("./lib/detect-target");
+const { resolvePlatformBinary } = require("./lib/resolve-binary");
+const { buildStdio } = require("./lib/control-fd");
+const { launch } = require("./lib/launch");
+
+function main() {
+  let target;
+  try {
+    target = detectTarget();
+  } catch (error) {
+    console.error(`linco: ${error.message}`);
+    console.error("Hint: set LINCO_NPM_TARGET to override platform detection.");
+    process.exit(1);
+  }
+
+  let binary;
+  try {
+    binary = resolvePlatformBinary(target);
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+
+  try {
+    fs.chmodSync(binary, 0o755);
+  } catch {
+    // best-effort
+  }
+
+  // Not a bare `stdio: "inherit"`: that is three slots and would drop the /space
+  // control fd codem-bridge passes as fd 3. See lib/control-fd.js.
+  const child = launch({
+    binary,
+    args: process.argv.slice(2),
+    stdio: buildStdio(),
+  });
+  if (!child) {
+    // launch() already reported the failure and called exit(1).
+    return;
+  }
+
+  const forwardSignal = (signal) => {
+    try {
+      child.kill(signal);
+    } catch {
+      // child may already be exiting
+    }
+  };
+  const signalHandlers = {
+    SIGINT: () => forwardSignal("SIGINT"),
+    SIGTERM: () => forwardSignal("SIGTERM"),
+    SIGHUP: () => forwardSignal("SIGHUP"),
+  };
+  for (const [name, handler] of Object.entries(signalHandlers)) {
+    process.on(name, handler);
+  }
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      for (const [name, handler] of Object.entries(signalHandlers)) {
+        process.off(name, handler);
+      }
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-codem/codem-core",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "description": "CodeM CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "bin": {
@@ -11,12 +11,12 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@lark-codem/codem-core-darwin-arm64": "0.8.9",
-    "@lark-codem/codem-core-darwin-x64": "0.8.9",
-    "@lark-codem/codem-core-linux-x64-gnu": "0.8.9",
-    "@lark-codem/codem-core-linux-arm64-gnu": "0.8.9",
-    "@lark-codem/codem-core-win32-arm64-gnu": "0.8.9",
-    "@lark-codem/codem-core-win32-x64-msvc": "0.8.9"
+    "@lark-codem/codem-core-darwin-arm64": "0.8.11",
+    "@lark-codem/codem-core-darwin-x64": "0.8.11",
+    "@lark-codem/codem-core-linux-x64-gnu": "0.8.11",
+    "@lark-codem/codem-core-linux-arm64-gnu": "0.8.11",
+    "@lark-codem/codem-core-win32-arm64-gnu": "0.8.11",
+    "@lark-codem/codem-core-win32-x64-msvc": "0.8.11"
   },
   "engines": {
     "node": ">=18"