itube-specs 0.0.1071 → 0.0.1073

package/SITE_UPDATES.md

@@ -11,6 +11,12 @@
 коммиты до бампа); `npm run patch` сам проставит ей номер версии. Формат пункта: что сделать и где,
 кому именно (всем / сайтам с N), что будет, если не сделать.
 
+## 0.0.1073 — 2026-11-03
+
+- **Всем — к сведению:** гость больше не видит заглушку «Sign in to upload» на `/upload`: клик по Upload (шапка,
+  бургер) и по выбору файла открывает попап регистрации с пояснением (новый общий ключ `register_to_upload`, пока
+  только en-US), после входа — сразу `/upload`. Делать ничего не надо.
+
 ## 0.0.1071 — 2026-11-03
 
 - **Сайтам со своей темой в `assets/scss/vars/_theme.scss` (hd-sex-new), срочно:** без новых токенов сборка падает

package/components/layout/burger.vue

@@ -162,6 +162,7 @@ function logOut() {
 }
 
 const featureFlags = useRuntimeConfig().public.featureFlags;
+const { requireAuth } = useUploadEntry();
 
 const burgerButtons = computed<{ icon: string, label: string, action?: () => void, link?: string }[]>(() => [
   ...isAuthorized.value ? [
@@ -184,11 +185,9 @@ const burgerButtons = computed<{ icon: string, label: string, action?: () => voi
         },
       ],
   ...featureFlags.FeatureUploadEnabled ? [
-    {
-      icon: 'upload',
-      label: 'upload',
-      link: generateLink('/upload'),
-    }
+    isAuthorized.value
+      ? { icon: 'upload', label: 'upload', link: generateLink('/upload') }
+      : { icon: 'upload', label: 'upload', action: () => requireAuth() },
   ] : [],
 ]);
 

package/components/layout/header.vue

@@ -63,6 +63,7 @@
         :tabindex="isUploadPage ? -1 : undefined"
         :class="{'--current': isUploadPage}"
         class="layout-header__upload _from-sd"
+        @click="onUploadClick"
       >
         <UiIcon
           name="upload-arrow"
@@ -122,6 +123,13 @@ const route = useRoute();
 const { generateLink } = useGenerateLink();
 
 const uploadLink = computed(() => generateLink('/upload'));
+const { requireAuth, watchUploadEntry } = useUploadEntry();
+
+watchUploadEntry();
+
+function onUploadClick(event: MouseEvent) {
+  if (!requireAuth()) event.preventDefault();
+}
 const isUploadPage = computed(() => route.path === uploadLink.value);
 
 const burgerShow = ref(false);

package/components/upload/main.vue

@@ -67,10 +67,8 @@
 
 <script setup lang="ts">
 import { UploadAccount, UploadStage } from '../../runtime';
-import { AuthorizationApiService } from '../../services/api/authorization.service';
 
 const { t } = useI18n();
