hostwares-cli 2.4.1 → 2.4.2

package/dist/session/store.js

@@ -1,144 +0,0 @@
-import { createHash } from "crypto";
-import { join } from "path";
-import { existsSync, readFileSync, readdirSync, unlinkSync, mkdirSync } from "fs";
-import { HW_DIR, writeJsonSecure } from "../config.js";
-/**
- * Per-project session state: which server conversation this directory is
- * talking to, and a local record of the exchange.
- *
- * The bug this replaces was severe and silent. The old filename was:
- *
- *     Buffer.from(cwd).toString("base64url").slice(0, 20)
- *
- * described in a comment as "hash the cwd". It is not a hash - it is base64 of
- * the path truncated to 20 characters, which is the first FIFTEEN BYTES of the
- * absolute path. Every directory under `/Users/<name>/` encodes to the same
- * filename. Verified on the reporting machine: one session file existed for
- * every project, its stored `cwd` was `/Users/<name>`, and each project
- * silently inherited and then overwrote the previous one's conversation.
- * `loadSession` never compared the stored cwd to the actual one, so nothing
- * ever surfaced the mismatch.
- *
- * Now: sha256 of the path, and the stored cwd is verified on load.
- */
-const SESSION_DIR = join(HW_DIR, "sessions");
-/** Bumped when the on-disk shape changes; older files are ignored, not crashed on. */
-const SCHEMA_VERSION = 2;
-function sessionPath(cwd) {
-    const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 24);
-    return join(SESSION_DIR, `${hash}.json`);
-}
-export function newSession(cwd = process.cwd()) {
-    const now = new Date().toISOString();
-    return {
-        version: SCHEMA_VERSION,
-        cwd,
-        conversationId: null,
-        createdAt: now,
-        updatedAt: now,
-        turns: [],
-        creditsSpent: 0,
-    };
-}
-/**
- * Load this directory's session, or null.
- *
- * Returns null rather than throwing for every failure mode - a corrupt or
- * foreign session file must degrade to "start fresh", never to a crash on
- * startup.
- *
- * Note what is NOT here: the old loader scanned past assistant messages for the
- * substrings "can't access your local", "outside my scope" and "out of scope",
- * and silently DELETED the entire session if it found any, printing
- * "↻ Fresh session (cleared stale context)". It was a workaround for a model
- * that used to refuse local access; the model no longer does. It also fired on
- * any legitimate discussion of those phrases, and it destroyed history with no
- * backup - which is a large part of why the CLI appeared to remember nothing.
- */
-export function loadSession(cwd = process.cwd()) {
-    const file = sessionPath(cwd);
-    if (!existsSync(file))
-        return null;
-    try {
-        const data = JSON.parse(readFileSync(file, "utf8"));
-        if (data.version !== SCHEMA_VERSION)
-            return null;
-        // The guard the old code lacked. With a correct hash this should never
-        // fire, but a stale file from a renamed directory would otherwise resume
-        // someone else's conversation into this project.
-        if (data.cwd !== cwd)
-            return null;
-        if (!Array.isArray(data.turns))
-            return null;
-        return {
-            version: SCHEMA_VERSION,
-            cwd,
-            conversationId: typeof data.conversationId === "string" ? data.conversationId : null,
-            createdAt: data.createdAt ?? new Date().toISOString(),
-            updatedAt: data.updatedAt ?? new Date().toISOString(),
-            turns: data.turns.filter(isTurn),
-            creditsSpent: typeof data.creditsSpent === "number" ? data.creditsSpent : 0,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function isTurn(t) {
-    return Boolean(t) && typeof t === "object"
-        && typeof t.content === "string"
-        && (t.role === "user" || t.role === "assistant");
-}
-/** How many turns to keep locally. The server holds the authoritative transcript. */
-const MAX_LOCAL_TURNS = 200;
-export function saveSession(session) {
-    mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
-    session.updatedAt = new Date().toISOString();
-    if (session.turns.length > MAX_LOCAL_TURNS) {
-        session.turns = session.turns.slice(-MAX_LOCAL_TURNS);
-    }
-    // Atomic + 0600: session files carry conversation text, and a half-written
-    // one loses the session.
-    writeJsonSecure(sessionPath(session.cwd), session);
-}
-/**
- * Append a turn.
- *
- * The timestamp is set HERE, once, when the turn is recorded. The old
- * autoSave() rewrote every entry with `new Date().toISOString()` on every save,
- * so the whole history collapsed to the time of the last write and the record
- * of when anything happened was destroyed.
- */
-export function appendTurn(session, role, content) {
-    session.turns.push({ role, content, at: new Date().toISOString() });
-}
-export function deleteSession(cwd = process.cwd()) {
-    try {
-        unlinkSync(sessionPath(cwd));
-    }
-    catch { /* already gone */ }
-}
-/** Every session on this machine, newest first. Powers `hw sessions`. */
-export function listSessions() {
-    if (!existsSync(SESSION_DIR))
-        return [];
-    const out = [];
-    for (const name of readdirSync(SESSION_DIR)) {
-        if (!name.endsWith(".json"))
-            continue;
-        try {
-            const data = JSON.parse(readFileSync(join(SESSION_DIR, name), "utf8"));
-            if (data.version !== SCHEMA_VERSION || !data.cwd)
-                continue;
-            out.push({
-                cwd: data.cwd,
-                conversationId: data.conversationId ?? null,
-                updatedAt: data.updatedAt,
-                turnCount: Array.isArray(data.turns) ? data.turns.length : 0,
-                creditsSpent: data.creditsSpent ?? 0,
-            });
-        }
-        catch { /* skip unreadable */ }
-    }
-    return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}

package/dist/ui/input.js

@@ -1,242 +0,0 @@
-import { createInterface } from "readline";
-import { c } from "./theme.js";
-/**
- * Single owner of stdin.
- *
- * This module exists because of one bug and a family of bugs behind it. The
- * permission prompt used to read a keypress like this:
- *
- *     stdin.setRawMode(true);
- *     stdin.once("data", d => { ... process.stdout.write(ch + "\n"); });
- *
- * while the REPL's readline interface was STILL attached to stdin and still in
- * terminal mode. Both received the keypress, so both echoed it: pressing `y`
- * once printed `yy`. A commit went in claiming to fix that; it stopped
- * multi-character answers echoing but never detached readline, so the bug
- * survived in the shipped build. Any leftover keystroke also stayed in
- * readline's line buffer and was submitted as the user's NEXT message.
- *
- * The fix is not more careful escape handling - it is having exactly one reader
- * at a time. `question()` and `readKey()` both go through `withExclusiveStdin`,
- * which pauses the REPL interface, does its work, and resumes it. Nothing else
- * in the codebase is allowed to touch `process.stdin`.
- */
-let repl = null;
-/** Serialises overlapping reads so two prompts can never race for stdin. */
-let queue = Promise.resolve();
-export function createReplInterface(prompt) {
-    repl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt,
-        // Ctrl-C is handled explicitly via the SIGINT event so an in-flight
-        // request can be aborted without killing the process.
-        terminal: process.stdout.isTTY === true,
-        historySize: 500,
-    });
-    return repl;
-}
-export function closeRepl() {
-    repl?.close();
-    repl = null;
-}
-/**
- * Run `fn` as the only consumer of stdin.
- *
- * Pausing the readline Interface is not enough on its own: in terminal mode,
- * with the REPL mid `for await (... of rl)`, readline keeps its own `data`
- * listener on stdin and echoes keys. Pressing `y` at a permission prompt then
- * registered TWICE — once echoed by readline, once by the raw reader below —
- * producing "yy" and, worse, feeding a stray "y" into the next prompt.
- *
- * The fix is to remove stdin's listeners entirely for the duration of `fn` and
- * restore them afterwards, so the raw reader is genuinely the only consumer.
- */
-async function withExclusiveStdin(fn) {
-    const run = queue.then(async () => {
-        const wasRepl = repl;
-        const stdin = process.stdin;
-        // Snapshot and detach every data/keypress listener currently on stdin
-        // (these belong to readline). We reattach them in the finally block.
-        const dataListeners = stdin.listeners("data");
-        const keypressListeners = stdin.listeners("keypress");
-        wasRepl?.pause();
-        for (const l of dataListeners)
-            stdin.removeListener("data", l);
-        for (const l of keypressListeners)
-            stdin.removeListener("keypress", l);
-        try {
-            return await fn();
-        }
-        finally {
-            // Reattach readline's listeners, then repaint its prompt — resume() alone
-            // leaves the line unpainted so the terminal looks frozen until a keypress.
-            for (const l of dataListeners)
-                stdin.on("data", l);
-            for (const l of keypressListeners)
-                stdin.on("keypress", l);
-            if (wasRepl) {
-                wasRepl.resume();
-            }
-        }
-    });
-    // Keep the chain alive even if this call rejects, or one failed prompt would
-    // deadlock every later one.
-    queue = run.catch(() => undefined);
-    return run;
-}
-/**
- * Read a single keypress without waiting for Enter.
- *
- * Returns the lowercased character, or a named key for the control sequences
- * that must not be swallowed. Ctrl-C in raw mode arrives as the byte 0x03 and
- * does NOT raise SIGINT - the old code treated it as "any other key", i.e. a
- * silent "no", so Ctrl-C at a permission prompt neither cancelled nor exited.
- */
-export async function readKey(allowed) {
-    if (!process.stdin.isTTY) {
-        // Piped or CI: there is no interactive user to answer, and blocking forever
-        // is the worst outcome. Callers treat "" as "no answer given".
-        return "";
-    }
-    return withExclusiveStdin(() => new Promise(resolve => {
-        const stdin = process.stdin;
-        const wasRaw = stdin.isRaw === true;
-        const cleanup = () => {
-            stdin.removeListener("data", onData);
-            // Restore precisely what we found. `wasRaw || false` (the old code) is
-            // not the same thing: it restores raw mode whenever readline had it on,
-            // which is a different state from "what it was before I touched it".
-            if (stdin.isTTY)
-                stdin.setRawMode(wasRaw);
-            if (!wasRaw)
-                stdin.pause();
-        };
-        const onData = (buf) => {
-            const seq = buf.toString("utf8");
-            let key;
-            if (seq === "")
-                key = "ctrl-c";
-            else if (seq === "\u001b[A")
-                key = "up";
-            else if (seq === "\u001b[B")
-                key = "down";
-            else if (seq === "\u001b[C")
-                key = "right";
-            else if (seq === "\u001b[D")
-                key = "left";
-            else if (seq === "")
-                key = "escape";
-            else if (seq === "\r" || seq === "\n")
-                key = "enter";
-            else
-                key = seq[0]?.toLowerCase() ?? "";
-            // Ignore keys the caller does not accept instead of treating them as a
-            // decision. Pressing an arrow key should not silently mean "no".
-            if (allowed && !allowed.includes(key) && key !== "ctrl-c" && key !== "escape")
-                return;
-            cleanup();
-            // Echo exactly once, and only a real character.
-            if (key.length === 1)
-                process.stdout.write(key);
-            process.stdout.write("\n");
-            resolve(key);
-        };
-        stdin.setRawMode(true);
-        stdin.resume();
-        stdin.on("data", onData);
-    }));
-}
-/** Read a full line, with Enter to submit. Used for free-text answers. */
-export async function question(prompt) {
-    if (!process.stdin.isTTY)
-        return "";
-    return withExclusiveStdin(() => new Promise(resolve => {
-        const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-        rl.question(prompt, answer => { rl.close(); resolve(answer.trim()); });
-    }));
-}
-/**
- * A yes/no confirmation with a safe default.
- *
- * `defaultAnswer` is what Enter means. It is false everywhere a destructive
- * action is involved: a user holding Enter to get through prompts must not be
- * able to approve a deletion by momentum.
- */
-export async function confirm(prompt, defaultAnswer = false) {
-    const hint = defaultAnswer ? "[Y/n]" : "[y/N]";
-    process.stdout.write(`${prompt} ${c.dim(hint)} `);
-    const key = await readKey();
-    if (key === "ctrl-c" || key === "escape")
-        return false;
-    if (key === "enter" || key === "")
-        return defaultAnswer;
-    return key === "y";
-}
-/**
- * Scope picker after `t` — Kiro-style: ↑↓ to navigate, ↵ to select
- * Returns 0: Specific paths, 1: Complete directory, 2: Entire Tool, -1: cancelled
- */
-export async function pickScope(options) {
-    if (!process.stdin.isTTY)
-        return 0;
-    return withExclusiveStdin(() => new Promise(resolve => {
-        let idx = 0;
-        const stdin = process.stdin;
-        const wasRaw = stdin.isRaw === true;
-        const render = () => {
-            // Move cursor up to redraw options in place
-            // First render: just print, subsequent: overwrite
-            process.stdout.write(`\n ${c.dim("Press")} ${c.bold("(↑↓)")} ${c.dim("to navigate ·")} ${c.bold("(↵)")} ${c.dim("to select scope")}\n`);
-            for (let i = 0; i < options.length; i++) {
-                const sel = i === idx;
-                const arrow = sel ? c.cyan(">") : " ";
-                const txt = sel ? c.bold(c.cyan(options[i])) : c.dim(options[i]);
-                process.stdout.write(`${arrow} ${txt}\n`);
-            }
-        };
-        const cleanup = () => {
-            stdin.removeListener("data", onData);
-            if (stdin.isTTY)
-                stdin.setRawMode(wasRaw);
-            if (!wasRaw)
-                stdin.pause();
-        };
-        const onData = (buf) => {
-            const seq = buf.toString("utf8");
-            if (seq === "") {
-                cleanup();
-                resolve(-1);
-                return;
-            }
-            if (seq === "") {
-                cleanup();
-                resolve(-1);
-                return;
-            }
-            if (seq === "\u001b[A") {
-                idx = (idx - 1 + options.length) % options.length; // up
-                // Clear previous render (options.length+1 lines)
-                process.stdout.write(`\x1b[${options.length + 1}A\x1b[J`);
-                render();
-                return;
-            }
-            if (seq === "\u001b[B") {
-                idx = (idx + 1) % options.length; // down
-                process.stdout.write(`\x1b[${options.length + 1}A\x1b[J`);
-                render();
-                return;
-            }
-            if (seq === "\r" || seq === "\n") {
-                cleanup();
-                process.stdout.write("\n");
-                resolve(idx);
-                return;
-            }
-        };
-        stdin.setRawMode(true);
-        stdin.resume();
-        stdin.on("data", onData);
-        render();
-    }));
-}