@rynt/sdk 0.9.53

package/src/shared/ui/special/ExtensionRegistrySlotButton.vue

@@ -0,0 +1,143 @@
+<template>
+  <template v-if="missing">
+    <Text v-if="lookupLoading" class="text-sm text-subtle-fg">Проверка каталога…</Text>
+
+    <Text v-else-if="lookupResult?.kind === 'none'" class="text-sm text-subtle-fg">
+      В каталоге нет расширения для этого слота.
+    </Text>
+
+    <Button
+      v-else-if="lookupResult?.kind === 'one'"
+      variant="secondary"
+      size="sm"
+      :loading="installing"
+      @click="installOne"
+    >
+      Установить «{{ lookupResult.extension.name }}»
+    </Button>
+
+    <Button
+      v-else-if="lookupResult?.kind === 'many'"
+      variant="secondary"
+      size="sm"
+      @click="openSlotPicker"
+    >
+      {{ label ?? 'Выбрать расширение…' }}
+    </Button>
+
+    <Button
+      v-else
+      variant="secondary"
+      size="sm"
+      @click="openSlotPicker"
+    >
+      {{ label ?? 'Добавить расширение…' }}
+    </Button>
+  </template>
+</template>
+
+<script setup lang="ts">
+  import { computed, inject, ref, watch } from 'vue';
+  import { extensionRegistriesRevision } from '../../../extensions/registries/store';
+  import { resolveRegistrySlot } from '../../../extensions/registries/registry-slot';
+  import {
+    RYNT_EXTENSION_MARKETPLACE_INSTALL,
+    RYNT_EXTENSION_MARKETPLACE_OPEN,
+    RYNT_EXTENSION_MARKETPLACE_SLOT_RESOLVE,
+  } from '../../../extensions/marketplace-open-key';
+  import type { MarketplaceSlotLookupResult } from '../../../extension-marketplace/api-types';
+  import Button from '../base/Button.vue';
+  import Text from '../primitives/Text.vue';
+
+  const props = withDefaults(
+    defineProps<{
+      registryId: string;
+      registryKey: string;
+      label?: string;
+      onResolved?: () => void;
+    }>(),
+    {},
+  );
+
+  const openMarketplace = inject(RYNT_EXTENSION_MARKETPLACE_OPEN, null);
+  const resolveSlot = inject(RYNT_EXTENSION_MARKETPLACE_SLOT_RESOLVE, null);
+  const installFromMarketplace = inject(RYNT_EXTENSION_MARKETPLACE_INSTALL, null);
+
+  const lookupResult = ref<MarketplaceSlotLookupResult | null>(null);
+  const lookupLoading = ref(false);
+  const installing = ref(false);
+
+  const missing = computed(() => {
+    void extensionRegistriesRevision.value;
+    return (
+      resolveRegistrySlot(props.registryId, props.registryKey).status ===
+      'missing'
+    );
+  });
+
+  async function refreshLookup(): Promise<void> {
+    if (!missing.value) {
+      lookupResult.value = null;
+      return;
+    }
+    if (!resolveSlot) {
+      lookupResult.value = null;
+      return;
+    }
+    lookupLoading.value = true;
+    try {
+      lookupResult.value = await resolveSlot({
+        registryId: props.registryId,
+        key: props.registryKey,
+      });
+    } catch (e) {
+      console.warn('[rynt/sdk] ExtensionRegistrySlotButton: lookup failed', e);
+      lookupResult.value = null;
+    } finally {
+      lookupLoading.value = false;
+    }
+  }
+
+  function openSlotPicker(): void {
+    if (openMarketplace) {
+      openMarketplace({
+        mode: 'slot',
+        registryId: props.registryId,
+        key: props.registryKey,
+      });
+    } else {
+      console.warn(
+        '[rynt/sdk] ExtensionRegistrySlotButton: RYNT_EXTENSION_MARKETPLACE_OPEN не задан в provide',
+      );
+    }
+  }
+
+  async function installOne(): Promise<void> {
+    if (lookupResult.value?.kind !== 'one') {
+      openSlotPicker();
+      return;
+    }
+    if (!installFromMarketplace) {
+      openSlotPicker();
+      return;
+    }
+    installing.value = true;
+    try {
+      await installFromMarketplace(lookupResult.value.extension.downloadUrl);
+      props.onResolved?.();
+    } catch (e) {
+      console.error('[rynt/sdk] ExtensionRegistrySlotButton: install failed', e);
+      openSlotPicker();
+    } finally {
+      installing.value = false;
+    }
+  }
+
+  watch(
+    () => [missing.value, props.registryId, props.registryKey] as const,
+    () => {
+      void refreshLookup();
+    },
+    { immediate: true },
+  );
+</script>

package/src/shared/ui/special/InfoRow.vue

