@nimbus-sh/core 0.4.0 → 0.5.0

package/src/substrate/lifo/shell/Shell.ts

@@ -18,7 +18,7 @@ import {
   type TerminalFdState,
   assignScalar,
 } from './interpreter.js';
-import { lex } from './lexer.js';
+import { continuationState, lex } from './lexer.js';
 import { TokenKind } from './types.js';
 import { HistoryManager } from './history.js';
 import { JobTable } from './jobs.js';
@@ -54,6 +54,9 @@ export function formatShellPrompt(env: Record<string, string>, cwd: string): str
   return `${BOLD}${GREEN}${user}@${host}${RESET}:${BOLD}${BLUE}${displayPath}${RESET}$ `;
 }
 
+/** PS2 — shown while an accepted line has not closed into a command yet. */
+const CONTINUATION_PROMPT = '> ';
+
 export interface ExecuteOptions {
   cwd?: string;
   env?: Record<string, string>;
@@ -136,6 +139,13 @@ export class Shell {
   // Paste queue for multiline paste support
   pasteQueue: string[] = [];
 
+  /**
+   * Accepted lines that do not form a complete command yet: an unclosed
+   * quote or a trailing `\` keeps the shell reading under PS2, as bash
+   * does, instead of executing a truncated command.
+   */
+  private pendingLine: string | null = null;
+
   /**
    * Keystrokes that arrived while a foreground command owned the terminal and
    * nothing was reading stdin. A tty buffers type-ahead and hands it to the
@@ -267,6 +277,15 @@ export class Shell {
     return this.vfs;
   }
 
+  /**
+   * The `runAs` host this shell re-credentials through. A caller building a
+   * second Shell over the same kernel needs it, or its commands lose the
+   * identity-transition path `sudo` and `su` are dispatched on.
+   */
+  getRunAsHost(): CommandRunAsHost | undefined {
+    return this.commandIdentity.runAs;
+  }
+
   getRegistry(): CommandRegistry {
     return this.registry;
   }
@@ -442,6 +461,11 @@ export class Shell {
   }
 
   printPrompt(): void {
+    if (this.pendingLine !== null) {
+      this.terminal.write(CONTINUATION_PROMPT);
+      return;
+    }
+
     // Report finished background jobs from JobTable (legacy)
     const doneJobs = this.jobTable.collectDone();
     for (const job of doneJobs) {
@@ -462,57 +486,32 @@ export class Shell {
       return;
     }
 
-    // Multiline paste detection: if data contains newlines and has multiple chars,
-    // split into lines and execute them sequentially via the paste queue
+    // Multiline paste detection: if data contains newlines and has multiple
+    // chars, split into lines and accept them sequentially via the paste
+    // queue. Middle segments are queued even when empty — a blank pasted
+    // line is a newline inside an open quote; only the tail after the final
+    // newline is dropped when empty, because no Enter followed it.
     if (!this.running && data.length > 1 && /[\r\n]/.test(data)) {
       const lines = data.split(/\r\n|\r|\n/);
-      for (let i = 0; i < lines.length; i++) {
-        const segment = lines[i];
-        if (i === 0) {
-          // First segment: append to current lineBuffer and execute
-          if (segment) {
-            this.lineBuffer = this.lineBuffer.slice(0, this.cursorPos) + segment + this.lineBuffer.slice(this.cursorPos);
-            this.cursorPos += segment.length;
-          }
-          if (i < lines.length - 1) {
-            // There's a newline after this segment, execute it
-            this.redrawLine();
-            this.terminal.write('\r\n');
-            const line = this.lineBuffer.trim();
-            this.lineBuffer = '';
-            this.cursorPos = 0;
-            this.historyIndex = -1;
-            if (line) {
-              this.history.push(line);
-              // Queue remaining lines before executing
-              for (let j = 1; j < lines.length - 1; j++) {
-                if (lines[j]) this.pasteQueue.push(lines[j]);
-              }
-              // Last segment (after final newline) goes into lineBuffer without executing
-              const lastSegment = lines[lines.length - 1];
-              if (lastSegment) {
-                this.pasteQueue.push(lastSegment);
-              }
-              this.executeLine(line);
-              return;
-            } else {
-              // Empty first line, queue the rest
-              for (let j = 1; j < lines.length - 1; j++) {
-                if (lines[j]) this.pasteQueue.push(lines[j]);
-              }
-              const lastSegment = lines[lines.length - 1];
-              if (lastSegment) {
-                this.pasteQueue.push(lastSegment);
-              }
-              this.drainPasteQueue();
-              return;
-            }
-          }
-        }
+      const first = lines[0];
+      if (first) {
+        this.lineBuffer = this.lineBuffer.slice(0, this.cursorPos) + first + this.lineBuffer.slice(this.cursorPos);
+        this.cursorPos += first.length;
+      }
+      this.redrawLine();
+      this.terminal.write('\r\n');
+      const line = this.lineBuffer;
+      this.lineBuffer = '';
+      this.cursorPos = 0;
+      this.historyIndex = -1;
+      for (let j = 1; j < lines.length - 1; j++) {
+        this.pasteQueue.push(lines[j]);
       }
-      // If we get here, data had newlines but only one segment (shouldn't happen)
-      // Fall through to normal handling
-      if (this.lineBuffer) this.redrawLine();
+      const lastSegment = lines[lines.length - 1];
+      if (lastSegment) {
+        this.pasteQueue.push(lastSegment);
+      }
+      this.acceptLine(line);
       return;
     }
 
@@ -541,6 +540,7 @@ export class Shell {
         this.abortController.abort(signalAbortReason(signal));
       } else if (signal === 'INT') {
         this.terminal.write('^C\r\n');
+        this.pendingLine = null;
         this.lineBuffer = '';
         this.cursorPos = 0;
         this.screenCursorRow = 0;
@@ -606,18 +606,12 @@ export class Shell {
     // Enter
     if (data === '\r') {
       this.terminal.write('\r\n');
-      const line = this.lineBuffer.trim();
+      const line = this.lineBuffer;
       this.lineBuffer = '';
       this.cursorPos = 0;
       this.screenCursorRow = 0;
       this.historyIndex = -1;
-
-      if (line) {
-        this.history.push(line);
-        this.executeLine(line);
-      } else {
-        this.printPrompt();
-      }
+      this.acceptLine(line);
       return;
     }
 
@@ -802,6 +796,7 @@ export class Shell {
   }
 
   private getPromptWidth(): number {
+    if (this.pendingLine !== null) return CONTINUATION_PROMPT.length;
     const { displayPath, user, host } = shellPromptParts(this.env, this.cwd);
     // "user@host:path$ " — count visible chars only (no ANSI codes)
     return user.length + 1 + host.length + 1 + displayPath.length + 2;
@@ -822,7 +817,9 @@ export class Shell {
     this.terminal.write('\x1b[J');
 
     // Rewrite prompt + buffer
-    this.terminal.write(formatShellPrompt(this.env, this.cwd));
+    this.terminal.write(
+      this.pendingLine === null ? formatShellPrompt(this.env, this.cwd) : CONTINUATION_PROMPT,
+    );
     this.terminal.write(this.lineBuffer);
 
     // After writing all content, figure out which row the cursor is on.
@@ -868,18 +865,10 @@ export class Shell {
 
   drainPasteQueue(): void {
     const next = this.pasteQueue.shift();
-    if (next !== undefined) {
-      const line = next.trim();
-      if (line) {
-        this.terminal.write(line);
-        this.terminal.write('\r\n');
-        this.history.push(line);
-        this.executeLine(line);
-      } else {
-        // Skip empty lines, try next
-        this.drainPasteQueue();
-      }
-    }
+    if (next === undefined) return;
+    this.terminal.write(next);
+    this.terminal.write('\r\n');
+    this.acceptLine(next);
   }
 
   private moveCursorLeft(): void {
@@ -943,6 +932,39 @@ export class Shell {
     this.redrawLine();
   }
 
+  /**
+   * A line the user finished with Enter. If it leaves a quote open or ends
+   * in a line continuation it is not a command yet: bash buffers it, shows
+   * PS2 and keeps reading, and so does this shell. A `\<newline>` join drops
+   * both characters; a quoted join keeps the newline in the string.
+   */
+  private acceptLine(rawLine: string): void {
+    let command: string;
+    if (this.pendingLine === null) {
+      command = rawLine.trim();
+      if (!command) {
+        this.printPrompt();
+        this.drainPasteQueue();
+        return;
+      }
+    } else {
+      command = continuationState(this.pendingLine) === 'backslash'
+        ? this.pendingLine.slice(0, -1) + rawLine
+        : this.pendingLine + '\n' + rawLine;
+    }
+
+    if (continuationState(command) !== null) {
+      this.pendingLine = command;
+      this.printPrompt();
+      this.drainPasteQueue();
+      return;
+    }
+
+    this.pendingLine = null;
+    this.history.push(command);
+    this.executeLine(command);
+  }
+
   async executeLine(line: string): Promise<void> {
     // History expansion
     const expanded = this.historyManager.expand(line);

package/src/substrate/lifo/shell/lexer.ts

@@ -69,6 +69,44 @@ export function lex(input: string): Token[] {
   return tokens;
 }
 
+export type ContinuationState = 'single' | 'double' | 'backslash';
+
+/**
+ * How `input` leaves the lexer at end of input: inside an unclosed single or
+ * double quote, or ending in a `\` line continuation (which bash also honors
+ * inside double quotes, where `\<newline>` is removed). The interactive shell
+ * uses this to keep reading (PS2) instead of executing a truncated command.
+ * Comments are skipped exactly where lex() treats `#` as one.
+ */
+export function continuationState(input: string): ContinuationState | null {
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (quote === "'") {
+      if (ch === "'") quote = null;
+      continue;
+    }
+    if (ch === '\\') {
+      if (i === input.length - 1) return 'backslash';
+      i++;
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === '"') quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === '#') {
+      while (i + 1 < input.length && input[i + 1] !== '\n') i++;
+    }
+  }
+  if (quote === null) return null;
+  return quote === '"' ? 'double' : 'single';
+}
+
 function tryOperator(input: string, pos: number): { token: Token; end: number } | null {
   const ch = input[pos];
   const next = input[pos + 1];

package/src/vfs/seed-project.ts

@@ -25,6 +25,7 @@ import type {
 } from './sqlite-vfs.js';
 import { CHUNK_SIZE } from '../constants.js';
 import { enc } from '../_shared/bytes.js';
+import { errorText } from '../_shared/error-text.js';
 import { CRED_KERNEL } from '../runtime/os-contracts.js';
 
 /** Sentinel: if present, seed never runs again (until user deletes it). */
@@ -1085,9 +1086,15 @@ export function seedProject(
       chunks: [{ path: SEED_SENTINEL_PATH, chunkId: 0, data: sentinelData }],
     });
     log?.(`[seed] sentinel written → ${SEED_SENTINEL_PATH}`);
-  } catch (e: any) {
-    log?.(`[seed] failed: ${e?.message || e}`);
-    return { seeded: false, files: fileCount, reason: e?.message || 'write-failed' };
+  } catch (e) {
+    log?.(`[seed] failed: ${errorText(e)}`);
+    // `reason` keeps its own fallback: a caught value carrying no message
+    // must still report 'write-failed', not the value's text.
+    const reason =
+      typeof e === 'object' && e !== null && 'message' in e && e.message
+        ? String(e.message)
+        : 'write-failed';
+    return { seeded: false, files: fileCount, reason };
   }
 
   return { seeded: true, files: fileCount };