alepha 0.22.0 → 0.24.0

package/src/command/helpers/PrettyAsker.ts

@@ -1,256 +0,0 @@
-import { stdin, stdout } from "node:process";
-import { createInterface as createPromptInterface } from "node:readline/promises";
-import { $inject, Alepha, AlephaError, type TSchema } from "alepha";
-import { ConsoleColorProvider } from "alepha/logger";
-
-/**
- * Clack-style interactive prompt renderer.
- *
- * Provides pretty enum selectors (arrow-key navigation),
- * text inputs, and confirm prompts with box-drawing framing.
- */
-export class PrettyAsker {
-  protected readonly alepha = $inject(Alepha);
-  protected readonly color = $inject(ConsoleColorProvider);
-
-  /**
-   * Whether to use pretty mode.
-   *
-   * Same conditions as Runner.useDynamicLogger.
-   */
-  public get enabled(): boolean {
-    if (this.alepha.isCI() || this.alepha.env.CLAUDECODE) {
-      return false;
-    }
-
-    const logLevel = String(this.alepha.env.LOG_LEVEL || "").toLowerCase();
-    if (logLevel === "debug" || logLevel === "trace") {
-      return false;
-    }
-
-    return true;
-  }
-
-  // ---------------------------------------------------------------------------
-  // Framing
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Print the opening frame with a title.
-   */
-  public intro(title: string): void {
-    const c = this.color;
-    this.write(`\n${c.set("DIM", "┌")}  ${c.set("BOLD", title)}\n`);
-    this.write(`${c.set("DIM", "│")}\n`);
-  }
-
-  /**
-   * Print the closing frame with a message.
-   */
-  public outro(message: string): void {
-    const c = this.color;
-    this.write(`${c.set("DIM", "│")}\n`);
-    this.write(`${c.set("DIM", "└")}  ${message}\n\n`);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Select (arrow-key navigation)
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Arrow-key select prompt for enum schemas.
-   */
-  public async select(question: string, options: string[]): Promise<string> {
-    let selectedIndex = 0;
-
-    this.write(`${this.color.set("DIM", "│")}\n`);
-    this.writeActiveMarker(question);
-    this.renderOptions(options, selectedIndex);
-
-    return new Promise<string>((resolve, reject) => {
-      const hasRawMode = typeof stdin.setRawMode === "function";
-      if (!hasRawMode) {
-        // Fallback: no raw mode (piped stdin, etc.)
-        this.clearOptions(options.length);
-        this.writeCompletedMarker(question);
-        this.writeAnswer(options[0]);
-        resolve(options[0]);
-        return;
-      }
-
-      stdin.setRawMode(true);
-      stdin.resume();
-
-      const onKeypress = (data: Buffer) => {
-        const key = data.toString();
-
-        // Ctrl+C
-        if (key === "\x03") {
-          cleanup();
-          stdin.setRawMode(false);
-          stdin.pause();
-          reject(new AlephaError("Aborted."));
-          return;
-        }
-
-        // Arrow up / k
-        if (key === "\x1b[A" || key === "k") {
-          selectedIndex = (selectedIndex - 1 + options.length) % options.length;
-          this.clearOptions(options.length);
-          this.renderOptions(options, selectedIndex);
-          return;
-        }
-
-        // Arrow down / j
-        if (key === "\x1b[B" || key === "j") {
-          selectedIndex = (selectedIndex + 1) % options.length;
-          this.clearOptions(options.length);
-          this.renderOptions(options, selectedIndex);
-          return;
-        }
-
-        // Enter
-        if (key === "\r" || key === "\n") {
-          cleanup();
-          stdin.setRawMode(false);
-          stdin.pause();
-
-          // Clear options and replace with completed marker + answer
-          this.clearOptions(options.length);
-          this.clearActiveMarker();
-          this.writeCompletedMarker(question);
-          this.writeAnswer(options[selectedIndex]);
-
-          resolve(options[selectedIndex]);
-        }
-      };
-
-      const cleanup = () => {
-        stdin.removeListener("data", onKeypress);
-      };
-
-      stdin.on("data", onKeypress);
-    });
-  }
-
-  // ---------------------------------------------------------------------------
-  // Text input
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Text input prompt with clack framing.
-   */
-  public async text(question: string, schema?: TSchema): Promise<string> {
-    const c = this.color;
-    const defaultValue =
-      schema && "default" in schema ? String(schema.default) : undefined;
-
-    this.write(`${c.set("DIM", "│")}\n`);
-    this.writeActiveMarker(question);
-
-    const defaultHint = defaultValue
-      ? ` ${c.set("DIM", `(${defaultValue})`)}`
-      : "";
-
-    this.write(`${c.set("DIM", "│")}  ${c.set("DIM", ">")}${defaultHint} `);
-
-    const rl = this.createPromptInterface();
-    try {
-      const answer = await rl.question("");
-      const value = answer.trim() || defaultValue || "";
-
-      // Move up to overwrite the input line
-      this.write("\x1b[1A\x1b[2K");
-      // Move up to overwrite the active marker
-      this.clearActiveMarker();
-      this.writeCompletedMarker(question);
-      this.writeAnswer(value);
-
-      if (schema) {
-        return this.alepha.codec.decode(schema, value || undefined) as string;
-      }
-      return value;
-    } finally {
-      rl.close();
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Confirm (Y/n)
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Yes/No confirm prompt with clack framing.
-   */
-  public async confirm(question: string): Promise<boolean> {
-    const c = this.color;
-
-    this.write(`${c.set("DIM", "│")}\n`);
-    this.writeActiveMarker(`${question} ${c.set("DIM", "(Y/n)")}`);
-    this.write(`${c.set("DIM", "│")}  ${c.set("DIM", ">")} `);
-
-    const rl = this.createPromptInterface();
-    try {
-      const answer = await rl.question("");
-      const value = answer.trim().toLowerCase();
-      const result = value !== "n" && value !== "no";
-
-      // Move up to overwrite input
-      this.write("\x1b[1A\x1b[2K");
-      this.clearActiveMarker();
-      this.writeCompletedMarker(question);
-      this.writeAnswer(result ? "Yes" : "No");
-
-      return result;
-    } finally {
-      rl.close();
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Rendering helpers
-  // ---------------------------------------------------------------------------
-
-  protected renderOptions(options: string[], selectedIndex: number): void {
-    const c = this.color;
-    for (let i = 0; i < options.length; i++) {
-      const isSelected = i === selectedIndex;
-      const marker = isSelected
-        ? `${c.set("CYAN", "❯")} ${c.set("CYAN", options[i])}`
-        : `  ${c.set("DIM", options[i])}`;
-      this.write(`${c.set("DIM", "│")}  ${marker}\n`);
-    }
-  }
-
-  protected clearOptions(count: number): void {
-    for (let i = 0; i < count; i++) {
-      this.write("\x1b[1A\x1b[2K");
-    }
-  }
-
-  protected writeActiveMarker(question: string): void {
-    this.write(`${this.color.set("CYAN", "◆")}  ${question}\n`);
-  }
-
-  protected clearActiveMarker(): void {
-    this.write("\x1b[1A\x1b[2K");
-  }
-
-  protected writeCompletedMarker(question: string): void {
-    this.write(`${this.color.set("DIM", "◇")}  ${question}\n`);
-  }
-
-  protected writeAnswer(value: string): void {
-    this.write(
-      `${this.color.set("DIM", "│")}  ${this.color.set("DIM", value)}\n`,
-    );
-  }
-
-  protected write(str: string): void {
-    stdout.write(str);
-  }
-
-  protected createPromptInterface() {
-    return createPromptInterface({ input: stdin, output: stdout });
-  }
-}

package/src/command/helpers/PrettyPrint.ts

@@ -1,332 +0,0 @@
-import { $inject } from "alepha";
-import { DateTimeProvider, type Interval } from "alepha/datetime";
-
-export class PrettyPrint {
-  protected dateTimeProvider = $inject(DateTimeProvider);
-  protected spinnerInterval?: Interval;
-  protected readonly frames = [
-    "⠋",
-    "⠙",
-    "⠹",
-    "⠸",
-    "⠼",
-    "⠴",
-    "⠦",
-    "⠧",
-    "⠇",
-    "⠏",
-  ];
-  protected tasks = new Map<
-    string,
-    {
-      taskName: string;
-      frameIndex: number;
-      status: "running" | "success" | "error";
-      startTime: number;
-      duration?: string;
-      message?: string;
-    }
-  >();
-  protected lastLineCount = 0;
-  protected header?: string;
-  protected commandStartTime?: number;
-  protected paused = false;
-
-  // stdout interception
-  protected originalStdoutWrite?: (...args: any[]) => boolean;
-  protected bufferedOutput: string[] = [];
-  protected isOwnWrite = false;
-
-  // ANSI color codes
-  protected readonly colors = {
-    reset: "\x1b[0m",
-    cyan: "\x1b[36m",
-    green: "\x1b[32m",
-    red: "\x1b[31m",
-    dim: "\x1b[2m",
-  };
-
-  /**
-   * Start a new command session with header
-   */
-  public startCommand(cliName: string, commandName: string): void {
-    this.header = commandName ? `${cliName} ${commandName}` : cliName;
-    this.commandStartTime = this.dateTimeProvider.nowMillis();
-    this.tasks.clear();
-    this.lastLineCount = 0;
-    this.write(`┌─ ${this.header}\n`);
-  }
-
-  /**
-   * End the command session with footer
-   */
-  public endCommand(): void {
-    this.restoreStdout();
-    if (this.commandStartTime) {
-      const totalDuration = (
-        (this.dateTimeProvider.nowMillis() - this.commandStartTime) /
-        1000
-      ).toFixed(1);
-      this.write(`└─ Done in ${totalDuration}s\n`);
-    }
-    this.header = undefined;
-    this.commandStartTime = undefined;
-  }
-
-  /**
-   * Start an animated spinner with a task name
-   */
-  public startSpinner(id: string, taskName: string): void {
-    this.tasks.set(id, {
-      taskName,
-      frameIndex: 0,
-      status: "running",
-      startTime: this.dateTimeProvider.nowMillis(),
-    });
-
-    this.interceptStdout();
-
-    // Start interval if not already running
-    if (!this.spinnerInterval) {
-      this.spinnerInterval = this.dateTimeProvider.createInterval(
-        () => this.updateDisplay(),
-        80,
-        true,
-      );
-    }
-
-    this.updateDisplay();
-  }
-
-  /**
-   * Stop the spinner and show success with a tick
-   */
-  public success(
-    id: string,
-    taskName?: string,
-    duration?: string,
-    message?: string,
-  ): void {
-    const task = this.tasks.get(id);
-    if (task) {
-      task.status = "success";
-      if (taskName) task.taskName = taskName;
-      if (duration) task.duration = duration;
-      if (message) task.message = message;
-      this.updateDisplay();
-    }
-
-    this.checkIfAllDone();
-  }
-
-  /**
-   * Stop the spinner and show error with a cross
-   */
-  public error(id: string, taskName?: string): void {
-    const task = this.tasks.get(id);
-    if (task) {
-      task.status = "error";
-      if (taskName) task.taskName = taskName;
-      this.updateDisplay();
-    }
-
-    this.checkIfAllDone();
-    this.restoreStdout();
-  }
-
-  /**
-   * Update the display for all tasks
-   */
-  protected updateDisplay(): void {
-    // Clear previous spinner lines
-    if (this.lastLineCount > 0) {
-      for (let i = 0; i < this.lastLineCount; i++) {
-        this.write("\x1b[1A\x1b[2K");
-      }
-    }
-
-    // Flush buffered external output (appears permanently above spinner)
-    if (this.bufferedOutput.length > 0) {
-      for (const chunk of this.bufferedOutput) {
-        this.write(chunk);
-      }
-      this.bufferedOutput = [];
-    }
-
-    // Render all tasks
-    const taskArray = Array.from(this.tasks.values());
-    const prefix = this.header ? "│  " : "";
-
-    for (const task of taskArray) {
-      let line = prefix;
-
-      if (task.status === "running") {
-        const frame = this.frames[task.frameIndex];
-        const elapsed = String(
-          Math.floor(
-            (this.dateTimeProvider.nowMillis() - task.startTime) / 100,
-          ) / 10,
-        ).padEnd(3, ".0");
-        line += `${this.colors.cyan}${frame}${this.colors.reset} ${this.colors.dim}${task.taskName}${this.colors.reset}  ${this.colors.dim}${elapsed}s${this.colors.reset}`;
-        task.frameIndex = (task.frameIndex + 1) % this.frames.length;
-      } else if (task.status === "success") {
-        const durationStr = task.duration
-          ? `  ${this.colors.dim}${task.duration}${this.colors.reset}`
-          : "";
-        const messageStr = task.message ? ` - ${task.message}` : "";
-        line += `${this.colors.green}✓${this.colors.reset} ${task.taskName}${durationStr}${messageStr}`;
-      } else if (task.status === "error") {
-        line += `${this.colors.red}✗${this.colors.reset} ${task.taskName}`;
-      }
-
-      this.write(`${line}\n`);
-    }
-
-    this.lastLineCount = taskArray.length;
-  }
-
-  /**
-   * Check if all tasks are done and stop the interval
-   */
-  protected checkIfAllDone(): void {
-    const hasRunningTasks = Array.from(this.tasks.values()).some(
-      (task) => task.status === "running",
-    );
-
-    if (!hasRunningTasks && this.spinnerInterval) {
-      this.dateTimeProvider.clearInterval(this.spinnerInterval);
-      this.spinnerInterval = undefined;
-    }
-  }
-
-  /**
-   * Pause the spinner animation and restore stdout so external processes
-   * (e.g. interactive login) can write to the terminal directly.
-   */
-  public pause(): void {
-    if (this.paused) return;
-    this.paused = true;
-
-    // Stop the animation interval
-    this.stopSpinner();
-
-    // Clear spinner lines from screen so external output starts clean
-    if (this.lastLineCount > 0) {
-      for (let i = 0; i < this.lastLineCount; i++) {
-        this.write("\x1b[1A\x1b[2K");
-      }
-      this.lastLineCount = 0;
-    }
-
-    // Close the box before external output
-    if (this.header) {
-      this.write("└───\n\n");
-    }
-
-    this.restoreStdout();
-  }
-
-  /**
-   * Resume the spinner animation after a pause.
-   */
-  public resume(): void {
-    if (!this.paused) return;
-    this.paused = false;
-
-    // Reopen the box after external output
-    if (this.header) {
-      this.write("\n┌───\n");
-    }
-
-    this.interceptStdout();
-
-    const hasRunningTasks = Array.from(this.tasks.values()).some(
-      (task) => task.status === "running",
-    );
-
-    if (hasRunningTasks) {
-      this.updateDisplay();
-
-      if (!this.spinnerInterval) {
-        this.spinnerInterval = this.dateTimeProvider.createInterval(
-          () => this.updateDisplay(),
-          80,
-          true,
-        );
-      }
-    }
-  }
-
-  /**
-   * Stop the spinner without showing any symbol
-   */
-  public stopSpinner(): void {
-    if (this.spinnerInterval) {
-      this.dateTimeProvider.clearInterval(this.spinnerInterval);
-      this.spinnerInterval = undefined;
-    }
-  }
-
-  /**
-   * Clear all tasks
-   */
-  public clear(): void {
-    this.tasks.clear();
-    this.stopSpinner();
-    this.restoreStdout();
-    this.lastLineCount = 0;
-  }
-
-  // ---------------------------------------------------------------------------
-  // stdout interception
-  // ---------------------------------------------------------------------------
-
-  /**
-   * Intercept process.stdout.write so external writes (logs, wrangler output)
-   * are buffered instead of breaking the spinner animation. Buffered output is
-   * flushed above the spinner area on each redraw.
-   */
-  protected interceptStdout(): void {
-    if (this.originalStdoutWrite) return;
-
-    const original = process.stdout.write.bind(process.stdout);
-    this.originalStdoutWrite = original;
-
-    process.stdout.write = ((
-      chunk: any,
-      encodingOrCb?: any,
-      cb?: any,
-    ): boolean => {
-      if (this.isOwnWrite) {
-        return original(chunk, encodingOrCb, cb);
-      }
-      this.bufferedOutput.push(String(chunk));
-      return true;
-    }) as typeof process.stdout.write;
-  }
-
-  /**
-   * Restore the original process.stdout.write and flush remaining buffer.
-   */
-  protected restoreStdout(): void {
-    if (!this.originalStdoutWrite) return;
-
-    const original = this.originalStdoutWrite;
-    this.originalStdoutWrite = undefined;
-    process.stdout.write = original as typeof process.stdout.write;
-
-    for (const chunk of this.bufferedOutput) {
-      original(chunk);
-    }
-    this.bufferedOutput = [];
-  }
-
-  /**
-   * Write to stdout bypassing the intercept.
-   */
-  protected write(str: string): void {
-    this.isOwnWrite = true;
-    process.stdout.write(str);
-    this.isOwnWrite = false;
-  }
-}

package/src/container/core/__tests__/$container.spec.ts

@@ -1,83 +0,0 @@
-import { Alepha, t } from "alepha";
-import { $action, AlephaServer } from "alepha/server";
-import { AlephaServerLinks } from "alepha/server/links";
-import { describe, it } from "vitest";
-import { AlephaContainer } from "../index.ts";
-import { $container } from "../primitives/$container.ts";
-import { ContainerProvider } from "../providers/ContainerProvider.ts";
-import { NodeContainerProvider } from "../providers/NodeContainerProvider.ts";
-
-describe("$container", () => {
-  it("routes proxy calls through the active provider", async ({ expect }) => {
-    class RocketController {
-      createJob = $action({
-        schema: {
-          body: t.object({ op: t.text() }),
-          response: t.object({ jobId: t.text(), status: t.text() }),
-        },
-        handler: async ({ body }) => ({
-          jobId: `job-${body.op}`,
-          status: "queued",
-        }),
-      });
-    }
-
-    class DeployService {
-      rocket = $container<RocketController>({
-        image: "alepha/rocket:latest",
-      });
-    }
-
-    // In test mode AlephaContainer binds the Mock provider by default,
-    // which routes the proxy's `.createJob(...)` call back through
-    // LinkProvider — so RocketController must live on the same Alepha.
-    const alepha = Alepha.create({ env: { LOG_LEVEL: "warn" } })
-      .with(AlephaServer)
-      .with(AlephaServerLinks)
-      .with(AlephaContainer)
-      .with(RocketController)
-      .with(DeployService);
-
-    await alepha.start();
-
-    const service = alepha.inject(DeployService);
-    const result = await alepha.context.run(() =>
-      (service.rocket as any).createJob({ body: { op: "up" } }),
-    );
-    expect(result).toStrictEqual({ jobId: "job-up", status: "queued" });
-  });
-
-  it("exposes the underlying primitive via instanceof + name", ({ expect }) => {
-    class App {
-      rocket = $container({
-        image: "alepha/rocket:latest",
-        name: "rocket",
-      });
-    }
-
-    const alepha = Alepha.create({ env: {} }).with(AlephaContainer).with(App);
-
-    // Force App instantiation so the primitive registers.
-    const app = alepha.inject(App);
-    expect((app.rocket as any).name).toBe("rocket");
-    expect((app.rocket as any).options.image).toBe("alepha/rocket:latest");
-    expect(alepha.primitives($container).length).toBe(1);
-  });
-
-  it("throws when a Node container has no URL", async ({ expect }) => {
-    class App {
-      rocket = $container({ image: "alepha/rocket:latest" });
-    }
-
-    const alepha = Alepha.create({ env: {} })
-      .with({ provide: ContainerProvider, use: NodeContainerProvider })
-      .with(AlephaContainer)
-      .with(App);
-    await alepha.start();
-
-    const app = alepha.inject(App);
-    await expect(
-      alepha.context.run(() => (app.rocket as any).deploy({ body: {} })),
-    ).rejects.toThrow(/no 'url' configured/i);
-  });
-});