@openagentsinc/pylon 0.1.0 → 0.1.1

package/README.md

@@ -1,13 +1,15 @@
 # `@openagentsinc/pylon`
 
 Bootstrap the latest tagged standalone `Pylon` release asset from GitHub
-Releases and run the first-run smoke path without Cargo.
+Releases, stream first-run status updates in the terminal, and open the Pylon
+terminal UI without Cargo.
 
 ## Usage
 
 ```bash
 npx @openagentsinc/pylon
-npx @openagentsinc/pylon --version 0.1.0
+npx @openagentsinc/pylon --version 0.0.1-rc3
+npx @openagentsinc/pylon --no-launch
 npx @openagentsinc/pylon --model gemma-4-e2b --diagnostic-repeats 2
 ```
 
@@ -20,9 +22,12 @@ The launcher:
 - downloads the archive and published SHA-256 checksum
 - verifies the checksum before extracting
 - caches the unpacked binaries under `~/.openagents/pylon/bootstrap/`
+- prints status lines such as release resolution, runtime checks, and local
+  model scanning while it runs
 - runs `pylon --help`, `init`, `status --json`, and `inventory --json`
 - runs `pylon gemma download <model>`
 - runs `pylon gemma diagnose <model> --json`
+- opens `pylon-tui` by default after the smoke path unless `--no-launch` is set
 
 ## Publish
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagentsinc/pylon",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Bootstrap the standalone OpenAgents Pylon release asset and run first-run smoke checks.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -6,6 +6,7 @@ import {
   DEFAULT_RELEASE_REPO,
   bootstrapInstalledPylon,
   ensureReleaseInstall,
+  launchInstalledPylonTui,
   renderBootstrapSummary,
 } from "./index.js";
 
@@ -17,6 +18,52 @@ function parseIntegerFlag(value, label) {
   return parsed;
 }
 
