@krx3d/tizentube2 1.16.30 → 1.30.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@krx3d/tizentube2",
-  "appName": "TizenTubeTest",
-  "version": "1.16.30",
+  "appName": "TizenTube",
+  "version": "1.30.0",
   "description": "TizenTube is an ad-free and sponsor-free solution for your favourite streaming website on your Tizen (Samsung) TVs.",
   "packageType": "mods",
   "websiteURL": "https://youtube.com/tv?additionalDataUrl=http%3A%2F%2Flocalhost%3A8085%2Fdial%2Fapps%2FYouTube",
   "main": "dist/userScript.js",
-  "author": "KrX3D",
+  "author": "Reis Can",
   "serviceFile": "dist/service.js",
   "keys": [
     "MediaPlayPause",
@@ -19,8 +19,7 @@
     "MediaTrackPrevious"
   ],
   "repository": {
-    "type": "git",
-    "url": "git+https://github.com/KrX3D/TizenTube.git"
+    "url": "https://github.com/KrX3D/TizenTube"
   },
   "license": "GPL-3.0-only"
 }

package/scripts/log-receiver/receiver.ps1

@@ -0,0 +1,116 @@
+param(
+  [int]$Port = 3030,
+  [string]$OutputFile = "tv.log",
+  [string]$SyslogForwardIp = "",      # Set to your syslog server IP to forward (e.g. "192.168.1.10")
+  [int]$SyslogForwardPort = 514
+)
+
+$ErrorActionPreference = 'Stop'
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$LogPath   = Join-Path $ScriptDir $OutputFile
+
+$Listener = [System.Net.HttpListener]::new()
+$Listener.Prefixes.Add("http://*:$Port/")
+$Listener.Start()
+
+Write-Host "Log receiver on http://*:$Port/tv-log  →  $LogPath"
+if ($SyslogForwardIp) {
+  Write-Host "Syslog forwarding: UDP $SyslogForwardIp`:$SyslogForwardPort"
+  $UdpClient = [System.Net.Sockets.UdpClient]::new()
+  $UdpClient.Connect($SyslogForwardIp, $SyslogForwardPort)
+} else {
+  Write-Host "Syslog forwarding: disabled  (use -SyslogForwardIp to enable)"
+  $UdpClient = $null
+}
+Write-Host "Press Ctrl+C to stop."
+Write-Host ""
+
+function Format-LogEntry {
+  param($Parsed)
+  $lines = @()
+  $lines += ""
+  $lines += "─" * 72
+  if ($Parsed._formatted) {
+    # Use pre-formatted string from logger.js
+    $lines += $Parsed._formatted
+  } else {
+    # Fallback for plain JSON payloads
+    $ts  = if ($Parsed.ts)      { $Parsed.ts }      else { (Get-Date -Format "yyyy-MM-dd HH:mm:ss.fff") }
+    $lvl = if ($Parsed.level)   { $Parsed.level }   else { "INFO" }
+    $ctx = if ($Parsed.context) { $Parsed.context } else { "unknown" }
+    $msg = if ($Parsed.message) { $Parsed.message } else { ($Parsed | ConvertTo-Json -Compress) }
+    $lines += "[$ts] [$lvl] [$ctx] $msg"
+    if ($Parsed.data) {
+      $lines += "  data: $($Parsed.data | ConvertTo-Json -Compress)"
+    }
+  }
+  return $lines -join "`n"
+}
+
+function Send-Syslog {
+  param($Parsed, $UdpClient)
+  if (-not $UdpClient) { return }
+  try {
+    $pri  = 134  # facility=local0 (16), severity=info (6) → (16*8)+6 = 134
+    $ts   = if ($Parsed.ts) { $Parsed.ts } else { (Get-Date -Format "yyyy-MM-dd HH:mm:ss") }
+    $host = "TizenTV"
+    $app  = if ($Parsed.app) { $Parsed.app } else { "TizenYouTube" }
+    $msg  = if ($Parsed.message) { $Parsed.message } else { ($Parsed | ConvertTo-Json -Compress) }
+    $syslog = "<$pri>1 $ts $host $app - - - $msg"
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($syslog)
+    $UdpClient.Send($bytes, $bytes.Length) | Out-Null
+  } catch {
+    Write-Host "Syslog forward error: $_" -ForegroundColor DarkYellow
+  }
+}
+
+try {
+  while ($Listener.IsListening) {
+    $Context  = $Listener.GetContext()
+    $Request  = $Context.Request
+    $Response = $Context.Response
+
+    $Response.Headers.Add("Access-Control-Allow-Origin",  "*")
+    $Response.Headers.Add("Access-Control-Allow-Methods", "POST, OPTIONS")
+    $Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type")
+
+    if ($Request.HttpMethod -eq 'OPTIONS') {
+      $Response.StatusCode = 204
+      $Response.Close()
+      continue
+    }
+
+    if ($Request.HttpMethod -eq 'POST' -and $Request.Url.AbsolutePath -eq '/tv-log') {
+      $Reader = [System.IO.StreamReader]::new($Request.InputStream, $Request.ContentEncoding)
+      $Body   = $Reader.ReadToEnd()
+      $Reader.Close()
+
+      $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+      $Parsed    = $null
+      try   { $Parsed = $Body | ConvertFrom-Json }
+      catch { $Parsed = $null }
+
+      if ($Parsed) {
+        $Formatted = Format-LogEntry -Parsed $Parsed
+        Add-Content -Path $LogPath -Value $Formatted
+        Write-Host $Formatted -ForegroundColor Cyan
+        Send-Syslog -Parsed $Parsed -UdpClient $UdpClient
+      } else {
+        $line = "[$Timestamp] $Body"
+        Add-Content -Path $LogPath -Value $line
+        Write-Host $line
+      }
+
+      $Response.StatusCode = 204
+    } else {
+      $Response.StatusCode = 404
+      $bytes = [System.Text.Encoding]::UTF8.GetBytes("Not Found")
+      $Response.OutputStream.Write($bytes, 0, $bytes.Length)
+    }
+    $Response.Close()
+  }
+} finally {
+  $Listener.Stop()
+  $Listener.Close()
+  if ($UdpClient) { $UdpClient.Close() }
+}

