@flowscripter/dynamic-cli-framework 2.0.0 → 2.2.0

package/src/service/printer/DefaultPrinterService.ts

@@ -13,6 +13,7 @@ import { Color } from "./terminal/Color.ts";
 import { getDarkModeTheme, getLightModeTheme } from "./terminal/Theme.ts";
 import { WritableStream } from "node:stream/web";
 import type Styler from "../../terminal/Styler.ts";
+
 export default class DefaultPrinterService implements PrinterService {
   readonly stdoutWritable: WritableStream;
   readonly stderrWritable: WritableStream;
@@ -30,18 +31,16 @@ export default class DefaultPrinterService implements PrinterService {
   #quote: Quote;
   #markedLineCount: number | undefined;
   #markEndedAt: number | undefined;
-  #markedTerminal: Terminal | undefined;
 
   #countLines(message: string): number {
     return message.split("\n").length - (message.endsWith("\n") ? 1 : 0);
   }
 
-  #recordMarkedWrite(terminal: Terminal, message: string): void {
+  #recordMarkedWrite(message: string): void {
     if (this.#markedLineCount === undefined) {
       return;
     }
     this.#markedLineCount += this.#countLines(message);
-    this.#markedTerminal = terminal;
   }
 
   async #log(level: number, message: string, icon?: Icon): Promise<void> {
