@cyberxon/xon 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# xoncli
+
+A small CLI for creating Xon projects and managing deployment requests.
+
+## Install
+
+The package is published to GitHub Packages (private to this repo, not the public npm
+registry) as `@balakrishnagujju/xon`. One-time setup per machine — add a GitHub
+personal access token with the `read:packages` scope to your npm config:
+
+```sh
+echo "@balakrishnagujju:registry=https://npm.pkg.github.com" >> ~/.npmrc
+echo "//npm.pkg.github.com/:_authToken=<your GitHub token>" >> ~/.npmrc
+```
+
+Then install globally, same as any other CLI:
+
+```sh
+npm install -g @balakrishnagujju/xon
+```
+
+The executable installed is `xon`.
+
+### Alternative: clone + link
+
+If you don't want to set up a GitHub token, you can still run it from a checkout:
+
+```sh
+git clone https://github.com/balakrishnagujju/xoncli.git
+cd xoncli
+npm install
+npm link
+```
+
+> `npm install -g git+https://...` looks tempting but is unreliable on current npm —
+> it can link the package to npm's internal cache tmp folder, which gets cleaned up
+> right after install and leaves `xon` broken. Use the GitHub Packages install above,
+> or clone + `npm link` — not the git URL form.
+
+**Contributing:** run `npm run build` and commit the resulting `dist/` changes
+alongside any `src/` edits — the repo has no CI to build it for you.
+
+**Publishing a new version:** bump `version` in `package.json`, then run
+`npm publish` from a machine with a GitHub token that has the `write:packages` scope
+configured the same way as above (with `write:packages` instead of `read:packages`).
+
+## Commands
+
+Create a project:
+
+```sh
+xon project create my-app
+xon project create my-app --directory ./workspace
+```
+
+Configure the API with `XON_BASE_URL` and optionally `XON_TOKEN`:
+
+```sh
+export XON_BASE_URL=https://api.example.com
+export XON_TOKEN=your-token
+```
+
+Create a deployment request. The file is sent unchanged as the JSON request body:
+
+```sh
+xon deploy create --file deploy-request.json
+```
+
+Or provide connection options per command:
+
+```sh
+xon deploy create --base-url https://api.example.com --token your-token --file deploy-request.json
+```
+
+Fetch a deployment request:
+
+```sh
+xon deploy get 123
+```
+
+Both API commands print the JSON response. Non-2xx responses are reported with their HTTP status and API message when available.

package/dist/api-client.js

@@ -0,0 +1,46 @@
+export class ApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+        this.name = "ApiError";
+    }
+}
+export class ApiClient {
+    baseUrl;
+    token;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.token = options.token;
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async get(path) {
+        return this.request("GET", path);
+    }
+    async request(method, path, body) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Accept: "application/json",
+                ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+                ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        });
+        const contentType = response.headers.get("content-type") ?? "";
+        const payload = contentType.includes("application/json")
+            ? await response.json()
+            : await response.text();
+        if (!response.ok) {
+            const message = typeof payload === "object" && payload !== null && "message" in payload
+                ? String(payload.message)
+                : `Request failed with status ${response.status}`;
+            throw new ApiError(message, response.status, payload);
+        }
+        return payload;
+    }
+}

package/dist/cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { Command, CommanderError } from "commander";
+import { ApiClient, ApiError } from "./api-client.js";
+import { createProject } from "./project.js";
+import { updateCli } from "./update.js";
+const program = new Command();
+function output(value) {
+    console.log(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+}
+function apiClient(options) {
+    const baseUrl = options.baseUrl ?? process.env.XON_BASE_URL;
+    if (!baseUrl) {
+        throw new Error("An API base URL is required. Set XON_BASE_URL or pass --base-url.");
+    }
+    return new ApiClient({ baseUrl, token: options.token ?? process.env.XON_TOKEN });
+}
+program
+    .name("xon")
+    .description("Manage Xon projects and deployments")
+    .version("0.1.0")
+    .showSuggestionAfterError();
+const project = program.command("project").description("Manage Xon projects");
+project
+    .command("create <name>")
+    .description("Create a new Xon project")
+    .option("-d, --directory <path>", "Directory to create the project in", ".")
+    .action(async (name, options) => {
+    const root = await createProject(options.directory, name);
+    console.log(`Created project ${name} in ${root}`);
+});
+program
+    .command("update")
+    .description("Update xon to the latest version")
+    .action(async () => {
+    await updateCli();
+});
+const deploy = program.command("deploy").description("Manage deployment requests");
+deploy
+    .command("create")
+    .description("Create a deployment request")
+    .requiredOption("-f, --file <path>", "Path to the deployment JSON payload")
+    .option("-b, --base-url <url>", "API base URL")
+    .option("-t, --token <token>", "Bearer token")
+    .action(async (options) => {
+    const payload = JSON.parse(await (await import("node:fs/promises")).readFile(options.file, "utf8"));
+    output(await apiClient(options).post("/deployRequests", payload));
+});
+deploy
+    .command("get <id>")
+    .description("Get a deployment request")
+    .option("-b, --base-url <url>", "API base URL")
+    .option("-t, --token <token>", "Bearer token")
+    .action(async (id, options) => {
+    output(await apiClient(options).get(`/deployRequests/${encodeURIComponent(id)}`));
+});
+program.parseAsync().catch((error) => {
+    if (error instanceof CommanderError) {
+        process.exitCode = error.exitCode;
+        return;
+    }
+    const message = error instanceof ApiError
+        ? `${error.message} (HTTP ${error.status})`
+        : error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+});

package/dist/project.js

@@ -0,0 +1,19 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+const projectFile = ".xon/project.json";
+export async function createProject(directory, name) {
+    const root = path.resolve(directory, name);
+    const config = {
+        name,
+        apiVersion: "v1",
+        createdAt: new Date().toISOString(),
+    };
+    await mkdir(path.join(root, ".xon"), { recursive: true });
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, projectFile), `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
+    return root;
+}
+export async function readProject(directory = ".") {
+    const contents = await readFile(path.resolve(directory, projectFile), "utf8");
+    return JSON.parse(contents);
+}

package/dist/update.js

@@ -0,0 +1,54 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+function packageRoot() {
+    const dist = path.dirname(fileURLToPath(import.meta.url));
+    return path.dirname(dist);
+}
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: "inherit" });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+        });
+    });
+}
+function captureOutput(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "inherit"] });
+        let output = "";
+        child.stdout.on("data", (chunk) => {
+            output += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve(output);
+            else
+                reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+        });
+    });
+}
+export async function updateCli() {
+    const root = packageRoot();
+    let status;
+    try {
+        status = await captureOutput("git", ["status", "--porcelain"], root);
+    }
+    catch {
+        throw new Error(`xon isn't installed from a git checkout at ${root}, so it can't self-update. ` +
+            "Reinstall following the README instructions.");
+    }
+    if (status.trim().length > 0) {
+        throw new Error(`xon has local changes in ${root}. Commit or stash them before updating.`);
+    }
+    console.log(`Updating xon in ${root}...`);
+    await run("git", ["pull", "--ff-only"], root);
+    await run("npm", ["install"], root);
+    await run("npm", ["run", "build"], root);
+    console.log("xon is up to date.");
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cyberxon/xon",
+  "version": "0.1.0",
+  "description": "A CLI for Xon projects and deployments",
+  "type": "module",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/balakrishnagujju/xoncli.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "xon": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "test": "node --test --import tsx test/**/*.test.ts"
+  },
+  "dependencies": {
+    "commander": "^14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0"
+  }
+}