@openscaffold/cli 0.1.5 → 0.1.6

package/dist/index.js

@@ -3,8 +3,8 @@
 import { execFileSync, spawn } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { briefingFacts, briefingStatus, browserCommand, collectDiff, gitInfo, hasOpenScaffoldPlugin, hookBase, HOSTED, installedHooks, loadedEntry, loginResultLine, MCP_NAME, mcpText, nameFromDomain, callerSession, commandLine, gitTracks, rememberedCache, DEFAULT_REVIEW_TITLE, parseReviewArgs, parseSetupArgs, planSummary, pluginServes, preCommitOutput, REVIEW_HELP, REVIEW_WAIT, reviewTitle, selectFiles, SETUP_EXTENSIONS, setupPrompt, setupResultLine, skillFile, statusReport, stopOutput, switchAllowed, switchedTo, transcriptActivity, whichCustomerError, windowsCommandLine, withHooks, withoutHooks, } from "./install.js";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { briefingFacts, briefingStatus, browserCommand, collectDiff, gitInfo, hasOpenScaffoldPlugin, hookBase, HOSTED, installedHooks, loadedEntry, loginResultLine, MCP_NAME, mcpText, nameFromDomain, cacheFromToolCall, callerSession, commandLine, editedPaths, filesModifiedSince, insideFolder, sessionFileChoice, sessionStartedAt, gitTracks, rememberedCache, DEFAULT_REVIEW_TITLE, parseReviewArgs, parseSetupArgs, planSummary, pluginServes, preCommitOutput, REVIEW_HELP, REVIEW_WAIT, reviewTitle, selectFiles, SETUP_EXTENSIONS, setupPrompt, setupResultLine, skillFile, statusReport, stopOutput, transcriptActivity, whichCustomerError, windowsCommandLine, withHooks, withoutHooks, } from "./install.js";
 const CONFIG = join(homedir(), ".config", "openscaffold");
 const CREDENTIALS = join(CONFIG, "credentials.json");
 const CACHE = join(CONFIG, "cache");
@@ -337,10 +337,12 @@ const git = (cwd, args) => {
     }
 };
 /** Caches a deployment's briefing as this folder's (and this Claude session's) deployment, for the guardrail hooks and review. */