package/scripts/tampermonkey/tizentube-loader.user.js

@@ -0,0 +1,18 @@
+// ==UserScript==
+// @name         TizenTube Loader
+// @namespace    https://github.com/KrX3D/TizenTube
+// @version      0.4
+// @description  Load TizenTube userscript bundle for local /tv debugging
+// @match        https://www.youtube.com/tv*
+// @match        https://youtube.com/tv*
+// @run-at       document-start
+// @grant        none
+// @updateURL    https://raw.githubusercontent.com/KrX3D/TizenTube/main/scripts/tampermonkey/tizentube-loader.user.js
+// @downloadURL  https://raw.githubusercontent.com/KrX3D/TizenTube/main/scripts/tampermonkey/tizentube-loader.user.js
+// @require      https://raw.githubusercontent.com/KrX3D/TizenTube/main/dist/userScript.js
+// ==/UserScript==
+
+(function () {
+  // The actual TizenTube code is loaded via @require.
+  // Tampermonkey updates this script by @version and update checks.
+})();

package/scripts/tampermonkey/tizentube-log-button.user.js

@@ -0,0 +1,54 @@
+// ==UserScript==
+// @name         TizenTube Log Download Button
+// @namespace    https://github.com/KrX3D/TizenTube
+// @version      0.4
+// @description  Inject a floating button to trigger window.downloadTizenTubeLogs()
+// @match        https://www.youtube.com/tv*
+// @match        https://youtube.com/tv*
+// @run-at       document-idle
+// @grant        none
+// @updateURL    https://raw.githubusercontent.com/KrX3D/TizenTube/main/scripts/tampermonkey/tizentube-log-button.user.js
+// @downloadURL  https://raw.githubusercontent.com/KrX3D/TizenTube/main/scripts/tampermonkey/tizentube-log-button.user.js
+// ==/UserScript==
+
+(function () {
+  const buttonId = 'tt-log-download-btn';
+
+  const ensureButton = () => {
+    if (document.getElementById(buttonId)) return;
+
+    const btn = document.createElement('button');
+    btn.id = buttonId;
+    btn.textContent = 'TT Logs';
+    btn.style.cssText = [
+      'position:fixed',
+      'right:14px',
+      'bottom:14px',
+      'z-index:2147483647',
+      'padding:8px 10px',
+      'font-size:12px',
+      'font-family:monospace',
+      'color:#0f0',
+      'background:#111',
+      'border:1px solid #0f0',
+      'border-radius:4px',
+      'cursor:pointer',
+      'opacity:0.9'
+    ].join(';');
+
+    btn.addEventListener('click', () => {
+      if (typeof window.downloadTizenTubeLogs === 'function') {
+        window.downloadTizenTubeLogs();
+      } else {
+        console.warn('[TT_LOG_BUTTON] window.downloadTizenTubeLogs is not available yet');
+      }
+    });
+
+    document.body.appendChild(btn);
+  };
+
+  const interval = setInterval(() => {
+    if (document.body) ensureButton();
+    if (document.getElementById(buttonId)) clearInterval(interval);
+  }, 500);
+})();