+function createTerminalStyles(enableColor) {
+  if (!enableColor) {
+    return {
+      bold: (value) => value,
+      cyan: (value) => value,
+      dim: (value) => value,
+      green: (value) => value,
+      red: (value) => value,
+      yellow: (value) => value,
+    };
+  }
+
+  const wrap = (open, close) => (value) => `${open}${value}${close}`;
+  return {
+    bold: wrap("\u001B[1m", "\u001B[22m"),
+    cyan: wrap("\u001B[36m", "\u001B[39m"),
+    dim: wrap("\u001B[2m", "\u001B[22m"),
+    green: wrap("\u001B[32m", "\u001B[39m"),
+    red: wrap("\u001B[31m", "\u001B[39m"),
+    yellow: wrap("\u001B[33m", "\u001B[39m"),
+  };
+}
+
+function createReporter({ enableColor = process.stdout.isTTY && !process.env.NO_COLOR } = {}) {
+  const styles = createTerminalStyles(enableColor);
+  return {
+    status({ message, detail = null }) {
+      const prefix = styles.cyan("›");
+      const suffix = detail ? ` ${styles.dim(detail)}` : "";
+      console.log(`${prefix} ${styles.bold(message)}${suffix}`);
+    },
+    success(message, detail = null) {
+      const suffix = detail ? ` ${styles.dim(detail)}` : "";
+      console.log(`${styles.green("✓")} ${styles.bold(message)}${suffix}`);
+    },
+    warning(message, detail = null) {
+      const suffix = detail ? ` ${styles.dim(detail)}` : "";
+      console.log(`${styles.yellow("!")} ${styles.bold(message)}${suffix}`);
+    },
+    failure(message, detail = null) {
+      const suffix = detail ? ` ${styles.dim(detail)}` : "";
+      console.error(`${styles.red("x")} ${styles.bold(message)}${suffix}`);
+    },
+  };
+}
+
 export function usage() {
   return `Usage:
   npx @openagentsinc/pylon [options]
@@ -24,7 +71,8 @@ export function usage() {
 Description:
   Download the latest tagged standalone Pylon release asset for this machine,
   or a specific tagged Pylon version when --version is set. Verify its
-  checksum, cache the binaries locally, and run the first-run smoke path.
+  checksum, cache the binaries locally, run the first-run smoke path, and then
+  open the Pylon terminal UI by default with live status updates.
 
 Options:
   --version <x.y.z>                    Resolve a specific Pylon release.
@@ -39,6 +87,7 @@ Options:
                                        Default: ${DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS}
   --skip-model-download                Skip pylon gemma download.
   --skip-diagnostics                   Skip pylon gemma diagnose.
+  --no-launch                          Do not open pylon-tui after bootstrap.
   --json                               Emit a machine-readable JSON summary.
 
 Test and maintainer options:
@@ -61,6 +110,7 @@ export function parseArgs(argv) {
     diagnosticMaxOutputTokens: DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS,
     skipModelDownload: false,
     skipDiagnostics: false,
+    noLaunch: false,
     json: false,
     help: false,
   };
@@ -116,6 +166,9 @@ export function parseArgs(argv) {
       case "--skip-diagnostics":
         options.skipDiagnostics = true;
         break;
+      case "--no-launch":
+        options.noLaunch = true;
+        break;
       case "--json":
         options.json = true;
         break;
@@ -144,26 +197,58 @@ export function parseArgs(argv) {
 }
 
 export async function main(argv = process.argv.slice(2), dependencies = {}) {
+  const {
+    ensureReleaseInstallImpl = ensureReleaseInstall,
+    bootstrapInstalledPylonImpl = bootstrapInstalledPylon,
+    launchInstalledPylonTuiImpl = launchInstalledPylonTui,
+  } = dependencies;
   const options = parseArgs(argv);
   if (options.help) {
     console.log(usage());
     return null;
   }
 
-  const install = await ensureReleaseInstall(options, dependencies);
-  const summary = await bootstrapInstalledPylon(
+  const reporter = options.json ? null : createReporter();
+
+  const install = await ensureReleaseInstallImpl(options, {
+    ...dependencies,
+    onStatus: reporter?.status,
+  });
+  const summary = await bootstrapInstalledPylonImpl(
     {
       ...options,
       ...install,
       version: install.version,
     },
-    dependencies,
+    {
+      ...dependencies,
+      onStatus: reporter?.status,
+    },
   );
 
   if (options.json) {
     console.log(JSON.stringify(summary, null, 2));
   } else {
+    reporter?.success("Pylon bootstrap complete");
     console.log(renderBootstrapSummary(summary));
+    if (!options.noLaunch) {
+      await launchInstalledPylonTuiImpl(
+        {
+          ...options,
+          ...install,
+          version: install.version,
+        },
+        {
+          ...dependencies,
+          onStatus: reporter?.status,
+        },
+      );
+    } else {
+      reporter?.warning(
+        "Skipped Pylon terminal UI launch",
+        "pass no flag to open pylon-tui by default",
+      );
+    }
   }
   return summary;
 }

package/src/index.js

@@ -12,6 +12,12 @@ export const DEFAULT_DIAGNOSTIC_REPEATS = 3;
 export const DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS = 96;
 const PYLON_RELEASE_TAG_PREFIX = "pylon-v";
 
+function emitStatus(onStatus, message, detail = null) {
+  if (typeof onStatus === "function") {
+    onStatus({ message, detail });
+  }
+}
+
 function normalizeVersion(value) {
   return value.replace(/^pylon-v/, "").replace(/^v/, "");
 }
@@ -264,22 +270,26 @@ export function buildInstallPaths(installRoot, version, target) {
 export async function runProcess(
   command,
   args,
-  { cwd, env } = {},
+  { cwd, env, stdio = ["ignore", "pipe", "pipe"] } = {},
 ) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
       env,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio,
     });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
     child.on("error", (error) => {
       reject(
         new Error(
@@ -343,17 +353,31 @@ async function runPylonJson(pylonPath, args, options, runProcessImpl) {
   }
 }
 
+function isUnsupportedGemmaDiagnoseError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes("unknown gemma command: diagnose") ||
+    message.includes("unknown command: diagnose")
+  );
+}
+
 export async function ensureReleaseInstall(
   options = {},
   {
     fetchImpl = globalThis.fetch,
     runProcessImpl = runProcess,
+    onStatus = null,
   } = {},
 ) {
   if (typeof fetchImpl !== "function") {
     throw new Error("A global fetch implementation is required to bootstrap Pylon.");
   }
 
+  emitStatus(
+    onStatus,
+    "Resolving latest tagged Pylon release",
+    options.version ? `requested ${options.version}` : "default release track",
+  );
   const target = resolvePlatformTarget(options.platform, options.arch);
   const installRoot = options.installRoot ?? defaultInstallRoot();
   const release = await fetchReleaseMetadata({
@@ -368,6 +392,11 @@ export async function ensureReleaseInstall(
   const binariesPresent =
     (await pathExists(paths.pylonPath)) && (await pathExists(paths.pylonTuiPath));
   if (binariesPresent) {
+    emitStatus(
+      onStatus,
+      "Using cached standalone binaries",
+      `${selected.tagName} for ${target.os}-${target.arch}`,
+    );
     return {
       ...selected,
       ...paths,
@@ -380,6 +409,11 @@ export async function ensureReleaseInstall(
     };
   }
 
+  emitStatus(
+    onStatus,
+    "Fetching release checksum",
+    selected.checksumAsset.name,
+  );
   const checksumPayload = await fetchText(fetchImpl, selected.checksumAsset.url);
   const expectedSha256 = parseSha256File(
     checksumPayload,
@@ -393,6 +427,11 @@ export async function ensureReleaseInstall(
     archiveReady = (await sha256File(paths.archivePath)) === expectedSha256;
   }
   if (!archiveReady) {
+    emitStatus(
+      onStatus,
+      "Downloading standalone binaries",
+      selected.archiveAsset.name,
+    );
     await downloadFile(fetchImpl, selected.archiveAsset.url, paths.archivePath);
   }
 
@@ -403,6 +442,11 @@ export async function ensureReleaseInstall(
     );
   }
 
+  emitStatus(
+    onStatus,
+    "Extracting standalone binaries",
+    paths.installDir,
+  );
   await fs.rm(paths.installDir, { recursive: true, force: true });
   await extractArchive(paths.archivePath, paths.versionsDir, runProcessImpl);
 
@@ -432,6 +476,12 @@ export async function ensureReleaseInstall(
     )}\n`,
   );
 
