@scalequality/cli 0.3.1 → 0.3.3

package/README.md

@@ -35,6 +35,13 @@ While `up` runs, the AI Workspace can:
 - start a session in one of your folders (at most 3 at once);
 - add a folder you pick there (it is checked here: it must exist, be inside
   your home folder and not be the home folder);
+- show you your folders to pick one, only while the folder picker is open in
+  the browser: the subfolders of one folder of your home at a time (no files,
+  no hidden or system folders, links only while they stay inside the home) and
+  suggestions (git repositories under `~/GIT`, `~/code`, `~/projects`,
+  `~/Developer` and similar folders, 3 levels down, plus the folders of your
+  Claude Code and Codex conversations). Only folder names, their paths and the
+  `origin` remote of repositories are sent, without any user or password;
 - list your Claude Code (`~/.claude/projects`) and Codex (`~/.codex/sessions`)
   conversations, and import the ones you choose. Secrets (cloud keys, provider
   tokens, private keys, JWTs, connection strings, `password=`-style values) are
@@ -42,6 +49,24 @@ While `up` runs, the AI Workspace can:
   without them. Only text is imported; tool results are left out and each tool
   call becomes a one-line summary.
 
+### What `up` counts to suggest an import
+
+When `up` starts, and then at most once every 6 hours while it runs, it counts
+the Claude Code and Codex conversations on this computer, so the AI Workspace
+can offer to import them. It reads the same files the import list reads
+(`~/.claude/projects/*/*.jsonl`, or `CLAUDE_CONFIG_DIR`; `~/.codex/sessions/**/rollout-*.jsonl`,
+or `CODEX_HOME`), at most the 500 most recent, each only up to its first
+message, and prints one line such as:
+
+```
+Found 28 Claude Code and 11 Codex conversations on this computer. You can import them from the browser.
+```
+
+Only the two numbers and the time of the count leave the computer
+(`importable: {claudeCode, codex, countedAt}` in the computer's inventory). No
+title, message, file name or folder name is sent until you open the import
+list in the browser and choose what to import.
+
 A Claude Code conversation continued on the same computer and folder resumes
 from its own transcript: a copy without secrets is written into the engine's
 folder (`~/.scalequality/workspace`); the original file is never changed.

package/dist/connect.build.json

@@ -1,5 +1,5 @@
 {
   "sdkVersion": "0.3.281",
-  "sha256": "d634393c324bdcca4062aca8326e5ce8d4cd637e42bf49d37edf5510e1dae6d4",
-  "sourceCommit": "d9d14ca31dd80a5a7bc14e489b362de9385261c3"
+  "sha256": "08314a95264b9909caa6a812f0bba154465f35fb82a3ffb541fdaeb5c3b95ee5",
+  "sourceCommit": "982edf3dc5d3c2e1473b4f13d0695caaed4eeaed"
 }

package/dist/connect.cjs

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/main/workspace-connect.ts
 var import_fs5 = require("fs");
 var import_os2 = require("os");
-var import_path8 = require("path");
+var import_path9 = require("path");
 var import_url = require("url");
 
 // src/application/services/workspaceSandbox/reasoning.ts
@@ -376,11 +376,11 @@ function routeLabel(path) {
   return path.split("?")[0];
 }
 function sleep(ms, signal) {
-  return new Promise((resolve6) => {
-    const t = setTimeout(resolve6, ms);
+  return new Promise((resolve7) => {
+    const t = setTimeout(resolve7, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(t);
-      resolve6();
+      resolve7();
     }, { once: true });
   });
 }
@@ -478,7 +478,7 @@ var RULES = [
   { kind: "PRIVATE_KEY", re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----|$)/g },
   { kind: "CONNECTION_STRING", re: /\b([a-z][a-z0-9+.-]{1,30}:\/\/)([^\s:@/'"]{1,200}):([^\s@/'"]{1,300})@/gi, replace: (_m, scheme, user) => `${scheme}${user}:${R("PASSWORD")}@` },
   { kind: "AWS_ACCESS_KEY", re: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA|ANPA|ANVA|AIPA|ABIA|ACCA)[A-Z0-9]{16}\b/g },
-  { kind: "AWS_SECRET_KEY", re: /\b(aws_?secret_?access_?key|aws_?secret|secretAccessKey)(["']?\s*[:=]\s*["']?)([A-Za-z0-9/+=]{40})\b/gi, replace: (_m, k, sep3) => `${k}${sep3}${R("AWS_SECRET_KEY")}` },
+  { kind: "AWS_SECRET_KEY", re: /\b(aws_?secret_?access_?key|aws_?secret|secretAccessKey)(["']?\s*[:=]\s*["']?)([A-Za-z0-9/+=]{40})\b/gi, replace: (_m, k, sep4) => `${k}${sep4}${R("AWS_SECRET_KEY")}` },
   { kind: "ANTHROPIC_KEY", re: /\bsk-ant-[a-z]{2,10}\d{0,3}-[A-Za-z0-9_-]{20,}/g },
   { kind: "OPENAI_KEY", re: /\bsk-(?:proj-|svcacct-|admin-|None-)?[A-Za-z0-9_-]{20,}/g },
   { kind: "GITHUB_TOKEN", re: /\b(?:gh[pousr]_[A-Za-z0-9]{30,255}|github_pat_[A-Za-z0-9_]{22,255})\b/g },
@@ -494,7 +494,7 @@ var RULES = [
     kind: "ASSIGNED_SECRET",
     // password=..., "api_key": "...", SECRET_TOKEN: ..., --token ... (key names that say "secret").
     re: /\b([A-Za-z0-9_.-]*(?:passw(?:or)?d|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|credential|auth[_-]?key)[A-Za-z0-9_-]*)(["']?\s*(?:=|:|\s)\s*)(["']?)([^\s"'`,;)}\]]{8,500})\3/gi,
-    replace: (_m, key, sep3, quote, value) => looksLikeSecretValue(value) ? `${key}${sep3}${quote}${R("SECRET")}${quote}` : null
+    replace: (_m, key, sep4, quote, value) => looksLikeSecretValue(value) ? `${key}${sep4}${quote}${R("SECRET")}${quote}` : null
   }
 ];
 function scrubSecrets(input) {
@@ -600,7 +600,7 @@ function claudeText(content, role) {
   }
   return { text: texts.join("\n\n").trim(), tools };
 }
-async function parseClaudeCodeFile(file) {
+async function parseClaudeCodeFile(file, opts = {}) {
   const externalId = (0, import_path.basename)(file, ".jsonl");
   if (!isExternalId(externalId)) return null;
   const win = new MessageWindow();
@@ -611,6 +611,7 @@ async function parseClaudeCodeFile(file) {
   let firstUser = null;
   let current = null;
   for await (const r of lines(file)) {
+    if (opts.probe && win.total) break;
     if (!folder && typeof r.cwd === "string") folder = r.cwd;
     if (r.type === "custom-title" && typeof r.customTitle === "string") customTitle = r.customTitle;
     else if (r.type === "ai-title" && typeof r.aiTitle === "string") aiTitle = r.aiTitle;
@@ -672,13 +673,14 @@ function codexText(content, role) {
   const want = role === "user" ? "input_text" : "output_text";
   return content.filter((b) => b?.type === want && typeof b.text === "string" && !(role === "user" && WRAPPER.test(b.text))).map((b) => b.text).join("\n\n").trim();
 }
-async function parseCodexFile(file) {
+async function parseCodexFile(file, opts = {}) {
   const fromName = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(file)?.[1] ?? null;
   let externalId = null;
   let folder = null;
   let firstUser = null;
   const win = new MessageWindow();
   for await (const r of lines(file)) {
+    if (opts.probe && win.total && externalId) break;
     const p = r.payload;
     if (!p || typeof p !== "object") continue;
     if (r.type === "session_meta") {
@@ -733,11 +735,14 @@ function secretsIn(c) {
   }
   return n;
 }
-async function scanImports(sources) {
-  const files = [
+async function importFiles(sources) {
+  return [
     ...(await claudeCodeFiles(sources.claudeDir)).map((f) => ({ ...f, source: "CLAUDE_CODE" })),
     ...(await codexFiles(sources.codexDir)).map((f) => ({ ...f, source: "CODEX" }))
   ].sort((a, b) => b.mtime - a.mtime).slice(0, MAX_FILES);
+}
+async function scanImports(sources) {
+  const files = await importFiles(sources);
   const items = [];
   const seen = /* @__PURE__ */ new Set();
   for (const f of files) {
@@ -756,6 +761,49 @@ async function scanImports(sources) {
   }
   return items;
 }
+async function countImports(sources) {
+  const counts = { claudeCode: 0, codex: 0 };
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of await importFiles(sources)) {
+    const c = await (f.source === "CLAUDE_CODE" ? parseClaudeCodeFile(f.path, { probe: true }) : parseCodexFile(f.path, { probe: true })).catch(() => null);
+    if (!c || seen.has(`${c.source}:${c.externalId}`)) continue;
+    seen.add(`${c.source}:${c.externalId}`);
+    if (c.source === "CLAUDE_CODE") counts.claudeCode++;
+    else counts.codex++;
+  }
+  return counts;
+}
+async function conversationFolders(sources, deadline) {
+  const claude = [];
+  for (const project of await subdirs((0, import_path.join)(sources.claudeDir, "projects"))) {
+    if (Date.now() > deadline) break;
+    const newest = (await regularFiles(project, (n) => n.endsWith(".jsonl"))).sort((a, b) => b.mtime - a.mtime)[0];
+    if (newest) claude.push({ ...newest, source: "CLAUDE_CODE" });
+  }
+  const codex = Date.now() > deadline ? [] : (await codexFiles(sources.codexDir)).map((f) => ({ ...f, source: "CODEX" }));
+  const files = [...claude, ...codex].sort((a, b) => b.mtime - a.mtime).slice(0, MAX_FILES);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    if (Date.now() > deadline) break;
+    let n = 0;
+    try {
+      for await (const r of lines(f.path)) {
+        if (++n > 50) break;
+        const cwd = f.source === "CLAUDE_CODE" ? r.cwd : r.type === "session_meta" && r.payload && typeof r.payload === "object" && !(r.payload.source && typeof r.payload.source === "object" && r.payload.source.subagent) ? r.payload.cwd : void 0;
+        if (typeof cwd === "string" && cwd) {
+          if (!seen.has(cwd)) {
+            seen.add(cwd);
+            out.push(cwd);
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  return out;
+}
 async function findConversation(sources, source, externalId) {
   if (!isExternalId(externalId)) return null;
   if (source === "CLAUDE_CODE") {
@@ -833,8 +881,8 @@ function scrubRecord(record) {
 async function writeScrubbedTranscript(source, target) {
   const out = (0, import_fs.createWriteStream)(target, { mode: 384, flags: "wx" });
   let removed = 0;
-  const done = new Promise((resolve6, reject) => {
-    out.on("finish", resolve6);
+  const done = new Promise((resolve7, reject) => {
+    out.on("finish", resolve7);
     out.on("error", reject);
   });
   const rl = (0, import_readline.createInterface)({ input: (0, import_fs.createReadStream)(source, { encoding: "utf8" }), crlfDelay: Infinity });
@@ -1308,13 +1356,13 @@ ${indent}`);
 function terminalCommandPrompt(o) {
   const bold = (s) => o.color ? `\x1B[1m${s}\x1B[22m` : s;
   const dim = (s) => o.color ? `\x1B[2m${s}\x1B[22m` : s;
-  return (q, signal) => new Promise((resolve6) => {
+  return (q, signal) => new Promise((resolve7) => {
     if (!o.input.isTTY) {
-      resolve6(null);
+      resolve7(null);
       return;
     }
     if (signal?.aborted) {
-      resolve6(null);
+      resolve7(null);
       return;
     }
     const rl = (0, import_readline2.createInterface)({ input: o.input, output: o.output, terminal: true });
@@ -1324,7 +1372,7 @@ function terminalCommandPrompt(o) {
       done = true;
       signal?.removeEventListener("abort", onAbort);
       rl.close();
-      resolve6(a);
+      resolve7(a);
     };
     const onAbort = () => {
       o.output.write(`
@@ -1553,7 +1601,11 @@ var MACHINE_USAGE = {
     "Keeps this computer connected: the AI Workspace can run sessions in the",
     "folders you added (scalequality add), list your Claude Code and Codex",
     "conversations and import the ones you choose. Every command a session",
-    "wants to run is confirmed in this terminal. Ctrl+C disconnects."
+    "wants to run is confirmed in this terminal. Ctrl+C disconnects.",
+    "",
+    "When it starts (and at most every 6 hours), it counts your Claude Code and",
+    "Codex conversations; only the two numbers are sent, so the AI Workspace can",
+    "offer to import them."
   ].join("\n"),
   add: [
     "Usage: scalequality add [PATH] [--api URL]",
@@ -1616,8 +1668,297 @@ function parseMachineArgs(argv) {
 
 // src/application/services/workspaceSandbox/machineCli.ts
 var import_fs3 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_path5 = require("path");
+
+// src/application/services/workspaceSandbox/machineFolders.ts
 var import_promises4 = require("fs/promises");
 var import_path4 = require("path");
+var FOLDER_LIST_LIMIT = 300;
+var FOLDER_SUGGEST_LIMIT = 200;
+var FOLDER_LIST_BUDGET_MS = 4e3;
+var FOLDER_SUGGEST_BUDGET_MS = 3e3;
+var MAX_DIRENTS = 5e3;
+var CHILD_PROBE = 256;
+var SUGGEST_DEPTH = 3;
+var MAX_REMOTE = 1024;
+var MAX_ANSWER_BYTES = 900 * 1024;
+var CONCURRENCY = 24;
+var DEV_ROOTS = ["GIT", "git", "code", "Code", "projects", "Projects", "dev", "src", "workspace", "repos", "Developer", "Documents/GitHub", "go/src"];
+var SKIP_ANYWHERE = /* @__PURE__ */ new Set(["node_modules", "bower_components", "jspm_packages", "__pycache__", "Caches", "CachedData", "DerivedData", "Pods"]);
+var SKIP_AT_HOME = /* @__PURE__ */ new Set([
+  "Library",
+  "Applications",
+  "System",
+  "Volumes",
+  "AppData",
+  "Application Data",
+  "Local Settings",
+  "Cookies",
+  "NetHood",
+  "PrintHood",
+  "Recent",
+  "SendTo",
+  "Start Menu",
+  "Templates",
+  "snap",
+  "Trash"
+]);
+var FolderBrowseError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "FolderBrowseError";
+  }
+  code;
+};
+var hidden = (name) => name.startsWith(".") || name.startsWith("$");
+var skipped = (name, atHome) => hidden(name) || SKIP_ANYWHERE.has(name) || atHome && SKIP_AT_HOME.has(name);
+function insideOrHome(path, home) {
+  const problem = folderPathProblem(path, home);
+  return problem === null || problem === "PATH_IS_HOME";
+}
+function logical(home, real) {
+  if (home.logical === home.real) return real;
+  const rel = (0, import_path4.relative)(home.real, real);
+  return rel ? (0, import_path4.join)(home.logical, rel) : home.logical;
+}
+async function realInside(home, path) {
+  const real = await (0, import_promises4.realpath)(path).catch(() => null);
+  if (!real || !insideOrHome(real, home.real)) return null;
+  return real;
+}
+async function resolveBrowsePath(raw, home) {
+  if (raw !== void 0 && raw !== null && typeof raw !== "string") throw new FolderBrowseError("INVALID_PATH");
+  const text2 = (raw ?? "").trim();
+  if (text2.length > MAX_PATH_LENGTH) throw new FolderBrowseError("INVALID_PATH");
+  if (/[\u0000-\u001f\u007f]/.test(text2)) throw new FolderBrowseError("INVALID_PATH");
+  let target;
+  if (!text2 || text2 === "~") target = home.logical;
+  else {
+    const rest = text2.startsWith("~/") || text2.startsWith("~\\") ? text2.slice(2) : text2;
+    if (rest.split(/[\\/]+/).some((part) => part === ".." || part === ".")) throw new FolderBrowseError("INVALID_PATH");
+    target = (0, import_path4.isAbsolute)(rest) && rest === text2 ? rest : (0, import_path4.resolve)(home.logical, rest);
+    if (!insideOrHome(target, home.logical)) throw new FolderBrowseError("PATH_OUTSIDE_HOME");
+  }
+  const st = await (0, import_promises4.stat)(target).catch(() => null);
+  if (!st?.isDirectory()) throw new FolderBrowseError("FOLDER_NOT_FOUND");
+  const real = await realInside(home, target);
+  if (!real) throw new FolderBrowseError("PATH_OUTSIDE_HOME");
+  return real;
+}
+async function originRemote(repo2) {
+  try {
+    const dotGit = (0, import_path4.join)(repo2, ".git");
+    const st = await (0, import_promises4.lstat)(dotGit);
+    let gitDir = dotGit;
+    if (st.isFile()) {
+      const pointer = /^gitdir:\s*(.+)\s*$/m.exec(await (0, import_promises4.readFile)(dotGit, "utf8"))?.[1];
+      if (!pointer) return null;
+      gitDir = (0, import_path4.resolve)(repo2, pointer.trim());
+      const common = (await (0, import_promises4.readFile)((0, import_path4.join)(gitDir, "commondir"), "utf8").catch(() => "")).trim();
+      if (common) gitDir = (0, import_path4.resolve)(gitDir, common);
+    } else if (!st.isDirectory()) return null;
+    const config = await (0, import_promises4.readFile)((0, import_path4.join)(gitDir, "config"), "utf8");
+    let inOrigin = false;
+    for (const line of config.split(/\r?\n/)) {
+      const section = /^\s*\[\s*([^\]]+?)\s*\]/.exec(line);
+      if (section) {
+        inOrigin = /^remote\s+"origin"$/.test(section[1]);
+        continue;
+      }
+      if (!inOrigin) continue;
+      const url = /^\s*url\s*=\s*(.+?)\s*$/.exec(line)?.[1];
+      if (url) return stripRemoteCredentials(url.replace(/^"(.*)"$/, "$1")).slice(0, MAX_REMOTE) || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function isGitRepo(dir) {
+  const st = await (0, import_promises4.lstat)((0, import_path4.join)(dir, ".git")).catch(() => null);
+  return !!st && (st.isDirectory() || st.isFile());
+}
+async function hasVisibleChild(dir) {
+  let handle;
+  try {
+    handle = await (0, import_promises4.opendir)(dir);
+  } catch {
+    return false;
+  }
+  let seen = 0;
+  try {
+    for await (const d of handle) {
+      if (++seen > CHILD_PROBE) return false;
+      if ((d.isDirectory() || d.isSymbolicLink()) && !skipped(d.name, false)) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    await handle.close().catch(() => void 0);
+  }
+}
+async function subfolderNames(dir, atHome) {
+  const names = [];
+  let handle;
+  try {
+    handle = await (0, import_promises4.opendir)(dir);
+  } catch {
+    return { names, cut: false };
+  }
+  let seen = 0, cut = false;
+  try {
+    for await (const d of handle) {
+      if (++seen > MAX_DIRENTS) {
+        cut = true;
+        break;
+      }
+      if (skipped(d.name, atHome)) continue;
+      if (d.isDirectory()) names.push({ name: d.name, link: false });
+      else if (d.isSymbolicLink()) names.push({ name: d.name, link: true });
+    }
+  } catch {
+  } finally {
+    await handle.close().catch(() => void 0);
+  }
+  return { names, cut };
+}
+async function eachUntil(items, deadline, work) {
+  for (let i = 0; i < items.length; i += CONCURRENCY) {
+    if (Date.now() > deadline) return false;
+    await Promise.all(items.slice(i, i + CONCURRENCY).map((item) => work(item).catch(() => void 0)));
+  }
+  return true;
+}
+var byGitThenName = (a, b) => (a.isGitRepo === b.isGitRepo ? 0 : a.isGitRepo ? -1 : 1) || a.name.localeCompare(b.name, void 0, { sensitivity: "base", numeric: true });
+function fit(answer) {
+  while (answer.entries.length && Buffer.byteLength(JSON.stringify(answer)) > MAX_ANSWER_BYTES) {
+    answer.entries.splice(Math.max(1, Math.floor(answer.entries.length * 0.9)));
+    answer.truncated = true;
+  }
+  return answer;
+}
+async function homeOf(home) {
+  return { logical: home, real: await (0, import_promises4.realpath)(home).catch(() => home) };
+}
+async function listFolders(homePath, rawPath, opts = {}) {
+  const deadline = Date.now() + (opts.budgetMs ?? FOLDER_LIST_BUDGET_MS);
+  const limit = opts.limit ?? FOLDER_LIST_LIMIT;
+  const home = await homeOf(homePath);
+  const real = await resolveBrowsePath(rawPath, home);
+  const atHome = real === home.real;
+  const { names, cut } = await subfolderNames(real, atHome);
+  let truncated = cut;
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  truncated = !await eachUntil(names, deadline, async ({ name, link }) => {
+    let target = (0, import_path4.join)(real, name);
+    if (link) {
+      const st = await (0, import_promises4.stat)(target).catch(() => null);
+      if (!st?.isDirectory()) return;
+      const inside2 = await realInside(home, target);
+      if (!inside2 || inside2 === home.real) return;
+      target = inside2;
+    }
+    if (seen.has(target)) return;
+    seen.add(target);
+    found.push({ name, real: target, isGitRepo: await isGitRepo(target) });
+  }) || truncated;
+  found.sort(byGitThenName);
+  if (found.length > limit) truncated = true;
+  const shown = found.slice(0, limit);
+  const entries = shown.map(() => null);
+  truncated = !await eachUntil(shown.map((f, i) => ({ f, i })), deadline, async ({ f, i }) => {
+    const [remoteUrl, hasChildren] = await Promise.all([f.isGitRepo ? originRemote(f.real) : Promise.resolve(null), hasVisibleChild(f.real)]);
+    entries[i] = { name: f.name, path: logical(home, f.real), isGitRepo: f.isGitRepo, remoteUrl, hasChildren };
+  }) || truncated;
+  const path = logical(home, real);
+  const rel = (0, import_path4.relative)(home.logical, path);
+  const parentReal = atHome ? null : (0, import_path4.resolve)(real, "..");
+  const parent = parentReal && insideOrHome(parentReal, home.real) ? logical(home, parentReal) : null;
+  return fit({ home: "~", homePath: home.logical, path, relative: rel.split(import_path4.sep).join("/"), parent, entries: entries.filter((e) => !!e), truncated });
+}
+async function suggestFolders(homePath, sources, opts = {}) {
+  const started = Date.now();
+  const deadline = started + (opts.budgetMs ?? FOLDER_SUGGEST_BUDGET_MS);
+  const limit = opts.limit ?? FOLDER_SUGGEST_LIMIT;
+  const home = await homeOf(homePath);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  let truncated = false;
+  const add = (real, source) => {
+    if (seen.has(real) || real === home.real) return;
+    if (out.length >= limit) {
+      truncated = true;
+      return;
+    }
+    seen.add(real);
+    out.push({ real, source });
+  };
+  const convoDeadline = started + Math.floor((deadline - started) / 2);
+  const folders = await (opts.conversations ?? ((d) => conversationFolders(sources, d)))(convoDeadline).catch(() => []);
+  for (const folder of folders) {
+    if (Date.now() > deadline) {
+      truncated = true;
+      break;
+    }
+    if (typeof folder !== "string" || folderPathProblem(folder, home.logical) && folderPathProblem(folder, home.real)) continue;
+    let dir = await realInside(home, folder);
+    while (dir && dir !== home.real) {
+      if (await isGitRepo(dir)) {
+        add(dir, "CONVERSATION");
+        break;
+      }
+      const up = (0, import_path4.resolve)(dir, "..");
+      if (up === dir) break;
+      dir = up;
+    }
+  }
+  const roots = [];
+  for (const root of DEV_ROOTS) {
+    const real = await realInside(home, (0, import_path4.join)(home.logical, root));
+    const st = real ? await (0, import_promises4.stat)(real).catch(() => null) : null;
+    if (real && real !== home.real && st?.isDirectory() && !roots.includes(real)) roots.push(real);
+  }
+  const devFound = [];
+  let level = [];
+  for (const root of roots) {
+    if (await isGitRepo(root)) devFound.push(root);
+    else level.push(root);
+  }
+  for (let depth = 1; depth <= SUGGEST_DEPTH && level.length && !truncated; depth++) {
+    const next = [];
+    const finished = await eachUntil(level, deadline, async (dir) => {
+      const { names } = await subfolderNames(dir, false);
+      for (const { name, link } of names) {
+        const child = (0, import_path4.join)(dir, name);
+        const real = link ? await realInside(home, child) : child;
+        if (!real || real === home.real) continue;
+        if (await isGitRepo(real)) devFound.push(real);
+        else if (depth < SUGGEST_DEPTH) next.push(real);
+      }
+    });
+    if (!finished) truncated = true;
+    if (devFound.length + out.length >= limit * 2) {
+      if (next.length) truncated = true;
+      break;
+    }
+    level = next;
+  }
+  devFound.sort((a, b) => (0, import_path4.relative)(home.real, a).localeCompare((0, import_path4.relative)(home.real, b), void 0, { sensitivity: "base", numeric: true }));
+  for (const real of devFound) add(real, "DEV_ROOT");
+  const entries = out.map(() => null);
+  const done = await eachUntil(out.map((f, i) => ({ f, i })), deadline + 1e3, async ({ f, i }) => {
+    const [remoteUrl, hasChildren] = await Promise.all([originRemote(f.real), hasVisibleChild(f.real)]);
+    const path = logical(home, f.real);
+    entries[i] = { name: path.split(/[\\/]/).pop() || path, path, isGitRepo: true, remoteUrl, hasChildren, source: f.source };
+  });
+  return fit({ home: "~", homePath: home.logical, entries: entries.filter((e) => !!e), truncated: truncated || !done });
+}
+
+// src/application/services/workspaceSandbox/machineCli.ts
 var CredentialStore = class {
   constructor(file) {
     this.file = file;
@@ -1651,7 +1992,7 @@ var CredentialStore = class {
     }
   }
   write(data) {
-    (0, import_fs3.mkdirSync)((0, import_path4.dirname)(this.file), { recursive: true, mode: 448 });
+    (0, import_fs3.mkdirSync)((0, import_path5.dirname)(this.file), { recursive: true, mode: 448 });
     const tmp = `${this.file}.${process.pid}.tmp`;
     (0, import_fs3.writeFileSync)(tmp, `${JSON.stringify(data, null, 2)}
 `, { mode: 384 });
@@ -1781,10 +2122,10 @@ var FOLDER_MESSAGES = {
 async function checkFolder(path, home) {
   const shape = folderPathProblem(path, home);
   if (shape) throw new FolderError(shape, FOLDER_MESSAGES[shape] ?? "That folder cannot be connected.");
-  const st = await (0, import_promises4.stat)(path).catch(() => null);
+  const st = await (0, import_promises5.stat)(path).catch(() => null);
   if (!st?.isDirectory()) throw new FolderError("FOLDER_NOT_FOUND", FOLDER_MESSAGES.FOLDER_NOT_FOUND);
-  const real = await (0, import_promises4.realpath)(path);
-  const realHome = await (0, import_promises4.realpath)(home).catch(() => home);
+  const real = await (0, import_promises5.realpath)(path);
+  const realHome = await (0, import_promises5.realpath)(home).catch(() => home);
   const problem = folderPathProblem(real, realHome);
   if (problem) throw new FolderError(problem, FOLDER_MESSAGES[problem] ?? "That folder cannot be connected.");
   return real;
@@ -1792,7 +2133,7 @@ async function checkFolder(path, home) {
 async function folderRemote(path) {
   try {
     const top = (await git(["rev-parse", "--show-toplevel"], { cwd: path })).trim();
-    const realTop = await (0, import_promises4.realpath)(top).catch(() => top);
+    const realTop = await (0, import_promises5.realpath)(top).catch(() => top);
     if (realTop !== path) return null;
     const url = (await git(["config", "--get", "remote.origin.url"], { cwd: path })).trim();
     return url ? stripRemoteCredentials(url) : null;
@@ -1813,33 +2154,42 @@ function claudeProjectDir(cwd) {
 }
 async function copyClaudeTranscript(sources, externalId, root, engineConfigDir) {
   if (!isExternalId(externalId)) return false;
-  const projects = (0, import_path4.join)(sources.claudeDir, "projects");
+  const projects = (0, import_path5.join)(sources.claudeDir, "projects");
   let original = null;
-  for (const dir of await (0, import_promises4.readdir)(projects).catch(() => [])) {
-    const candidate = (0, import_path4.join)(projects, dir, `${externalId}.jsonl`);
-    const st = await (0, import_promises4.lstat)(candidate).catch(() => null);
+  for (const dir of await (0, import_promises5.readdir)(projects).catch(() => [])) {
+    const candidate = (0, import_path5.join)(projects, dir, `${externalId}.jsonl`);
+    const st = await (0, import_promises5.lstat)(candidate).catch(() => null);
     if (st?.isFile()) {
       original = candidate;
       break;
     }
   }
   if (!original) return false;
-  const targetDir = (0, import_path4.join)(engineConfigDir, "projects", claudeProjectDir(root));
-  const target = (0, import_path4.join)(targetDir, `${externalId}.jsonl`);
+  const targetDir = (0, import_path5.join)(engineConfigDir, "projects", claudeProjectDir(root));
+  const target = (0, import_path5.join)(targetDir, `${externalId}.jsonl`);
   if ((0, import_fs3.existsSync)(target)) return true;
-  await (0, import_promises4.mkdir)(targetDir, { recursive: true, mode: 448 });
+  await (0, import_promises5.mkdir)(targetDir, { recursive: true, mode: 448 });
   const partial = `${target}.${process.pid}.partial`;
   try {
     await writeScrubbedTranscript(original, partial);
-    await (0, import_promises4.chmod)(partial, 384).catch(() => void 0);
-    await (0, import_promises4.rename)(partial, target);
+    await (0, import_promises5.chmod)(partial, 384).catch(() => void 0);
+    await (0, import_promises5.rename)(partial, target);
   } catch {
-    await (0, import_promises4.rm)(partial, { force: true }).catch(() => void 0);
+    await (0, import_promises5.rm)(partial, { force: true }).catch(() => void 0);
     return false;
   }
   return true;
 }
 var MAX_MACHINE_SESSIONS = 3;
+var IMPORT_COUNT_INTERVAL_MS = 6 * 60 * 6e4;
+function importableLine(c) {
+  const parts = [];
+  if (c.claudeCode > 0) parts.push(`${c.claudeCode} Claude Code`);
+  if (c.codex > 0) parts.push(`${c.codex} Codex`);
+  if (!parts.length) return null;
+  const total = c.claudeCode + c.codex;
+  return `Found ${parts.join(" and ")} ${total === 1 ? "conversation" : "conversations"} on this computer. You can import ${total === 1 ? "it" : "them"} from the browser.`;
+}
 var MachineAgent = class {
   constructor(deps) {
     this.deps = deps;
@@ -1849,6 +2199,10 @@ var MachineAgent = class {
   abort = new AbortController();
   lastState = "";
   stopped = false;
+  importable = null;
+  lastCountAt = null;
+  /** The terminal line of the last count, printed once the push that carries it went through. */
+  foundLine = null;
   credential() {
     return this.deps.credentials.get(this.deps.api);
   }
@@ -1859,11 +2213,33 @@ var MachineAgent = class {
   async pushState(force = false) {
     const credential = this.credential();
     if (!credential) return;
-    const key = JSON.stringify([credential.name, credential.folders]);
+    const key = JSON.stringify([credential.name, credential.folders, this.importable]);
     if (!force && key === this.lastState) return;
-    await this.deps.client.state(await machineState(credential, this.deps.home, this.deps.info));
+    const state = await machineState(credential, this.deps.home, this.deps.info);
+    await this.deps.client.state(this.importable ? { ...state, importable: this.importable } : state);
     this.lastState = key;
   }
+  /**
+   * Counts the Claude Code and Codex conversations on this computer when `up`
+   * starts and then at most once every 6 hours; the next inventory push carries
+   * the two numbers. Leaves one terminal line when it starts, and again only
+   * when the numbers change. A failed count is skipped until the next interval.
+   */
+  async countImportable() {
+    const now = (this.deps.now ?? Date.now)();
+    if (this.lastCountAt !== null && now - this.lastCountAt < IMPORT_COUNT_INTERVAL_MS) return;
+    const first = this.lastCountAt === null;
+    this.lastCountAt = now;
+    let counts;
+    try {
+      counts = await (this.deps.countImports ?? countImports)(this.deps.sources);
+    } catch {
+      return;
+    }
+    const changed = !this.importable || this.importable.claudeCode !== counts.claudeCode || this.importable.codex !== counts.codex;
+    this.importable = { claudeCode: counts.claudeCode, codex: counts.codex, countedAt: new Date(now).toISOString() };
+    if (first || changed) this.foundLine = importableLine(counts);
+  }
   stop() {
     this.stopped = true;
     this.abort.abort();
@@ -1881,9 +2257,14 @@ var MachineAgent = class {
     let announced = false;
     while (!this.stopped) {
       try {
+        await this.countImportable();
         await this.pushState(!announced);
         if (!announced) this.deps.say("Connected. This computer is available in the ScaleQuality AI Workspace.");
         announced = true;
+        if (this.foundLine) {
+          this.deps.say(this.foundLine);
+          this.foundLine = null;
+        }
         const { commands = [] } = await this.deps.client.commands(this.deps.waitSeconds ?? 25, this.abort.signal);
         backoff = 1e3;
         for (const c of commands) await this.handle(c);
@@ -1914,6 +2295,13 @@ var MachineAgent = class {
         case "scan_imports":
           answer = { ok: true, result: { items: await scanImports(this.deps.sources) } };
           break;
+        // The folder picker of the browser: only folder names, paths and remotes leave this computer, and only when asked.
+        case "list_folders":
+          answer = { ok: true, result: await listFolders(this.deps.home, p.path) };
+          break;
+        case "suggest_folders":
+          answer = { ok: true, result: await suggestFolders(this.deps.home, this.deps.sources) };
+          break;
         case "upload_imports":
           answer = await this.upload(p);
           break;
@@ -1921,7 +2309,7 @@ var MachineAgent = class {
           answer = { ok: false, error: { code: "UNKNOWN_COMMAND" } };
       }
     } catch (e) {
-      answer = { ok: false, error: { code: e instanceof FolderError || e instanceof LocalWorkspaceError ? e.code : "MACHINE_COMMAND_FAILED" } };
+      answer = { ok: false, error: { code: e instanceof FolderError || e instanceof LocalWorkspaceError || e instanceof FolderBrowseError ? e.code : "MACHINE_COMMAND_FAILED" } };
     }
     await this.deps.client.reply(c.id, answer).catch(() => void 0);
   }
@@ -2025,9 +2413,9 @@ function serialPrompt(ask) {
 }
 
 // src/application/services/workspaceSandbox/WorkspaceEngine.ts
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 var import_fs4 = require("fs");
-var import_path7 = require("path");
+var import_path8 = require("path");
 
 // src/application/services/execution/LanguageAdapter.ts
 var import_async_hooks = require("async_hooks");
@@ -2116,15 +2504,15 @@ var ApprovalBroker = class {
       return Promise.resolve(ready);
     }
     if (signal?.aborted) return Promise.resolve(null);
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const onAbort = () => {
         this.waiting.delete(approvalId);
-        resolve6(null);
+        resolve7(null);
       };
       signal?.addEventListener("abort", onAbort, { once: true });
       this.waiting.set(approvalId, (d) => {
         signal?.removeEventListener("abort", onAbort);
-        resolve6(d);
+        resolve7(d);
       });
     });
   }
@@ -6295,8 +6683,8 @@ var coerce = {
 var NEVER = INVALID;
 
 // src/application/services/workspaceSandbox/toolPolicy.ts
-var import_promises5 = require("fs/promises");
-var import_path5 = require("path");
+var import_promises6 = require("fs/promises");
+var import_path6 = require("path");
 var SQ_MCP_SERVER = "scalequality";
 var SQ_MCP_PREFIX = `mcp__${SQ_MCP_SERVER}__`;
 var DENIED_TOOLS = ["WebFetch", "WebSearch", "Task", "Agent", "RemoteTrigger", "CronCreate", "CronDelete", "CronList", "ScheduleWakeup", "PushNotification", "EnterWorktree", "ExitWorktree", "Artifact", "Workflow", "SendFeedback", "ClaudeDesign", "Projects"];
@@ -6334,7 +6722,7 @@ function bashDenial(command, opts = {}) {
   return null;
 }
 function inside(root, abs) {
-  return abs === root || abs.startsWith(root + import_path5.sep);
+  return abs === root || abs.startsWith(root + import_path6.sep);
 }
 async function decideToolUse(toolName, input, ctx) {
   if (toolName.startsWith("mcp__")) {
@@ -6351,13 +6739,13 @@ async function decideToolUse(toolName, input, ctx) {
     const abs = await resolveInside(ctx.root, raw);
     let denied = false;
     for (const d of ctx.deniedRoots ?? []) {
-      const realDenied = await (0, import_promises5.realpath)(d).catch(() => (0, import_path5.resolve)(d));
+      const realDenied = await (0, import_promises6.realpath)(d).catch(() => (0, import_path6.resolve)(d));
       if (abs && inside(realDenied, abs)) denied = true;
     }
     if (abs && !denied) {
       if (toolName in WRITE_TOOLS) {
-        const realRoot = await (0, import_promises5.realpath)(ctx.root).catch(() => (0, import_path5.resolve)(ctx.root));
-        const rel = (0, import_path5.relative)(realRoot, abs).split(import_path5.sep);
+        const realRoot = await (0, import_promises6.realpath)(ctx.root).catch(() => (0, import_path6.resolve)(ctx.root));
+        const rel = (0, import_path6.relative)(realRoot, abs).split(import_path6.sep);
         if (rel.includes(".git")) return { behavior: "deny", message: "Files under .git cannot be written from the workspace." };
       }
       return { behavior: "allow", updatedInput: input };
@@ -6365,7 +6753,7 @@ async function decideToolUse(toolName, input, ctx) {
     if (toolName in READ_TOOLS) {
       for (const extra of ctx.extraReadRoots ?? []) {
         const e = await resolveInside(extra, raw);
-        const realExtra = await (0, import_promises5.realpath)(extra).catch(() => (0, import_path5.resolve)(extra));
+        const realExtra = await (0, import_promises6.realpath)(extra).catch(() => (0, import_path6.resolve)(extra));
         if (e && inside(realExtra, e)) return { behavior: "allow", updatedInput: input };
       }
     }
@@ -6501,7 +6889,7 @@ function buildScaleQualityServer(sdk, host) {
 }
 
 // src/application/services/workspaceSandbox/sdkEventMapper.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 var TERMINAL_TAIL_BYTES = 64 * 1024;
 var FILE_CHANGING = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit", "Bash"]);
 var SQ_TOOL_LABELS = {
@@ -6713,8 +7101,8 @@ function describeTool(name, input, root) {
   const s = (k) => typeof input[k] === "string" ? input[k] : "";
   const rel = (p) => {
     if (!p) return "";
-    if (!(0, import_path6.isAbsolute)(p)) return p;
-    const r = (0, import_path6.relative)(root, p);
+    if (!(0, import_path7.isAbsolute)(p)) return p;
+    const r = (0, import_path7.relative)(root, p);
     return r && !r.startsWith("..") ? r : p;
   };
   switch (name) {
@@ -7047,7 +7435,7 @@ var WorkspaceEngine = class {
   register(r) {
     const repo2 = {
       ...r,
-      measurer: this.deps.createMeasurer && !this.local ? this.deps.createMeasurer(r.repoFullName ?? (0, import_path7.basename)(r.root), r.root) : null,
+      measurer: this.deps.createMeasurer && !this.local ? this.deps.createMeasurer(r.repoFullName ?? (0, import_path8.basename)(r.root), r.root) : null,
       lastDiff: null
     };
     this.repos.set(r.root, repo2);
@@ -7062,14 +7450,14 @@ var WorkspaceEngine = class {
     const short = folderName(lastSegment(repoFullName));
     const full = folderName(repoFullName.split("/").filter(Boolean).join("__"));
     const clash = this.scope.repos.some((r) => r.repoFullName !== repoFullName && folderName(lastSegment(r.repoFullName)) === short);
-    const privateDirs = (this.deps.privateDirs ?? []).map((d) => (0, import_path7.resolve)(d));
+    const privateDirs = (this.deps.privateDirs ?? []).map((d) => (0, import_path8.resolve)(d));
     const taken = (name2) => {
-      const dir = (0, import_path7.resolve)(this.deps.root, name2);
+      const dir = (0, import_path8.resolve)(this.deps.root, name2);
       return this.repos.has(dir) || privateDirs.includes(dir) || (0, import_fs4.existsSync)(dir);
     };
     let name = clash || taken(short) ? full : short;
     for (let n = 2; taken(name); n++) name = `${full}-${n}`;
-    return (0, import_path7.join)(this.deps.root, name);
+    return (0, import_path8.join)(this.deps.root, name);
   }
   /** Clones one repository into its folder and registers it. The token is dropped either way. */
   async cloneInto(access, onStep) {
@@ -7079,7 +7467,7 @@ var WorkspaceEngine = class {
     try {
       prepared = await this.deps.clone(access, dir, saved, onStep);
     } catch (e) {
-      await (0, import_promises6.rm)(dir, { recursive: true, force: true }).catch(() => void 0);
+      await (0, import_promises7.rm)(dir, { recursive: true, force: true }).catch(() => void 0);
       throw e;
     } finally {
       access.token = "";
@@ -7118,7 +7506,7 @@ var WorkspaceEngine = class {
     }
     if (open.length === 1) return { repo: open[0] };
     if (!open.length) return { error: "No repository is open in this workspace. Call list_repositories, then open_repository." };
-    return { error: `Several repositories are open (${open.map((o) => o.repoFullName ?? (0, import_path7.basename)(o.root)).join(", ")}). Pass repoFullName.` };
+    return { error: `Several repositories are open (${open.map((o) => o.repoFullName ?? (0, import_path8.basename)(o.root)).join(", ")}). Pass repoFullName.` };
   }
   notInScope(repo2, target) {
     if (this.inScope(target ?? repo2.repoFullName)) return null;
@@ -7623,8 +8011,8 @@ _Measured on an earlier version of this change._`);
       });
       const opened = out?.pullRequest ?? out;
       const url = typeof opened?.url === "string" ? opened.url : "";
-      const skipped = final.skipped.length ? ` Not included: ${final.skipped.map((s) => `${s.path} (${s.reason})`).join(", ")}.` : "";
-      return text(url ? `Pull request opened on ${target}: ${url} (title: "${editedTitle}").${skipped}` : `The pull request request was accepted.${skipped}`);
+      const skipped2 = final.skipped.length ? ` Not included: ${final.skipped.map((s) => `${s.path} (${s.reason})`).join(", ")}.` : "";
+      return text(url ? `Pull request opened on ${target}: ${url} (title: "${editedTitle}").${skipped2}` : `The pull request request was accepted.${skipped2}`);
     } catch (e) {
       const status = e instanceof SessionGoneError || e instanceof TransportError ? e.status : null;
       if (e instanceof TransportError && e.code === REPOSITORY_NOT_IN_SCOPE) {
@@ -7800,9 +8188,9 @@ function buildQueryOptions(o) {
 }
 async function hasLocalTranscript(configDir, sessionId) {
   if (!/^[A-Za-z0-9-]{8,80}$/.test(sessionId)) return false;
-  const projects = (0, import_path7.join)(configDir, "projects");
-  const dirs = await (0, import_promises6.readdir)(projects).catch(() => []);
-  return dirs.some((d) => (0, import_fs4.existsSync)((0, import_path7.join)(projects, d, `${sessionId}.jsonl`)));
+  const projects = (0, import_path8.join)(configDir, "projects");
+  const dirs = await (0, import_promises7.readdir)(projects).catch(() => []);
+  return dirs.some((d) => (0, import_fs4.existsSync)((0, import_path8.join)(projects, d, `${sessionId}.jsonl`)));
 }
 
 // src/main/workspace-connect.ts
@@ -7818,9 +8206,9 @@ var say = (line = "") => err.write(`${line}
 var cliVersion = process.env.SCALEQUALITY_CLI_VERSION || "dev";
 var userAgent = (mode) => `scalequality-cli/${cliVersion} (${mode}; node ${process.versions.node}; ${process.platform})`;
 var HOME = (0, import_os2.homedir)();
-var SQ_HOME = (0, import_path8.join)(HOME, ".scalequality");
-var ENGINE_HOME = (0, import_path8.join)(SQ_HOME, "workspace");
-var credentials = new CredentialStore((0, import_path8.join)(SQ_HOME, "credentials.json"));
+var SQ_HOME = (0, import_path9.join)(HOME, ".scalequality");
+var ENGINE_HOME = (0, import_path9.join)(SQ_HOME, "workspace");
+var credentials = new CredentialStore((0, import_path9.join)(SQ_HOME, "credentials.json"));
 var NotLocalSessionError = class extends Error {
 };
 function startFailure(e, api) {
@@ -7835,8 +8223,8 @@ function startFailure(e, api) {
   return "ScaleQuality could not start this session. Try again in a moment, or get a new code from the AI Workspace.";
 }
 function engineDirs() {
-  const configDir = (0, import_path8.join)(ENGINE_HOME, "claude-home");
-  const scratch = (0, import_path8.join)(ENGINE_HOME, "tmp");
+  const configDir = (0, import_path9.join)(ENGINE_HOME, "claude-home");
+  const scratch = (0, import_path9.join)(ENGINE_HOME, "tmp");
   (0, import_fs5.mkdirSync)(configDir, { recursive: true, mode: 448 });
   (0, import_fs5.mkdirSync)(scratch, { recursive: true, mode: 448 });
   return { configDir, scratch };
@@ -8068,7 +8456,7 @@ async function upMain(api, verbose) {
     onInterrupt: () => void shutdown()
   }));
   const startSession = ({ sessionId, secret, root }) => {
-    const label = (0, import_path8.basename)(root);
+    const label = (0, import_path9.basename)(root);
     const prefix = style.dim(`[${label}] `);
     const consoleLog = new ConsoleLog(style);
     let resolveDone = () => void 0;
@@ -8131,7 +8519,7 @@ async function upMain(api, verbose) {
 }
 async function addMain(api, path) {
   try {
-    const real = await addFolder(credentials, api, (0, import_path8.resolve)(path ?? process.cwd()), HOME);
+    const real = await addFolder(credentials, api, (0, import_path9.resolve)(path ?? process.cwd()), HOME);
     say(style.green(`Added ${real}.`));
     const credential = credentials.get(api);
     const client = new MachineClient(api, { token: credential.machineToken, userAgent: userAgent("add") });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalequality/cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "ScaleQuality CLI. Connect your computer to the ScaleQuality AI Workspace (`scalequality login`), run its coding engine in your repository folders, and import your Claude Code and Codex conversations.",
   "type": "module",
   "bin": {