@@ -51,7 +50,7 @@ export default class DefaultPrinterService implements PrinterService {
     await this.#spinner.pause();
     await this.#progress.pause();
     const composed = `${icon !== undefined ? `${this.#iconDefinitions[icon]} ` : ""}${message}`;
-    this.#recordMarkedWrite(this.#stderrTerminal, composed);
+    this.#recordMarkedWrite(composed);
     await this.#stderrTerminal.write(this.#quote.prefixLines(composed));
     this.#spinner.resume();
     this.#progress.resume();
@@ -277,8 +276,7 @@ export default class DefaultPrinterService implements PrinterService {
     const composed = `${
       icon !== undefined ? `${this.#iconDefinitions[icon]} ` : ""
     }${colorMessage}`;
-    this.#recordMarkedWrite(this.#stdoutTerminal, composed);
-    const encoded = this.#encoder.encode(this.#quote.prefixLines(composed));
+    const encoded = this.#encoder.encode(composed);
 
     await writer.ready;
     await writer.write(encoded);
@@ -318,16 +316,18 @@ export default class DefaultPrinterService implements PrinterService {
     if (this.#markedLineCount === undefined || this.#markEndedAt === undefined) {
       throw new Error("clearMarked() called without a preceding endMark()");
     }
+    if (!this.#stderrTerminal.isTty()) {
+      this.#markedLineCount = undefined;
+      this.#markEndedAt = undefined;
+      return;
+    }
     const remaining = minimumDisplayTimeMs - (Date.now() - this.#markEndedAt);
     if (remaining > 0) {
       await new Promise((resolve) => setTimeout(resolve, remaining));
     }
-    if (this.#markedTerminal !== undefined) {
-      await this.#markedTerminal.clearUpLines(this.#markedLineCount);
-    }
+    await this.#stderrTerminal.clearUpLines(this.#markedLineCount);
     this.#markedLineCount = undefined;
     this.#markEndedAt = undefined;
-    this.#markedTerminal = undefined;
   }
 
   public async setLevel(level: Level): Promise<void> {
@@ -343,6 +343,9 @@ export default class DefaultPrinterService implements PrinterService {
   }
 
   public async showSpinner(message?: string, style?: SpinnerStyle): Promise<void> {
+    if (!this.#stderrTerminal.isTty()) {
+      return;
+    }
     await this.#progress.hideAll();
     if (this.#threshold > Level.INFO) {
       return;
@@ -364,6 +367,9 @@ export default class DefaultPrinterService implements PrinterService {
     current = 0,
     style?: ProgressStyle,
   ): Promise<number> {
+    if (!this.#stderrTerminal.isTty()) {
+      return -1;
+    }
     await this.#spinner.hide();
     if (this.#threshold > Level.INFO) {
       return -1;

package/src/service/spawn/DefaultSpawnService.ts

@@ -0,0 +1,119 @@
+import type {
+  PrinterService,
+  ShutdownService,
+  SpawnOptions,
+  SpawnResult,
+  SpawnService,
+} from "@flowscripter/dynamic-cli-framework-api";
+import getLogger from "../../util/logger.ts";
+
+const logger = getLogger("DefaultSpawnService");
+
+const SHUTDOWN_GRACE_PERIOD_MS = 5000;
+
+export default class DefaultSpawnService implements SpawnService {
+  #printerService: PrinterService | undefined;
+  #shutdownService: ShutdownService | undefined;
+
+  public setDependencies(printerService: PrinterService, shutdownService: ShutdownService): void {
+    this.#printerService = printerService;
+    this.#shutdownService = shutdownService;
+  }
+
+  async #pipeLines(
+    stream: ReadableStream<Uint8Array> | number | undefined,
+    streamName: "stdout" | "stderr",
+    onOutput: (line: string, stream: "stdout" | "stderr") => void,
+  ): Promise<void> {
+    if (typeof stream !== "object" || stream === null) {
+      return;
+    }
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = "";
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        onOutput(buffer.slice(0, newlineIndex), streamName);
+        buffer = buffer.slice(newlineIndex + 1);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) {
+      onOutput(buffer, streamName);
+    }
+  }
+
+  public async spawn(
+    command: ReadonlyArray<string>,
+    options: SpawnOptions = {},
+  ): Promise<SpawnResult> {
+    if (this.#printerService === undefined || this.#shutdownService === undefined) {
+      throw new Error("DefaultSpawnService.spawn() called before setDependencies()");
+    }
+    const printerService = this.#printerService;
+    const shutdownService = this.#shutdownService;
+    const stdio = options.stdio ?? "inherit";
+    const longRunning = options.longRunning ?? true;
+
+    if (stdio === "inherit") {
+      await printerService.hideSpinner();
+      await printerService.hideAllProgressBars();
+    }
+
+    let proc;
+    try {
+      proc = Bun.spawn([...command], {
+        cwd: options.cwd,
+        stdout: stdio === "wrapped" ? "pipe" : "inherit",
+        stderr: stdio === "wrapped" ? "pipe" : "inherit",
+      });
+    } catch (error) {
+      logger.debug(() => `Failed to launch command '${command.join(" ")}': ${error}`);
+      return { ok: false, error: error as Error };
+    }
+
+    let settled = false;
+
+    if (longRunning) {
+      shutdownService.enterLongRunningMode();
+    }
+
+    shutdownService.addShutdownListener(async () => {
+      if (settled) {
+        return;
+      }
+      logger.debug(() => `Sending SIGTERM to spawned command '${command.join(" ")}'`);
+      proc.kill("SIGTERM");
+      await Promise.race([
+        proc.exited.then(() => {}),
+        new Promise<void>((resolve) => setTimeout(resolve, SHUTDOWN_GRACE_PERIOD_MS)),
+      ]);
+      if (!settled) {
+        logger.debug(() => `Sending SIGKILL to spawned command '${command.join(" ")}'`);
+        proc.kill("SIGKILL");
+      }
+    });
+
+    if (stdio === "wrapped" && options.onOutput) {
+      const onOutput = options.onOutput;
+      void this.#pipeLines(proc.stdout, "stdout", onOutput);
+      void this.#pipeLines(proc.stderr, "stderr", onOutput);
+    }
+
+    try {
+      const exitCode = await proc.exited;
+      settled = true;
+      return exitCode === 0 ? { ok: true, exitCode } : { ok: false, exitCode };
+    } finally {
+      if (longRunning) {
+        shutdownService.leaveLongRunningMode();
+      }
+    }
+  }
+}

package/src/service/spawn/SpawnServiceProvider.ts

@@ -0,0 +1,32 @@
+import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
+import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
+import type { PrinterService, ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
+import { PRINTER_SERVICE_ID, SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import DefaultSpawnService from "./DefaultSpawnService.ts";
+
+export default class SpawnServiceProvider implements ServiceProvider {
+  readonly serviceId: string = SPAWN_SERVICE_ID;
+  readonly servicePriority: number;
+  #spawnService: DefaultSpawnService | undefined;
+
+  public constructor(servicePriority: number) {
+    this.servicePriority = servicePriority;
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    this.#spawnService = new DefaultSpawnService();
+    return Promise.resolve({
+      service: this.#spawnService,
+      commands: [],
+    });
+  }
+
+  public initService(context: Context): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
+    const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService;
+    this.#spawnService!.setDependencies(printerService, shutdownService);
+    return Promise.resolve();
+  }
+}

package/src/terminal/NonTtyTerminal.ts

@@ -0,0 +1,48 @@
+import { WriteStream } from "node:tty";
+import type Terminal from "./Terminal.ts";
+
+export default class NonTtyTerminal implements Terminal {
+  readonly #writeStream: NodeJS.WritableStream;
+  readonly #encoder = new TextEncoder();
+
+  constructor(writeStream: NodeJS.WritableStream) {
+    if ((writeStream as WriteStream).isTTY === true) {
+      throw new Error("The provided WriteStream is a TTY");
+    }
+
+    this.#writeStream = writeStream;
+  }
+
+  write(text: string): Promise<void> {
+    this.#writeStream.write(this.#encoder.encode(text));
+    return Promise.resolve();
+  }
+
+  columns(): number {
+    return 80;
+  }
+
+  rows(): number {
+    return 24;
+  }
+
+  clearLine(): Promise<void> {
+    return Promise.reject(new Error("clearLine() is not supported on a non-TTY terminal"));
+  }
+
+  clearUpLines(_count: number): Promise<void> {
+    return Promise.reject(new Error("clearUpLines() is not supported on a non-TTY terminal"));
+  }
+
+  hideCursor(): Promise<void> {
+    return Promise.reject(new Error("hideCursor() is not supported on a non-TTY terminal"));
+  }
+
+  showCursor(): Promise<void> {
+    return Promise.reject(new Error("showCursor() is not supported on a non-TTY terminal"));
+  }
+
+  isTty(): boolean {
+    return false;
+  }
+}

package/src/terminal/Terminal.ts

@@ -6,4 +6,5 @@ export default interface Terminal {
   write(text: string): Promise<void>;
   columns(): number;
   rows(): number;
+  isTty(): boolean;
 }

package/src/terminal/TtyStyler.ts

@@ -17,6 +17,7 @@ export default class TtyStyler implements Styler {
   /**
    * The color level in use.
    *
+   * 0 = no color
    * 1 = 16 color
    * 2 = 256 color
    * 3 = 16 million color
@@ -27,7 +28,7 @@ export default class TtyStyler implements Styler {
   }
 
   colorText(text: string, colorValue: number): string {
-    if (!this.colorEnabled) {
+    if (!this.colorEnabled || this.colorLevel === 0) {
       return text;
     }
 
@@ -43,7 +44,7 @@ export default class TtyStyler implements Styler {
   }
 
   backgroundColorText(text: string, colorValue: number): string {
-    if (!this.colorEnabled) {
+    if (!this.colorEnabled || this.colorLevel === 0) {
       return text;
     }
 
@@ -68,6 +69,9 @@ export default class TtyStyler implements Styler {
   }
 
   italicText(text: string): string {
+    if (!this.colorEnabled || this.colorLevel === 0) {
+      return text;
+    }
     return ITALIC_START + text + ITALIC_END;
   }
 

package/src/terminal/TtyTerminal.ts

@@ -62,4 +62,8 @@ export default class TtyTerminal implements Terminal {
       return 24;
     }
   }
+
+  isTty(): boolean {
+    return true;
+  }
 }