@4xeoz/re-entry 0.2.3 → 0.2.4

package/README.md

@@ -19,8 +19,8 @@ npx @4xeoz/re-entry install
 This uses the deployed Re-entry Cloud Receiver by default:
 `https://reentry-cloud.vercel.app`.
 
-The interactive CLI lets you choose the Codex workspace with ↑/↓ and Enter. If you want to choose
-the workspace explicitly, pass it directly:
+The interactive CLI first offers Desktop, the current folder, or a small folder browser. Choose
+with ↑/↓ and Enter. If you want to skip the picker, pass the workspace directly:
 
 ```sh
 npx @4xeoz/re-entry install \
@@ -31,11 +31,11 @@ Run this from the Host project directory, your home directory, or another normal
 directory—not from a checked-out `runtime/local-connector` package directory. npm can treat that
 source directory as the package itself and fail to create the temporary executable link.
 
-If npm prints `sh: re-entry: command not found`, the package is present but that npm installation
-has an `npx` temporary-bin `PATH` bug. Use the reliable one-time global installation instead:
+If your npm installation cannot create the temporary `npx` executable, use the one-time global
+installation instead:
 
 ```sh
-npm install --global @4xeoz/re-entry@0.2.1
+npm install --global @4xeoz/re-entry
 re-entry install --codex-cd /absolute/path/to/your/project
 ```
 
@@ -51,8 +51,8 @@ npx --yes --package=@4xeoz/re-entry re-entry install \
 `re-entry install` performs the whole user setup:
 
 ```text
