@meistrari/remy-cli 1.16.0 → 1.17.1

package/README.md

@@ -38,7 +38,7 @@ The dashboard is the starting point for all interactive work. It refreshes the v
 
 Press `n` in the dashboard. The new-session flow asks what you want done, selects a GitHub installation when needed, suggests repositories based on your request, and lets you review those suggestions. Remy analyzes the request for existing work: a Remy session ID or number, a PR URL or number (`PR 267`, `#267`, or `owner/repo#267`), or an exact or approximate branch name. It verifies matches against the selected repositories and offers up to five branches per repository. In the branch step, use arrows to move, Space to select, and Enter to select the current option and review your choices. Each repository can continue one branch or start a new session branch. A lookup failure stays on a retry screen; press `r` to retry, `n` to explicitly choose new branches, or Esc to edit the request. Before creating the session, choose the agent model and reasoning effort. The wizard starts with `gpt-6-astra` and `medium` reasoning by default. Remy then opens the session and streams its activity.
 
-Use `Tab` while writing the request to complete a local file or directory path. Remy attaches selected paths when you confirm the request. Each file may be at most 20 MiB. A directory may contain at most 20 MiB across its regular files before compression; Remy uploads it as a temporary `<directory>.tar.gz` archive with the selected directory preserved as its root, so the remote agent can extract and use its files. Remy rejects oversized attachments with guidance to choose a smaller file or directory, and rejects directory attachments that contain symbolic links or other non-regular entries. On macOS, `Ctrl+V` adds a PNG from the system clipboard to the request; Remy attaches it on confirmation. Remy uploads attachments before creating the session and shows their filenames beneath your message.
+Use `Tab` while writing the request to complete a local file or directory path. Remy attaches selected paths when you confirm the request. You can also paste an absolute path directly; quote paths containing spaces (for example, `"/Users/me/Desktop/Screen Shot.png"`) or use shell-style backslash escapes. Autocomplete selection is not required. Each file may be at most 20 MiB. A directory may contain at most 20 MiB across its regular files before compression; Remy uploads it as a temporary `<directory>.tar.gz` archive with the selected directory preserved as its root, so the remote agent can extract and use its files. Remy rejects oversized attachments with guidance to choose a smaller file or directory, and rejects directory attachments that contain symbolic links or other non-regular entries. On macOS, `Ctrl+V` saves a clipboard image as a temporary PNG and adds its path to the request; Remy attaches it on confirmation. Remy uploads attachments before creating the session and shows their filenames beneath your message.
 
 ### Resume or follow up
 