-const { isAuthorized } = useUser(AuthorizationApiService);
 
 const {
   stage,
@@ -96,11 +94,7 @@ const isRulesOpen = ref(false);
 
 const isPick = computed(() => stage.value === UploadStage.Pick);
 
-const account = computed(() => {
-  if (!isAuthorized.value) return UploadAccount.SignedOut;
-
-  return remaining.value > 0 ? UploadAccount.Ok : UploadAccount.Limit;
-});
+const account = computed(() => remaining.value > 0 ? UploadAccount.Ok : UploadAccount.Limit);
 
 function onBeforeUnload(event: BeforeUnloadEvent) {
   if (!isUploading.value) return;

package/components/upload/picker.vue

@@ -1,34 +1,6 @@
-<!-- First upload step: sign-in gate, drop zone (desktop) or file button (mobile), requirement checks of the picked file -->
+<!-- First upload step: drop zone (desktop) or file button (mobile), requirement checks of the picked file; a guest gets the auth popup instead of the file dialog -->
 <template>
-  <div
-    v-if="account === UploadAccount.SignedOut"
-    class="upload-picker__gate"
-  >
-    <UiIcon
-      class="upload-picker__gate-icon"
-      name="lock"
-      size="24"
-      aria-hidden="true"
-    />
-    <p class="upload-picker__gate-title">{{ t('upload_page.sign_in') }}</p>
-    <div class="upload-picker__gate-buttons">
-      <UiBtn
-        theme="primary"
-        @click="openAuthPopup(AuthSteps.Registration)"
-      >{{ t('auth.sign_up') }}
-      </UiBtn>
-      <UiBtn
-        theme="muted"
-        @click="openAuthPopup(AuthSteps.Login)"
-      >{{ t('auth.log_in') }}
-      </UiBtn>
-    </div>
-  </div>
-
-  <div
-    v-else
-    class="upload-picker"
-  >
+  <div class="upload-picker">
     <div class="upload-picker__mobile _to-sd">
       <UiBtn
         :disabled="isDisabled"
@@ -120,7 +92,7 @@
 </template>
 
 <script setup lang="ts">
-import { AuthSteps, UPLOAD_LIMITS, UploadAccount, UploadCheckStatus } from '../../runtime';
+import { UPLOAD_LIMITS, UploadAccount, UploadCheckStatus } from '../../runtime';
 import type { IUploadFile } from '../../types';
 import { checkUploadFile } from '../../utils/upload/check-upload-file';
 import { createIdleUploadChecks } from '../../utils/upload/create-idle-upload-checks';
@@ -135,7 +107,7 @@ const emit = defineEmits<{
 }>();
 
 const { t } = useI18n();
-const { openAuthPopup } = useAuthPopup();
+const { requireAuth } = useUploadEntry();
 
 const inputRef = ref<HTMLInputElement>();
 const isDragging = ref(false);
@@ -158,7 +130,7 @@ const zoneLabel = computed(() => {
 });
 
 function openDialog() {
-  inputRef.value?.click();
+  if (requireAuth()) inputRef.value?.click();
 }
 
 async function check(file?: File) {
@@ -182,7 +154,7 @@ function onDragOver() {
 
 function onDrop(event: DragEvent) {
   isDragging.value = false;
-  check(event.dataTransfer?.files[0]);
+  if (requireAuth()) check(event.dataTransfer?.files[0]);
 }
 
 function onChange(event: Event) {
@@ -283,37 +255,4 @@ function onChange(event: Event) {
   color: $upload-text;
   font-variant-numeric: tabular-nums;
 }
-
-.upload-picker__gate {
-  display: flex;
-  flex-direction: column;
-  justify-content: center;
-  align-items: center;
-  gap: 16px;
-  min-height: 180px;
-  padding: 24px;
-  text-align: center;
-  background-color: $upload-card-bg;
-  border-radius: $radius-12;
-
-  @include from-br(sm) {
-    min-height: 220px;
-  }
-}
-
-.upload-picker__gate-icon {
-  color: $upload-text;
-}
-
-.upload-picker__gate-title {
-  @include font-base;
-
-  font-weight: 500;
-  color: $upload-title;
-}
-
-.upload-picker__gate-buttons {
-  display: flex;
-  gap: 8px;
-}
 </style>

package/composables/use-upload-entry.ts

@@ -0,0 +1,33 @@
+import { AuthSteps } from '../runtime';
+import { AuthorizationApiService } from '../services/api/authorization.service';
+
+/**
+ * Entry to the upload page for guests: instead of a sign-in placeholder the auth popup opens with an explanation,
+ * and after a successful login the user lands on `/upload`. `watchUploadEntry` is called once, by the header.
+ */
+export function useUploadEntry() {
+  const { isAuthorized } = useUser(AuthorizationApiService);
+  const { isAuthPopupOpen, openAuthPopup } = useAuthPopup();
+  const { generateLink } = useGenerateLink();
+  const isPending = useState('upload-entry-pending', () => false);
+
+  function requireAuth() {
+    if (isAuthorized.value) return true;
+
+    isPending.value = true;
+    openAuthPopup(AuthSteps.Registration, 'register_to_upload');
+
+    return false;
+  }
+
+  function watchUploadEntry() {
+    watch(isAuthPopupOpen, (isOpen) => {
+      if (isOpen || !isPending.value) return;
+
+      isPending.value = false;
+      if (isAuthorized.value) navigateTo(generateLink('/upload'));
+    });
+  }
+
+  return { requireAuth, watchUploadEntry };
+}

package/i18n/locales/en-US.json

@@ -1,4 +1,5 @@
 {
+  "register_to_upload": "Please sign up or log in to upload your videos",
   "age_gate": {
     "thumb": "18+",
     "title": "Laws in your region require age verification to view 18+ content",
@@ -58,7 +59,6 @@
     "title_details": "Video details",
     "subtitle_pick": "Pick a file. You'll add models and tags while it uploads.",
     "subtitle_details": "Your video keeps uploading while you fill this in.",
-    "sign_in": "Sign in to upload",
     "drag": "Drag a video here",
     "drag_another": "Drag another video here",
     "checking_video": "Checking video...",

package/middleware/age.global.ts

@@ -1,4 +1,4 @@
-import { isGeoMatch, isAgeVerified } from '../runtime';
+import { isGeoMatch, isAgeVerified, isSearchBotIp, getClientHeaders } from '../runtime';
 import { useAgeGate } from '../composables/use-age-gate';
 
 export default defineNuxtRouteMiddleware(async () => {
@@ -10,6 +10,8 @@ export default defineNuxtRouteMiddleware(async () => {
   const event = useRequestEvent();
   if (!(await isGeoMatch(event, config))) return;
 
+  if (await isSearchBotIp(getClientHeaders(event).remoteIP)) return;
+
   const { isAgeGated } = useAgeGate();
   try {
     isAgeGated.value = !(await isAgeVerified(event, config));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.1071",
+  "version": "0.0.1073",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {

package/runtime/constants/upload.ts

@@ -18,7 +18,6 @@ export type UploadStatus = typeof UploadStatus[keyof typeof UploadStatus];
 
 export const UploadAccount = {
   Ok: 'ok',
-  SignedOut: 'signed-out',
   Limit: 'limit',
 } as const;
 

package/runtime/index.ts

@@ -71,5 +71,7 @@ export * from './utils/check-device-width';
 export * from './utils/is-mobile-device';
 export * from './utils/vtt-helper';
 export * from './utils/server/age';
+export * from './utils/server/ip-ranges';
+export * from './utils/server/search-bot-ips';
 export * from './utils/server/get-client-headers';
 export * from './utils/server/get-path-locale';

package/runtime/utils/server/__tests__/ip-ranges.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { parseIp, parseCidr, isIpInRanges, type IIpRange } from '../ip-ranges';
+
+const ranges = (...cidrs: string[]) => cidrs.map((cidr) => parseCidr(cidr)).filter((range): range is IIpRange => range !== null);
+
+describe('parseIp', () => {
+  it('разбирает IPv4', () => {
+    expect(parseIp('66.249.66.1')).toEqual({ bits: 32, value: 0x42f94201n });
+    expect(parseIp(' 0.0.0.0 ')).toEqual({ bits: 32, value: 0n });
+  });
+
+  it('сводит IPv4-mapped IPv6 к IPv4', () => {
+    expect(parseIp('::ffff:66.249.66.1')).toEqual({ bits: 32, value: 0x42f94201n });
+  });
+
+  it('разбирает IPv6 с сокращением и без', () => {
+    expect(parseIp('::1')).toEqual({ bits: 128, value: 1n });
+    expect(parseIp('::')).toEqual({ bits: 128, value: 0n });
+    expect(parseIp('2001:4860:4801:10::')?.value).toBe(0x20014860480100100000000000000000n);
+    expect(parseIp('2001:4860:4801:10:0:0:0:1')?.value).toBe(0x20014860480100100000000000000001n);
+    expect(parseIp('64:ff9b::1.2.3.4')?.value).toBe(0x0064ff9b000000000000000001020304n);
+  });
+
+  it('невалидное — null', () => {
+    expect(parseIp('')).toBeNull();
+    expect(parseIp('256.1.1.1')).toBeNull();
+    expect(parseIp('1.2.3')).toBeNull();
+    expect(parseIp('1::2::3')).toBeNull();
+    expect(parseIp('1:2:3:4:5:6:7:8:9')).toBeNull();
+    expect(parseIp('gggg::1')).toBeNull();
+    expect(parseIp('unknown')).toBeNull();
+  });
+});
+
+describe('parseCidr', () => {
+  it('обнуляет хост-биты базы', () => {
+    expect(parseCidr('66.249.66.77/24')).toEqual({ bits: 32, base: 0x42f94200n, mask: 0xffffff00n });
+  });
+
+  it('без префикса — один адрес', () => {
+    expect(parseCidr('1.2.3.4')?.mask).toBe(0xffffffffn);
+  });
+
+  it('невалидный префикс — null', () => {
+    expect(parseCidr('1.2.3.4/33')).toBeNull();
+    expect(parseCidr('1.2.3.4/x')).toBeNull();
+    expect(parseCidr('::/129')).toBeNull();
+    expect(parseCidr('nope/24')).toBeNull();
+  });
+});
+
+describe('isIpInRanges', () => {
+  const list = ranges('66.249.64.0/27', '2001:4860:4801:10::/64', '157.55.39.0/24');
+
+  it('находит IPv4 внутри диапазона и на его границах', () => {
+    expect(isIpInRanges('66.249.64.0', list)).toBe(true);
+    expect(isIpInRanges('66.249.64.31', list)).toBe(true);
+    expect(isIpInRanges('157.55.39.200', list)).toBe(true);
+    expect(isIpInRanges('::ffff:66.249.64.5', list)).toBe(true);
+  });
+
+  it('не находит соседние адреса', () => {
+    expect(isIpInRanges('66.249.64.32', list)).toBe(false);
+    expect(isIpInRanges('66.249.63.255', list)).toBe(false);
+  });
+
+  it('находит IPv6 внутри /64 и не путает разрядности', () => {
+    expect(isIpInRanges('2001:4860:4801:10::1', list)).toBe(true);
+    expect(isIpInRanges('2001:4860:4801:10:ffff:ffff:ffff:ffff', list)).toBe(true);
+    expect(isIpInRanges('2001:4860:4801:11::1', list)).toBe(false);
+    expect(isIpInRanges('::42f9:4001', list)).toBe(false);
+  });
+
+  it('невалидный адрес и пустой список — false', () => {
+    expect(isIpInRanges('garbage', list)).toBe(false);
+    expect(isIpInRanges('66.249.64.1', [])).toBe(false);
+  });
+});

package/runtime/utils/server/ip-ranges.ts

@@ -0,0 +1,81 @@
+export interface IIpRange {
+  bits: 32 | 128;
+  base: bigint;
+  mask: bigint;
+}
+
+function parseIpv4(ip: string): bigint | null {
+  const parts = ip.split('.');
+  if (parts.length !== 4) return null;
+
+  let value = 0n;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part) || Number(part) > 255) return null;
+    value = (value << 8n) | BigInt(part);
+  }
+  return value;
+}
+
+function parseIpv6(ip: string): bigint | null {
+  let address = ip;
+  let tail: bigint | null = null;
+
+  const lastColon = address.lastIndexOf(':');
+  if (address.slice(lastColon + 1).includes('.')) {
+    tail = parseIpv4(address.slice(lastColon + 1));
+    if (tail === null) return null;
+    address = `${address.slice(0, lastColon + 1)}0:0`;
+  }
+
+  const halves = address.split('::');
+  if (halves.length > 2) return null;
+
+  const head = halves[0] ? halves[0].split(':') : [];
+  const rest = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+  const missing = 8 - head.length - rest.length;
+  if (halves.length === 2 ? missing < 1 : missing !== 0) return null;
+
+  const groups = [...head, ...Array(halves.length === 2 ? missing : 0).fill('0'), ...rest];
+
+  let value = 0n;
+  for (const group of groups) {
+    if (!/^[\da-f]{1,4}$/i.test(group)) return null;
+    value = (value << 16n) | BigInt(`0x${group}`);
+  }
+
+  return tail === null ? value : (value & ~0xffffffffn) | tail;
+}
+
+/** Адрес → число и разрядность. IPv4-mapped IPv6 (`::ffff:1.2.3.4`) сводится к IPv4. */
+export function parseIp(ip: string): { bits: 32 | 128, value: bigint } | null {
+  const trimmed = ip.trim();
+  const mapped = trimmed.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
+  const v4 = parseIpv4(mapped ? mapped[1] : trimmed);
+  if (v4 !== null) return { bits: 32, value: v4 };
+
+  const v6 = parseIpv6(trimmed);
+  return v6 === null ? null : { bits: 128, value: v6 };
+}
+
+/** CIDR (`66.249.64.0/27`, `2001:4860:4801:10::/64`) → диапазон для `isIpInRanges`. */
+export function parseCidr(cidr: string): IIpRange | null {
+  const [ip, prefix] = cidr.split('/');
+  const parsed = parseIp(ip);
+  if (!parsed) return null;
+
+  const length = prefix === undefined ? parsed.bits : Number(prefix);
+  if (!Number.isInteger(length) || length < 0 || length > parsed.bits) return null;
+
+  const all = (1n << BigInt(parsed.bits)) - 1n;
+  const mask = all ^ ((1n << BigInt(parsed.bits - length)) - 1n);
+
+  return { bits: parsed.bits, base: parsed.value & mask, mask };
+}
+
+/** Попадает ли адрес хотя бы в один диапазон. Невалидный адрес — нет. */
+export function isIpInRanges(ip: string, ranges: IIpRange[]): boolean {
+  const parsed = parseIp(ip);
+  if (!parsed) return false;
+
+  return ranges.some((range) => range.bits === parsed.bits && (parsed.value & range.mask) === range.base);
+}

package/runtime/utils/server/search-bot-ips.ts

@@ -0,0 +1,62 @@
+import { isIpInRanges, parseCidr, type IIpRange } from './ip-ranges';
+
+/** Официальные списки адресов поисковых роботов. */
+const SOURCES = [
+  'https://developers.google.com/static/crawling/ipranges/common-crawlers.json',
+  'https://www.bing.com/toolbox/bingbot.json',
+];
+
+const TTL = 24 * 60 * 60 * 1000;
+const RETRY_TTL = 5 * 60 * 1000;
+const FETCH_TIMEOUT = 5000;
+
+interface IPrefixesResponse {
+  prefixes?: { ipv4Prefix?: string, ipv6Prefix?: string }[];
+}
+
+const rangesBySource = new Map<string, IIpRange[]>();
+let expiresAt = 0;
+let loading: Promise<void> | null = null;
+
+async function loadSource(url: string): Promise<boolean> {
+  try {
+    const res = await $fetch<IPrefixesResponse>(url, { timeout: FETCH_TIMEOUT, parseResponse: JSON.parse });
+    const ranges = (res.prefixes || [])
+      .map((prefix) => parseCidr(prefix.ipv4Prefix || prefix.ipv6Prefix || ''))
+      .filter((range): range is IIpRange => range !== null);
+    if (!ranges.length) return false;
+
+    rangesBySource.set(url, ranges);
+    return true;
+  } catch (error) {
+    console.error(`Search bot IP list failed: ${url}`, error);
+    return false;
+  }
+}
+
+async function refresh(): Promise<void> {
+  const results = await Promise.all(SOURCES.map(loadSource));
+  expiresAt = Date.now() + (results.every(Boolean) ? TTL : RETRY_TTL);
+}
+
+/**
+ * Адрес принадлежит проверенному поисковому роботу (Google, Bing) — по их официальным спискам, не по
+ * User-Agent: тот подделывается. Списки живут в памяти процесса: качаются при первой проверке, дальше
+ * обновляются в фоне раз в сутки (после ошибки — через 5 минут), упавший источник держит прежний список.
+ * Ни одного списка ещё нет — ждём первую загрузку, не дольше таймаута; не скачалось — «не робот».
+ */
+export async function isSearchBotIp(ip: string | undefined): Promise<boolean> {
+  if (!ip) return false;
+
+  if (Date.now() >= expiresAt && !loading) {
+    loading = refresh().finally(() => {
+      loading = null;
+    });
+  }
+  if (!rangesBySource.size && loading) await loading;
+
+  for (const ranges of rangesBySource.values()) {
+    if (isIpInRanges(ip, ranges)) return true;
+  }
+  return false;
+}