-check Node + find Codex + validate project directory
-  -> choose the Codex workspace with ↑/↓ and Enter when --codex-cd is omitted
+choose Desktop, the current folder, or another Codex workspace
+  -> check Node + find Codex + validate the selected directory
   -> request a device authorization from Re-entry
   -> show the verification URL and wait for the user to press Enter
   -> open Re-entry in the default browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4xeoz/re-entry",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "type": "module",
   "description": "Outbound Local Connector process for the Re-entry Core local preview.",
   "publishConfig": {

package/src/main.mjs

@@ -32,6 +32,7 @@ import { createTerminalUi } from "./terminal-ui.mjs";
 const DEFAULT_RECEIVER_ORIGIN = process.env.REENTRY_RECEIVER_ORIGIN ?? "https://reentry-cloud.vercel.app";
 const DEFAULT_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_MAX_CONSECUTIVE_ERRORS = 5;
+const DEFAULT_PAIRING_REQUEST_TIMEOUT_MS = 20_000;
 const CONNECTOR_VERSION = readConnectorVersion();
 
 async function main() {
@@ -207,9 +208,14 @@ async function pair(flags, ui, options = {}) {
   }
   const userCode = flags.code ?? await askForPairingCode(ui);
   if (ui.interactive) ui.step("Pairing code", "received");
-  const client = new LocalConnectorPairingClient({ baseUrl: receiver });
+  const client = new LocalConnectorPairingClient({
+    baseUrl: receiver,
+    requestTimeoutMs: DEFAULT_PAIRING_REQUEST_TIMEOUT_MS,
+  });
+  if (ui.interactive) ui.wait("Contacting Re-entry…");
   const credentials = await client.pair({ userCode }, async ({ verificationUri }) => {
     if (ui.interactive) {
+      ui.stopWait("Re-entry ready", "approval link created");
       ui.step("Browser", "press Enter to open the Re-entry approval page");
       ui.info("Open this URL", verificationUri);
       await waitForEnterToOpenBrowser();
@@ -271,11 +277,16 @@ async function connect(flags, ui, options = {}) {
     ui.step("Re-entry", receiver);
     ui.step("This Mac", flags["device-name"] ?? defaultDeviceName());
   }
-  const client = new LocalConnectorPairingClient({ baseUrl: receiver });
+  const client = new LocalConnectorPairingClient({
+    baseUrl: receiver,
+    requestTimeoutMs: DEFAULT_PAIRING_REQUEST_TIMEOUT_MS,
+  });
+  if (ui.interactive) ui.wait("Contacting Re-entry…");
   const credentials = await client.connect(
     { deviceName: flags["device-name"] ?? defaultDeviceName() },
     async ({ verificationUri }) => {
       if (ui.interactive) {
+        ui.stopWait("Re-entry ready", "secure approval link created");
         ui.step("Browser", "press Enter to open Re-entry sign-in and approval");
         ui.info("If it does not open", verificationUri);
         await waitForEnterToOpenBrowser();
@@ -802,6 +813,10 @@ function errorHint(error) {
     pairing_code_invalid: "use the 16-character code returned by the Host, for example ABCD-EFGH-IJKL-MNOP",
     host_subject_already_paired: "use the existing Connector credential or revoke/reset the preview pairing",
     pairing_expired: "ask the Host backend for a new pairing code",
+    pairing_request_timeout: "the Receiver took too long to answer; check your connection and run the command again",
+    pairing_network_error: "check your internet connection and the Receiver address, then try again",
+    workspace_directory_unavailable: "choose a readable folder or pass --codex-cd /absolute/path",
+    workspace_selection_cancelled: "run the command again when you are ready to choose a workspace",
     device_authorization_expired: "run `re-entry connect` again and approve within ten minutes",
     device_authorization_denied: "run `re-entry connect` again when you are ready to approve this Mac",
     connector_poll_interval_invalid: "use a polling interval between 1000 and 60000 milliseconds",

package/src/workspace-picker.mjs

@@ -1,10 +1,10 @@
-import { readdir } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import process from "node:process";
 
-const MAX_VISIBLE_DIRECTORIES = 40;
+const MAX_VISIBLE_DIRECTORIES = 12;
 
 /**
  * Let an interactive user choose the directory passed to Codex as its workspace.
@@ -19,19 +19,47 @@ export async function chooseWorkspaceDirectory(options = {}) {
 
   const homeDirectory = resolve(options.homeDirectory ?? homedir());
   const preferredDirectory = resolve(options.startDirectory ?? process.cwd());
-  let current = homeDirectory;
-  const shortcuts = shortcutDirectories(homeDirectory);
   let selected = 0;
   const wasRaw = Boolean(input.isRaw);
   emitKeypressEvents(input);
   input.setRawMode(true);
 
   try {
+    const quickChoices = await createQuickChoices({ homeDirectory, preferredDirectory });
+    while (true) {
+      renderPicker(output, {
+        title: "Choose where Codex should open for approved work.",
+        choices: quickChoices,
+        selected,
+      });
+      const key = await readKey(input);
+      if (key.name === "up") {
+        selected = (selected - 1 + quickChoices.length) % quickChoices.length;
+      } else if (key.name === "down") {
+        selected = (selected + 1) % quickChoices.length;
+      } else if (key.name === "return" || key.name === "enter") {
+        const choice = quickChoices[selected];
+        if (choice.action === "use") return choice.path;
+        if (choice.action === "cancel") throw cancelledFailure();
+        break;
+      } else if (key.name === "escape" || key.sequence === "\u0003") {
+        throw cancelledFailure();
+      }
+    }
+
+    let current = homeDirectory;
+    selected = 0;
     while (true) {
       const directories = await readableDirectories(current);
-      const choices = createChoices({ current, homeDirectory, preferredDirectory, shortcuts, directories });
+      const choices = createBrowserChoices({ current, directories });
       selected = Math.min(selected, choices.length - 1);
-      renderPicker(output, current, choices, selected);
+      renderPicker(output, {
+        title: "Choose another folder.",
+        current,
+        choices,
+        selected,
+        truncated: directories.truncated,
+      });
       const key = await readKey(input);
       if (key.name === "up") {
         selected = (selected - 1 + choices.length) % choices.length;
@@ -40,13 +68,11 @@ export async function chooseWorkspaceDirectory(options = {}) {
       } else if (key.name === "return" || key.name === "enter") {
         const choice = choices[selected];
         if (choice.action === "use") return choice.path;
-        if (choice.action === "cancel") {
-          throw pickerFailure("workspace_selection_cancelled", "Workspace selection was cancelled");
-        }
+        if (choice.action === "cancel") throw cancelledFailure();
         current = choice.path;
         selected = 0;
       } else if (key.name === "escape" || key.sequence === "\u0003") {
-        throw pickerFailure("workspace_selection_cancelled", "Workspace selection was cancelled");
+        throw cancelledFailure();
       }
     }
   } finally {
@@ -55,55 +81,94 @@ export async function chooseWorkspaceDirectory(options = {}) {
   }
 }
 
-function createChoices({ current, homeDirectory, preferredDirectory, shortcuts, directories }) {
+async function createQuickChoices({ homeDirectory, preferredDirectory }) {
   const choices = [];
-  if (current === homeDirectory && preferredDirectory !== homeDirectory) {
-    choices.push({ label: `Use current folder  ${preferredDirectory}`, action: "use", path: preferredDirectory });
+  const desktop = join(homeDirectory, "Desktop");
+  if (await isDirectory(desktop)) {
+    choices.push({
+      label: "Use Desktop (recommended)",
+      detail: desktop,
+      action: "use",
+      path: desktop,
+    });
   }
-  choices.push({ label: `Use this folder  ${current}`, action: "use", path: current });
-  if (current === homeDirectory) {
-    for (const shortcut of shortcuts) {
-      if (directories.some((directory) => directory.path === shortcut.path)) {
-        choices.push({ label: `Open ${shortcut.label}`, action: "open", path: shortcut.path });
-      }
-    }
+  if (preferredDirectory !== desktop && await isDirectory(preferredDirectory)) {
+    choices.push({
+      label: "Use current folder",
+      detail: preferredDirectory,
+      action: "use",
+      path: preferredDirectory,
+    });
   }
+  if (choices.length === 0) {
+    choices.push({
+      label: "Use Home",
+      detail: homeDirectory,
+      action: "use",
+      path: homeDirectory,
+    });
+  }
+  choices.push({ label: "Choose another folder…", action: "browse", path: homeDirectory });
+  choices.push({ label: "Cancel", action: "cancel", path: null });
+  return choices;
+}
+
+function createBrowserChoices({ current, directories }) {
+  const choices = [
+    { label: "Use this folder", detail: current, action: "use", path: current },
+  ];
   const parent = dirname(current);
-  if (parent !== current) choices.push({ label: `Go up  ${parent}`, action: "open", path: parent });
-  const shortcutPaths = new Set(shortcuts.map((shortcut) => shortcut.path));
-  for (const directory of directories) {
-    if (current === homeDirectory && shortcutPaths.has(directory.path)) continue;
-    choices.push({ label: `Open ${directory.name}`, action: "open", path: directory.path });
+  if (parent !== current) {
+    choices.push({ label: "Go up", detail: parent, action: "open", path: parent });
+  }
+  for (const directory of directories.items) {
+    choices.push({ label: directory.name, action: "open", path: directory.path });
   }
   choices.push({ label: "Cancel", action: "cancel", path: null });
   return choices;
 }
 
-async function readableDirectories(directory) {
-  const entries = await readdir(directory, { withFileTypes: true });
-  return entries
-    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
-    .sort((left, right) => left.name.localeCompare(right.name))
-    .slice(0, MAX_VISIBLE_DIRECTORIES)
-    .map((entry) => ({ name: entry.name, path: join(directory, entry.name) }));
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
 }
 
-function shortcutDirectories(home) {
-  return [
-    { label: "Desktop", path: join(home, "Desktop") },
-    { label: "Documents", path: join(home, "Documents") },
-    { label: "Downloads", path: join(home, "Downloads") },
-    { label: "Home", path: home },
-  ];
+async function readableDirectories(directory) {
+  let entries;
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    const failure = pickerFailure("workspace_directory_unavailable", `Cannot open ${directory}`);
+    failure.cause = error;
+    throw failure;
+  }
+  const directories = entries
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+    .sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    items: directories
+      .slice(0, MAX_VISIBLE_DIRECTORIES)
+      .map((entry) => ({ name: entry.name, path: join(directory, entry.name) })),
+    truncated: directories.length > MAX_VISIBLE_DIRECTORIES,
+  };
 }
 
-function renderPicker(output, current, choices, selected) {
+function renderPicker(output, { title, current, choices, selected, truncated = false }) {
   output.write("\u001b[2J\u001b[H");
   output.write("RE-ENTRY WORKSPACE\n\n");
-  output.write("Choose the folder where Codex will work. Files stay inside this workspace.\n");
-  output.write(`Current folder: ${current}\n\n`);
+  output.write(`${title}\n`);
+  if (current) output.write(`Current folder: ${current}\n`);
+  output.write("\n");
   for (let index = 0; index < choices.length; index += 1) {
-    output.write(`${index === selected ? "❯" : " "} ${choices[index].label}\n`);
+    const choice = choices[index];
+    output.write(`${index === selected ? "❯" : " "} ${choice.label}\n`);
+    if (choice.detail) output.write(`    ${choice.detail}\n`);
+  }
+  if (truncated) {
+    output.write(`\nShowing the first ${MAX_VISIBLE_DIRECTORIES} folders. Open a folder to continue.\n`);
   }
   output.write("\n↑/↓ Move   Enter Select   Esc Cancel");
 }
@@ -118,6 +183,10 @@ function readKey(input) {
   });
 }
 
+function cancelledFailure() {
+  return pickerFailure("workspace_selection_cancelled", "Workspace selection was cancelled");
+}
+
 function pickerFailure(code, message) {
   const error = new Error(message);
   error.code = code;