@@ -0,0 +1,39 @@
+<template>
+  <div class="space-y-2.5 text-xs">
+    <div
+      v-for="(item, index) in items"
+      :key="index"
+      class="flex items-start gap-1"
+    >
+      <div
+        class="text-muted-foreground mb-1 flex-shrink-0"
+        :style="{ width: labelWidth }"
+      >
+        {{ item.label }}
+      </div>
+      <div class="text-foreground flex-1" :class="item.valueClass">
+        <slot :name="`value-${index}`" :item="item">
+          {{ item.value }}
+        </slot>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+  interface InfoRowItem {
+    label: string;
+    value: string | number;
+    valueClass?: string;
+  }
+
+  const props = withDefaults(
+    defineProps<{
+      items: InfoRowItem[];
+      labelWidth?: string;
+    }>(),
+    {
+      labelWidth: 'auto',
+    },
+  );
+</script>

package/src/shared/ui/special/LogViewer.vue

@@ -0,0 +1,53 @@
+<template>
+  <div ref="logContainer" :class="viewerClasses" class="h-full grow">
+    <div v-for="(log, index) in logs" :key="index" :class="logClasses(log)">
+      {{ log }}
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+  import { computed, ref, watch, nextTick } from 'vue';
+  import { cn } from '../../utils/cn';
+
+  interface Props {
+    logs: string[];
+    maxHeight?: string;
+    class?: string;
+  }
+
+  const props = withDefaults(defineProps<Props>(), {
+    maxHeight: 'max-h-28',
+  });
+
+  const logContainer = ref<HTMLElement | null>(null);
+
+  const viewerClasses = computed(() => {
+    return cn(
+      'bg-surface-list p-2 border border-border overflow-y-auto',
+      'text-[10px] text-muted-foreground font-mono space-y-0.5 grow whitespace-pre-wrap break-all overflow-x-hidden',
+      props.class,
+    );
+  });
+
+  const logClasses = (log: string) => {
+    if (log.includes('[ERROR]') || log.includes('[WARN]')) {
+      return 'text-red-400';
+    }
+    if (log.includes('[INFO]') && log.includes('присоединился')) {
+      return 'text-green-400';
+    }
+    return 'text-muted-foreground';
+  };
+
+  // Автоскролл при добавлении новых логов
+  watch(
+    () => props.logs.length,
+    async () => {
+      await nextTick();
+      if (logContainer.value) {
+        logContainer.value.scrollTop = logContainer.value.scrollHeight;
+      }
+    },
+  );
+</script>

package/src/shared/ui/special/PageHeader.vue

@@ -0,0 +1,23 @@
+<template>
+  <div class="flex items-center justify-between mb-5">
+    <div>
+      <h1 class="text-2xl font-bold text-foreground mb-1">
+        <slot name="title">{{ title }}</slot>
+      </h1>
+      <p v-if="description || $slots.description" class="text-muted-foreground text-sm">
+        <slot name="description">{{ description }}</slot>
+      </p>
+    </div>
+    <div v-if="$slots.actions" class="flex items-center gap-2">
+      <slot name="actions" />
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+  const props = defineProps<{
+    title?: string;
+    description?: string;
+  }>();
+</script>
+

package/src/shared/ui/special/RegistrySlotMissingCallout.vue

@@ -0,0 +1,48 @@
+<template>
+  <Callout
+    v-if="isMissing"
+    :tone="tone"
+    :icon="icon"
+    :title="title"
+    :class="cn('block w-full', props.class)"
+  >
+    <div class="mt-1.5 flex flex-col gap-2.5">
+      <Text v-if="hint" class="text-sm leading-relaxed opacity-90">{{ hint }}</Text>
+      <div class="flex flex-wrap items-center gap-2">
+        <ExtensionRegistrySlotButton
+          :registry-id="registryId"
+          :registry-key="registryKey"
+        />
+      </div>
+    </div>
+  </Callout>
+</template>
+
+<script setup lang="ts">
+  import { Callout } from '../layout';
+  import { Text } from '../primitives';
+  import { cn } from '../../utils/cn';
+  import ExtensionRegistrySlotButton from './ExtensionRegistrySlotButton.vue';
+  import { useRegistrySlotMissing } from '../../composables/registrySlot/useRegistrySlotMissing';
+
+  const props = withDefaults(
+    defineProps<{
+      registryId: string;
+      registryKey: string;
+      title: string;
+      hint?: string;
+      tone?: 'info' | 'success' | 'warning' | 'error';
+      icon?: string;
+      class?: string;
+    }>(),
+    {
+      tone: 'error',
+      icon: 'alert-circle',
+    },
+  );
+
+  const { isMissing } = useRegistrySlotMissing(
+    () => props.registryId,
+    () => props.registryKey,
+  );
+</script>

package/src/shared/ui/special/WelcomeCard.vue