package/standalone/config.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<widget xmlns:tizen="http://tizen.org/ns/widgets" xmlns="http://www.w3.org/ns/widgets" id="https://tizentube.app" version="1.0.0" viewmodes="maximized">
+    <access origin="*" subdomains="true"></access>
+    <tizen:allow-navigation href="*"/>
+    <tizen:app-control>
+        <tizen:src name="index.html" reload="disable"/>
+        <tizen:operation name="http://samsung.com/appcontrol/operation/eden_resume"/>
+    </tizen:app-control>
+    <tizen:application id="krx3dTtSt1.TizenTubeStandalone" package="krx3dTtSt1" required_version="3.0"/>
+    <author href="https://github.com/KrX3D/TizenTube">KrX3D</author>
+    <content src="index.html"/>
+    <feature name="http://tizen.org/feature/screen.size.all"/>
+    <feature name="http://tizen.org/feature/web.service"/>
+    <icon src="icon_16b9.png" width="1920" height="1080"/>
+    <icon src="icon.png" width="1024" height="1024"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/prelaunch.support" value="true"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/floating.navigation" value="false"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/use.game.mode" value="true"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/use.uwe" value="true"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/no_use_process_pool" value="true"/>
+    <tizen:metadata key="multiview_support" value="true"/>
+    <tizen:metadata key="multiview_min_resource" value="FHD+"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/html5.4k.support" value="true"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/microphone.support" value="1"/>
+    <tizen:metadata key="http://samsung.com/tv/metadata/microphone.area" value="open"/>
+    <name>TizenTube</name>
+    <tizen:privilege name="http://tizen.org/privilege/internet"/>
+    <tizen:privilege name="http://developer.samsung.com/privilege/network.public"/>
+    <tizen:privilege name="http://tizen.org/privilege/tv.inputdevice"/>
+    <tizen:privilege name="http://tizen.org/privilege/recorder"/>
+    <tizen:privilege name="http://tizen.org/privilege/mediacapture"/>
+    <tizen:privilege name="http://tizen.org/privilege/unlimitedstorage"/>
+    <tizen:privilege name="http://tizen.org/privilege/application.launch"/>
+    <tizen:profile name="tv-samsung"/>
+    <tizen:service id="krx3dTtSt1.StandaloneService">
+        <tizen:content src="service/dist/index.js"/>
+        <tizen:name>StandaloneService</tizen:name>
+        <tizen:description>StandaloneService</tizen:description>
+    </tizen:service>
+    <tizen:setting screen-orientation="landscape" context-menu="enable" background-support="enable" encryption="disable" install-location="auto" hwkey-event="enable"/>
+</widget>

package/standalone/index.html

