toolroll 0.9.104 → 0.9.105

package/dist/project.js

@@ -1,28 +1,8 @@
-/**
- * Projects, as the console means them: a project IS a repo path on this
- * server — one row of truth, no new concept — and, critically, project
- * *selection* is never project *authorization*.
- *
- * The ceiling is server configuration: the repos named at startup, plus any
- * git repository under a configured project root. A session picking a
- * project picks from inside that ceiling; a registry row, a store row, or a
- * request header can name a path, but naming is not access (per the v2
- * review's first finding). No configuration at all is the legacy unscoped
- * mode — everything visible — and the code says so where it decides.
- */
 import { realpathSync, statSync } from "node:fs";
 import { basename, resolve, sep } from "node:path";
 import { run } from "./exec.js";
 import { folderAnswers, FolderUnavailable } from "./folder-gate.js";
-/**
- * One canonicalization for every path that becomes project identity:
- * startup config, a session open, task placement. Comparisons elsewhere
- * fall back to raw equality for legacy rows written before this existed.
- * Throws FolderUnavailable when the console's folder gate holds the read back (folder-gate.ts).
- */
 export function canonicalProject(path) {
-    // In the console, a folder that hasn't answered a look lately is not read on its thread (folder-gate.ts). That is
-    // "unavailable", never "not a folder": it throws, so no caller falls back to the path's spelling because of it.
     if (!folderAnswers(path))
         throw new FolderUnavailable(resolve(path));
     try {
@@ -33,7 +13,6 @@ export function canonicalProject(path) {
         return null;
     }
 }
-/** Two repo identities, canonical when possible, raw-equal as the legacy fallback. */
 export function sameRepo(a, b) {
     if (a === null || b === null)
         return a === b;
@@ -43,12 +22,10 @@ export function sameRepo(a, b) {
     const cb = canonicalProject(b);
     return ca !== null && ca === cb;
 }
-/** Whether this path is actually a git repository — direct argv, bounded, no shell. */
 export async function isGitRepo(path, exec = run) {
     const result = await exec("git", ["rev-parse", "--git-dir"], { cwd: path, timeoutMs: 5_000 });
     return result.code === 0;
 }
-/** Validate a whole selection before enrolling anything; subfolders resolve to their checkout root. */
 export async function projectSelection(paths, exec = run) {
     if (paths.length === 0 || paths.length > 50)
         throw new Error("Choose between 1 and 50 project folders.");
@@ -67,12 +44,6 @@ export async function projectSelection(paths, exec = run) {
     }
     return [...repos];
 }
-/**
- * Resolve the startup configuration once. A configured path that does not
- * currently resolve is kept in its normalized form rather than dropped —
- * dropping would silently *widen* the server toward unscoped mode, and a
- * ceiling that loosens itself when a disk is unmounted is not a ceiling.
- */
 export function resolveCeiling(repos, roots, canon = canonicalProject) {
     const unresolved = [];
     const keep = (paths) => [...new Set(paths.map(path => {
@@ -84,15 +55,9 @@ export function resolveCeiling(repos, roots, canon = canonicalProject) {
         }))];
     return { ceiling: { repos: keep(repos), roots: keep(roots) }, unresolved };
 }
-/** Whether the ceiling is even configured. Unconfigured = legacy unscoped mode. */
 export function unscoped(ceiling) {
     return ceiling.repos.length === 0 && ceiling.roots.length === 0;
 }
-/**
- * The authorization question, answered from configuration alone. A path
- * under a root must additionally BE a git repository — a root authorizes
- * its repos, not every directory beneath it — which is why this is async.
- */
 export async function authorizedProject(ceiling, path, exec = run) {
     if (unscoped(ceiling))
         return true;
@@ -107,24 +72,12 @@ export async function authorizedProject(ceiling, path, exec = run) {
     }
     return false;
 }
-/**
- * The cheap synchronous subset for per-row visibility checks: a row whose
- * repo is NULL (unplaced) is always visible; a named repo must match the
- * configured set or live under a root. The under-a-root case skips the
- * git check here — rows only enter the store through placement, which
- * validated them; this guards reads, and a non-repo directory under an
- * authorized root read-visible is a smaller wrong than an async row filter.
- */
 export function rowVisible(ceiling, repo) {
     if (repo === null || unscoped(ceiling))
         return true;
-    // Exact saved identities are common. Check the whole set before resolving
-    // aliases, so the hundredth project does not stat the other99 directories.
     const canon = ceiling.canon;
     if (ceiling.repos.includes(repo) || ceiling.repos.some(one => canon === undefined ? sameRepo(one, repo) : (canon(one) ?? null) !== null && canon(one) === canon(repo)))
         return true;
-    // With a resolver (the console's saved identities), an identity it can't vouch for fails closed before any root is
-    // matched: a path's spelling never stands in for where it leads.
     if (canon !== undefined) {
         const resolved = canon(repo);
         return resolved !== null && ceiling.roots.some(root => resolved.startsWith(root + sep));
@@ -132,7 +85,6 @@ export function rowVisible(ceiling, repo) {
     const canonical = canonicalProject(repo) ?? repo;
     return ceiling.roots.some(root => canonical.startsWith(root + sep));
 }
-/** A display name for a project: its basename, the way people say it. */
 export function projectName(path) {
     return basename(path);
 }

package/dist/prompt.js

@@ -1,25 +1,12 @@
-/**
- * Interactive prompts, for exactly one situation: a person at a real
- * terminal left out a value a command needs. Every prompt is gated on a
- * TTY at both ends and never fires under --json — an agent or a cron job
- * gets the same immediate usage refusal as always, because a scheduler
- * hanging on "password:" at 3am is the one bug this module must not have.
- */
 import { spawnSync } from "node:child_process";
 import { basename } from "node:path";
 import { createInterface } from "node:readline";
-/** Whether asking is even possible: a human on both ends of the pipe. */
 export function interactive() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
-/** Variables a coding agent sets for the commands it runs. Only Codex's own CODEX_ names: a person exports others
- * (CODEX_HOME, CODEX_API_KEY, a profile) for themselves. */
 const AGENT_VARIABLES = ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "GEMINI_CLI", "CURSOR_AGENT", "OPENCODE", "GOOSE_TERMINAL", "AIDER_CHAT",
     "CODEX_SANDBOX", "CODEX_SANDBOX_NETWORK_DISABLED", "CODEX_THREAD_ID", "CODEX_CI", "CODEX_MANAGED_BY_NPM", "CODEX_MANAGED_BY_BUN"];
-/** Agents known by the program running this command, for those that set no variable of their own. */
 const AGENT_PROGRAMS = new Set(["claude", "codex", "gemini", "cursor-agent", "opencode", "aider", "copilot", "amp", "goose", "crush", "qwen"]);
-/** The program names of this process's ancestors, nearest first: each one's command and, for a script run by node
- * or python, the script's name. Empty where `ps` cannot say. */
 export function ancestorPrograms() {
     if (process.platform === "win32")
         return [];
@@ -39,13 +26,6 @@ export function ancestorPrograms() {
     }
     return names;
 }
-/**
- * Whether a coding agent is running this command. An agent's shell can be a
- * real terminal, yet whatever is printed lands in its transcript and nobody
- * types at the prompt, so it is treated like no terminal at all. The agent is
- * known by a variable it sets or, for one that sets none, by the program above
- * this one. `programs` is read only for this process's own environment.
- */
 export function underAgent(env = process.env, programs = env === process.env ? ancestorPrograms : () => []) {
     if (AGENT_VARIABLES.some(name => env[name] !== undefined && env[name] !== ""))
         return true;
@@ -58,16 +38,7 @@ export function ask(question) {
         resolve(answer.trim());
     }));
 }
-/** Like ask, but what is typed never echoes — passwords live here. */
-/**
- * Raw-mode input is not text: a terminal with bracketed paste on wraps a
- * pasted password in ESC[200~ … ESC[201~, and any arrow or function key
- * arrives as an escape sequence. Every CSI/SS3 sequence is dropped whole,
- * so a pasted secret compares equal to a typed one (setup review: the
- * hidden prompt refused every pasted password on iTerm and Terminal.app).
- */
 export function sanitizeHiddenInput(text) {
-    // eslint-disable-next-line no-control-regex
     return text.replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\u001bO[@-~]/g, "").replace(/\u001b/g, "");
 }
 export function askHidden(question) {
@@ -93,7 +64,6 @@ export function askHidden(question) {
                     return;
                 }
                 if (ch === "\u0003") {
-                    // Ctrl-C during a hidden prompt: leave the terminal usable, then go.
                     finish();
                     process.exit(130);
                 }
@@ -106,7 +76,6 @@ export function askHidden(question) {
         stdin.on("data", onData);
     });
 }
-/** A yes/no gate for an act worth a beat of deliberateness. */
 export async function confirm(question) {
     const answer = await ask(`${question} (yes/no) `);
     return answer.toLowerCase() === "yes" || answer.toLowerCase() === "y";