@tessl/cli 0.62.1 → 0.63.0

package/bin/tessl.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+
+// installer/src/main.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { createInterface } from "node:readline";
+
+// installer/src/channels.ts
+async function fetchLatestVersion(channel) {
+  const url = getChannelUrl(channel);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch version from ${url}: ${response.status} ${response.statusText}`);
+  }
+  const version = (await response.text()).trim();
+  if (!version) {
+    throw new Error(`Empty version returned from ${url}`);
+  }
+  return version;
+}
+function getChannelFromVersion(version) {
+  if (version.includes("head"))
+    return "head";
+  if (version.includes("nightly"))
+    return "nightly";
+  if (version.includes("beta"))
+    return "beta";
+  return "latest";
+}
+function getChannelUrl(channel) {
+  const baseUrl = process.env.TESSL_INSTALL_BASE_URL || "https://install.tessl.io";
+  return `${baseUrl}/.well-known/tessl/${channel}.txt`;
+}
+function getBinaryUrl(version, platform) {
+  const baseUrl = process.env.TESSL_INSTALL_BASE_URL || "https://install.tessl.io";
+  const encodedVersion = encodeURIComponent(version);
+  return `${baseUrl}/binaries/${encodedVersion}/tessl-${encodedVersion}-${platform}.tar.gz`;
+}
+
+// installer/src/download.ts
+async function downloadTarball(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download binary: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  return response.body;
+}
+
+// installer/src/extract.ts
+import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+async function extractTarball(stream, destination) {
+  await mkdir(destination, { recursive: true });
+  const tar = spawn("tar", ["-xzf", "-", "-C", destination], {
+    stdio: ["pipe", "inherit", "inherit"]
+  });
+  if (!tar.stdin) {
+    throw new Error("Failed to open tar stdin");
+  }
+  const tarExit = new Promise((resolve, reject) => {
+    tar.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`tar exited with code ${code}`));
+      }
+    });
+    tar.on("error", reject);
+  });
+  await pipeline(stream, tar.stdin);
+  await tarExit;
+}
+
+// installer/src/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getXdgDataHome() {
+  return process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+function getSymlinkPath() {
+  return join(homedir(), ".local", "bin", "tessl");
+}
+function getVersionsDirectory() {
+  return join(getXdgDataHome(), "tessl", "versions");
+}
+function getBinaryPath(version, platform) {
+  return join(getVersionsDirectory(), `tessl-${version}-${platform}`);
+}
+
+// installer/src/platform.ts
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+function getLibcVariant() {
+  if (process.platform !== "linux")
+    return null;
+  try {
+    if (existsSync("/etc/alpine-release"))
+      return "musl";
+  } catch {}
+  try {
+    const lddOutput = execSync("ldd /bin/ls 2>/dev/null", {
+      encoding: "utf-8"
+    });
+    if (lddOutput.includes("musl"))
+      return "musl";
+  } catch {}
+  return "glibc";
+}
+function getPlatformString() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    if (arch === "arm64")
+      return "darwin-arm64";
+    if (arch === "x64")
+      return "darwin-x64";
+  }
+  if (platform === "linux") {
+    const variant = getLibcVariant();
+    if (arch === "x64") {
+      return variant === "musl" ? "linux-x64-musl" : "linux-x64";
+    }
+    if (arch === "arm64") {
+      return variant === "musl" ? "linux-arm64-musl" : "linux-arm64";
+    }
+  }
+  return null;
+}
+function getPlatformDescription() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const platformNames = {
+    darwin: "macOS",
+    linux: "Linux",
+    win32: "Windows"
+  };
+  const archNames = {
+    arm64: "ARM64",
+    x64: "x64",
+    ia32: "x86"
+  };
+  const platformName = platformNames[platform] ?? platform;
+  const archName = archNames[arch] ?? arch;
+  return `${platformName} ${archName}`;
+}
+
+// installer/src/spawn.ts
+import { spawn as spawn2 } from "node:child_process";
+function spawnBinary(binaryPath, args) {
+  const child = spawn2(binaryPath, args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      TESSL_MANAGED_BY_NPM: "1"
+    }
+  });
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const handlers = new Map;
+  for (const signal of signals) {
+    const handler = () => {
+      child.kill(signal);
+    };
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      for (const [sig, handler] of handlers) {
+        process.removeListener(sig, handler);
+      }
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 1);
+    }
+  });
+  child.on("error", (err) => {
+    console.error(`Failed to spawn binary: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// installer/src/symlink.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { symlink, rename, unlink, mkdir as mkdir2, readlink } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+async function getExistingBinaryPath(symlinkPath) {
+  if (!existsSync2(symlinkPath)) {
+    return null;
+  }
+  try {
+    const binaryPath = await readlink(symlinkPath);
+    const resolvedPath = resolve(dirname(symlinkPath), binaryPath);
+    if (!existsSync2(resolvedPath)) {
+      return null;
+    }
+    return resolvedPath;
+  } catch {
+    return null;
+  }
+}
+async function createSymlinkAtomic(target, linkPath) {
+  const tempPath = `${linkPath}.tmp`;
+  await mkdir2(dirname(linkPath), { recursive: true });
+  try {
+    await unlink(tempPath);
+  } catch {}
+  await symlink(target, tempPath);
+  await rename(tempPath, linkPath);
+}
+
+// installer/src/main.ts
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function promptConfirmation(message) {
+  return new Promise((resolve2) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${message} (Y/n) `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      resolve2(a === "" || a === "y");
+    });
+  });
+}
+function printUnsupportedPlatformMessage() {
+  console.error("Error: Unsupported platform", getPlatformDescription());
+  console.error(`Tessl CLI binaries are available for:
+    - macOS (ARM64, x64)
+    - Linux (x64, ARM64)
+  `);
+}
+async function prepareBinary() {
+  const symlinkPath = getSymlinkPath();
+  const symlinkTarget = await getExistingBinaryPath(symlinkPath);
+  const installerVersion = "0.63.0";
+  const isTestOrDevBuild = installerVersion.includes("test") || installerVersion.includes("dev");
+  let symlinkMismatch = false;
+  if (isTestOrDevBuild && symlinkTarget) {
+    const platform2 = getPlatformString();
+    if (!platform2) {
+      printUnsupportedPlatformMessage();
+      return process.exit(1);
+    }
+    if (symlinkTarget !== getBinaryPath(installerVersion, platform2)) {
+      console.log(`Test/dev build - switching to version: ${installerVersion}`);
+      symlinkMismatch = true;
+    }
+  }
+  if (symlinkTarget && !symlinkMismatch) {
+    return symlinkPath;
+  }
+  const platform = getPlatformString();
+  if (!platform) {
+    printUnsupportedPlatformMessage();
+    return process.exit(1);
+  }
+  const version = isTestOrDevBuild ? installerVersion : await fetchLatestVersion(getChannelFromVersion(installerVersion));
+  const binaryPath = getBinaryPath(version, platform);
+  if (existsSync3(binaryPath)) {
+    return binaryPath;
+  }
+  console.log(`Downloading ${version} for ${platform}`);
+  const url = getBinaryUrl(version, platform);
+  const progressInterval = setInterval(() => process.stdout.write("."), 500).unref();
+  try {
+    const tarballStream = await downloadTarball(url);
+    const versionsDir = getVersionsDirectory();
+    await extractTarball(tarballStream, versionsDir);
+  } finally {
+    clearInterval(progressInterval);
+    console.log("");
+  }
+  const shouldCreateSymlink = !isInteractive() || await promptConfirmation(`Install Tessl CLI to ${symlinkPath}?`);
+  if (shouldCreateSymlink) {
+    await createSymlinkAtomic(binaryPath, symlinkPath);
+    if (platform.includes("musl")) {
+      console.log(`
+This system requires libgcc and libstdc++. Install these using your distribution's package manager.
+On Alpine: apk add libgcc libstdc++
+`);
+    }
+    return symlinkPath;
+  }
+  return binaryPath;
+}
+async function main() {
+  const path = await prepareBinary();
+  spawnBinary(path, process.argv.slice(2));
+}
+main().catch((err) => {
+  console.error("Unexpected error:");
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,38 +1,18 @@
 {
   "name": "@tessl/cli",
-  "version": "0.62.1",
-  "description": "Tessl CLI - Registry and workspace operations with MCP support",
+  "version": "0.63.0",
+  "description": "Tessl CLI",
   "author": "Tessl",
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE.md",
   "type": "module",
-  "main": "src/main.js",
   "bin": {
-    "tessl": "src/main.js"
+    "tessl": "bin/tessl.js"
   },
   "files": [
-    "src/main.js"
+    "bin"
   ],
   "engines": {
     "node": ">=20"
   },
-  "dependencies": {
-    "better-sqlite3": "12.6.2",
-    "pino": "10.3.0",
-    "pino-pretty": "13.1.3",
-    "pino-opentelemetry-transport": "2.0.0",
-    "atomic-sleep": "1.0.0",
-    "@opentelemetry/api-logs": "0.211.0",
-    "@opentelemetry/sdk-logs": "0.211.0",
-    "@opentelemetry/exporter-logs-otlp-http": "0.211.0",
-    "@opentelemetry/exporter-logs-otlp-proto": "0.211.0",
-    "@opentelemetry/exporter-trace-otlp-http": "0.211.0",
-    "@opentelemetry/otlp-transformer": "0.211.0",
-    "@opentelemetry/semantic-conventions": "1.39.0",
-    "@opentelemetry/sdk-metrics": "2.5.0",
-    "@opentelemetry/api": "1.9.0",
-    "@opentelemetry/instrumentation-undici": "0.21.0",
-    "@opentelemetry/resources": "2.5.0",
-    "@opentelemetry/sdk-node": "0.211.0",
-    "@opentelemetry/sdk-trace-node": "2.5.0"
-  }
+  "dependencies": {}
 }