@@ -102,6 +102,14 @@ The branch-suggestion flow belongs to the interactive new-session wizard (`remy`
 remy --session <session-id>
 ```
 
+To submit a follow-up immediately, add one quoted positional `prompt`:
+
+```bash
+remy --session <session-id> "Add regression coverage for that fix"
+```
+
+Remy sends the prompt as **Steer**, then opens the conversation. Omitting the prompt only attaches. An explicitly empty prompt is rejected. Use `--` before a prompt beginning with `--` to treat it as text.
+
 ### Automate a session
 
 `remy new` and `remy --session` use JSON Lines output automatically when standard input or output is not a terminal. Pass `--no-tui` to choose that mode explicitly; `--json` also selects it.
@@ -111,8 +119,11 @@ Opaque session and message metadata returned by the API is accepted for compatib
 ```bash
 remy new --no-tui --repository owner/repository "Add a health check endpoint"
 remy --session <session-id> --json
+remy --session <session-id> --no-tui "Add regression coverage for that fix"
 ```
 
+With a follow-up prompt, Remy submits it once and streams JSON Lines until that message reaches a terminal outcome, even if a previous message is cached locally. It exits with status `0` for a completed turn or `1` for another terminal outcome or an API failure. A follow-up does not emit a `created` record because the session already exists. If the local session cache becomes unavailable after admission, Remy warns once and continues observing the accepted follow-up in memory. Do not resubmit the prompt because of that warning; local resume metadata may remain stale. These commands require prior sign-in and can be used by scripts or other agents.
+
 For a newly created session, Remy writes a `created` record, event-name records as they arrive, then a `terminal` record when the submitted turn settles. A completed turn exits with status `0`; another terminal outcome exits with status `1`.
 
 ```json
@@ -154,7 +165,7 @@ remy logout [--api-url <url>]
 remy whoami
 remy dashboard
 remy new [--repository <owner/name> ... --installation <id> --model <name> --reasoning-effort <low|medium|high|xhigh> --attach <path> ... --no-tui --json] <prompt>
-remy --session <session-id> [--no-tui] [--json]
+remy --session <session-id> [--no-tui] [--json] [prompt]
 ```
 
 Run `remy <command> --help` for flags and command-specific usage. `remy whoami` prints the saved signed-in identity and organization.

package/dist/remy.js

@@ -35315,6 +35315,7 @@ function createRemoteSessionController(dependencies) {
   let stopped = false;
   let state;
   let cachedLastRetainedEventId;
+  let cacheUnavailable = false;
   let reasoningPreviewState = initialReasoningPreviewState();
   let reasoningConnectionGeneration = 0;
   let reasoningHistorySequenceFloor = -1;
@@ -35323,7 +35324,10 @@ function createRemoteSessionController(dependencies) {
     ready = new Promise((resolve) => {
       resolveReady = resolve;
     });
-    const cache = await readSessionCache(cachePath);
+    const cache = await readSessionCache(cachePath).catch((error93) => {
+      handleCacheError(error93);
+      return null;
+    });
     cachedLastRetainedEventId = input.mode === "live" ? input.lastRetainedEventId ?? cache?.lastRetainedEventId : undefined;
     state = createSessionViewState({
       detail: input.detail,
@@ -35550,6 +35554,8 @@ function createRemoteSessionController(dependencies) {
     };
   }
   async function writeCache() {
+    if (cacheUnavailable)
+      return;
     const currentState = getState();
     const cache = {
       version: 1,
@@ -35559,7 +35565,13 @@ function createRemoteSessionController(dependencies) {
       ...currentState.activeMessageId ? { activeMessageId: currentState.activeMessageId } : {},
       updatedAt: new Date().toISOString()
     };
-    await writeSessionCache({ path: cachePath, cache });
+    await writeSessionCache({ path: cachePath, cache }).catch(handleCacheError);
+  }
+  function handleCacheError(error93) {
+    if (!dependencies.onCacheError)
+      throw error93;
+    cacheUnavailable = true;
+    dependencies.onCacheError(error93);
   }
   function publishState(frame) {
     const update = { state: getState(), ...frame ? { frame } : {} };
@@ -39350,13 +39362,35 @@ var directoryArchiveMediaType = "application/gzip";
 var directoryArchiveSuffix = ".tar.gz";
 var maxPortableFilenameBytes = 255;
 var attachmentSizeLimitLabel = `${fileUploadMaxBytes / (1024 * 1024)} MiB`;
+var clipboardImageScript = `
+ObjC.import('AppKit');
+const pasteboard = $.NSPasteboard.generalPasteboard;
+let png = pasteboard.dataForType($.NSPasteboardTypePNG);
+if (!png || png.isNil()) {
+    const tiff = pasteboard.dataForType($.NSPasteboardTypeTIFF);
+    if (!tiff || tiff.isNil()) throw new Error('Clipboard does not contain an image.');
+    const bitmap = $.NSBitmapImageRep.imageRepWithData(tiff);
+    if (!bitmap || bitmap.isNil()) throw new Error('Clipboard image could not be decoded.');
+    png = bitmap.representationUsingTypeProperties($.NSPNGFileType, $.NSDictionary.dictionary);
+}
+if (!png || png.isNil()) throw new Error('Clipboard image could not be converted to PNG.');
+if (png.length > ${fileUploadMaxBytes}) throw new Error('Clipboard image is larger than ${attachmentSizeLimitLabel}.');
+ObjC.unwrap(png.base64EncodedStringWithOptions(0));
+`;
 async function readClipboardImage() {
   if (process.platform !== "darwin")
     throw new Error("Clipboard image paste is supported on macOS only.");
-  const clipboard = Bun.spawn(["pbpaste", "-Prefer", "png"], { stdout: "pipe", stderr: "ignore" });
-  const bytes = new Uint8Array(await new Response(clipboard.stdout).arrayBuffer());
-  if (await clipboard.exited !== 0 || !isPng(bytes))
-    throw new Error("Clipboard does not contain an image.");
+  const clipboard = Bun.spawn(["/usr/bin/osascript", "-l", "JavaScript", "-e", clipboardImageScript], { stdout: "pipe", stderr: "pipe" });
+  const [encoded, error93, exitCode] = await Promise.all([
+    new Response(clipboard.stdout).text(),
+    new Response(clipboard.stderr).text(),
+    clipboard.exited
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Could not read clipboard image: ${error93.trim() || "macOS clipboard reader failed."}`);
+  const bytes = new Uint8Array(Buffer2.from(encoded.trim(), "base64"));
+  if (!isPng(bytes))
+    throw new Error("Clipboard image could not be decoded as PNG.");
   return { bytes, mediaType: "image/png" };
 }
 async function writePastedImage({
@@ -39546,8 +39580,11 @@ function promptFilePaths({ text, cwd, selectedPaths }) {
   const paths = new Map;
   for (const selectedPath of selectedPaths)
     paths.set(isAbsolute2(selectedPath) ? selectedPath : resolve2(cwd, selectedPath), true);
-  for (const rawToken of text.split(/\s+/)) {
-    const token = rawToken.replace(/^[([{'"`]+/, "").replace(/[),.;:!?\]}"`]+$/, "");
+  const tokens = text.match(/[([{]*@?(?:"[^"]*"|'[^']*'|`[^`]*`)|(?:\\.|[^\s\\])+/g) ?? [];
+  for (const quotedToken of tokens) {
+    const wrappedToken = quotedToken.replace(/^[([{]+/, "").replace(/[),.;:!?\]}]+$/, "");
+    const quotedPath = /^(@?)(["'`])([\s\S]*)\2$/.exec(wrappedToken);
+    const token = quotedPath ? `${quotedPath[1]}${quotedPath[3]}` : wrappedToken.replace(/\\(.)/g, "$1");
     const pathText = token.startsWith("@") ? token.slice(1) : token;
     if (!pathText)
       continue;
@@ -39596,7 +39633,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.16.0";
+var remyCliVersion = "1.17.1";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -39969,7 +40006,7 @@ async function dispatchCliCommandWithShutdown({
     });
   }
   if (command.name === "session")
-    return await attachSession({ dependencies, sessionId: command.sessionId, noTui: command.noTui, json: command.json });
+    return await attachSession({ dependencies, sessionId: command.sessionId, noTui: command.noTui, json: command.json, prompt: command.prompt });
   return await createNewSession({ dependencies, command });
 }
 function createCliShutdown({ abortSignal }) {
@@ -40876,12 +40913,30 @@ async function attachSession({
   dependencies,
   sessionId,
   noTui,
-  json: json3
+  json: json3,
+  prompt
 }) {
   const operations = await createSessionOperations(dependencies);
   const detail = await operations.getSession({ client: operations.client, sessionId });
   const repositories = detail.repositories.map((repository) => ({ id: repository.id, fullName: repository.full_name }));
   const cache = await (dependencies.readSessionCache ?? readSessionCache)(resolveSessionCachePathForCommand({ dependencies, sessionId }));
+  let activeMessageId = cache?.activeMessageId;
+  let cacheWarningReported = false;
+  const onCacheError = prompt === undefined ? undefined : () => {
+    if (cacheWarningReported)
+      return;
+    cacheWarningReported = true;
+    dependencies.output.writeStderr(`Local session cache is unavailable; continuing to observe the accepted follow-up. Do not resubmit the prompt.
+`);
+  };
+  if (prompt !== undefined) {
+    throwIfAborted2(dependencies.abortSignal);
+    const appended = await operations.appendSessionMessage({
+      client: operations.client,
+      input: { sessionId, text: prompt, fileIds: [], mode: "steer", idempotencyKey: randomUUID5() }
+    });
+    activeMessageId = appended.message.id;
+  }
   await (dependencies.writeSessionCache ?? writeSessionCache)({
     path: resolveSessionCachePathForCommand({ dependencies, sessionId }),
     cache: {
@@ -40889,20 +40944,25 @@ async function attachSession({
       sessionId,
       repositories,
       ...cache?.lastRetainedEventId ? { lastRetainedEventId: cache.lastRetainedEventId } : {},
-      ...cache?.activeMessageId ? { activeMessageId: cache.activeMessageId } : {},
+      ...activeMessageId ? { activeMessageId } : {},
       updatedAt: new Date().toISOString()
     }
+  }).catch((error93) => {
+    if (!onCacheError)
+      throw error93;
+    onCacheError();
   });
   return await runAttachedSession({
     dependencies,
     operations,
     sessionId,
     repositories,
-    activeMessageId: cache?.activeMessageId,
+    activeMessageId,
     start: { mode: "cold-resume", detail },
     noTui,
     json: json3,
-    emitCreated: false
+    emitCreated: false,
+    onCacheError
   });
 }
 async function runAttachedSession({
@@ -40914,7 +40974,8 @@ async function runAttachedSession({
   start,
   noTui,
   json: json3,
-  emitCreated
+  emitCreated,
+  onCacheError
 }) {
   if (dependencies.abortSignal?.aborted)
     throw dependencies.abortSignal.reason ?? new Error("interrupted");
@@ -40924,6 +40985,7 @@ async function runAttachedSession({
     repositories,
     ...activeMessageId ? { activeMessageId } : {},
     environment: dependencies.environment,
+    onCacheError,
     getSession: async ({ sessionId: id }) => await operations.getSession({ client: operations.client, sessionId: id }),
     listSessionEvents: async ({ sessionId: id, limit, after, signal }) => await operations.listSessionEvents({ client: operations.client, sessionId: id, limit, after, signal }),
     openEventStream: ({ sessionId: id, lastRetainedEventId, signal, onSynchronized }) => operations.streamSessionEvents({ client: operations.client, sessionId: id, lastRetainedEventId, signal, onSynchronized })
@@ -41306,10 +41368,15 @@ Options:
 `;
   }
   if (topic === "session") {
-    return `Usage: remy --session <session-id> [options]
+    return `Usage: remy --session <session-id> [options] [prompt]
 
 Attach to an existing remote session. An interactive terminal opens the session view; --no-tui streams output instead.
 
+Arguments:
+  prompt                                  Submit a follow-up as Steer before attaching
+
+With a prompt, JSON output waits for that message's turn result. Use -- before a prompt beginning with --.
+
 Options:
   --no-tui                                Do not open the interactive terminal view
   --json                                  Write session updates as JSON
@@ -41341,8 +41408,8 @@ Usage:
 Commands:
   remy                                      Open interactive dashboard
   remy dashboard                            Open interactive dashboard
-  remy --session <session-id> [--no-tui] [--json]
-                                            Attach to a session
+  remy --session <session-id> [--no-tui] [--json] [prompt]
+                                            Attach to a session, optionally submitting a follow-up
   remy new [--repository <owner/name> ... --installation <id> --model <name> --reasoning-effort <low|medium|high|xhigh> --attach <path> ... --no-tui --json] <prompt>
                                             Create a session
   remy login [--env production|staging] [--api-url <url> --auth-api-url <url> --requester-application-id <uuid> --target-application-id <uuid>]
@@ -41374,14 +41441,32 @@ function parseSessionAttach(argv) {
   const sessionId = argv[0];
   if (!sessionId || sessionId.startsWith("--"))
     throw new Error("--session requires a session ID.");
-  const flags = parseFlags(argv.slice(1));
-  if (typeof flags["no-tui"] === "string" || typeof flags.json === "string")
-    throw new Error("--no-tui and --json do not accept values.");
-  for (const flag of Object.keys(flags)) {
-    if (flag !== "no-tui" && flag !== "json")
-      throw new Error(`Unknown --session flag --${flag}.`);
+  let noTui = false;
+  let json3 = false;
+  let prompt;
+  let positionalOnly = false;
+  for (const token of argv.slice(1)) {
+    if (!positionalOnly && token === "--") {
+      positionalOnly = true;
+      continue;
+    }
+    if (!positionalOnly && token === "--no-tui") {
+      noTui = true;
+      continue;
+    }
+    if (!positionalOnly && token === "--json") {
+      json3 = true;
+      continue;
+    }
+    if (!positionalOnly && token.startsWith("--"))
+      throw new Error(`Unknown --session flag ${token}.`);
+    if (prompt !== undefined)
+      throw new Error("--session accepts one prompt. Quote the full prompt as a single argument.");
+    if (!token.trim())
+      throw new Error("A follow-up prompt must not be empty.");
+    prompt = token;
   }
-  return { name: "session", sessionId, noTui: flags["no-tui"] === true, json: flags.json === true };
+  return { name: "session", sessionId, noTui, json: json3, ...prompt === undefined ? {} : { prompt } };
 }
 function parseNewCommand(argv) {
   const repositories = [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.16.0",
+    "version": "1.17.1",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {