@next-vibe/checker 1.0.11 → 1.0.13

package/src/app/api/[locale]/system/unified-interface/cli/setup/install/repository.ts

@@ -0,0 +1,421 @@
+/**
+ * Setup Install Repository
+ * Business logic for CLI global installation
+ * Following migration guide: Repository-only logic pattern
+ */
+
+import "server-only";
+
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import {
+  ErrorResponseTypes,
+  fail,
+  success,
+} from "next-vibe/shared/types/response.schema";
+import { parseError } from "next-vibe/shared/utils";
+
+import type { CountryLanguage } from "@/i18n/core/config";
+import { simpleT } from "@/i18n/core/shared";
+
+import type { JwtPayloadType } from "../../../../../user/auth/types";
+import type { InstallRequestOutput, InstallResponseOutput } from "./definition";
+
+/**
+ * Setup Install Repository Interface
+ */
+export interface SetupInstallRepository {
+  installCli(
+    data: InstallRequestOutput,
+    user: JwtPayloadType,
+    locale: CountryLanguage,
+  ): Promise<ResponseType<InstallResponseOutput>>;
+}
+
+/**
+ * Setup Install Repository Implementation
+ */
+class SetupInstallRepositoryImpl implements SetupInstallRepository {
+  // eslint-disable-next-line i18next/no-literal-string
+  private readonly NPM_UNLINK_ARGS = ["unlink", "-g"] as const;
+  private readonly NPM_LINK_ARGS = ["link"] as const;
+  private readonly NPM_LINK_FORCE_ARGS = ["link", "--force"] as const;
+
+  /**
+   * Get the appropriate binary directory for the current platform
+   */
+  private getBinaryDirectory(): string {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+
+    switch (platform) {
+      case "win32": {
+        // Windows: Use a directory in PATH or create one
+
+        const windowsPath =
+          // eslint-disable-next-line i18next/no-literal-string
+          process.env.APPDATA || path.join(homeDir, "AppData", "Roaming");
+
+        return path.join(windowsPath, "vibe", "bin");
+      }
+
+      case "darwin":
+      case "linux":
+        // macOS and Linux: Use ~/.local/bin (commonly in PATH)
+        // eslint-disable-next-line i18next/no-literal-string
+        return path.join(homeDir, ".local", "bin");
+
+      default:
+        // Return a fallback path for unsupported platforms
+        // eslint-disable-next-line i18next/no-literal-string
+        return path.join(homeDir, ".local", "bin");
+    }
+  }
+
+  /**
+   * Get the binary filename for the current platform
+   */
+  private getBinaryFilename(): string {
+    return os.platform() === "win32" ? "vibe.cmd" : "vibe";
+  }
+
+  /**
+   * Create the binary content for the current platform
+   */
+  private createBinaryContent(vibeTsPath: string): string {
+    const platform = os.platform();
+
+    if (platform === "win32") {
+      // Windows batch file
+      // eslint-disable-next-line i18next/no-literal-string
+      return `@echo off
+setlocal enabledelayedexpansion
+
+REM Vibe CLI Windows Binary
+REM Executes vibe.ts with Bun
+
+REM Execute with Bun
+bun "${vibeTsPath}" %*
+
+REM Exit with the same code as the Bun process
+exit /b %errorlevel%
+`;
+    }
+    // Unix shell script (Linux/macOS)
+    // eslint-disable-next-line i18next/no-literal-string
+    return `#!/bin/bash
+
+# Vibe CLI Unix Binary
+# Executes vibe.ts with Bun
+
+# Execute with Bun
+exec bun "${vibeTsPath}" "$@"
+`;
+  }
+
+  /**
+   * Check if bun is available
+   */
+  private async checkBunAvailable(): Promise<boolean> {
+    try {
+      await this.runCommand("bun", ["--version"], {
+        verbose: false,
+        ignoreErrors: true,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async installCli(
+    data: InstallRequestOutput,
+    user: JwtPayloadType,
+    locale: CountryLanguage,
+  ): Promise<ResponseType<InstallResponseOutput>> {
+    const { t } = simpleT(locale);
+
+    // Validate user permissions for CLI installation
+    if (!user?.id) {
+      return fail({
+        message:
+          "app.api.system.unifiedInterface.cli.setup.install.post.errors.unauthorized.title",
+        errorType: ErrorResponseTypes.UNAUTHORIZED,
+        messageParams: {
+          error: t(
+            "app.api.system.unifiedInterface.cli.setup.install.post.errors.unauthorized.description",
+          ),
+        },
+      });
+    }
+
+    try {
+      // Check if already installed
+      const status = await this.checkInstallationStatus();
+
+      if (status.installed && !data.force) {
+        return success({
+          success: true,
+          installed: true,
+          version: status.version,
+          path: status.path,
+          message: status.path
+            ? t(
+                "app.api.system.unifiedInterface.cli.setup.install.post.success.description",
+              )
+            : t(
+                "app.api.system.unifiedInterface.cli.setup.install.post.success.description",
+              ),
+        });
+      }
+
+      // Check if Bun is available
+      const bunAvailable = await this.checkBunAvailable();
+      if (!bunAvailable) {
+        return fail({
+          message:
+            "app.api.system.unifiedInterface.cli.setup.install.post.errors.server.title",
+          errorType: ErrorResponseTypes.INTERNAL_ERROR,
+          messageParams: {
+            error:
+              // eslint-disable-next-line i18next/no-literal-string
+              "Bun is not installed or not in PATH. Please install Bun first: curl -fsSL https://bun.sh/install | bash",
+            // eslint-disable-next-line i18next/no-literal-string
+            command: "bun --version",
+          },
+        });
+      }
+
+      // Get paths for Bun-based installation
+
+      /* eslint-disable i18next/no-literal-string */
+      const vibeTsPath = path.join(
+        process.cwd(),
+        "src",
+        "app",
+        "api",
+        "[locale]",
+        "system",
+        "unified-interface",
+        "cli",
+        "vibe-runtime.ts",
+      );
+      /* eslint-enable i18next/no-literal-string */
+
+      // Verify vibe-runtime.ts exists
+      if (!existsSync(vibeTsPath)) {
+        return fail({
+          message:
+            "app.api.system.unifiedInterface.cli.setup.install.post.errors.server.title",
+          errorType: ErrorResponseTypes.INTERNAL_ERROR,
+          messageParams: {
+            // eslint-disable-next-line i18next/no-literal-string
+            error: `vibe-runtime.ts not found at ${vibeTsPath}`,
+
+            cwd: process.cwd(),
+          },
+        });
+      }
+
+      // Get binary installation paths
+      const binDir = this.getBinaryDirectory();
+      const binaryFilename = this.getBinaryFilename();
+      const targetPath = path.join(binDir, binaryFilename);
+
+      // Remove existing binary if force is enabled
+      if (data.force && existsSync(targetPath)) {
+        try {
+          const fs = await import("node:fs/promises");
+          await fs.unlink(targetPath);
+        } catch {
+          // Ignore removal errors
+        }
+      }
+
+      // Ensure binary directory exists
+      try {
+        mkdirSync(binDir, { recursive: true });
+      } catch (error) {
+        const parsedError = parseError(error);
+        return fail({
+          message:
+            "app.api.system.unifiedInterface.cli.setup.install.post.errors.server.title",
+          errorType: ErrorResponseTypes.INTERNAL_ERROR,
+          messageParams: {
+            // eslint-disable-next-line i18next/no-literal-string
+            error: `Failed to create directory`,
+
+            directory: binDir,
+
+            reason: parsedError.message,
+          },
+        });
+      }
+
+      // Create binary content
+      const binaryContent = this.createBinaryContent(vibeTsPath);
+
+      // Write binary file
+      writeFileSync(targetPath, binaryContent, { mode: 0o755 });
+
+      // Make executable on Unix systems
+      if (os.platform() !== "win32") {
+        chmodSync(targetPath, 0o755);
+      }
+
+      // eslint-disable-next-line i18next/no-literal-string
+      let output = `Binary installed at ${targetPath}`;
+
+      // Add to PATH on Windows if needed
+      if (os.platform() === "win32") {
+        // eslint-disable-next-line i18next/no-literal-string
+        output += `\nNote: You may need to add ${binDir} to your PATH manually or restart your terminal`;
+      } else {
+        // eslint-disable-next-line i18next/no-literal-string
+        output += `\nNote: Make sure ${binDir} is in your PATH. Add this to your shell profile if needed:\nexport PATH="${binDir}:$PATH"`;
+      }
+
+      // Verify installation
+      const newStatus = await this.checkInstallationStatus();
+
+      return success({
+        success: newStatus.installed,
+        installed: newStatus.installed,
+        version: newStatus.version,
+        path: newStatus.path,
+        message: newStatus.installed
+          ? t(
+              "app.api.system.unifiedInterface.cli.setup.install.post.success.description",
+            )
+          : t(
+              "app.api.system.unifiedInterface.cli.setup.install.post.errors.server.description",
+            ),
+        output: data.verbose ? output : undefined,
+      });
+    } catch (error) {
+      const parsedError = parseError(error);
+      return fail({
+        message:
+          "app.api.system.unifiedInterface.cli.setup.install.post.errors.server.title",
+        errorType: ErrorResponseTypes.INTERNAL_ERROR,
+        messageParams: {
+          // eslint-disable-next-line i18next/no-literal-string
+          error: "CLI installation failed",
+
+          reason: parsedError.message,
+          // eslint-disable-next-line i18next/no-literal-string
+          stack: parsedError.stack || "No stack trace available",
+        },
+      });
+    }
+  }
+
+  private async checkInstallationStatus(): Promise<{
+    installed: boolean;
+    version?: string;
+    path?: string;
+  }> {
+    try {
+      // Check common installation paths directly instead of using which/where
+      const possiblePaths = [
+        // eslint-disable-next-line i18next/no-literal-string
+        path.join(process.env.HOME || "/tmp", ".local", "bin", "vibe"),
+        // eslint-disable-next-line i18next/no-literal-string
+        path.join(process.env.HOME || "/tmp", ".yarn", "bin", "vibe"),
+
+        "/usr/local/bin/vibe",
+
+        "/usr/bin/vibe",
+      ];
+
+      for (const vibePath of possiblePaths) {
+        if (existsSync(vibePath)) {
+          // Get version
+          let version: string | undefined;
+          try {
+            const packageJsonPath = path.join(process.cwd(), "package.json");
+            if (existsSync(packageJsonPath)) {
+              const packageJson = JSON.parse(
+                await readFile(packageJsonPath, "utf8"),
+              ) as { version?: string };
+              version = packageJson.version;
+            }
+          } catch {
+            // Ignore version detection errors
+          }
+
+          return {
+            installed: true,
+            version,
+            path: vibePath,
+          };
+        }
+      }
+
+      return { installed: false };
+    } catch {
+      return { installed: false };
+    }
+  }
+
+  private async runCommand(
+    command: string,
+    args: string[],
+    options: {
+      cwd?: string;
+      verbose?: boolean;
+      ignoreErrors?: boolean;
+    } = {},
+  ): Promise<string> {
+    return await new Promise((resolve, reject) => {
+      const childProcess = spawn(command, args, {
+        cwd: options.cwd || process.cwd(),
+        stdio: options.verbose ? "inherit" : "pipe",
+        shell: false, // Disable shell to avoid security warnings
+
+        env: { ...process.env, NODE_ENV: "development" },
+      });
+
+      let output = "";
+      let errorOutput = "";
+
+      if (!options.verbose) {
+        childProcess.stdout?.on("data", (data: Buffer) => {
+          output += data.toString();
+        });
+
+        childProcess.stderr?.on("data", (data: Buffer) => {
+          errorOutput += data.toString();
+        });
+      }
+
+      childProcess.on("close", (code: number | null) => {
+        if (code === 0 || options.ignoreErrors) {
+          resolve(output);
+        } else {
+          const errorMessage =
+            // eslint-disable-next-line i18next/no-literal-string
+            errorOutput || output || `Command failed with code ${code}`;
+          reject(new Error(errorMessage));
+        }
+      });
+
+      childProcess.on("error", (error: Error) => {
+        if (!options.ignoreErrors) {
+          reject(error);
+        } else {
+          resolve("");
+        }
+      });
+    });
+  }
+}
+
+/**
+ * Default repository instance
+ */
+export const setupInstallRepository = new SetupInstallRepositoryImpl();

package/src/app/api/[locale]/system/unified-interface/cli/setup/install/route.ts

@@ -0,0 +1,25 @@
+/**
+ * Setup Install Route
+ * API route for CLI global installation
+ */
+
+import "server-only";
+
+import { endpointsHandler } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/route/multi";
+import { Methods } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+
+import installEndpoints from "./definition";
+import { setupInstallRepository } from "./repository";
+
+export const { POST, tools } = endpointsHandler({
+  endpoint: installEndpoints,
+  [Methods.POST]: {
+    handler: ({ data, user, logger, locale }) => {
+      logger.debug("Setup install operation started", {
+        force: data.force,
+        verbose: data.verbose,
+      });
+      return setupInstallRepository.installCli(data, user, locale);
+    },
+  },
+});

package/src/app/api/[locale]/system/unified-interface/cli/setup/status/definition.ts

@@ -0,0 +1,181 @@
+/**
+ * Setup Status Definition
+ * API endpoint definition for checking CLI installation status
+ * Following migration guide: Files at level of usage, split god repositories
+ */
+
+import { z } from "zod";
+
+import { createEndpoint } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/definition/create";
+import {
+  objectField,
+  responseField,
+} from "@/app/api/[locale]/system/unified-interface/shared/field/utils";
+import {
+  EndpointErrorTypes,
+  LayoutType,
+  Methods,
+  WidgetType,
+} from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+
+import { UserRole } from "../../../../../user/user-roles/enum";
+
+/**
+ * Setup Status Endpoint Definition
+ */
+const { POST } = createEndpoint({
+  title: "app.api.system.unifiedInterface.cli.setup.status.post.title",
+  description:
+    "app.api.system.unifiedInterface.cli.setup.status.post.description",
+  icon: "terminal",
+  category: "app.api.system.unifiedInterface.cli.setup.status.post.title",
+  tags: ["app.api.system.unifiedInterface.cli.setup.status.post.title"],
+  allowedRoles: [
+    UserRole.ADMIN,
+    UserRole.WEB_OFF,
+    UserRole.AI_TOOL_OFF,
+    UserRole.MCP_OFF,
+  ],
+  aliases: ["status", "setup:status"],
+  method: Methods.POST,
+  path: ["system", "setup", "status"],
+  examples: {
+    requests: {},
+    urlPathParams: undefined,
+    responses: {},
+  },
+
+  fields: objectField(
+    {
+      type: WidgetType.CONTAINER,
+      title: "app.api.system.unifiedInterface.cli.setup.status.post.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.description",
+      layoutType: LayoutType.GRID,
+      columns: 12,
+    },
+    { request: "data", response: true },
+    {
+      // === RESPONSE FIELDS ===
+      success: responseField(
+        {
+          type: WidgetType.TEXT,
+          content:
+            "app.api.system.unifiedInterface.cli.setup.status.post.response.fields.success",
+        },
+        z.boolean(),
+      ),
+
+      installed: responseField(
+        {
+          type: WidgetType.TEXT,
+          content:
+            "app.api.system.unifiedInterface.cli.setup.status.post.response.fields.installed",
+        },
+        z.boolean(),
+      ),
+
+      version: responseField(
+        {
+          type: WidgetType.TEXT,
+          content:
+            "app.api.system.unifiedInterface.cli.setup.status.post.response.fields.version",
+        },
+        z.string().optional(),
+      ),
+
+      path: responseField(
+        {
+          type: WidgetType.TEXT,
+          content:
+            "app.api.system.unifiedInterface.cli.setup.status.post.response.fields.path",
+        },
+        z.string().optional(),
+      ),
+
+      message: responseField(
+        {
+          type: WidgetType.TEXT,
+          content:
+            "app.api.system.unifiedInterface.cli.setup.status.post.response.fields.message",
+        },
+        z.string(),
+      ),
+    },
+  ),
+
+  // === ERROR HANDLING ===
+  errorTypes: {
+    [EndpointErrorTypes.VALIDATION_FAILED]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.validation.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.validation.description",
+    },
+    [EndpointErrorTypes.UNAUTHORIZED]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.unauthorized.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.unauthorized.description",
+    },
+    [EndpointErrorTypes.SERVER_ERROR]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.server.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.server.description",
+    },
+    [EndpointErrorTypes.NETWORK_ERROR]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.network.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.network.description",
+    },
+    [EndpointErrorTypes.FORBIDDEN]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.forbidden.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.forbidden.description",
+    },
+    [EndpointErrorTypes.NOT_FOUND]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.notFound.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.notFound.description",
+    },
+    [EndpointErrorTypes.UNKNOWN_ERROR]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.unknown.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.unknown.description",
+    },
+    [EndpointErrorTypes.UNSAVED_CHANGES]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.conflict.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.conflict.description",
+    },
+    [EndpointErrorTypes.CONFLICT]: {
+      title:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.conflict.title",
+      description:
+        "app.api.system.unifiedInterface.cli.setup.status.post.errors.conflict.description",
+    },
+  },
+
+  // === SUCCESS HANDLING ===
+  successTypes: {
+    title:
+      "app.api.system.unifiedInterface.cli.setup.status.post.success.title",
+    description:
+      "app.api.system.unifiedInterface.cli.setup.status.post.success.description",
+  },
+});
+
+const endpoints = { POST };
+export default endpoints;
+
+// Export types for repository usage - following migration guide pattern
+export type StatusRequestInput = typeof POST.types.RequestInput;
+export type StatusRequestOutput = typeof POST.types.RequestOutput;
+export type StatusResponseInput = typeof POST.types.ResponseInput;
+export type StatusResponseOutput = typeof POST.types.ResponseOutput;