@@ -0,0 +1,32 @@
+<template>
+  <Card variant="hover" angular class="relative overflow-hidden">
+    <AngularAccent :position="accentPosition" :size="accentSize" :color="accentColor || 'indigo'" />
+    <div class="p-4 relative z-10">
+      <slot>
+        <h1 v-if="title" class="text-2xl font-bold text-foreground mb-1">{{ title }}</h1>
+        <p v-if="description" class="text-muted-foreground text-sm">{{ description }}</p>
+      </slot>
+    </div>
+  </Card>
+</template>
+
+<script setup lang="ts">
+  import { Card } from '../layout';
+  import AngularAccent from './AngularAccent.vue';
+
+  const props = withDefaults(
+    defineProps<{
+      title?: string;
+      description?: string;
+      accentPosition?: 'left' | 'right' | 'top' | 'bottom';
+      accentSize?: 'sm' | 'md' | 'lg';
+      accentColor?: InstanceType<typeof AngularAccent>['$props']['color'];
+    }>(),
+    {
+      accentPosition: 'right',
+      accentSize: 'lg',
+      accentColor: 'indigo',
+    }
+  );
+</script>
+

package/src/shared/ui/special/index.ts

@@ -0,0 +1,9 @@
+export { default as AngularAccent } from './AngularAccent.vue';
+export { default as LogViewer } from './LogViewer.vue';
+export { default as PageHeader } from './PageHeader.vue';
+export { default as WelcomeCard } from './WelcomeCard.vue';
+
+export { default as InfoRow } from './InfoRow.vue';
+export { default as ExtensionRegistrySlotButton } from './ExtensionRegistrySlotButton.vue';
+export { default as RegistrySlotMissingCallout } from './RegistrySlotMissingCallout.vue';
+

package/src/shared/utils/app-paths.ts

@@ -0,0 +1,50 @@
+const path = require("path");
+const os = require('os');
+
+/**
+ * Получить путь к директории приложения в зависимости от ОС
+ * 
+ * Windows: C:\Users\username\AppData\Roaming\.zaklauncher
+ * macOS: ~/Library/Application Support/.zaklauncher
+ * Linux: ~/.local/share/.zaklauncher
+ */
+export function getAppDataPath(): string {
+    const platform = process.platform;
+    const homeDir = os.homedir();
+
+    switch (platform) {
+        case 'win32':
+            // Windows: %APPDATA%\.zaklauncher
+            return path.join(process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming'), '.zaklauncher');
+
+        case 'darwin':
+            // macOS: ~/Library/Application Support/.zaklauncher
+            return path.join(homeDir, 'Library', 'Application Support', '.zaklauncher');
+
+        default:
+            // Linux и другие: ~/.local/share/.zaklauncher
+            return path.join(process.env.XDG_DATA_HOME || path.join(homeDir, '.local', 'share'), '.zaklauncher');
+    }
+}
+
+/**
+ * Получить путь к директории с версиями Minecraft
+ */
+export function getVersionsPath(): string {
+    return path.join(getAppDataPath(), 'versions');
+}
+
+/**
+ * Получить путь к скрытой директории с версиями
+ */
+export function getHiddenVersionsPath(): string {
+    return path.join(getAppDataPath(), '.versions');
+}
+
+/**
+ * Получить путь к директории конкретной версии/билда
+ */
+export function getBuildPath(buildId: string): string {
+    return path.join(getVersionsPath(), buildId);
+}
+

package/src/shared/utils/attachments.ts

@@ -0,0 +1,16 @@
+/** Нормализует attachments из GraphQL JSON в массив URL. */
+export function parseAttachments(value: unknown): string[] {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.filter((item): item is string => typeof item === 'string' && item.length > 0);
+  }
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return parseAttachments(parsed);
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}

package/src/shared/utils/autostart.ts

