@openagentsinc/pylon 0.1.4 → 0.1.5

package/README.md

@@ -3,7 +3,7 @@
 Bootstrap the latest tagged standalone `Pylon` release asset from GitHub
 Releases, fall back to a deterministic source build when no matching asset
 exists for the local platform, stream first-run status updates in the terminal,
-and open the Pylon terminal UI without Cargo when prebuilt binaries are
+and start the Pylon default earning loop without Cargo when prebuilt binaries are
 available.
 
 ## Usage
@@ -51,7 +51,8 @@ The launcher:
   itself
 - falls back to `curl` for release metadata and asset downloads when the Node
   fetch path fails in constrained network contexts
-- opens `pylon-tui` by default after the smoke path unless `--no-launch` is set
+- starts the installed `pylon` earning loop by default after the smoke path
+  unless `--no-launch` is set
 - does not try to install or register a local runtime automatically; the
   bootstrap stays honest about the separate Ollama-compatible runtime
   prerequisite instead of mutating the host behind the user's back

package/package.json

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

package/src/cli.js

@@ -6,7 +6,7 @@ import {
   DEFAULT_RELEASE_REPO,
   bootstrapInstalledPylon,
   ensureReleaseInstall,
-  launchInstalledPylonTui,
+  launchInstalledPylon,
   resolveBootstrapOutcome,
   resolvePlatformTarget,
   renderBootstrapSummary,
@@ -83,7 +83,7 @@ Description:
   or a specific tagged Pylon version when --version is set. If no matching
   asset exists for the local platform, fetch the exact tagged source checkout
   and build it locally instead. Cache the binaries, run the first-run smoke
-  path, and then open the Pylon terminal UI by default with live status
+  path, and then start the Pylon default earning loop by default with live status
   updates. The launcher checks GitHub for newer tagged pylon-v... releases on
   each default run, but only caches the standalone binaries under the local
   bootstrap root; it does not replace your global npm or bun pylon command.
@@ -97,14 +97,14 @@ Options:
                                        prefetch into the local GGUF cache.
                                        Default: ${DEFAULT_MODEL_ID}
   --download-curated-cache             Prefetch the optional Hugging Face GGUF
-                                       cache before opening the TUI.
+                                       cache before launching pylon.
   --diagnostic-repeats <n>             Repeat count for pylon gemma diagnose.
                                        Default: ${DEFAULT_DIAGNOSTIC_REPEATS}
   --diagnostic-max-output-tokens <n>   Max output tokens for diagnostics.
                                        Default: ${DEFAULT_DIAGNOSTIC_MAX_OUTPUT_TOKENS}
   --skip-model-download                Keep the curated GGUF cache skipped.
   --skip-diagnostics                   Skip pylon gemma diagnose.
-  --no-launch                          Do not open pylon-tui after bootstrap.
+  --no-launch                          Do not start pylon after bootstrap.
   --verbose                            Print extra network and recovery detail.
   --debug-network                      Alias for --verbose.
   --json                               Emit a machine-readable JSON summary.
@@ -227,7 +227,7 @@ export async function main(argv = process.argv.slice(2), dependencies = {}) {
   const {
     ensureReleaseInstallImpl = ensureReleaseInstall,
     bootstrapInstalledPylonImpl = bootstrapInstalledPylon,
-    launchInstalledPylonTuiImpl = launchInstalledPylonTui,
+    launchInstalledPylonImpl = launchInstalledPylon,
     createTelemetryClientImpl = createTelemetryClient,
   } = dependencies;
   const options = parseArgs(argv);
@@ -308,7 +308,7 @@ export async function main(argv = process.argv.slice(2), dependencies = {}) {
       }
       console.log(renderBootstrapSummary(summary));
       if (!options.noLaunch) {
-        await launchInstalledPylonTuiImpl(
+        await launchInstalledPylonImpl(
           {
             ...options,
             ...install,
@@ -321,8 +321,8 @@ export async function main(argv = process.argv.slice(2), dependencies = {}) {
         );
       } else {
         reporter?.warning(
-          "Skipped Pylon terminal UI launch",
-          "pass no flag to open pylon-tui by default",
+          "Skipped Pylon launch",
+          "pass no flag to start the default earning loop",
         );
       }
     }

package/src/index.js

@@ -24,6 +24,9 @@ const PYLON_RELEASE_TAG_PREFIX = "pylon-v";
 const RELEASE_ASSET_INSTALL_METHOD = "release_asset";
 const SOURCE_BUILD_INSTALL_METHOD = "source_build";
 const PREFERRED_RUNTIME_MODEL_NAME = "gemma4:e4b";
+const LEGACY_SOURCE_BUILD_SIBLING_REPOSITORIES = {
+  "spark-sdk": "https://github.com/AtlantisPleb/spark-sdk.git",
+};
 
 function emitStatus(onStatus, message, detail = null) {
   if (typeof onStatus === "function") {
@@ -128,6 +131,27 @@ async function pathExists(value) {
   }
 }
 
+async function findFilesNamed(rootDir, targetName, results = []) {
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules" || entry.name === "target") {
+      continue;
+    }
+
+    const fullPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      await findFilesNamed(fullPath, targetName, results);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name === targetName) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
 function defaultInstallRoot() {
   return path.join(os.homedir(), ".openagents", "pylon", "bootstrap");
 }
@@ -800,6 +824,105 @@ function manualSourceBuildCommands(tagName, cloneUrl) {
   ].join("\n");
 }
 
+function inferLegacySiblingRepositoryName(relativeDependencyPath) {
+  if (typeof relativeDependencyPath !== "string" || !relativeDependencyPath.startsWith("..")) {
+    return null;
+  }
+
+  const segments = relativeDependencyPath
+    .split(/[\\/]+/)
+    .filter(Boolean);
+  const firstRepoSegment = segments.find((segment) => segment !== "..");
+  if (!firstRepoSegment) {
+    return null;
+  }
+
+  return Object.hasOwn(LEGACY_SOURCE_BUILD_SIBLING_REPOSITORIES, firstRepoSegment)
+    ? firstRepoSegment
+    : null;
+}
+
+async function discoverLegacySiblingRepositories(repoDir) {
+  const cargoTomlFiles = await findFilesNamed(repoDir, "Cargo.toml");
+  const discovered = new Set();
+
+  for (const cargoTomlPath of cargoTomlFiles) {
+    const payload = await fs.readFile(cargoTomlPath, "utf8");
+    const matches = payload.matchAll(/path\s*=\s*"([^"]+)"/g);
+    for (const match of matches) {
+      const dependencyPath = match[1]?.trim();
+      const repoName = inferLegacySiblingRepositoryName(dependencyPath);
+      if (!repoName) {
+        continue;
+      }
+
+      const resolvedPath = path.resolve(path.dirname(cargoTomlPath), dependencyPath);
+      if (resolvedPath.startsWith(`${repoDir}${path.sep}`) || resolvedPath === repoDir) {
+        continue;
+      }
+
+      discovered.add(repoName);
+    }
+  }
+
+  return [...discovered];
+}
+
+async function hydrateLegacySiblingRepositories({
+  repoDir,
+  buildEnv,
+  runProcessImpl,
+  onStatus,
+  telemetryClient,
+  releaseTag,
+  target,
+}) {
+  const repoNames = await discoverLegacySiblingRepositories(repoDir);
+  const workspaceRoot = path.dirname(repoDir);
+
+  for (const repoName of repoNames) {
+    const cloneUrl = LEGACY_SOURCE_BUILD_SIBLING_REPOSITORIES[repoName];
+    const checkoutDir = path.join(workspaceRoot, repoName);
+    if (!cloneUrl || (await pathExists(checkoutDir))) {
+      continue;
+    }
+
+    emitStatus(onStatus, "Hydrating legacy sibling checkout", repoName);
+    emitTelemetry(telemetryClient, "installer_legacy_sibling_checkout_started", {
+      release_tag: releaseTag,
+      os: target.os,
+      arch: target.arch,
+      repository: repoName,
+    });
+
+    try {
+      await runProcessImpl(
+        "git",
+        ["clone", "--depth", "1", cloneUrl, checkoutDir],
+        {
+          cwd: workspaceRoot,
+          env: buildEnv,
+        },
+      );
+      emitTelemetry(telemetryClient, "installer_legacy_sibling_checkout_completed", {
+        release_tag: releaseTag,
+        os: target.os,
+        arch: target.arch,
+        repository: repoName,
+      });
+    } catch (error) {
+      emitTelemetry(telemetryClient, "installer_legacy_sibling_checkout_failed", {
+        release_tag: releaseTag,
+        os: target.os,
+        arch: target.arch,
+        repository: repoName,
+        ...telemetryFailureContext(error, "legacy_sibling_checkout"),
+      });
+      throw error;
+    }
+  }
+}
+
 function rustInstallCommand() {
   return "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y";
 }
@@ -1008,6 +1131,15 @@ async function installSourceBuild(
         env: buildEnv,
       },
     );
+    await hydrateLegacySiblingRepositories({
+      repoDir,
+      buildEnv,
+      runProcessImpl,
+      onStatus,
+      telemetryClient,
+      releaseTag: selected.tagName,
+      target,
+    });
 
     const { stdout: commitStdout } = await runProcessImpl(
       "git",
@@ -1778,21 +1910,23 @@ export async function bootstrapInstalledPylon(
   }
 }
 
-export async function launchInstalledPylonTui(
+export async function launchInstalledPylon(
   options,
   {
     runProcessImpl = runProcess,
     onStatus = null,
   } = {},
 ) {
-  const pylonTuiPath = path.resolve(options.pylonTuiPath);
-  emitStatus(onStatus, "Opening Pylon terminal UI", path.basename(pylonTuiPath));
-  return runProcessImpl(pylonTuiPath, [], {
+  const pylonPath = path.resolve(options.pylonPath);
+  emitStatus(onStatus, "Starting Pylon default earning loop", path.basename(pylonPath));
+  return runProcessImpl(pylonPath, [], {
     env: buildPylonEnv(options),
     stdio: "inherit",
   });
 }
 
+export const launchInstalledPylonTui = launchInstalledPylon;
+
 export function resolveBootstrapOutcome(summary) {
   const runtimeState =
     summary.status?.snapshot?.runtime?.authoritative_status ?? "unknown";
@@ -1855,7 +1989,7 @@ function renderBootstrapNextSteps(summary, outcome) {
   ];
 
   if (outcome.verdict === "fully online" || outcome.verdict === "runtime ready") {
-    lines.push("Next step: open the TUI with `pylon`, or keep using the package-managed launcher.");
+    lines.push("Next step: run `pylon`; it starts the default online earning loop.");
     return lines;
   }