package/src/app/api/[locale]/system/unified-interface/cli/setup/status/i18n/de/index.ts

@@ -0,0 +1,61 @@
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  post: {
+    title: "Titel",
+    description: "Endpunkt-Beschreibung",
+    form: {
+      title: "Konfiguration",
+      description: "Parameter konfigurieren",
+    },
+    response: {
+      title: "Antwort",
+      description: "Antwortdaten",
+      fields: {
+        success: "Betriebsstatus",
+        installed: "Installiert",
+        version: "CLI-Version",
+        path: "Installationspfad",
+        message: "Statusmeldung",
+      },
+    },
+    errors: {
+      unauthorized: {
+        title: "Nicht autorisiert",
+        description: "Authentifizierung erforderlich",
+      },
+      validation: {
+        title: "Validierungsfehler",
+        description: "Ungültige Anfrageparameter",
+      },
+      server: {
+        title: "Serverfehler",
+        description: "Interner Serverfehler",
+      },
+      unknown: {
+        title: "Unbekannter Fehler",
+        description: "Ein unbekannter Fehler ist aufgetreten",
+      },
+      network: {
+        title: "Netzwerkfehler",
+        description: "Netzwerkfehler aufgetreten",
+      },
+      forbidden: {
+        title: "Verboten",
+        description: "Zugriff verboten",
+      },
+      notFound: {
+        title: "Nicht gefunden",
+        description: "Ressource nicht gefunden",
+      },
+      conflict: {
+        title: "Konflikt",
+        description: "Datenkonflikt aufgetreten",
+      },
+    },
+    success: {
+      title: "Erfolg",
+      description: "Vorgang erfolgreich abgeschlossen",
+    },
+  },
+};