tessl 0.0.0 → 0.63.2

package/LICENSE.md

@@ -0,0 +1,3 @@
+Copyright 2025 Tessl. All rights reserved.
+This software is proprietary to Tessl and is subject to Tessl's Terms of Service (see: https://tessl.io/policies/terms).
+Unauthorized reproduction or distribution is prohibited.

package/README.md

@@ -1,5 +1,33 @@
-Coming soon.
+# Tessl
 
-Please follow the early access instructions you were provided with. 
+Tessl is an Agent Enablement Platform that gives your agents the context they're missing.
 
-http://tessl.io
+- Install usage docs for your favorite open source library from the Tessl Spec Registry
+- Create your own internal docs and share with your team 
+
+**Explore more in our [official documentation](https://docs.tessl.io)**.
+
+Visit the [Registry](https://tessl.io/registry) to see which open source libraries we provide documentation for.
+
+## Get started
+
+1. Install Tessl:
+
+```sh
+curl -fsSL https://get.tessl.io | sh
+```
+
+2. Now in your project directory run `tessl`
+
+## Reporting Bugs
+
+We love feedback. You can use the `tessl feedback` command to report issues or share feedback directly within Tessl, file a [GitHub issue](https://github.com/tesslio/cli/issues) or just email <support@tessl.io>.
+
+## Connect on Discord
+
+You are welcome to join the [Tessl Discord](https://tessl.co/4eV736y) to connect with other developers using Tessl.
+
+## Terms and Conditions
+
+- [Terms of Service](https://tessl.io/policies/terms)
+- [Privacy Policy](https://tessl.io/policies/privacy-cookies)

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.2";
+  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,8 +1,18 @@
 {
   "name": "tessl",
-  "version": "0.0.0",
-  "description": "",
-  "readme": "README.md",
-  "homepage": "https://tessl.io",
-  "license": "UNLICENSED"
+  "version": "0.63.2",
+  "description": "Tessl CLI",
+  "author": "Tessl",
+  "license": "SEE LICENSE.md",
+  "type": "module",
+  "bin": {
+    "tessl": "bin/tessl.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {}
 }