-function remember(creds, deployment, briefing, cwd, sessionId, switching = false) {
+function remember(creds, deployment, briefing, cwd, sessionId, switching = false, transcript) {
     mkdirSync(CACHE, { recursive: true });
-    writeFileSync(join(CACHE, `${deployment}.md`), briefing);
-    const entry = { deployment, at: new Date().toISOString(), login: loginKey(creds) };
+    // No briefing (a plain tool call named the deployment): keep the cached one, if any; review works without it.
+    if (briefing !== null)
+        writeFileSync(join(CACHE, `${deployment}.md`), briefing);
+    const entry = { deployment, at: new Date().toISOString(), login: loginKey(creds), ...(transcript ? { transcript } : {}) };
     // Per Claude session too: two sessions in one folder on different customers each keep their own guardrails.
     const next = rememberedCache(readJson(join(CACHE, "index.json"), {}), readJson(SESSIONS, {}), cwd, sessionId, entry, switching);
     writeJson(join(CACHE, "index.json"), next.index);
@@ -369,7 +371,7 @@ async function sessionStart() {
         console.log(briefing);
         const dep = r.body.deployment?.id;
         if (dep)
-            remember(creds, dep, briefing, cwd, hook.session_id);
+            remember(creds, dep, briefing, cwd, hook.session_id, false, hook.transcript_path);
     }
     catch {
         const last = index[cwd]?.login === loginKey(creds) ? index[cwd] : undefined; // a session started before a re-login may write late
@@ -425,16 +427,53 @@ const knownDeployments = (creds) => {
     });
 };
 /**
- * PostToolUse after use_deployment / create_deployment: the new deployment becomes this session's and folder's, so review
- * and the hooks follow it; only when it is this login's server and workspace (switchAllowed), never a foreign id.
+ * PostToolUse after any OpenScaffold tool: use_deployment / create_deployment switch this session (and, with no session, the
+ * folder); any other call naming a deployment_id makes it this session's, so `review` finds the customer the agent loaded
+ * with get_briefing. Only this login's server and workspace, never a foreign id (cacheFromToolCall). Local files only.
  */
 async function useDeployment() {
     const hook = await hookInput();
     const creds = credentials();
-    const got = switchedTo(hook.tool_response);
-    if (!creds || !got || !switchAllowed(hook.tool_name, got.deployment, creds.api_url, knownDeployments(creds).map((d) => d.id)))
+    if (!creds)
         return;
-    remember(creds, got.deployment, got.briefing, hook.cwd ?? process.cwd(), hook.session_id, true);
+    const current = hook.session_id ? readJson(SESSIONS, {})[hook.session_id]?.deployment : undefined;
+    const got = cacheFromToolCall(hook, creds.api_url, knownDeployments(creds).map((d) => d.id), current);
+    if (got)
+        remember(creds, got.deployment, got.briefing, hook.cwd ?? process.cwd(), hook.session_id, true, hook.transcript_path);
+}
+/** The Claude session's transcript: the path its hooks cached, else ~/.claude/projects/<any>/<session id>.jsonl. */
+const transcriptOf = (sessionId, entry) => {
+    if (entry?.transcript && existsSync(entry.transcript))
+        return entry.transcript;
+    const projects = join(CLAUDE, "projects");
+    const dir = existsSync(projects) ? readdirSync(projects).find((d) => existsSync(join(projects, d, `${sessionId}.jsonl`))) : undefined;
+    return dir ? join(projects, dir, `${sessionId}.jsonl`) : undefined;
+};
+/** Outside git with no files named: what this Claude session changed under the cwd, from its transcript, else by mtime. */
+function sessionFiles(sessionId, cwd) {
+    if (!sessionId)
+        return null;
+    const entry = readJson(SESSIONS, {})[sessionId];
+    const transcript = transcriptOf(sessionId, entry);
+    const text = transcript ? readFileSync(transcript, "utf8") : null;
+    const edited = text === null ? null : editedPaths(text).map((p) => relative(cwd, resolve(cwd, p))).filter((p) => p && !p.startsWith("..") && !isAbsolute(p));
+    const since = sessionStartedAt(text, transcript ? statSync(transcript).birthtimeMs : null, entry?.started);
+    // Automatic picks only: links resolved, each must still be inside this folder (a path the agent names is sent as named).
+    return sessionFileChoice(edited && insideFolder(edited, cwd), since, (at) => insideFolder(filesModifiedSince(cwd, at), cwd));
+}
+/** OpenScaffold's own record of this Claude session's deployment (the session-start endpoint), cached for next time. */
+async function serverSession(creds, sessionId, cwd) {
+    try {
+        // peek: learn the deployment without marking the briefing read; an existing row for this session is reused, never duplicated.
+        const r = await api(creds.api_url, "/api/sessions/start", { claude_session_id: sessionId, cwd, peek: true, ...gitInfo(git(cwd, ["remote", "get-url", "origin"]), git(cwd, ["branch", "--show-current"])) }, { token: creds.token, timeoutMs: 5000 });
+        const dep = r.status === 200 ? r.body.deployment?.id : undefined;
+        if (dep)
+            remember(creds, dep, String(r.body.briefing), cwd, sessionId, true);
+        return dep;
+    }
+    catch {
+        return undefined;
+    }
 }
 // --- review -------------------------------------------------------------------------------------
 /**
@@ -453,10 +492,24 @@ async function review() {
     if (!creds)
         throw new Error(`Not signed in here. Run ${commandLine(["login"])} (one click in the browser), then ${commandLine(again)}. With the plugin or OAuth only, send the diff with the request_review tool instead.`);
     // The calling Claude session's deployment first (another session in this folder may have switched), else the folder's.
-    const deployment = args.deployment ?? loadedHere(callerSession(process.env), process.cwd())?.deployment;
+    // Nothing cached (the agent loaded the customer some other way, or no hooks): ask OpenScaffold which deployment this session used.
+    const sid = callerSession(process.env);
+    const deployment = args.deployment ?? loadedHere(sid, process.cwd())?.deployment ?? (sid ? await serverSession(creds, sid, process.cwd()) : undefined);
     if (!deployment)
         throw new Error(whichCustomerError(again, knownDeployments(creds)));
     const git = (a) => execFileSync("git", a, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+    let repo = false;
+    try {
+        repo = git(["rev-parse", "--is-inside-work-tree"]).trim() === "true";
+    }
+    catch { }
+    if (!repo && !args.files.length) {
+        const found = sessionFiles(sid, process.cwd());
+        if (found?.files.length) {
+            args.files.push(...found.files);
+            console.log(`Not a git repo: reviewing the ${found.files.length} file${found.files.length === 1 ? "" : "s"} ${found.from}: ${found.files.join(", ")}`);
+        }
+    }
     const got = collectDiff(args.files, git, (f) => (lstatSync(f).isSymbolicLink() ? { link: readlinkSync(f) } : readFileSync(f, "utf8")));
     if ("error" in got)
         throw new Error(got.error);
@@ -479,7 +532,7 @@ async function review() {
     }
     catch (e) {
         if (e instanceof LoggedOut)
-            throw new Error(`${e.message} Run \`npx -y @openscaffold/cli@latest login\`, then review again.`);
+            throw new Error(`${e.message} Run ${commandLine(["login"])}, then ${commandLine(again)}.`);
         throw e;
     }
 }

package/dist/install.js

@@ -1,5 +1,7 @@
 // Pure helpers for what `openscaffold login`/`logout` write into Claude Code (SPEC §8.4).
 // Formats checked against code.claude.com docs (hooks, mcp, skills), 2026-10-23.
+import { readdirSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 export const MCP_NAME = "openscaffold";
 /** Our hook commands mention openscaffold and end in one of our subcommands (npx form or a local build path). */
 const isOurCommand = (cmd) => /openscaffold/.test(cmd) && /\b(session-start|pre-commit|stop|use-deployment)"?$/.test(cmd.trim());
@@ -16,7 +18,7 @@ export const OUR_HOOKS = [
     { event: "SessionStart", sub: "session-start", matcher: HOOK_MATCHER, handler: { timeout: 10 } },
     { event: "PreToolUse", sub: "pre-commit", matcher: "Bash", handler: { if: "Bash(git commit *)", timeout: 2 } },
     { event: "Stop", sub: "stop", matcher: undefined, handler: { timeout: 5 } },
-    { event: "PostToolUse", sub: "use-deployment", matcher: "mcp__.*openscaffold.*__(use|create)_deployment", handler: { timeout: 2 } },
+    { event: "PostToolUse", sub: "use-deployment", matcher: "mcp__.*openscaffold.*__.*", handler: { timeout: 2 } },
 ];
 const withoutOurs = (groups = []) => groups.map((g) => ({ ...g, hooks: g.hooks.filter((h) => !isOurs(h)) })).filter((g) => g.hooks.length > 0);
 /** Adds (or replaces) our hooks, `<base> <subcommand>` each; leaves everything else in settings.json as it was. */
@@ -76,8 +78,11 @@ export function gitInfo(remoteOut, branchOut) {
     const branch = branchOut?.trim() || undefined;
     return { git_remote: remote, git_branch: branch };
 }
-/** Which of our hooks are in settings.json, e.g. ["session-start", "pre-commit", "stop"]. */
-export const installedHooks = (settings) => OUR_HOOKS.filter((h) => (settings.hooks?.[h.event] ?? []).some((g) => g.hooks.some((x) => isOurs(x) && x.command.trim().replace(/"$/, "").endsWith(h.sub)))).map((h) => h.sub);
+/**
+ * Which of our hooks are in settings.json, e.g. ["session-start", "pre-commit", "stop"]: each with today's matcher, so an
+ * older login's (the use-deployment hook's narrow `(use|create)_deployment` matcher) reads as missing and status asks for login.
+ */
+export const installedHooks = (settings) => OUR_HOOKS.filter((h) => (settings.hooks?.[h.event] ?? []).some((g) => g.matcher === h.matcher && g.hooks.some((x) => isOurs(x) && x.command.trim().replace(/"$/, "").endsWith(h.sub)))).map((h) => h.sub);
 export const hasSessionHook = (settings) => installedHooks(settings).includes("session-start");
 /** The hosted app, which the Claude Code plugin's MCP server always points at (plugin/.mcp.json). */
 export const HOSTED = "https://app.openscaffold.ai";
@@ -96,7 +101,7 @@ export function statusReport(s) {
         `Signed in:    ${s.workspace ? `yes, workspace "${s.workspace}" (${s.apiUrl}${s.server === "down" ? ", not answering" : s.server === "revoked" ? ", login revoked" : ""})` : "no"}`,
         `MCP server:   ${s.plugin ? "from the openscaffold plugin" : s.mcp === null ? "unknown (Claude Code not on PATH)" : s.mcp ? "added" : "missing"}`,
         `Session hook: ${s.hook ? "installed" : "missing"}`,
-        ...(s.guardrails === undefined ? [] : [`Guardrails:   ${s.guardrails ? "pre-commit plan check and end-of-session report reminder" : "missing or out of date (logins before 2026-10-29 lack the customer-switch hook): re-run npx @openscaffold/cli login"}`]),
+        ...(s.guardrails === undefined ? [] : [`Guardrails:   ${s.guardrails ? "pre-commit plan check and end-of-session report reminder" : "missing or out of date (an older login's customer-switch hook): re-run npx @openscaffold/cli login"}`]),
         `Commands:     ${s.plugin ? "/openscaffold:* from the plugin" : commandsOk ? `${s.skills} /os-* commands` : s.skills ? `${s.skills} of ${s.skillsExpected || "?"} /os-* commands` : "missing"}`,
     ];
     const next = !s.workspace || s.server === "revoked" || mcpOk === false || !s.hook || s.guardrails === false || !commandsOk
@@ -207,10 +212,161 @@ export function withSession(sessions, sessionId, entry, keep = 200) {
  * which session called it) never picks it up; a session start, or a switch with no session, sets the folder default. Pure.
  */
 export function rememberedCache(index, sessions, cwd, sessionId, entry, switching = false) {
+    const prev = sessionId ? sessions[sessionId] : undefined;
     return {
-        index: switching && sessionId ? index : { ...index, [cwd]: entry },
-        sessions: sessionId ? withSession(sessions, sessionId, entry) : sessions,
+        index: switching && sessionId ? index : { ...index, [cwd]: { deployment: entry.deployment, at: entry.at, login: entry.login } },
+        sessions: sessionId ? withSession(sessions, sessionId, { ...entry, started: prev?.started ?? entry.at, transcript: entry.transcript ?? prev?.transcript }) : sessions,
+    };
+}
+/**
+ * What the use-deployment hook (PostToolUse on every OpenScaffold tool) caches, or null. use_deployment / create_deployment:
+ * the deployment it switched to, with its briefing. Any other call with a `deployment_id` (get_briefing, get_plan, …): that
+ * deployment, for the calling session only (`sessionOnly`; no session id, nothing), no briefing. Unchanged (`current`) or
+ * not this login's server and workspace (switchAllowed): null.
+ */
+export function cacheFromToolCall(call, apiUrl, known, current) {
+    const tool = /^mcp__.*openscaffold.*__(\w+)$/.exec(call.tool_name ?? "")?.[1];
+    if (!tool || toolFailed(call.tool_response))
+        return null; // an error ("No active deployment…") keeps the current cache
+    let got = null;
+    if (tool === "use_deployment" || tool === "create_deployment") {
+        const s = switchedTo(call.tool_response);
+        got = s && { ...s, sessionOnly: false };
+    }
+    else {
+        const id = call.tool_input?.deployment_id;
+        if (typeof id === "string" && /^dep_\w+$/.test(id) && call.session_id && id !== current)
+            got = { deployment: id, briefing: null, sessionOnly: true };
+    }
+    return got && switchAllowed(call.tool_name, got.deployment, apiUrl, known) ? got : null;
+}
+/** A tool_response that reports an error: MCP `isError`, an `{error}` object, or text that starts "Error" / "MCP error". */
+const toolFailed = (r) => (Boolean(r) && typeof r === "object" && !Array.isArray(r) && (r.isError === true || "error" in r))
+    || /^(MCP )?error\b/i.test(textOf(r).trim());
+/**
+ * A file automatic selection never sends (a path the agent names still goes): every dot-file (.env, .npmrc, .netrc, …)
+ * and names that look like keys or credentials. ponytail: name patterns, not content scanning; extend the list as found.
+ */
+export const looksSecret = (path) => {
+    const name = path.split(/[\\/]/).pop() ?? path;
+    return name.startsWith(".") || /\.(pem|key|p12|pfx|jks|keystore|asc|gpg|ppk)$|\.env$|\.env\.|^id_(rsa|dsa|ecdsa|ed25519)|credential|secret/i.test(name);
+};
+/**
+ * Outside git with no files named: the session's edited files (transcript) when any are usable, else files modified since
+ * `since` (sessionStart); likely secrets dropped either way. `edited`: null with no transcript.
+ */
+export function sessionFileChoice(edited, since, modifiedSince) {
+    const safe = (fs) => fs.filter((f) => !looksSecret(f));
+    const fromTranscript = safe(edited ?? []);
+    if (fromTranscript.length)
+        return { files: fromTranscript, from: "edited in this session" };
+    return { files: safe(modifiedSince(since.at)), from: `modified ${since.label}` };
+}
+/** The mtime fallback's window when nothing says when the session started. */
+export const UNKNOWN_START_WINDOW_MS = 12 * 3_600_000;
+/**
+ * When the Claude session started, independent of our cache: the earliest `"timestamp"` in its transcript, else the
+ * transcript file's birthtime, else the cache's `started` (first cache write: late when hooks are missing), else the
+ * last 12 hours.
+ */
+export function sessionStartedAt(transcript, birthtimeMs, cachedStarted, now = Date.now()) {
+    let first = Infinity;
+    for (const m of (transcript ?? "").matchAll(/"timestamp":"([^"]+)"/g)) {
+        const t = Date.parse(m[1]);
+        if (t < first)
+            first = t;
+    }
+    const iso = (t) => new Date(t).toISOString();
+    if (Number.isFinite(first))
+        return { at: first, label: `since this session started (${iso(first)})` };
+    if (birthtimeMs && birthtimeMs > 0)
+        return { at: birthtimeMs, label: `since this session started (${iso(birthtimeMs)})` };
+    // Our cache's `started` is only when we first cached a deployment (after a server recovery, moments ago), never the
+    // session's start: it can widen the window, never narrow it below the last 12 hours.
+    const cached = cachedStarted ? Date.parse(cachedStarted) : NaN;
+    const window = now - UNKNOWN_START_WINDOW_MS;
+    if (Number.isFinite(cached) && cached < window)
+        return { at: cached, label: `since ${cachedStarted}` };
+    return { at: window, label: "in the last 12 hours (session start unknown)" };
+}
+/**
+ * Automatic selection only: the paths (relative to `cwd`) whose real location, links resolved, is still inside the real
+ * `cwd`, so `linked/config.json` through a link to another folder is never sent. Missing or unreadable paths drop out.
+ */
+export function insideFolder(paths, cwd) {
+    let root;
+    try {
+        root = realpathSync(cwd);
+    }
+    catch {
+        return [];
+    }
+    return paths.filter((p) => {
+        try {
+            const r = relative(root, realpathSync(resolve(cwd, p)));
+            return Boolean(r) && r !== ".." && !r.startsWith(`..${sep}`) && !isAbsolute(r);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The files a session's transcript (JSONL) shows it wrote or edited, in order, each once: file_path / notebook_path. */
+export function editedPaths(jsonl) {
+    const out = new Set();
+    for (const line of jsonl.split("\n")) {
+        if (!line.includes('"tool_use"'))
+            continue;
+        let content;
+        try {
+            content = JSON.parse(line).message?.content;
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        for (const c of content) {
+            const path = c?.input?.file_path ?? c?.input?.notebook_path;
+            if (c?.type === "tool_use" && EDIT_TOOLS.has(c.name ?? "") && typeof path === "string")
+                out.add(path);
+        }
+    }
+    return [...out];
+}
+/**
+ * Files under `root` modified after `since` (ms), paths relative to it, sorted: the change outside git when no transcript
+ * says what was edited. Skips node_modules, dot-folders (.git, .venv, …) and likely secrets (looksSecret); at most `cap` files.
+ */
+export function filesModifiedSince(root, since, cap = 200) {
+    const out = [];
+    const walk = (dir, rel) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= cap)
+                return;
+            const r = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (e.name !== "node_modules" && !e.name.startsWith("."))
+                    walk(join(dir, e.name), r);
+            }
+            else if (e.isFile() && !looksSecret(e.name)) {
+                try {
+                    if (statSync(join(dir, e.name)).mtimeMs > since)
+                        out.push(r);
+                }
+                catch { }
+            }
+        }
     };
+    walk(root, "");
+    return out;
 }
 /** The deployment a hook's session loaded: by its Claude session_id first (two sessions can share a folder), else the folder's. */
 export const loadedEntry = (sessions, index, sessionId, cwd) => (sessionId ? sessions[sessionId] : undefined) ?? deploymentForCwd(index, cwd);
@@ -455,10 +611,10 @@ export function parseReviewArgs(args, exists = () => true) {
     return { ...out, title: out.title.trim() || DEFAULT_REVIEW_TITLE, reqs: [...new Set(out.reqs)] };
 }
 /**
- * A CLI command line to copy and run: `npx -y @openscaffold/cli@latest <args>`, each argument single-quoted when a shell
+ * A CLI command line to copy and run: `npx @openscaffold/cli <args>` (no `@latest`: the version already on this machine), each argument single-quoted when a shell
  * would split or expand it ($, backticks, spaces), so the copy keeps the exact text: PowerShell's form on Windows.
  */
-export const commandLine = (args, platform = process.platform) => ["npx -y @openscaffold/cli@latest", ...args.map((a) => /^[\w./:@=,-]+$/.test(a) ? a
+export const commandLine = (args, platform = process.platform) => ["npx @openscaffold/cli", ...args.map((a) => /^[\w./:@=,-]+$/.test(a) ? a
         // PowerShell: single quotes are literal and a quote is doubled; elsewhere POSIX's '\'' escape.
         : platform === "win32" ? `'${a.replace(/'/g, "''")}'` : `'${a.replace(/'/g, `'\\''`)}'`)].join(" ");
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openscaffold/cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Connect Claude Code to your OpenScaffold workspace: each session loads the right customer deployment.",
   "type": "module",
   "bin": {