@coderook/cli 0.16.0 → 0.17.0

package/.claude-plugin/plugin.json

@@ -2,9 +2,17 @@
   "name": "coderook",
   "displayName": "CodeRook",
   "description": "Save, browse and restore whole-snapshot versions of a project on CodeRook, from Claude Code.",
-  "version": "0.16.0",
-  "author": { "name": "ACCA Gaming Productions", "url": "https://coderook.com" },
+  "version": "0.17.0",
+  "author": {
+    "name": "ACCA Gaming Productions",
+    "url": "https://coderook.com"
+  },
   "homepage": "https://coderook.com/docs#assistants",
   "license": "SEE LICENSE IN LICENSE.txt",
-  "keywords": ["coderook", "versioning", "snapshots", "backup"]
+  "keywords": [
+    "coderook",
+    "versioning",
+    "snapshots",
+    "backup"
+  ]
 }

package/dist/cli/src/cli.js

@@ -352,6 +352,31 @@ async function commandSubmit(parsed) {
     const secrets = await (0, worktree_js_1.detectSecrets)(folder);
     const sending = new Set(files.map((file) => file.path));
     const exposed = secrets.filter((secret) => sending.has(secret));
+    /*
+      Whole folders that belong to a program rather than to the work.
+  
+      The credential check answers by name, one file at a time, and cannot see
+      into a dependency folder at all — which is where a real cached login sat
+      while a project went up carrying a browser profile, an emulated database
+      and an unrelated work tree. Naming the folder is the only answer that
+      keeps working after the program next runs and rewrites what is inside it.
+    */
+    const shielded = (await (0, worktree_js_1.detectPrivateDirectories)(folder)).filter((finding) => [...sending].some((file) => file === finding.path || file.startsWith(`${finding.path}/`)));
+    if (shielded.length && !hasFlag(parsed, "allow-private")) {
+        console.log(red(`
+${shielded.length} folder${shielded.length === 1 ? "" : "s"} here belong${shielded.length === 1 ? "s" : ""} to a program, not to your project:`));
+        for (const finding of shielded) {
+            console.log(`  ${finding.path}  ${dim(`— ${finding.because}`)}`);
+        }
+        console.log(`
+Nothing was sent. To leave them behind:`);
+        for (const finding of shielded) {
+            console.log(`  ${accent(`echo "${finding.rule}" >> .gitignore`)}`);
+        }
+        console.error(`
+Or pass ${accent("--allow-private")} if they genuinely belong in the project.`);
+        return 1;
+    }
     if (exposed.length) {
         console.log(red(`\n${exposed.length} file${exposed.length === 1 ? " looks like a credential" : "s look like credentials"}:`));
         for (const secret of exposed.slice(0, 20))

package/dist/desktop-app/src/main/worktree.js

@@ -18,6 +18,7 @@ exports.fileSizes = fileSizes;
 exports.fileDiff = fileDiff;
 exports.projectTree = projectTree;
 exports.evaluateRules = evaluateRules;
+exports.detectPrivateDirectories = detectPrivateDirectories;
 exports.detectSecrets = detectSecrets;
 /** Reading a project folder: changed files, diffs, and rule measurement. */
 const node_child_process_1 = require("node:child_process");
@@ -773,8 +774,110 @@ function emptyEvaluation(truncated) {
         truncated,
     };
 }
-const SECRET_NAMES = new Set([".env", ".env.local", ".env.production"]);
-const SECRET_SUFFIXES = [".pem", ".key", ".p12", ".pfx"];
+/*
+  Names that are a credential whatever is inside them.
+
+  The first three were the whole list, which meant the check answered for a
+  hand-written `.env` and for nothing a tool leaves behind. Every addition
+  below is something a program writes without being asked: a cloud CLI's
+  cached login, an SSH key, a registry token. Those are the ones that get
+  published, precisely because nobody chose to put them there.
+*/
+const SECRET_NAMES = new Set([
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".npmrc",
+    ".netrc",
+    ".git-credentials",
+    ".dockercfg",
+    ".pypirc",
+    "credentials",
+    "credentials.json",
+    "wrangler-account.json",
+    "id_rsa",
+    "id_dsa",
+    "id_ecdsa",
+    "id_ed25519",
+]);
+const SECRET_SUFFIXES = [".pem", ".key", ".p12", ".pfx", ".keystore", ".jks"];
+/*
+  Directories that are one program's private state, not somebody's project.
+
+  These are judged by directory rather than by file because that is how they
+  arrive: nobody adds `Local Storage/leveldb/000005.ldb`, they add a folder
+  and everything under it comes too. Matching the folder is also what lets
+  the answer be a rule — one line in .gitignore covers the lot, where a list
+  of the files inside it would go stale the moment the program ran again.
+*/
+const PRIVATE_DIRECTORIES = [
+    {
+        match: /^(Local Storage|Session Storage|IndexedDB|Service Worker|Cache|Code Cache|GPUCache)$/i,
+        because: "a browser profile, which holds the sites you are signed in to",
+    },
+    { match: /^\.wrangler$/i, because: "local service state, including emulated databases" },
+    { match: /^\.aws$/i, because: "cloud credentials" },
+    { match: /^\.ssh$/i, because: "SSH keys" },
+    { match: /^\.gnupg$/i, because: "signing keys" },
+    { match: /^\.docker$/i, because: "registry logins" },
+    { match: /^\.terraform$/i, because: "infrastructure state" },
+    /*
+      Not private in itself, and included for a reason worth stating: the
+      credential check refuses to walk it, sensibly, because it is enormous and
+      none of it is yours. That makes it the one place a cached login can sit
+      and never be found by name — which is exactly where a real one was, at
+      `node_modules/.cache/wrangler/wrangler-account.json`. Naming the folder
+      covers everything the name check cannot reach into.
+    */
+    {
+        match: /^node_modules$/i,
+        because: "a dependency folder, which is rebuilt from your manifest and is where tools cache their logins",
+    },
+];
+/**
+ * Folders in this project that belong to a program rather than to the work.
+ *
+ * Deliberately separate from `detectSecrets`. A credential is a refusal: it
+ * must not be published and the answer is to remove it. One of these is a
+ * question — the files are not dangerous in themselves, they are simply not
+ * the project, and the useful response is a rule rather than a refusal.
+ */
+async function detectPrivateDirectories(root) {
+    const found = [];
+    const pending = [root];
+    let seen = 0;
+    while (pending.length && found.length < 25 && seen < 40_000) {
+        const directory = pending.pop();
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            seen += 1;
+            if (!entry.isDirectory())
+                continue;
+            if ((0, rules_js_1.isUncounted)(entry.name))
+                continue;
+            const full = node_path_1.default.join(directory, entry.name);
+            const relative = node_path_1.default.relative(root, full).split(node_path_1.default.sep).join("/");
+            const rule = PRIVATE_DIRECTORIES.find((candidate) => candidate.match.test(entry.name));
+            if (rule) {
+                found.push({
+                    path: relative,
+                    because: rule.because,
+                    rule: `${relative}/`,
+                });
+                /* No need to walk into it; the whole folder is the answer. */
+                continue;
+            }
+            pending.push(full);
+        }
+    }
+    return found;
+}
 /** Files the flow must ask about before the first upload. */
 async function detectSecrets(root) {
     const found = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "CodeRook from the command line, on any operating system",
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderook.com",