@neat.is/core 0.10.2 → 0.10.3

package/dist/cli.cjs

@@ -19403,14 +19403,12 @@ async function readLockPid(lockPath) {
 async function classifyLockHolder(lockPath, probe = defaultLockHolderProbe) {
   const lockPid = await readLockPid(lockPath);
   const daemonPid = await probe.daemonPidFromFile();
-  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // The lock already names the daemon, or the daemon answers on its port.
-  // Either confirms a live daemon is in the picture (the second guards
-  // against a stale pidfile whose PID got reused).
-  (daemonPid === lockPid || await probe.daemonResponds())) {
-    return { kind: "daemon", pid: daemonPid };
-  }
   if (lockPid !== void 0 && lockPid !== process.pid && probe.isPidAlive(lockPid)) {
-    return { kind: "command", pid: lockPid };
+    return { kind: lockPid === daemonPid ? "daemon" : "command", pid: lockPid };
+  }
+  if (daemonPid !== void 0 && daemonPid !== process.pid && probe.isPidAlive(daemonPid) && // Guards against a stale pidfile whose PID got reused.
+  await probe.daemonResponds()) {
+    return { kind: "daemon", pid: daemonPid };
   }
   return { kind: "stale" };
 }
@@ -29364,9 +29362,15 @@ async function snapshotProjectStatus(restPort, project, body) {
   }
   return [{ name: project, status: await probeProjectHealth(restPort, project) }];
 }