@@ -0,0 +1,240 @@
+<!DOCTYPE html>
+
+<head>
+    <style>
+        @keyframes indeterminate-bar {
+            0% {
+                left: 0%;
+                width: 0;
+            }
+
+            50% {
+                left: 0%;
+                width: 100%;
+            }
+
+            100% {
+                left: 100%;
+                width: 0;
+            }
+        }
+
+        .progress-container {
+            position: relative;
+            width: 300px;
+            height: 4px;
+            margin-top: 40px;
+            background-color: rgba(25, 118, 210, 0.3);
+            border-radius: 2px;
+            overflow: hidden;
+        }
+
+        .progress-bar {
+            position: absolute;
+            top: 0;
+            left: 0;
+            height: 100%;
+            background-color: #1976D2;
+            animation: indeterminate-bar 1.5s cubic-bezier(0.4, 0, 0.2, 1) infinite;
+        }
+    </style>
+    <script>
+        "use strict";
+
+        // Earliest possible diagnostic hook — runs before the service is even
+        // launched, so it can catch failures the service's own self-logging
+        // never gets a chance to (e.g. launchAppControl's callback never
+        // firing at all). Same /tv-log target and payload shape as the
+        // service's own relayLog, so scripts/log-receiver/receiver.ps1 needs
+        // no changes.
+        // No address is written down here any more. index.html cannot read the
+        // page's settings — those live in localStorage on a different origin —
+        // so instead of carrying a constant it hands its lines to the service,
+        // which knows the receiver the user configured in the settings menu and
+        // persists it across restarts.
+        //
+        // The service is not listening yet when the first lines are produced, so
+        // they are buffered and flushed as soon as it answers. Bounded, because
+        // a service that never comes up must not grow this forever.
+        var MAX_BUFFERED_LOGS = 100;
+        var bufferedLogs = [];
+
+        function postLog(entry) {
+            return fetch('http://localhost:8099/tizentube/log', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ entry: entry })
+            });
+        }
+
+        function flushBufferedLogs() {
+            if (!bufferedLogs.length) return;
+            var pending = bufferedLogs.splice(0, bufferedLogs.length);
+            for (var i = 0; i < pending.length; i++) {
+                (function (entry) {
+                    try {
+                        postLog(entry).catch(function () { });
+                    } catch (e) { }
+                })(pending[i]);
+            }
+        }
+
+        function sendLog(level, message) {
+            var ts = new Date().toISOString();
+            var entry = {
+                _formatted: '[' + ts + '] [' + level + '] [StandaloneIndexHtml] ' + message,
+                app: 'TizenTube Standalone',
+                ts: ts,
+                level: level,
+                context: 'StandaloneIndexHtml',
+                message: message
+            };
+            try {
+                postLog(entry).then(function () {
+                    flushBufferedLogs();
+                }).catch(function () {
+                    if (bufferedLogs.length < MAX_BUFFERED_LOGS) bufferedLogs.push(entry);
+                });
+            } catch (e) {
+                if (bufferedLogs.length < MAX_BUFFERED_LOGS) bufferedLogs.push(entry);
+            }
+        }
+
+        sendLog('INFO', 'index.html script started');
+
+        tizen.tvinputdevice.registerKey("ColorF0Red");
+        tizen.tvinputdevice.registerKey("ColorF1Green");
+        tizen.tvinputdevice.registerKey("ColorF2Yellow");
+        tizen.tvinputdevice.registerKey("ColorF3Blue");
+
+        const keys = [
+            "MediaPlayPause",
+            "MediaPlay",
+            "MediaPause",
+            "MediaStop",
+            "MediaFastForward",
+            "MediaRewind",
+            "MediaTrackNext",
+            "MediaTrackPrevious"
+        ];
+
+        for (let i = 0; i < keys.length; i++) {
+            tizen.tvinputdevice.registerKey(keys[i]);
+        }
+
+        const pkgId = tizen.application.getCurrentApplication().appInfo.packageId;
+
+        const serviceId = pkgId + ".StandaloneService";
+
+        // Bounds the isConnecting poll below. Waiting is preferred over the proxy
+        // path — the proxy rewrites YouTube's traffic, which is confirmed to
+        // trigger verification challenges that stop playback (see README) — but
+        // waiting forever is how a wedged isConnecting became a permanent splash
+        // screen. Roughly 30s of patience, then take the degraded path rather
+        // than none at all.
+        var MAX_CONNECTING_POLLS = 30;
+        var connectingPolls = 0;
+
+        // The service needs roughly three seconds to listen; these cover that
+        // without restarting the page underneath it.
+        var MAX_STARTUP_RETRIES = 20;
+        var STARTUP_RETRY_MS = 300;
+        var startupRetries = 0;
+
+        function useInjectorOrProxy() {
+            sendLog('INFO', 'useInjectorOrProxy() called, fetching getState');
+            const data = tizen.application.getCurrentApplication().getRequestedAppControl().appControl.data;
+            let args;
+            try {
+                const parsedData = JSON.parse(data[0].value[0]);
+                args = parsedData.args;
+            } catch (e) {
+                // Do nothing.
+            }
+            fetch('http://localhost:8099/tizentube/getState')
+                .then(r => r.json())
+                .then(res => {
+                    sendLog('INFO', 'getState resolved: ' + JSON.stringify(res));
+                    if (res.canConnectToDaemon && !res.isConnecting) {
+                        sendLog('INFO', 'Taking CDP-injection path, launching debugger and exiting');
+                        fetch(`http://localhost:8099/tizentube/debugger${args ? `?${args}` : ''}`);
+                        tizen.application.getCurrentApplication().exit();
+                    } else if (!res.canConnectToDaemon) {
+                        sendLog('INFO', 'Taking proxy path, navigating to localhost:8099/tv');
+                        location.href = `http://localhost:8099/tv?additionalDataUrl=http%3A%2F%2Flocalhost%3A8095%2Fdial%2Fapps%2FYouTube${args ? `&${args}` : ''}`
+                    } else if (connectingPolls < MAX_CONNECTING_POLLS) {
+                        // canConnectToDaemon && isConnecting: a connection attempt is
+                        // (or was) already in progress. Neither branch above matched,
+                        // so previously this silently did nothing — a permanent hang
+                        // whenever isConnecting got stuck true (e.g. a previous CDP
+                        // attempt that never completed or failed, confirmed on-device).
+                        // Poll rather than give up: injector.js times out a stuck
+                        // attempt, so the usual outcome is the preferred CDP path.
+                        connectingPolls++;
+                        sendLog('INFO', 'canConnectToDaemon but isConnecting, retrying in 1s (' + connectingPolls + '/' + MAX_CONNECTING_POLLS + ')');
+                        setTimeout(useInjectorOrProxy, 1000);
+                    } else {
+                        // Out of patience. isConnecting has stayed true well past
+                        // injector.js's own give-up point, so nothing is coming —
+                        // fall back to the proxy instead of sitting on the splash
+                        // screen indefinitely, which is what this state used to do.
+                        sendLog('ERROR', 'isConnecting still true after ' + MAX_CONNECTING_POLLS + ' polls, falling back to proxy path');
+                        location.href = `http://localhost:8099/tv?additionalDataUrl=http%3A%2F%2Flocalhost%3A8095%2Fdial%2Fapps%2FYouTube${args ? `&${args}` : ''}`
+                    }
+                }).catch((err) => {
+                    // The service takes a couple of seconds to come up, and every
+                    // getState during that window fails. Reloading the whole page
+                    // for each one restarted launchAppControl too, producing 16
+                    // reloads in 3 seconds on a 6.5 capture — wasted work that
+                    // shows up as a long wait on the loading screen. Retry just
+                    // the fetch instead, and only fall back to a reload once it
+                    // is clear the service is not merely slow to start.
+                    startupRetries++;
+                    if (startupRetries <= MAX_STARTUP_RETRIES) {
+                        sendLog('INFO', 'getState not up yet, retrying in ' + STARTUP_RETRY_MS + 'ms (' + startupRetries + '/' + MAX_STARTUP_RETRIES + ')');
+                        setTimeout(useInjectorOrProxy, STARTUP_RETRY_MS);
+                        return;
+                    }
+                    sendLog('ERROR', 'getState still failing after ' + MAX_STARTUP_RETRIES + ' retries, reloading: ' + (err && err.message || err));
+                    window.location.reload();
+                });
+        }
+
+        function launchService() {
+            sendLog('INFO', 'Launching StandaloneService via launchAppControl');
+            tizen.application.launchAppControl(
+                new tizen.ApplicationControl("http://tizen.org/appcontrol/operation/service"),
+                serviceId,
+                function () {
+                    sendLog('INFO', 'launchAppControl success callback fired');
+                    useInjectorOrProxy();
+                },
+                function (e) {
+                    // Confirmed on-device: right after a TV reboot, this can
+                    // genuinely fail (Tizen's own service-launch subsystem
+                    // still warming up) — previously just showed an alert
+                    // and stopped, unlike the getState-fetch-failure path
+                    // below which already retries automatically. User had
+                    // to manually close/reopen the app to get past it.
+                    // Retry the same way instead.
+                    sendLog('ERROR', 'launchAppControl failed, retrying in 1s: ' + e.message);
+                    setTimeout(launchService, 1000);
+                }
+            );
+        }
+        launchService();
+    </script>
+</head>
+
+<body
+    style="background-color: #0f0f0f; display: flex; flex-direction: column; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+    <h1
+        style="color: #FFFFFF; font-size: 80px; font-family: Roboto,Noto Sans CJK ZH-HK,Noto Sans Thai,Arial,Helvetica,sans-serif; margin: 0;">
+        TizenTube
+    </h1>
+    <div class="progress-container">
+        <div class="progress-bar"></div>
+    </div>
+</body>
+
+</html>