@_davideast/stitch-mcp 0.3.2 → 0.5.0

package/dist/chunk-sdp429xd.js

@@ -0,0 +1,914 @@
+import {
+  require_cli_spinners
+} from "./chunk-nq68kghz.js";
+import {
+  eastAsianWidth,
+  require_emoji_regex,
+  stripAnsi
+} from "./chunk-mv9ssgmx.js";
+import {
+  GcloudExecutor
+} from "./chunk-nthabjd9.js";
+import {
+  isUnicodeSupported
+} from "./chunk-4jygt4d6.js";
+import {
+  onExit
+} from "./chunk-tz7wnw4s.js";
+import {
+  source_default
+} from "./chunk-3sfn889r.js";
+import {
+  __toESM
+} from "./chunk-9wyra8hs.js";
+
+// src/services/stitch/iam.ts
+class StitchIamService {
+  executor;
+  constructor(executor) {
+    this.executor = executor;
+  }
+  async configureIAM(input) {
+    try {
+      const role = "roles/serviceusage.serviceUsageConsumer";
+      const member = `user:${input.userEmail}`;
+      const result = await this.executor.exec([
+        "projects",
+        "add-iam-policy-binding",
+        input.projectId,
+        `--member=${member}`,
+        `--role=${role}`,
+        "--condition=None",
+        "--quiet"
+      ]);
+      if (!result.success) {
+        const errorMsg = result.stderr || result.error || result.stdout || "Unknown error";
+        return {
+          success: false,
+          error: {
+            code: "IAM_CONFIG_FAILED",
+            message: `Failed to configure IAM permissions: ${errorMsg}`,
+            suggestion: "Ensure you have Owner or Editor role on the project",
+            recoverable: true,
+            details: `Exit code: ${result.exitCode}
+Stderr: ${result.stderr}
+Stdout: ${result.stdout}`
+          }
+        };
+      }
+      return {
+        success: true,
+        data: {
+          role,
+          member
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "IAM_CONFIG_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  async checkIAMRole(input) {
+    try {
+      const role = "roles/serviceusage.serviceUsageConsumer";
+      const member = `user:${input.userEmail}`;
+      const result = await this.executor.exec([
+        "projects",
+        "get-iam-policy",
+        input.projectId,
+        `--flatten=bindings[].members`,
+        `--filter=bindings.role=${role} AND bindings.members=${member}`,
+        "--format=value(bindings.members)"
+      ]);
+      return result.success && result.stdout.trim().includes(member);
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/services/stitch/api.ts
+class StitchApiService {
+  executor;
+  constructor(executor) {
+    this.executor = executor;
+  }
+  async enableAPI(input) {
+    try {
+      const api = "stitch.googleapis.com";
+      const result = await this.executor.exec(["beta", "services", "mcp", "enable", api, `--project=${input.projectId}`, "--quiet"]);
+      if (!result.success) {
+        const errorMsg = result.stderr || result.error || result.stdout || "Unknown error";
+        return {
+          success: false,
+          error: {
+            code: "API_ENABLE_FAILED",
+            message: `Failed to enable Stitch API: ${errorMsg}`,
+            suggestion: "Ensure the project has billing enabled",
+            recoverable: true,
+            details: `Exit code: ${result.exitCode}
+Stderr: ${result.stderr}
+Stdout: ${result.stdout}`
+          }
+        };
+      }
+      return {
+        success: true,
+        data: {
+          api,
+          enabled: true
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "API_ENABLE_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  async checkAPIEnabled(input) {
+    try {
+      const result = await this.executor.exec([
+        "services",
+        "list",
+        `--project=${input.projectId}`,
+        "--enabled",
+        "--filter=name:stitch.googleapis.com",
+        "--format=value(name)"
+      ]);
+      return result.success && result.stdout.trim().includes("stitch.googleapis.com");
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/services/stitch/connection.ts
+class StitchConnectionService {
+  async testConnectionWithApiKey(input) {
+    try {
+      const url = process.env.STITCH_HOST || "https://stitch.googleapis.com/mcp";
+      const payload = {
+        method: "tools/call",
+        jsonrpc: "2.0",
+        params: {
+          name: "list_projects",
+          arguments: {}
+        },
+        id: 1
+      };
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          "X-Goog-Api-Key": input.apiKey
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        let errorDetails = "";
+        let errorMessage = `API request failed with status ${response.status}`;
+        try {
+          const errorBody = await response.json();
+          errorDetails = JSON.stringify(errorBody, null, 2);
+          if (errorBody?.error?.message) {
+            errorMessage = errorBody.error.message;
+          }
+        } catch {
+          try {
+            errorDetails = await response.text();
+          } catch {
+            errorDetails = `Status ${response.status}: ${response.statusText}`;
+          }
+        }
+        return {
+          success: false,
+          error: {
+            code: response.status === 403 ? "PERMISSION_DENIED" : "CONNECTION_TEST_FAILED",
+            message: errorMessage,
+            suggestion: response.status === 403 ? "Check that your API key is valid and has access to the Stitch API" : "Verify API key configuration and try again",
+            recoverable: true,
+            details: errorDetails
+          }
+        };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        data: {
+          connected: true,
+          statusCode: response.status,
+          url,
+          response: data
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "CONNECTION_TEST_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  async testConnection(input) {
+    try {
+      const url = process.env.STITCH_HOST || "https://stitch.googleapis.com/mcp";
+      const payload = {
+        method: "tools/call",
+        jsonrpc: "2.0",
+        params: {
+          name: "list_projects",
+          arguments: {}
+        },
+        id: 1
+      };
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          Authorization: `Bearer ${input.accessToken}`,
+          "X-Goog-User-Project": input.projectId
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        let errorDetails = "";
+        let errorMessage = `API request failed with status ${response.status}`;
+        try {
+          const errorBody = await response.json();
+          errorDetails = JSON.stringify(errorBody, null, 2);
+          if (errorBody?.error?.message) {
+            errorMessage = errorBody.error.message;
+          }
+        } catch {
+          try {
+            errorDetails = await response.text();
+          } catch {
+            errorDetails = `Status ${response.status}: ${response.statusText}`;
+          }
+        }
+        return {
+          success: false,
+          error: {
+            code: response.status === 403 ? "PERMISSION_DENIED" : "CONNECTION_TEST_FAILED",
+            message: errorMessage,
+            suggestion: response.status === 403 ? "Check IAM permissions and ensure API is enabled" : "Verify project configuration and try again",
+            recoverable: true,
+            details: errorDetails
+          }
+        };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        data: {
+          connected: true,
+          statusCode: response.status,
+          url,
+          response: data
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "CONNECTION_TEST_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+}
+
+// src/services/stitch/handler.ts
+class StitchHandler {
+  executor;
+  iamService;
+  apiService;
+  connectionService;
+  constructor() {
+    this.executor = new GcloudExecutor;
+    this.iamService = new StitchIamService(this.executor);
+    this.apiService = new StitchApiService(this.executor);
+    this.connectionService = new StitchConnectionService;
+  }
+  async configureIAM(input) {
+    return this.iamService.configureIAM(input);
+  }
+  async enableAPI(input) {
+    return this.apiService.enableAPI(input);
+  }
+  async checkIAMRole(input) {
+    return this.iamService.checkIAMRole(input);
+  }
+  async checkAPIEnabled(input) {
+    return this.apiService.checkAPIEnabled(input);
+  }
+  async testConnectionWithApiKey(input) {
+    return this.connectionService.testConnectionWithApiKey(input);
+  }
+  async testConnection(input) {
+    return this.connectionService.testConnection(input);
+  }
+}
+
+// node_modules/ora/index.js
+import process6 from "node:process";
+
+// node_modules/ora/node_modules/cli-cursor/index.js
+import process3 from "node:process";
+
+// node_modules/ora/node_modules/cli-cursor/node_modules/restore-cursor/index.js
+import process2 from "node:process";
+
+// node_modules/mimic-function/index.js
+var copyProperty = (to, from, property, ignoreNonConfigurable) => {
+  if (property === "length" || property === "prototype") {
+    return;
+  }
+  if (property === "arguments" || property === "caller") {
+    return;
+  }
+  const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+  if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+    return;
+  }
+  Object.defineProperty(to, property, fromDescriptor);
+};
+var canCopyProperty = function(toDescriptor, fromDescriptor) {
+  return toDescriptor === undefined || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+};
+var changePrototype = (to, from) => {
+  const fromPrototype = Object.getPrototypeOf(from);
+  if (fromPrototype === Object.getPrototypeOf(to)) {
+    return;
+  }
+  Object.setPrototypeOf(to, fromPrototype);
+};
+var wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`;
+var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
+var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
+var changeToString = (to, from, name) => {
+  const withName = name === "" ? "" : `with ${name.trim()}() `;
+  const newToString = wrappedToString.bind(null, withName, from.toString());
+  Object.defineProperty(newToString, "name", toStringName);
+  const { writable, enumerable, configurable } = toStringDescriptor;
+  Object.defineProperty(to, "toString", { value: newToString, writable, enumerable, configurable });
+};
+function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
+  const { name } = to;
+  for (const property of Reflect.ownKeys(from)) {
+    copyProperty(to, from, property, ignoreNonConfigurable);
+  }
+  changePrototype(to, from);
+  changeToString(to, from, name);
+  return to;
+}
+
+// node_modules/onetime/index.js
+var calledFunctions = new WeakMap;
+var onetime = (function_, options = {}) => {
+  if (typeof function_ !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  let returnValue;
+  let callCount = 0;
+  const functionName = function_.displayName || function_.name || "<anonymous>";
+  const onetime2 = function(...arguments_) {
+    calledFunctions.set(onetime2, ++callCount);
+    if (callCount === 1) {
+      returnValue = function_.apply(this, arguments_);
+      function_ = undefined;
+    } else if (options.throw === true) {
+      throw new Error(`Function \`${functionName}\` can only be called once`);
+    }
+    return returnValue;
+  };
+  mimicFunction(onetime2, function_);
+  calledFunctions.set(onetime2, callCount);
+  return onetime2;
+};
+onetime.callCount = (function_) => {
+  if (!calledFunctions.has(function_)) {
+    throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+  }
+  return calledFunctions.get(function_);
+};
+var onetime_default = onetime;
+
+// node_modules/ora/node_modules/cli-cursor/node_modules/restore-cursor/index.js
+var terminal = process2.stderr.isTTY ? process2.stderr : process2.stdout.isTTY ? process2.stdout : undefined;
+var restoreCursor = terminal ? onetime_default(() => {
+  onExit(() => {
+    terminal.write("\x1B[?25h");
+  }, { alwaysLast: true });
+}) : () => {};
+var restore_cursor_default = restoreCursor;
+
+// node_modules/ora/node_modules/cli-cursor/index.js
+var isHidden = false;
+var cliCursor = {};
+cliCursor.show = (writableStream = process3.stderr) => {
+  if (!writableStream.isTTY) {
+    return;
+  }
+  isHidden = false;
+  writableStream.write("\x1B[?25h");
+};
+cliCursor.hide = (writableStream = process3.stderr) => {
+  if (!writableStream.isTTY) {
+    return;
+  }
+  restore_cursor_default();
+  isHidden = true;
+  writableStream.write("\x1B[?25l");
+};
+cliCursor.toggle = (force, writableStream) => {
+  if (force !== undefined) {
+    isHidden = force;
+  }
+  if (isHidden) {
+    cliCursor.show(writableStream);
+  } else {
+    cliCursor.hide(writableStream);
+  }
+};
+var cli_cursor_default = cliCursor;
+
+// node_modules/ora/index.js
+var import_cli_spinners = __toESM(require_cli_spinners(), 1);
+
+// node_modules/ora/node_modules/log-symbols/node_modules/is-unicode-supported/index.js
+import process4 from "node:process";
+function isUnicodeSupported2() {
+  if (process4.platform !== "win32") {
+    return process4.env.TERM !== "linux";
+  }
+  return Boolean(process4.env.CI) || Boolean(process4.env.WT_SESSION) || Boolean(process4.env.TERMINUS_SUBLIME) || process4.env.ConEmuTask === "{cmd::Cmder}" || process4.env.TERM_PROGRAM === "Terminus-Sublime" || process4.env.TERM_PROGRAM === "vscode" || process4.env.TERM === "xterm-256color" || process4.env.TERM === "alacritty" || process4.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// node_modules/ora/node_modules/log-symbols/index.js
+var main = {
+  info: source_default.blue("ℹ"),
+  success: source_default.green("✔"),
+  warning: source_default.yellow("⚠"),
+  error: source_default.red("✖")
+};
+var fallback = {
+  info: source_default.blue("i"),
+  success: source_default.green("√"),
+  warning: source_default.yellow("‼"),
+  error: source_default.red("×")
+};
+var logSymbols = isUnicodeSupported2() ? main : fallback;
+var log_symbols_default = logSymbols;
+
+// node_modules/ora/node_modules/string-width/index.js
+var import_emoji_regex = __toESM(require_emoji_regex(), 1);
+var segmenter = new Intl.Segmenter;
+var defaultIgnorableCodePointRegex = /^\p{Default_Ignorable_Code_Point}$/u;
+function stringWidth(string, options = {}) {
+  if (typeof string !== "string" || string.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  if (!countAnsiEscapeCodes) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment: character } of segmenter.segment(string)) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
+      continue;
+    }
+    if (codePoint >= 8203 && codePoint <= 8207 || codePoint === 65279) {
+      continue;
+    }
+    if (codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071) {
+      continue;
+    }
+    if (codePoint >= 55296 && codePoint <= 57343) {
+      continue;
+    }
+    if (codePoint >= 65024 && codePoint <= 65039) {
+      continue;
+    }
+    if (defaultIgnorableCodePointRegex.test(character)) {
+      continue;
+    }
+    if (import_emoji_regex.default().test(character)) {
+      width += 2;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// node_modules/is-interactive/index.js
+function isInteractive({ stream = process.stdout } = {}) {
+  return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
+}
+
+// node_modules/stdin-discarder/index.js
+import process5 from "node:process";
+var ASCII_ETX_CODE = 3;
+
+class StdinDiscarder {
+  #activeCount = 0;
+  start() {
+    this.#activeCount++;
+    if (this.#activeCount === 1) {
+      this.#realStart();
+    }
+  }
+  stop() {
+    if (this.#activeCount <= 0) {
+      throw new Error("`stop` called more times than `start`");
+    }
+    this.#activeCount--;
+    if (this.#activeCount === 0) {
+      this.#realStop();
+    }
+  }
+  #realStart() {
+    if (process5.platform === "win32" || !process5.stdin.isTTY) {
+      return;
+    }
+    process5.stdin.setRawMode(true);
+    process5.stdin.on("data", this.#handleInput);
+    process5.stdin.resume();
+  }
+  #realStop() {
+    if (!process5.stdin.isTTY) {
+      return;
+    }
+    process5.stdin.off("data", this.#handleInput);
+    process5.stdin.pause();
+    process5.stdin.setRawMode(false);
+  }
+  #handleInput(chunk) {
+    if (chunk[0] === ASCII_ETX_CODE) {
+      process5.emit("SIGINT");
+    }
+  }
+}
+var stdinDiscarder = new StdinDiscarder;
+var stdin_discarder_default = stdinDiscarder;
+
+// node_modules/ora/index.js
+var import_cli_spinners2 = __toESM(require_cli_spinners(), 1);
+
+class Ora {
+  #linesToClear = 0;
+  #isDiscardingStdin = false;
+  #lineCount = 0;
+  #frameIndex = -1;
+  #lastSpinnerFrameTime = 0;
+  #options;
+  #spinner;
+  #stream;
+  #id;
+  #initialInterval;
+  #isEnabled;
+  #isSilent;
+  #indent;
+  #text;
+  #prefixText;
+  #suffixText;
+  color;
+  constructor(options) {
+    if (typeof options === "string") {
+      options = {
+        text: options
+      };
+    }
+    this.#options = {
+      color: "cyan",
+      stream: process6.stderr,
+      discardStdin: true,
+      hideCursor: true,
+      ...options
+    };
+    this.color = this.#options.color;
+    this.spinner = this.#options.spinner;
+    this.#initialInterval = this.#options.interval;
+    this.#stream = this.#options.stream;
+    this.#isEnabled = typeof this.#options.isEnabled === "boolean" ? this.#options.isEnabled : isInteractive({ stream: this.#stream });
+    this.#isSilent = typeof this.#options.isSilent === "boolean" ? this.#options.isSilent : false;
+    this.text = this.#options.text;
+    this.prefixText = this.#options.prefixText;
+    this.suffixText = this.#options.suffixText;
+    this.indent = this.#options.indent;
+    if (process6.env.NODE_ENV === "test") {
+      this._stream = this.#stream;
+      this._isEnabled = this.#isEnabled;
+      Object.defineProperty(this, "_linesToClear", {
+        get() {
+          return this.#linesToClear;
+        },
+        set(newValue) {
+          this.#linesToClear = newValue;
+        }
+      });
+      Object.defineProperty(this, "_frameIndex", {
+        get() {
+          return this.#frameIndex;
+        }
+      });
+      Object.defineProperty(this, "_lineCount", {
+        get() {
+          return this.#lineCount;
+        }
+      });
+    }
+  }
+  get indent() {
+    return this.#indent;
+  }
+  set indent(indent = 0) {
+    if (!(indent >= 0 && Number.isInteger(indent))) {
+      throw new Error("The `indent` option must be an integer from 0 and up");
+    }
+    this.#indent = indent;
+    this.#updateLineCount();
+  }
+  get interval() {
+    return this.#initialInterval ?? this.#spinner.interval ?? 100;
+  }
+  get spinner() {
+    return this.#spinner;
+  }
+  set spinner(spinner) {
+    this.#frameIndex = -1;
+    this.#initialInterval = undefined;
+    if (typeof spinner === "object") {
+      if (spinner.frames === undefined) {
+        throw new Error("The given spinner must have a `frames` property");
+      }
+      this.#spinner = spinner;
+    } else if (!isUnicodeSupported()) {
+      this.#spinner = import_cli_spinners.default.line;
+    } else if (spinner === undefined) {
+      this.#spinner = import_cli_spinners.default.dots;
+    } else if (spinner !== "default" && import_cli_spinners.default[spinner]) {
+      this.#spinner = import_cli_spinners.default[spinner];
+    } else {
+      throw new Error(`There is no built-in spinner named '${spinner}'. See https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json for a full list.`);
+    }
+  }
+  get text() {
+    return this.#text;
+  }
+  set text(value = "") {
+    this.#text = value;
+    this.#updateLineCount();
+  }
+  get prefixText() {
+    return this.#prefixText;
+  }
+  set prefixText(value = "") {
+    this.#prefixText = value;
+    this.#updateLineCount();
+  }
+  get suffixText() {
+    return this.#suffixText;
+  }
+  set suffixText(value = "") {
+    this.#suffixText = value;
+    this.#updateLineCount();
+  }
+  get isSpinning() {
+    return this.#id !== undefined;
+  }
+  #getFullPrefixText(prefixText = this.#prefixText, postfix = " ") {
+    if (typeof prefixText === "string" && prefixText !== "") {
+      return prefixText + postfix;
+    }
+    if (typeof prefixText === "function") {
+      return prefixText() + postfix;
+    }
+    return "";
+  }
+  #getFullSuffixText(suffixText = this.#suffixText, prefix = " ") {
+    if (typeof suffixText === "string" && suffixText !== "") {
+      return prefix + suffixText;
+    }
+    if (typeof suffixText === "function") {
+      return prefix + suffixText();
+    }
+    return "";
+  }
+  #updateLineCount() {
+    const columns = this.#stream.columns ?? 80;
+    const fullPrefixText = this.#getFullPrefixText(this.#prefixText, "-");
+    const fullSuffixText = this.#getFullSuffixText(this.#suffixText, "-");
+    const fullText = " ".repeat(this.#indent) + fullPrefixText + "--" + this.#text + "--" + fullSuffixText;
+    this.#lineCount = 0;
+    for (const line of stripAnsi(fullText).split(`
+`)) {
+      this.#lineCount += Math.max(1, Math.ceil(stringWidth(line, { countAnsiEscapeCodes: true }) / columns));
+    }
+  }
+  get isEnabled() {
+    return this.#isEnabled && !this.#isSilent;
+  }
+  set isEnabled(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isEnabled` option must be a boolean");
+    }
+    this.#isEnabled = value;
+  }
+  get isSilent() {
+    return this.#isSilent;
+  }
+  set isSilent(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isSilent` option must be a boolean");
+    }
+    this.#isSilent = value;
+  }
+  frame() {
+    const now = Date.now();
+    if (this.#frameIndex === -1 || now - this.#lastSpinnerFrameTime >= this.interval) {
+      this.#frameIndex = ++this.#frameIndex % this.#spinner.frames.length;
+      this.#lastSpinnerFrameTime = now;
+    }
+    const { frames } = this.#spinner;
+    let frame = frames[this.#frameIndex];
+    if (this.color) {
+      frame = source_default[this.color](frame);
+    }
+    const fullPrefixText = typeof this.#prefixText === "string" && this.#prefixText !== "" ? this.#prefixText + " " : "";
+    const fullText = typeof this.text === "string" ? " " + this.text : "";
+    const fullSuffixText = typeof this.#suffixText === "string" && this.#suffixText !== "" ? " " + this.#suffixText : "";
+    return fullPrefixText + frame + fullText + fullSuffixText;
+  }
+  clear() {
+    if (!this.#isEnabled || !this.#stream.isTTY) {
+      return this;
+    }
+    this.#stream.cursorTo(0);
+    for (let index = 0;index < this.#linesToClear; index++) {
+      if (index > 0) {
+        this.#stream.moveCursor(0, -1);
+      }
+      this.#stream.clearLine(1);
+    }
+    if (this.#indent || this.lastIndent !== this.#indent) {
+      this.#stream.cursorTo(this.#indent);
+    }
+    this.lastIndent = this.#indent;
+    this.#linesToClear = 0;
+    return this;
+  }
+  render() {
+    if (this.#isSilent) {
+      return this;
+    }
+    this.clear();
+    this.#stream.write(this.frame());
+    this.#linesToClear = this.#lineCount;
+    return this;
+  }
+  start(text) {
+    if (text) {
+      this.text = text;
+    }
+    if (this.#isSilent) {
+      return this;
+    }
+    if (!this.#isEnabled) {
+      if (this.text) {
+        this.#stream.write(`- ${this.text}
+`);
+      }
+      return this;
+    }
+    if (this.isSpinning) {
+      return this;
+    }
+    if (this.#options.hideCursor) {
+      cli_cursor_default.hide(this.#stream);
+    }
+    if (this.#options.discardStdin && process6.stdin.isTTY) {
+      this.#isDiscardingStdin = true;
+      stdin_discarder_default.start();
+    }
+    this.render();
+    this.#id = setInterval(this.render.bind(this), this.interval);
+    return this;
+  }
+  stop() {
+    if (!this.#isEnabled) {
+      return this;
+    }
+    clearInterval(this.#id);
+    this.#id = undefined;
+    this.#frameIndex = 0;
+    this.clear();
+    if (this.#options.hideCursor) {
+      cli_cursor_default.show(this.#stream);
+    }
+    if (this.#options.discardStdin && process6.stdin.isTTY && this.#isDiscardingStdin) {
+      stdin_discarder_default.stop();
+      this.#isDiscardingStdin = false;
+    }
+    return this;
+  }
+  succeed(text) {
+    return this.stopAndPersist({ symbol: log_symbols_default.success, text });
+  }
+  fail(text) {
+    return this.stopAndPersist({ symbol: log_symbols_default.error, text });
+  }
+  warn(text) {
+    return this.stopAndPersist({ symbol: log_symbols_default.warning, text });
+  }
+  info(text) {
+    return this.stopAndPersist({ symbol: log_symbols_default.info, text });
+  }
+  stopAndPersist(options = {}) {
+    if (this.#isSilent) {
+      return this;
+    }
+    const prefixText = options.prefixText ?? this.#prefixText;
+    const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
+    const symbolText = options.symbol ?? " ";
+    const text = options.text ?? this.text;
+    const separatorText = symbolText ? " " : "";
+    const fullText = typeof text === "string" ? separatorText + text : "";
+    const suffixText = options.suffixText ?? this.#suffixText;
+    const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
+    const textToWrite = fullPrefixText + symbolText + fullText + fullSuffixText + `
+`;
+    this.stop();
+    this.#stream.write(textToWrite);
+    return this;
+  }
+}
+function ora(options) {
+  return new Ora(options);
+}
+
+// src/ui/spinner.ts
+class Spinner {
+  spinner = null;
+  start(message) {
+    this.spinner = ora({
+      text: message,
+      color: "blue",
+      spinner: "dots"
+    }).start();
+  }
+  succeed(message) {
+    if (this.spinner) {
+      this.spinner.succeed(message);
+      this.spinner = null;
+    }
+  }
+  fail(message) {
+    if (this.spinner) {
+      this.spinner.fail(message);
+      this.spinner = null;
+    }
+  }
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+}
+function createSpinner() {
+  return new Spinner;
+}
+
+export { StitchHandler, createSpinner };
+
+//# debugId=97879FD05296F9BA64756E2164756E21