@@ -0,0 +1,213 @@
+import { isDevMode } from './updater';
+
+const isNodeEnv = typeof window !== 'undefined' && (window as any).nw;
+
+let fs: typeof import('fs') | undefined;
+let path: typeof import('path') | undefined;
+let os: typeof import('os') | undefined;
+let childProcess: typeof import('child_process') | undefined;
+
+if (isNodeEnv) {
+  try {
+    const nw = (window as any).nw;
+    fs = nw.require('fs');
+    path = nw.require('path');
+    os = nw.require('os');
+    childProcess = nw.require('child_process');
+  } catch (error) {
+    console.error('[autostart] Не удалось загрузить Node.js модули:', error);
+  }
+}
+
+const AUTOSTART_APP_NAME = 'Rynt';
+const MACOS_PLIST_NAME = 'com.rynt.launcher.plist';
+const LINUX_DESKTOP_NAME = 'rynt.desktop';
+
+function getMacOsPlistPath(): string | null {
+  if (!path || !os) return null;
+  return path.join(os.homedir(), 'Library', 'LaunchAgents', MACOS_PLIST_NAME);
+}
+
+function getLinuxDesktopPath(): string | null {
+  if (!path || !os) return null;
+  return path.join(os.homedir(), '.config', 'autostart', LINUX_DESKTOP_NAME);
+}
+
+function getExecutablePath(): string | null {
+  if (!isNodeEnv) return null;
+  try {
+    return process.execPath;
+  } catch {
+    return null;
+  }
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function buildMacOsPlist(execPath: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.rynt.launcher</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(execPath)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>`;
+}
+
+function buildLinuxDesktop(execPath: string): string {
+  return `[Desktop Entry]
+Type=Application
+Name=${AUTOSTART_APP_NAME}
+Exec=${execPath}
+Hidden=false
+NoDisplay=false
+X-GNOME-Autostart-enabled=true
+`;
+}
+
+function isAutostartEnabledWindows(): boolean {
+  if (!childProcess) return false;
+  try {
+    const result = childProcess.execSync(
+      `reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${AUTOSTART_APP_NAME}"`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] },
+    );
+    return result.includes(AUTOSTART_APP_NAME);
+  } catch {
+    return false;
+  }
+}
+
+function enableAutostartWindows(execPath: string): void {
+  if (!childProcess) return;
+  const escapedPath = execPath.replace(/"/g, '\\"');
+  childProcess.execSync(
+    `reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${AUTOSTART_APP_NAME}" /t REG_SZ /d "${escapedPath}" /f`,
+    { stdio: 'pipe' },
+  );
+}
+
+function disableAutostartWindows(): void {
+  if (!childProcess) return;
+  try {
+    childProcess.execSync(
+      `reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "${AUTOSTART_APP_NAME}" /f`,
+      { stdio: 'pipe' },
+    );
+  } catch {
+    // Ключ мог отсутствовать
+  }
+}
+
+function isAutostartEnabledMacOs(): boolean {
+  const plistPath = getMacOsPlistPath();
+  return Boolean(plistPath && fs?.existsSync(plistPath));
+}
+
+function enableAutostartMacOs(execPath: string): void {
+  const plistPath = getMacOsPlistPath();
+  if (!plistPath || !fs || !path) return;
+  const dir = path.dirname(plistPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(plistPath, buildMacOsPlist(execPath), 'utf-8');
+}
+
+function disableAutostartMacOs(): void {
+  const plistPath = getMacOsPlistPath();
+  if (!plistPath || !fs?.existsSync(plistPath)) return;
+  fs.unlinkSync(plistPath);
+}
+
+function isAutostartEnabledLinux(): boolean {
+  const desktopPath = getLinuxDesktopPath();
+  return Boolean(desktopPath && fs?.existsSync(desktopPath));
+}
+
+function enableAutostartLinux(execPath: string): void {
+  const desktopPath = getLinuxDesktopPath();
+  if (!desktopPath || !fs || !path) return;
+  const dir = path.dirname(desktopPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(desktopPath, buildLinuxDesktop(execPath), 'utf-8');
+}
+
+function disableAutostartLinux(): void {
+  const desktopPath = getLinuxDesktopPath();
+  if (!desktopPath || !fs?.existsSync(desktopPath)) return;
+  fs.unlinkSync(desktopPath);
+}
+
+/**
+ * Проверить, включён ли автозапуск в системе.
+ */
+export function isAutostartEnabled(): boolean {
+  if (!isNodeEnv || !os) return false;
+
+  switch (os.platform()) {
+    case 'win32':
+      return isAutostartEnabledWindows();
+    case 'darwin':
+      return isAutostartEnabledMacOs();
+    default:
+      return isAutostartEnabledLinux();
+  }
+}
+
+/**
+ * Синхронизировать автозапуск с настройкой пользователя.
+ * В dev-режиме ничего не делает.
+ */
+export function syncAutostart(enabled: boolean): void {
+  if (!isNodeEnv || isDevMode()) return;
+
+  const execPath = getExecutablePath();
+  if (!execPath || !os) {
+    console.warn('[autostart] Не удалось определить путь к исполняемому файлу');
+    return;
+  }
+
+  try {
+    switch (os.platform()) {
+      case 'win32':
+        if (enabled) {
+          enableAutostartWindows(execPath);
+        } else {
+          disableAutostartWindows();
+        }
+        break;
+      case 'darwin':
+        if (enabled) {
+          enableAutostartMacOs(execPath);
+        } else {
+          disableAutostartMacOs();
+        }
+        break;
+      default:
+        if (enabled) {
+          enableAutostartLinux(execPath);
+        } else {
+          disableAutostartLinux();
+        }
+        break;
+    }
+  } catch (error) {
+    console.error('[autostart] Ошибка синхронизации автозапуска:', error);
+  }
+}