@lark-codem/codem-core 0.7.61

package/LICENSE

@@ -0,0 +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.

package/bin/lib/detect-target.js

@@ -0,0 +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 };

package/bin/lib/resolve-binary.js

@@ -0,0 +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 };

package/bin/linco

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const { detectTarget } = require("./lib/detect-target");
+const { resolvePlatformBinary } = require("./lib/resolve-binary");
+
+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
+  }
+
+  const child = spawn(binary, process.argv.slice(2), {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  child.on("error", (error) => {
+    console.error(`linco: failed to spawn ${binary}: ${error.message}`);
+    process.exit(1);
+  });
+
+  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

@@ -0,0 +1,34 @@
+{
+  "name": "@lark-codem/codem-core",
+  "version": "0.7.61",
+  "description": "CodeM CLI.",
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "linco": "bin/linco"
+  },
+  "files": [
+    "bin/",
+    "LICENSE"
+  ],
+  "optionalDependencies": {
+    "@lark-codem/codem-core-darwin-arm64": "0.7.61",
+    "@lark-codem/codem-core-darwin-x64": "0.7.61",
+    "@lark-codem/codem-core-linux-arm64-gnu": "0.7.61",
+    "@lark-codem/codem-core-linux-arm64-musl": "0.7.61",
+    "@lark-codem/codem-core-linux-x64-gnu": "0.7.61",
+    "@lark-codem/codem-core-linux-x64-musl": "0.7.61",
+    "@lark-codem/codem-core-win32-arm64-gnu": "0.7.61",
+    "@lark-codem/codem-core-win32-arm64-msvc": "0.7.61",
+    "@lark-codem/codem-core-win32-ia32-gnu": "0.7.61",
+    "@lark-codem/codem-core-win32-ia32-msvc": "0.7.61",
+    "@lark-codem/codem-core-win32-x64-gnu": "0.7.61",
+    "@lark-codem/codem-core-win32-x64-msvc": "0.7.61"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  }
+}