@matheusbbarni/atelier 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matheus B. Barni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,16 @@
+# @matheusbbarni/atelier
+
+Global npm distribution for the `atelier` CLI.
+
+```sh
+npm install -g @matheusbbarni/atelier
+atelier --doctor
+atelier
+```
+
+This package contains a small JavaScript launcher. The native executable is
+provided by a platform-specific optional dependency selected by npm for macOS,
+glibc Linux, or Windows on arm64/x64.
+
+Installation does not initialize configuration, probe credentials, or start the
+TUI. Run `atelier --doctor` after installation to inspect runtime readiness.

package/bin/atelier.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+
+const { main } = require("../lib/launcher.cjs");
+
+main();

package/lib/launcher.cjs

@@ -0,0 +1,134 @@
+"use strict";
+
+const { spawn } = require("node:child_process");
+const os = require("node:os");
+const {
+  TARGETS,
+  supportedTargetKeys,
+  targetForPlatform,
+} = require("./targets.cjs");
+
+function unsupportedPlatformMessage(platform, arch, libc) {
+  const libcSuffix = libc ? ` libc=${libc}` : "";
+  return [
+    `unsupported platform: platform=${platform} arch=${arch}${libcSuffix}`,
+    `supported targets: ${supportedTargetKeys().join(", ")}`,
+    "Download a native archive from GitHub Releases or build from source with Cargo.",
+  ].join("\n");
+}
+
+function missingOptionalDependencyMessage(target) {
+  return [
+    `missing optional dependency for ${target.key}`,
+    `expected package: ${target.packageName}`,
+    "Optional dependencies may have been omitted by npm configuration.",
+    "Reinstall with: npm install -g @matheusbbarni/atelier --include=optional",
+  ].join("\n");
+}
+
+function resolveBinary({
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+  libc,
+  requireResolve = require.resolve,
+} = {}) {
+  if (env.ATELIER_BINARY_PATH && env.ATELIER_BINARY_PATH.trim() !== "") {
+    return {
+      binaryPath: env.ATELIER_BINARY_PATH,
+      target: null,
+      overridden: true,
+    };
+  }
+
+  const target = targetForPlatform(platform, arch, libc);
+  if (!target) {
+    throw new Error(unsupportedPlatformMessage(platform, arch, libc));
+  }
+
+  try {
+    return {
+      binaryPath: requireResolve(`${target.packageName}/${target.binPath}`),
+      target,
+      overridden: false,
+    };
+  } catch (error) {
+    if (error && error.code === "MODULE_NOT_FOUND") {
+      throw new Error(missingOptionalDependencyMessage(target));
+    }
+    throw error;
+  }
+}
+
+function exitCodeForSignal(signal) {
+  const signalNumber = os.constants.signals?.[signal];
+  return typeof signalNumber === "number" ? 128 + signalNumber : 1;
+}
+
+function spawnBinary({
+  binaryPath,
+  argv = process.argv.slice(2),
+  env = process.env,
+  cwd = process.cwd(),
+  spawnImpl = spawn,
+  exit = process.exit,
+  stderr = process.stderr,
+}) {
+  const child = spawnImpl(binaryPath, argv, {
+    cwd,
+    env,
+    stdio: "inherit",
+  });
+
+  child.on("error", (error) => {
+    stderr.write(`atelier launcher failed to start native binary: ${error.message}\n`);
+    exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    exit(code ?? exitCodeForSignal(signal));
+  });
+
+  return child;
+}
+
+function main({
+  argv = process.argv.slice(2),
+  env = process.env,
+  cwd = process.cwd(),
+  platform = process.platform,
+  arch = process.arch,
+  libc,
+  requireResolve = require.resolve,
+  spawnImpl = spawn,
+  exit = process.exit,
+  stderr = process.stderr,
+} = {}) {
+  let resolved;
+  try {
+    resolved = resolveBinary({ env, platform, arch, libc, requireResolve });
+  } catch (error) {
+    stderr.write(`atelier launcher error:\n${error.message}\n`);
+    exit(1);
+    return null;
+  }
+
+  return spawnBinary({
+    binaryPath: resolved.binaryPath,
+    argv,
+    env,
+    cwd,
+    spawnImpl,
+    exit,
+    stderr,
+  });
+}
+
+module.exports = {
+  TARGETS,
+  main,
+  missingOptionalDependencyMessage,
+  resolveBinary,
+  spawnBinary,
+  unsupportedPlatformMessage,
+};

package/lib/targets.cjs