-async function waitForDaemonReady(restPort, project, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  let lastBootstrapping = [];
+var STILL_WAITING_INTERVAL_MS = 1e4;
+function daemonProgressLine(project, event) {
+  if (event.kind === "starting") return `starting the daemon for ${project}\u2026`;
+  return `still waiting for ${project}'s daemon (${Math.round(event.elapsedMs / 1e3)}s)`;
+}
+async function waitForDaemonReady(restPort, project, timeoutMs, onProgress, reminderIntervalMs = STILL_WAITING_INTERVAL_MS) {
+  const startedAt = Date.now();
+  const deadline = startedAt + timeoutMs;
+  let nextReminderAt = startedAt + reminderIntervalMs;
   while (Date.now() < deadline) {
     const body = await fetchDaemonHealth(restPort);
     if (body !== null) {
@@ -29376,15 +29380,10 @@ async function waitForDaemonReady(restPort, project, timeoutMs) {
       if (bootstrapping.length === 0) {
         return { ready: true, brokenProjects: broken, stillBootstrapping: [] };
       }
-      const key = bootstrapping.slice().sort().join(",");
-      const prevKey = lastBootstrapping.slice().sort().join(",");
-      if (key !== prevKey) {
-        const plural = bootstrapping.length === 1 ? "" : "s";
-        console.log(
-          `neat: waiting on ${bootstrapping.length} project${plural}: ${bootstrapping.join(", ")}`
-        );
-        lastBootstrapping = bootstrapping;
-      }
+    }
+    if (Date.now() >= nextReminderAt) {
+      onProgress?.({ kind: "waiting", elapsedMs: Date.now() - startedAt });
+      nextReminderAt += reminderIntervalMs;
     }
     await new Promise((r) => setTimeout(r, PROBE_INTERVAL_MS));
   }
@@ -29596,7 +29595,8 @@ async function ensureProjectDaemon(opts) {
       projectPath: opts.projectPath,
       ports: allocated
     });
-    const ready = await waitForDaemonReady(allocated.rest, opts.project, timeoutMs);
+    opts.onProgress?.({ kind: "starting" });
+    const ready = await waitForDaemonReady(allocated.rest, opts.project, timeoutMs, opts.onProgress);
     if (!ready.ready) {
       return {
         status: "timed-out",
@@ -29742,7 +29742,8 @@ async function runOrchestrator(opts) {
   const outcome = await ensureProjectDaemon({
     project: currentProjectName,
     projectPath: opts.scanPath,
-    timeoutMs
+    timeoutMs,
+    onProgress: (event) => console.log(`neat: ${daemonProgressLine(currentProjectName, event)}`)
   });
   const allocated = "ports" in outcome ? outcome.ports : null;
   switch (outcome.status) {
@@ -30606,6 +30607,15 @@ function bindUrl(webUrl, projectId) {
 function onboardingUrl(webUrl) {
   return `${webUrl}/onboarding`;
 }
+async function offerLocalExtraction(input, d, out, readLine) {
+  const run = d.orchestrator;
+  if (!run || !readLine) return false;
+  const answer = (await readLine("Build it now? [Y/n] "))?.trim().toLowerCase();
+  if (answer === "n" || answer === "no") return false;
+  out("");
+  const code = await run(d.cwd ?? process.cwd(), {});
+  return code === 0;
+}
 async function runPostLoginConnect(input) {
   const d = input.deps;
   const out = d.out ?? ((line) => console.log(line));
@@ -30615,9 +30625,27 @@ async function runPostLoginConnect(input) {
   const readLine = d.readLine;
   const repo = await detect6(cwd);
   out("");
+  const cmd = commandPrefix();
+  const syncLine = `${cmd} sync --to ${input.project.name}`;
   if (!repo) {
     out("This directory has no GitHub remote, so it can't be bound to the project.");
-    out(`  Push its graph instead:      neat sync --to ${input.project.name}`);
+    const hasGraph = await (d.hasLocalGraph ?? hasLocalSnapshot)(cwd);
+    if (!hasGraph) {
+      out(`A graph of this directory has to be built first, then pushed to ${input.project.name}.`);
+      const built = await offerLocalExtraction(input, d, out, readLine);
+      out("");
+      if (built) {
+        out(`Now push it to ${input.project.name}:`);
+        out(`  ${syncLine}`);
+      } else {
+        out(`When you're ready, build it and push it to ${input.project.name}:`);
+        out(`  ${cmd}`);
+        out(`  ${syncLine}`);
+      }
+      out(`  Manage projects and repos:   ${input.webUrl}`);
+      return;
+    }
+    out(`  Push its graph instead:      ${syncLine}`);
     out(`  Manage projects and repos:   ${input.webUrl}`);
     return;
   }
@@ -30651,18 +30679,18 @@ async function runPostLoginConnect(input) {
     out("");
     if (!hasGraph) {
       out("There is no local graph to push yet. Build one, then push it:");
-      out("  neat");
-      out(`  neat sync --to ${input.project.name}`);
+      out(`  ${cmd}`);
+      out(`  ${syncLine}`);
       return;
     }
     out("Push the local graph with:");
-    out(`  neat sync --to ${input.project.name}`);
+    out(`  ${syncLine}`);
     return;
   }
   out("");
   out("No problem \u2014 when you want this repo in the graph:");
   out(`  Bind it:        ${bindUrl(input.webUrl, input.project.id)}`);
-  out(`  Or push it:     neat sync --to ${input.project.name}`);
+  out(`  Or push it:     ${syncLine}`);
 }
 
 // src/login-sso.ts
@@ -30841,7 +30869,7 @@ async function runSsoLogin(opts, deps) {
       ...deps.signal ? { signal: deps.signal } : {}
     });
     if (waited.kind === "aborted") {
-      out("Stopped. Run `neat login` again once your project is up.");
+      out(`Stopped. Run \`${commandPrefix()} login\` again once your project is up.`);
       return 130;
     }
     if (waited.kind === "timeout") {
@@ -30909,7 +30937,7 @@ async function runSsoLogin(opts, deps) {
       }
     });
     out("");
-    out("Run `neat logout` to switch back to your local daemon.");
+    out(`Run \`${commandPrefix()} logout\` to switch back to your local daemon.`);
   }
   return 0;
 }
@@ -31811,7 +31839,13 @@ async function runUpCommand(argv, deps) {
     err("neat up: that daemon doesn't run on this machine, so it isn't yours to start.");
     return 2;
   }
-  const outcome = await ensure({ project: entry2.name, projectPath: entry2.path });
+  const project = entry2.name;
+  const outcome = await ensure({
+    project,
+    projectPath: entry2.path,
+    // `--json` prints one object and nothing else, so progress stays quiet there.
+    ...args.json ? {} : { onProgress: (event) => out(`neat up: ${daemonProgressLine(project, event)}`) }
+  });
   const log = daemonLogPath(entry2.path);
   if (args.json) {
     const ports = "ports" in outcome ? outcome.ports : void 0;
@@ -34931,23 +34965,24 @@ async function tryOrchestrator(cmd, parsed, overrides = {}) {
   return result.exitCode;
 }
 async function runWelcomeFlow(parsed) {
+  const runLocal = async (cwd, opts) => await tryOrchestrator(
+    cwd,
+    {
+      ...parsed,
+      ...opts?.project !== void 0 ? { project: opts.project } : {},
+      ...opts?.noInstrument !== void 0 ? { noInstrument: opts.noInstrument } : {},
+      ...opts?.yes !== void 0 ? { yes: opts.yes } : {}
+    },
+    { skipBanner: opts?.headerShown === true }
+  ) ?? 0;
   return runWelcome({
-    login: (loginArgv) => runLoginCommand(loginArgv),
+    login: (loginArgv) => runLoginCommand(loginArgv, { connect: { orchestrator: runLocal } }),
     // What the person chose at the door reaches the orchestrator as the flags they
     // stand for: the name as `--project`, the instrument answer as `--no-instrument`
     // or as `yes` (which keeps the orchestrator's own prompt quiet, since the door
     // already asked). `headerShown` isn't a flag anyone can type — it says the
     // door's wordmark already opened this run, so the orchestrator's banner is skipped.
-    orchestrator: async (cwd, opts) => await tryOrchestrator(
-      cwd,
-      {
-        ...parsed,
-        ...opts?.project !== void 0 ? { project: opts.project } : {},
-        ...opts?.noInstrument !== void 0 ? { noInstrument: opts.noInstrument } : {},
-        ...opts?.yes !== void 0 ? { yes: opts.yes } : {}
-      },
-      { skipBanner: opts?.headerShown === true }
-    ) ?? 0,
+    orchestrator: runLocal,
     // An explicit flag is an answer; don't ask again.
     instrumentFlagGiven: parsed.noInstrument || parsed.dryRun
   });