inferay 0.0.1 → 0.1.1

package/README.md

@@ -1,3 +1,34 @@
 # inferay
 
-Placeholder npm package reserved for the Inferay name.
+Command-line installer and launcher for Inferay.
+
+```sh
+npx inferay
+```
+
+The package is intentionally small. It does not contain the desktop app. It resolves the right release asset, opens the installer, launches an installed app, and runs setup checks.
+
+## Commands
+
+```sh
+inferay                 # install or launch Inferay
+inferay .               # open the current folder
+inferay install         # download/open the latest release installer
+inferay install --local ./build/stable-macos-arm64/inferay.app
+inferay launch ~/code   # open a workspace
+inferay doctor          # check user setup
+inferay doctor --dev    # check contributor setup
+inferay update          # show latest release asset
+inferay channel nightly # switch release channel
+```
+
+## Development
+
+Contributors should work from the source repo:
+
+```sh
+bun install
+bun run dev
+```
+
+Users should not need Bun or a source checkout.

package/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from "./src/cli.js";
+
+main(process.argv).catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`inferay: ${message}`);
+	process.exitCode = 1;
+});

package/package.json

@@ -1,14 +1,22 @@
 {
 	"name": "inferay",
-	"version": "0.0.1",
-	"description": "Placeholder package for the Inferay name.",
+	"version": "0.1.1",
+	"description": "Command-line installer and launcher for Inferay.",
 	"type": "module",
 	"main": "./index.js",
 	"exports": "./index.js",
+	"bin": {
+		"inferay": "cli.js"
+	},
 	"files": [
 		"index.js",
+		"cli.js",
+		"src",
 		"README.md"
 	],
+	"engines": {
+		"node": ">=18"
+	},
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"

package/src/cli.js

@@ -0,0 +1,135 @@
+import { install } from "./install.js";
+import { launchApp } from "./launch.js";
+import { doctor } from "./doctor.js";
+import { getChannel, setChannel } from "./config.js";
+import { fetchRelease, findAsset } from "./releases.js";
+import { platformInfo } from "./platform.js";
+
+const VERSION = "0.1.1";
+
+function printHelp() {
+	console.log(`inferay ${VERSION}
+
+Usage:
+  inferay                 Install or launch Inferay
+  inferay .               Open the current folder in Inferay
+  inferay <path>          Open a folder in Inferay
+  inferay install         Install Inferay from the latest release
+  inferay install --local <app>
+  inferay launch [path]   Launch Inferay with a workspace
+  inferay update          Re-run the release installer
+  inferay doctor [--dev]  Check local setup
+  inferay channel [name]  Show or set release channel
+  inferay version         Print CLI version
+
+Channels:
+  stable, nightly, dev
+`);
+}
+
+function optionValue(args, name) {
+	const index = args.indexOf(name);
+	if (index === -1) {
+		return null;
+	}
+	return args[index + 1] || null;
+}
+
+async function printDoctor(args) {
+	const checks = await doctor({ dev: args.includes("--dev") });
+	for (const [label, value] of checks) {
+		console.log(`${label.padEnd(18)} ${value}`);
+	}
+}
+
+async function update() {
+	const channel = await getChannel();
+	const release = await fetchRelease(channel);
+	const asset = findAsset(release, platformInfo());
+	if (!asset) {
+		throw new Error(
+			`no installable asset found for ${release.tag_name || channel}`
+		);
+	}
+	console.log(
+		`Latest ${channel}: ${release.tag_name || release.name || "unknown"}`
+	);
+	console.log(`Asset: ${asset.name}`);
+	console.log("Run `inferay install` to download and open the installer.");
+}
+
+async function installAndReport(args) {
+	const local = optionValue(args, "--local");
+	const result = await install({ local });
+	console.log(result.message);
+}
+
+export async function main(argv) {
+	const args = argv.slice(2);
+	const command = args[0];
+
+	if (
+		!command ||
+		command === "." ||
+		(!command.startsWith("-") && !isKnownCommand(command))
+	) {
+		const target = command || process.cwd();
+		try {
+			await launchApp(target);
+		} catch (error) {
+			if (command && command !== ".") {
+				throw error;
+			}
+			const result = await install();
+			console.log(result.message);
+		}
+		return;
+	}
+
+	switch (command) {
+		case "--help":
+		case "-h":
+		case "help":
+			printHelp();
+			return;
+		case "--version":
+		case "-v":
+		case "version":
+			console.log(VERSION);
+			return;
+		case "install":
+			await installAndReport(args);
+			return;
+		case "launch":
+			await launchApp(args[1] || process.cwd());
+			return;
+		case "doctor":
+			await printDoctor(args);
+			return;
+		case "update":
+			await update();
+			return;
+		case "channel":
+			if (!args[1]) {
+				console.log(await getChannel());
+			} else {
+				await setChannel(args[1]);
+				console.log(`Channel set to ${args[1]}`);
+			}
+			return;
+		default:
+			throw new Error(`unknown command "${command}". Run \`inferay --help\`.`);
+	}
+}
+
+function isKnownCommand(command) {
+	return new Set([
+		"help",
+		"install",
+		"launch",
+		"doctor",
+		"update",
+		"channel",
+		"version",
+	]).has(command);
+}

package/src/config.js

@@ -0,0 +1,39 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export const CONFIG_DIR = join(homedir(), ".inferay");
+export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export async function readConfig() {
+	try {
+		return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
+	} catch (error) {
+		if (error?.code === "ENOENT") {
+			return {};
+		}
+		throw error;
+	}
+}
+
+export async function writeConfig(config) {
+	await mkdir(dirname(CONFIG_PATH), { recursive: true });
+	await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+export async function getChannel() {
+	const config = await readConfig();
+	return config.channel || "stable";
+}
+
+export async function setChannel(channel) {
+	const allowed = new Set(["stable", "nightly", "dev"]);
+	if (!allowed.has(channel)) {
+		throw new Error(
+			`unknown channel "${channel}". Use stable, nightly, or dev.`
+		);
+	}
+	const config = await readConfig();
+	config.channel = channel;
+	await writeConfig(config);
+}

package/src/doctor.js

@@ -0,0 +1,84 @@
+import { access, readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { getChannel, CONFIG_PATH } from "./config.js";
+import { findExistingApp, platformInfo } from "./platform.js";
+import { releaseApiUrl, releaseRepo } from "./releases.js";
+
+async function canAccess(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function commandExists(command) {
+	const result = spawnSync("which", [command], { encoding: "utf8" });
+	return result.status === 0 ? result.stdout.trim() : null;
+}
+
+async function appVersion(appPath) {
+	if (!appPath) {
+		return null;
+	}
+	const plist = join(appPath, "Contents/Info.plist");
+	if (!existsSync(plist)) {
+		return null;
+	}
+	const result = spawnSync(
+		"/usr/libexec/PlistBuddy",
+		["-c", "Print :CFBundleShortVersionString", plist],
+		{
+			encoding: "utf8",
+		}
+	);
+	return result.status === 0 ? result.stdout.trim() : null;
+}
+
+export async function doctor({ dev = false } = {}) {
+	const platform = platformInfo();
+	const appPath = findExistingApp();
+	const version = await appVersion(appPath);
+	const channel = await getChannel();
+	const checks = [
+		[
+			"Platform",
+			`${platform.os}-${platform.cpu}${platform.supported ? "" : " (unsupported)"}`,
+		],
+		["Release repo", releaseRepo()],
+		["Release metadata", releaseApiUrl(channel)],
+		["Channel", channel],
+		[
+			"Config",
+			(await canAccess(CONFIG_PATH)) ? CONFIG_PATH : "not created yet",
+		],
+		["Installed app", appPath || "not found"],
+		["Installed version", version || "unknown"],
+		["Claude CLI", commandExists("claude") || "not found"],
+		["Codex CLI", commandExists("codex") || "not found"],
+	];
+
+	if (dev) {
+		checks.push(["Bun", commandExists("bun") || "not found"]);
+		checks.push(["Git", commandExists("git") || "not found"]);
+		checks.push([
+			"package.json",
+			(await canAccess(join(process.cwd(), "package.json")))
+				? "found"
+				: "not found",
+		]);
+		try {
+			const packageJson = JSON.parse(
+				await readFile(join(process.cwd(), "package.json"), "utf8")
+			);
+			checks.push(["Project", packageJson.name || "unknown"]);
+		} catch {
+			checks.push(["Project", "unknown"]);
+		}
+	}
+
+	return checks;
+}

package/src/install.js

@@ -0,0 +1,76 @@
+import { cp, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { getChannel } from "./config.js";
+import {
+	defaultInstallPath,
+	findExistingApp,
+	platformInfo,
+} from "./platform.js";
+import { downloadAsset, fetchRelease, findAsset } from "./releases.js";
+import { openFile } from "./launch.js";
+
+async function copyAppBundle(source, destination = defaultInstallPath()) {
+	if (!source.endsWith(".app")) {
+		throw new Error("local install source must be a .app bundle");
+	}
+	await mkdir(dirname(destination), { recursive: true });
+	await cp(source, destination, { recursive: true, force: true });
+	return destination;
+}
+
+export async function install({ local, launch = true } = {}) {
+	const platform = platformInfo();
+	if (!platform.supported) {
+		throw new Error(`unsupported platform ${platform.os}-${platform.cpu}`);
+	}
+
+	if (local) {
+		const source = resolve(local);
+		if (!existsSync(source)) {
+			throw new Error(`local app not found: ${source}`);
+		}
+		const destination = await copyAppBundle(source);
+		return {
+			kind: "local-app",
+			message: `Installed ${basename(source)} to ${destination}`,
+			installedPath: destination,
+		};
+	}
+
+	const existing = findExistingApp();
+	if (existing) {
+		return {
+			kind: "already-installed",
+			message: `Inferay is already available at ${existing}`,
+			installedPath: existing,
+		};
+	}
+
+	const channel = await getChannel();
+	const release = await fetchRelease(channel);
+	const asset = findAsset(release, platform);
+	if (!asset) {
+		throw new Error(
+			`no ${platform.target} release asset found for ${release.tag_name || channel}`
+		);
+	}
+
+	const downloadedPath = await downloadAsset(asset);
+	if (downloadedPath.endsWith(".dmg")) {
+		if (launch) {
+			await openFile(downloadedPath);
+		}
+		return {
+			kind: "dmg",
+			message: `Downloaded ${asset.name}. Drag Inferay to Applications from the opened DMG.`,
+			downloadedPath,
+		};
+	}
+
+	return {
+		kind: "downloaded",
+		message: `Downloaded ${asset.name} to ${downloadedPath}`,
+		downloadedPath,
+	};
+}

package/src/launch.js

@@ -0,0 +1,39 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+	defaultInstallPath,
+	findExistingApp,
+	platformInfo,
+} from "./platform.js";
+
+function run(command, args) {
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(command, args, { stdio: "inherit" });
+		child.on("error", reject);
+		child.on("exit", (code) => {
+			if (code === 0) {
+				resolvePromise();
+			} else {
+				reject(new Error(`${command} exited with code ${code}`));
+			}
+		});
+	});
+}
+
+export async function launchApp(targetPath = process.cwd()) {
+	const platform = platformInfo();
+	if (platform.os !== "macos") {
+		throw new Error("launch is currently supported on macOS only");
+	}
+	const appPath = findExistingApp() || defaultInstallPath();
+	if (!existsSync(appPath)) {
+		throw new Error("Inferay is not installed. Run `inferay install` first.");
+	}
+	const cwd = resolve(targetPath);
+	await run("open", ["-a", appPath, "--args", "--cwd", cwd]);
+}
+
+export async function openFile(filePath) {
+	await run("open", [filePath]);
+}

package/src/platform.js

@@ -0,0 +1,37 @@
+import { existsSync } from "node:fs";
+import { platform, arch, homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export function platformInfo() {
+	const os = platform();
+	const cpu = arch();
+	if (os !== "darwin") {
+		return { os, cpu, supported: false, target: `${os}-${cpu}` };
+	}
+	const mappedArch = cpu === "arm64" ? "arm64" : cpu === "x64" ? "x64" : cpu;
+	return {
+		os: "macos",
+		cpu: mappedArch,
+		supported: mappedArch === "arm64" || mappedArch === "x64",
+		target: `macos-${mappedArch}`,
+	};
+}
+
+export function defaultInstallPath() {
+	return "/Applications/inferay.app";
+}
+
+export function devAppCandidates(cwd = process.cwd()) {
+	return [
+		resolve(cwd, "build/dev-macos-arm64/inferay-dev.app"),
+		resolve(cwd, "build/dev-macos-arm64/inferay.app"),
+		resolve(cwd, "build/stable-macos-arm64/inferay.app"),
+		resolve(cwd, "build/macos-arm64/inferay.app"),
+		join(homedir(), "Applications/inferay.app"),
+		defaultInstallPath(),
+	];
+}
+
+export function findExistingApp(cwd = process.cwd()) {
+	return devAppCandidates(cwd).find((candidate) => existsSync(candidate));
+}

package/src/releases.js

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { tmpdir } from "node:os";
+
+const DEFAULT_REPO = "raymondreaming/inferay";
+
+export function releaseRepo() {
+	return process.env.INFERAY_RELEASE_REPO || DEFAULT_REPO;
+}
+
+export function releaseApiUrl(channel = "stable") {
+	const repo = releaseRepo();
+	if (process.env.INFERAY_RELEASE_URL) {
+		return process.env.INFERAY_RELEASE_URL;
+	}
+	if (channel === "stable") {
+		return `https://api.github.com/repos/${repo}/releases/latest`;
+	}
+	return `https://api.github.com/repos/${repo}/releases/tags/${channel}`;
+}
+
+export async function fetchRelease(channel = "stable") {
+	const response = await fetch(releaseApiUrl(channel), {
+		headers: {
+			accept: "application/vnd.github+json",
+			"user-agent": "inferay-cli",
+		},
+	});
+	if (!response.ok) {
+		throw new Error(`could not fetch release metadata (${response.status})`);
+	}
+	return response.json();
+}
+
+export function findAsset(release, platform) {
+	const assets = Array.isArray(release.assets) ? release.assets : [];
+	const target = platform.target;
+	const preferred = [
+		(asset) => asset.name?.includes(target) && asset.name?.endsWith(".dmg"),
+		(asset) =>
+			asset.name?.includes(platform.os) &&
+			asset.name?.includes(platform.cpu) &&
+			asset.name?.endsWith(".dmg"),
+		(asset) => asset.name?.endsWith(".dmg"),
+		(asset) => asset.name?.includes(target) && asset.name?.endsWith(".tar.zst"),
+	];
+	return preferred.map((matcher) => assets.find(matcher)).find(Boolean);
+}
+
+export function findChecksumAsset(release) {
+	const assets = Array.isArray(release.assets) ? release.assets : [];
+	return assets.find((asset) => /checksums?\.txt$/i.test(asset.name || ""));
+}
+
+export async function downloadAsset(asset) {
+	if (!asset?.browser_download_url) {
+		throw new Error("release asset is missing a download URL");
+	}
+	const cacheDir = join(tmpdir(), "inferay-downloads");
+	await mkdir(cacheDir, { recursive: true });
+	const destination = join(cacheDir, asset.name);
+	const response = await fetch(asset.browser_download_url, {
+		headers: { "user-agent": "inferay-cli" },
+	});
+	if (!response.ok || !response.body) {
+		throw new Error(`could not download ${asset.name} (${response.status})`);
+	}
+	await pipeline(response.body, createWriteStream(destination));
+	return destination;
+}
+
+export async function sha256(filePath) {
+	const hash = createHash("sha256");
+	const file = await readFile(filePath);
+	hash.update(file);
+	return hash.digest("hex");
+}
+
+export async function verifyChecksum(filePath, expected) {
+	if (!expected) {
+		return null;
+	}
+	const actual = await sha256(filePath);
+	if (actual !== expected) {
+		throw new Error(`checksum mismatch for ${filePath}`);
+	}
+	return actual;
+}