+  emitStatus(
+    onStatus,
+    "Installed standalone binaries",
+    `${selected.tagName} for ${target.os}-${target.arch}`,
+  );
+
   return {
     ...selected,
     ...paths,
@@ -445,6 +495,7 @@ export async function bootstrapInstalledPylon(
   options,
   {
     runProcessImpl = runProcess,
+    onStatus = null,
   } = {},
 ) {
   const pylonPath = path.resolve(options.pylonPath);
@@ -455,14 +506,18 @@ export async function bootstrapInstalledPylon(
   const diagnosticMaxOutputTokens =
     options.diagnosticMaxOutputTokens ?? DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS;
 
+  emitStatus(onStatus, "Verifying Pylon binary", path.basename(pylonPath));
   await runPylonCommand(pylonPath, ["--help"], options, runProcessImpl);
+  emitStatus(onStatus, "Bootstrapping local Pylon identity");
   const init = await runPylonJson(pylonPath, ["init"], options, runProcessImpl);
+  emitStatus(onStatus, "Checking runtime health");
   const status = await runPylonJson(
     pylonPath,
     ["status", "--json"],
     options,
     runProcessImpl,
   );
+  emitStatus(onStatus, "Scanning for local models");
   const inventory = await runPylonJson(
     pylonPath,
     ["inventory", "--json"],
@@ -472,31 +527,48 @@ export async function bootstrapInstalledPylon(
 
   let download = null;
   if (!options.skipModelDownload) {
+    emitStatus(onStatus, "Downloading curated model bundle", model);
     download = await runPylonJson(
       pylonPath,
       ["gemma", "download", model, "--json"],
       options,
       runProcessImpl,
     );
+  } else {
+    emitStatus(onStatus, "Skipping curated model download", model);
   }
 
   let diagnostic = null;
   if (!options.skipDiagnostics) {
-    diagnostic = await runPylonJson(
-      pylonPath,
-      [
-        "gemma",
-        "diagnose",
-        model,
-        "--max-output-tokens",
-        String(diagnosticMaxOutputTokens),
-        "--repeats",
-        String(diagnosticRepeats),
-        "--json",
-      ],
-      options,
-      runProcessImpl,
-    );
+    emitStatus(onStatus, "Running first-run diagnostic", model);
+    try {
+      diagnostic = await runPylonJson(
+        pylonPath,
+        [
+          "gemma",
+          "diagnose",
+          model,
+          "--max-output-tokens",
+          String(diagnosticMaxOutputTokens),
+          "--repeats",
+          String(diagnosticRepeats),
+          "--json",
+        ],
+        options,
+        runProcessImpl,
+      );
+    } catch (error) {
+      if (!isUnsupportedGemmaDiagnoseError(error)) {
+        throw error;
+      }
+      emitStatus(
+        onStatus,
+        "Skipping first-run diagnostic",
+        "installed Pylon release does not expose gemma diagnose",
+      );
+    }
+  } else {
+    emitStatus(onStatus, "Skipping first-run diagnostic", model);
   }
 
   const diagnosticResult =
@@ -504,6 +576,14 @@ export async function bootstrapInstalledPylon(
     diagnostic?.results?.[0] ??
     null;
 
+  emitStatus(
+    onStatus,
+    "Bootstrap complete",
+    diagnosticResult?.status
+      ? `diagnostic ${diagnosticResult.status}`
+      : "smoke path complete",
+  );
+
   return {
     version: options.version,
     tagName: options.tagName ?? `pylon-v${options.version}`,
@@ -525,6 +605,21 @@ export async function bootstrapInstalledPylon(
   };
 }
 
+export async function launchInstalledPylonTui(
+  options,
+  {
+    runProcessImpl = runProcess,
+    onStatus = null,
+  } = {},
+) {
+  const pylonTuiPath = path.resolve(options.pylonTuiPath);
+  emitStatus(onStatus, "Opening Pylon terminal UI", path.basename(pylonTuiPath));
+  return runProcessImpl(pylonTuiPath, [], {
+    env: buildPylonEnv(options),
+    stdio: "inherit",
+  });
+}
+
 export function renderBootstrapSummary(summary) {
   const lines = [
     `Pylon release: ${summary.version} (${summary.target.os}-${summary.target.arch})`,