@@ -0,0 +1,108 @@
+"use strict";
+
+const PACKAGE_SCOPE = "@matheusbbarni";
+const TOP_LEVEL_PACKAGE = `${PACKAGE_SCOPE}/atelier`;
+
+const TARGETS = Object.freeze({
+  "darwin-arm64": Object.freeze({
+    key: "darwin-arm64",
+    os: "darwin",
+    cpu: "arm64",
+    exe: "atelier",
+    archive: "tar.gz",
+    packageName: `${PACKAGE_SCOPE}/atelier-darwin-arm64`,
+    binPath: "bin/atelier",
+  }),
+  "darwin-x64": Object.freeze({
+    key: "darwin-x64",
+    os: "darwin",
+    cpu: "x64",
+    exe: "atelier",
+    archive: "tar.gz",
+    packageName: `${PACKAGE_SCOPE}/atelier-darwin-x64`,
+    binPath: "bin/atelier",
+  }),
+  "linux-arm64": Object.freeze({
+    key: "linux-arm64",
+    os: "linux",
+    cpu: "arm64",
+    libc: "glibc",
+    exe: "atelier",
+    archive: "tar.gz",
+    packageName: `${PACKAGE_SCOPE}/atelier-linux-arm64`,
+    binPath: "bin/atelier",
+  }),
+  "linux-x64": Object.freeze({
+    key: "linux-x64",
+    os: "linux",
+    cpu: "x64",
+    libc: "glibc",
+    exe: "atelier",
+    archive: "tar.gz",
+    packageName: `${PACKAGE_SCOPE}/atelier-linux-x64`,
+    binPath: "bin/atelier",
+  }),
+  "win32-arm64": Object.freeze({
+    key: "win32-arm64",
+    os: "win32",
+    cpu: "arm64",
+    exe: "atelier.exe",
+    archive: "zip",
+    packageName: `${PACKAGE_SCOPE}/atelier-win32-arm64`,
+    binPath: "bin/atelier.exe",
+  }),
+  "win32-x64": Object.freeze({
+    key: "win32-x64",
+    os: "win32",
+    cpu: "x64",
+    exe: "atelier.exe",
+    archive: "zip",
+    packageName: `${PACKAGE_SCOPE}/atelier-win32-x64`,
+    binPath: "bin/atelier.exe",
+  }),
+});
+
+function supportedTargetKeys() {
+  return Object.keys(TARGETS);
+}
+
+function detectLibc(proc = process) {
+  if (proc.platform !== "linux") {
+    return undefined;
+  }
+  const report = proc.report?.getReport?.();
+  const header = report?.header ?? {};
+  if (header.glibcVersionRuntime || header.glibcVersionCompiler) {
+    return "glibc";
+  }
+  return "unknown";
+}
+
+function targetKeyFor(platform = process.platform, arch = process.arch, libc) {
+  const runtimeLibc = platform === "linux" ? libc ?? detectLibc() : undefined;
+  for (const target of Object.values(TARGETS)) {
+    if (target.os !== platform || target.cpu !== arch) {
+      continue;
+    }
+    if (target.libc && runtimeLibc !== target.libc) {
+      continue;
+    }
+    return target.key;
+  }
+  return null;
+}
+
+function targetForPlatform(platform = process.platform, arch = process.arch, libc) {
+  const key = targetKeyFor(platform, arch, libc);
+  return key ? TARGETS[key] : null;
+}
+
+module.exports = {
+  PACKAGE_SCOPE,
+  TOP_LEVEL_PACKAGE,
+  TARGETS,
+  detectLibc,
+  supportedTargetKeys,
+  targetForPlatform,
+  targetKeyFor,
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@matheusbbarni/atelier",
+  "version": "0.1.0",
+  "description": "Terminal-native agent orchestration harness",
+  "license": "MIT",
+  "bin": {
+    "atelier": "bin/atelier.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MatheusBBarni/atelier.git"
+  },
+  "homepage": "https://github.com/MatheusBBarni/atelier#readme",
+  "bugs": {
+    "url": "https://github.com/MatheusBBarni/atelier/issues"
+  },
+  "optionalDependencies": {
+    "@matheusbbarni/atelier-darwin-arm64": "0.1.0",
+    "@matheusbbarni/atelier-darwin-x64": "0.1.0",
+    "@matheusbbarni/atelier-linux-arm64": "0.1.0",
+    "@matheusbbarni/atelier-linux-x64": "0.1.0",
+    "@matheusbbarni/atelier-win32-arm64": "0.1.0",
+    "@matheusbbarni/atelier-win32-x64": "0.1.0"
+  }
+}