premanmcp 1.1.8 → 1.1.9

package/bin/agent.js

@@ -885,21 +885,27 @@ export function logo(paint, columns) {
 /**
  * Hold the terminal, and give it back whatever happens to this process.
  *
- * A session takes three things that outlive it if nobody puts them back: the
- * alternate screen, a scrolling region, and the window title. Until now the
- * only thing that returned them was a `finally` around the read loop, which
- * covers a clean exit and nothing else -- not SIGTERM, not the tab being
- * closed, not an exception thrown from a callback rather than from the loop
- * body. And the damage is not self-correcting: the next `preman` sets its
- * region on top of the live one, so a shell keeps its clipped bottom rows
- * until something writes `ESC[r`.
+ * A session takes two things that outlive it if nobody puts them back: a
+ * scrolling region and the window title. Until now the only thing that
+ * returned them was a `finally` around the read loop, which covers a clean
+ * exit and nothing else -- not SIGTERM, not the tab being closed, not an
+ * exception thrown from a callback rather than from the loop body. And the
+ * damage is not self-correcting: the next `preman` sets its region on top of
+ * the live one, so a shell keeps its clipped bottom rows until something
+ * writes `ESC[r`.
  *
- * So restoration is one idempotent routine with every exit wired to it. The
- * order inside it is the part that matters: the teardowns registered by the
- * session run first, while the screen they are writing to is still the one
- * they painted; then the region is released; then the alternate screen is left,
- * because releasing margins after switching buffers would leave them set on the
- * shell's screen -- `ESC[?1049h` does not save or reset them.
+ * It used to be three things, the alternate screen among them, and the order
+ * of the hand-back was mostly about that -- margins had to come off before the
+ * buffer was left, because `ESC[?1049h` neither saves nor resets them. The
+ * session shares the shell's screen now, so there is no buffer to leave and
+ * that constraint is gone with it.
+ *
+ * So restoration is one idempotent routine with every exit wired to it, and
+ * the order still matters for what remains: the teardowns registered by the
+ * session run first, while the rows they are writing to are still the rows
+ * they painted, and the region comes off after them -- released first, the
+ * furniture they are erasing would no longer be addressable, because inside a
+ * scrolling region the bottom rows cannot be cursored to.
  *
  * `exit` is registered too, as the last resort, which is why every write here
  * is synchronous and every step is wrapped: an exit handler that throws turns a

package/bin/desktop.js

@@ -445,7 +445,7 @@ const BYTES_PER_MB = 1024 * 1024;
  * through. Redirected output gets the summary line that already existed rather
  * than a few hundred carriage returns, which is why this is TTY-only.
  */
-function progressLine() {
+export function progressLine() {
   if (!process.stdout.isTTY) return { tick: () => {}, clear: () => {} };
   let lastDrawn = 0;
   let width = 0;
@@ -470,7 +470,7 @@ function progressLine() {
   return { tick, clear };
 }
 
-async function download(url, destination, onProgress) {
+export async function download(url, destination, onProgress) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
   try {

package/bin/detect.js

@@ -51,6 +51,35 @@ function readIfExists(filePath) {
   }
 }
 
+/**
+ * The repository's own dotenv values, later files winning.
+ *
+ * An agent that reads its provider key with a bare `os.getenv` works in a
+ * terminal where somebody exported it and fails under a runner that did not --
+ * even though the key is sitting in the repository it was started from. Reading
+ * these files closes that gap without asking anybody to re-export anything.
+ *
+ * Callers must treat the result as secret: it belongs in the agent's own child
+ * process and nowhere else. It is never logged and never sent to the backend.
+ */
+export function repoEnv(projectPath) {
+  const out = {};
+  for (const name of ENV_FILES) {
+    for (const [key, value] of Object.entries(
+      parseEnvFile(readIfExists(path.join(projectPath, name)))
+    )) {
+      // An empty value is a placeholder, not a value. `OPENAI_API_KEY=` is the
+      // normal shape of a committed `.env.example`-style line, and carrying the
+      // empty string forward spread it over a real key saved in the dashboard
+      // and left the variable unset -- so a run failed for want of a key that
+      // was available. Skipping empties keeps the documented precedence
+      // (shell, then repository, then stored) true at every layer.
+      if (value) out[key] = value;
+    }
+  }
+  return out;
+}
+
 /** Minimal dotenv reader: KEY=value, ignoring comments, exports, and quotes. */
 export function parseEnvFile(text) {
   const out = {};