Quelle  pi_command.go   Sprache: unbekannt

package main

import (
 "context"
 "errors"
 "fmt"
 "os"
 "os/exec"
 "path/filepath"
 "strings"
 "sync"
 "time"
)

const (
 envDocsPiExecutable     = "OPENCLAW_DOCS_I18N_PI_EXECUTABLE"
 envDocsPiArgs           = "OPENCLAW_DOCS_I18N_PI_ARGS"
 envDocsPiPackageVersion = "OPENCLAW_DOCS_I18N_PI_PACKAGE_VERSION"
 envDocsPiOmitProvider   = "OPENCLAW_DOCS_I18N_PI_OMIT_PROVIDER"
 defaultPiPackageVersion = "0.58.3"
)

type docsPiCommand struct {
 Executable string
 Args       []string
}

var (
 materializedPiRuntimeMu      sync.Mutex
 materializedPiRuntimeCommand docsPiCommand
 materializedPiRuntimeErr     error
)

func resolveDocsPiCommand(ctx context.Context) (docsPiCommand, error) {
 if executable := strings.TrimSpace(os.Getenv(envDocsPiExecutable)); executable != "" {
  return docsPiCommand{
   Executable: executable,
   Args:       strings.Fields(os.Getenv(envDocsPiArgs)),
  }, nil
 }

 piPath, err := exec.LookPath("pi")
 if err == nil && !shouldMaterializePiRuntime(piPath) {
  return docsPiCommand{Executable: piPath}, nil
 }

 return ensureMaterializedPiRuntime(ctx)
}

func shouldMaterializePiRuntime(piPath string) bool {
 realPath, err := filepath.EvalSymlinks(piPath)
 if err != nil {
  realPath = piPath
 }
 return strings.Contains(filepath.ToSlash(realPath), "/Projects/pi-mono/")
}

func ensureMaterializedPiRuntime(ctx context.Context) (docsPiCommand, error) {
 materializedPiRuntimeMu.Lock()
 defer materializedPiRuntimeMu.Unlock()

 if materializedPiRuntimeErr == nil && materializedPiRuntimeCommand.Executable != "" {
  return materializedPiRuntimeCommand, nil
 }

 runtimeDir, err := getMaterializedPiRuntimeDir()
 if err != nil {
  materializedPiRuntimeErr = err
  return docsPiCommand{}, err
 }
 cliPath := filepath.Join(runtimeDir, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "cli.js")
 if _, err := os.Stat(cliPath); errors.Is(err, os.ErrNotExist) {
  installCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
  defer cancel()

  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
   materializedPiRuntimeErr = err
   return docsPiCommand{}, err
  }

  packageVersion := getMaterializedPiPackageVersion()
  install := exec.CommandContext(
   installCtx,
   "npm",
   "install",
   "--silent",
   "--no-audit",
   "--no-fund",
   fmt.Sprintf("@mariozechner/pi-coding-agent@%s", packageVersion),
  )
  install.Dir = runtimeDir
  install.Env = os.Environ()
  output, err := install.CombinedOutput()
  if err != nil {
   materializedPiRuntimeErr = fmt.Errorf("materialize pi runtime: %w (%s)", err, strings.TrimSpace(string(output)))
   return docsPiCommand{}, materializedPiRuntimeErr
  }
 }

 materializedPiRuntimeCommand = docsPiCommand{
  Executable: "node",
  Args:       []string{cliPath},
 }
 materializedPiRuntimeErr = nil
 return materializedPiRuntimeCommand, nil
}

func getMaterializedPiRuntimeDir() (string, error) {
 cacheDir, err := os.UserCacheDir()
 if err != nil {
  cacheDir = os.TempDir()
 }
 return filepath.Join(cacheDir, "openclaw", "docs-i18n", "pi-runtime", getMaterializedPiPackageVersion()), nil
}

func getMaterializedPiPackageVersion() string {
 if version := strings.TrimSpace(os.Getenv(envDocsPiPackageVersion)); version != "" {
  return version
 }
 return defaultPiPackageVersion
}

func docsPiOmitProvider() bool {
 switch strings.ToLower(strings.TrimSpace(os.Getenv(envDocsPiOmitProvider))) {
 case "1", "true", "yes", "on":
  return true
 default:
  return false
 }
}