aigc-vault-x-video-service 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AIGC Vault
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# AIGC Vault X Video Service
+
+Local helper service for AIGC Vault. It resolves X/Twitter status URLs with `yt-dlp`, downloads MP4 files to the user's machine, and exposes local file URLs for the browser extension.
+
+## Install
+
+```bash
+brew install node yt-dlp ffmpeg
+npm install -g aigc-vault-x-video-service
+```
+
+## Start
+
+```bash
+aigc-vault-x-video-service
+```
+
+The default service URL is:
+
+```txt
+http://127.0.0.1:8899
+```
+
+The default download directory is:
+
+```txt
+~/Movies/AIGC-Vault-X-Videos
+```
+
+## Auto-start on macOS
+
+```bash
+aigc-vault-x-video-service --install
+```
+
+Remove auto-start:
+
+```bash
+aigc-vault-x-video-service --uninstall
+```
+
+## Options
+
+```bash
+aigc-vault-x-video-service --host 127.0.0.1 --port 8899
+aigc-vault-x-video-service --download-dir ~/Movies/AIGC-Vault-X-Videos
+```
+
+If you want another computer on the same network to access this service, start it with a LAN host such as:
+
+```bash
+aigc-vault-x-video-service --host 0.0.0.0
+```
+
+Then set the AIGC Vault extension service URL to that computer's LAN address, for example:
+
+```txt
+http://192.168.1.23:8899
+```
+
+## API
+
+### GET `/health`
+
+Returns service status.
+
+### POST `/resolve-x-video`
+
+Body:
+
+```json
+{
+  "url": "https://x.com/user/status/123",
+  "download": true
+}
+```
+
+Response:
+
+```json
+{
+  "success": true,
+  "videoUrl": "http://127.0.0.1:8899/files/123.mp4",
+  "filePath": "/Users/name/Movies/AIGC-Vault-X-Videos/123.mp4",
+  "fileName": "123.mp4"
+}
+```
+
+Only `x.com` / `twitter.com` status URLs are accepted.
+
+## Notes
+
+This service uses:
+
+```bash
+yt-dlp --cookies-from-browser chrome -S "res,ext:mp4:m4a" --merge-output-format mp4
+```
+
+Chrome may ask for macOS Keychain permission when `yt-dlp` reads browser cookies. Enter the Mac login password and allow access.

package/bin/aigc-vault-x-video-service.mjs

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+import http from 'node:http';
+import { spawn, execFileSync } from 'node:child_process';
+import { createReadStream, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { mkdir, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const SERVICE_LABEL = 'com.aigcvault.x-video-service';
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_PORT = 8899;
+const DEFAULT_DOWNLOAD_DIR = path.join(os.homedir(), 'Movies', 'AIGC-Vault-X-Videos');
+
+function parseArgs(argv) {
+  const args = {
+    command: 'serve',
+    host: process.env.X_VIDEO_SERVICE_HOST || DEFAULT_HOST,
+    port: Number(process.env.X_VIDEO_SERVICE_PORT || DEFAULT_PORT),
+    downloadDir: process.env.X_VIDEO_DOWNLOAD_DIR || DEFAULT_DOWNLOAD_DIR,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === 'install' || arg === '--install') args.command = 'install';
+    else if (arg === 'uninstall' || arg === '--uninstall') args.command = 'uninstall';
+    else if (arg === 'help' || arg === '--help' || arg === '-h') args.command = 'help';
+    else if (arg === '--host') args.host = argv[++i] || args.host;
+    else if (arg.startsWith('--host=')) args.host = arg.slice('--host='.length);
+    else if (arg === '--port') args.port = Number(argv[++i] || args.port);
+    else if (arg.startsWith('--port=')) args.port = Number(arg.slice('--port='.length));
+    else if (arg === '--download-dir') args.downloadDir = argv[++i] || args.downloadDir;
+    else if (arg.startsWith('--download-dir=')) args.downloadDir = arg.slice('--download-dir='.length);
+  }
+
+  args.downloadDir = path.resolve(args.downloadDir);
+  if (!Number.isFinite(args.port) || args.port <= 0) args.port = DEFAULT_PORT;
+  return args;
+}
+
+function printHelp() {
+  console.log(`AIGC Vault X video service
+
+Usage:
+  aigc-vault-x-video-service
+  aigc-vault-x-video-service --host 127.0.0.1 --port 8899
+  aigc-vault-x-video-service --download-dir ~/Movies/AIGC-Vault-X-Videos
+  aigc-vault-x-video-service --install
+  aigc-vault-x-video-service --uninstall
+
+Prerequisites:
+  brew install yt-dlp ffmpeg
+
+Endpoints:
+  GET  /health
+  POST /resolve-x-video
+  GET  /files/<filename>.mp4
+`);
+}
+
+function corsHeaders() {
+  return {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Headers': 'content-type',
+    'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
+  };
+}
+
+function sendJson(res, status, data) {
+  res.writeHead(status, {
+    ...corsHeaders(),
+    'content-type': 'application/json; charset=utf-8',
+  });
+  res.end(JSON.stringify(data));
+}
+
+function isAllowedStatusUrl(value = '') {
+  try {
+    const parsed = new URL(String(value));
+    const host = parsed.hostname.toLowerCase();
+    return ['x.com', 'www.x.com', 'twitter.com', 'www.twitter.com'].includes(host)
+      && /^\/[^/]+\/status\/\d+/.test(parsed.pathname);
+  } catch {
+    return false;
+  }
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = '';
+    req.on('data', chunk => {
+      raw += chunk;
+      if (raw.length > 16 * 1024) {
+        reject(new Error('Request body is too large'));
+        req.destroy();
+      }
+    });
+    req.on('end', () => {
+      if (!raw.trim()) return resolve({});
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error('Request body is not valid JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function runYtDlp(url, downloadDir) {
+  return new Promise((resolve, reject) => {
+    const outputTemplate = path.join(downloadDir, '%(id)s.%(ext)s');
+    const args = [
+      '--cookies-from-browser',
+      'chrome',
+      '-S',
+      'res,ext:mp4:m4a',
+      '--merge-output-format',
+      'mp4',
+      '-o',
+      outputTemplate,
+      url,
+    ];
+    const child = spawn('yt-dlp', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', chunk => { stdout += chunk.toString(); });
+    child.stderr.on('data', chunk => { stderr += chunk.toString(); });
+    child.on('error', error => {
+      reject(new Error(`Failed to start yt-dlp: ${error.message}`));
+    });
+    child.on('close', code => {
+      if (code === 0) return resolve({ stdout, stderr });
+      reject(new Error((stderr || stdout || `yt-dlp exited with code ${code}`).trim()));
+    });
+  });
+}
+
+async function findNewestMp4(downloadDir, beforeMs) {
+  const entries = await readdir(downloadDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || path.extname(entry.name).toLowerCase() !== '.mp4') continue;
+    const filePath = path.join(downloadDir, entry.name);
+    const info = await stat(filePath);
+    if (info.mtimeMs + 2000 >= beforeMs) {
+      files.push({ name: entry.name, path: filePath, mtimeMs: info.mtimeMs });
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return files[0] || null;
+}
+
+async function handleResolve(req, res, config) {
+  try {
+    const body = await readJsonBody(req);
+    const url = String(body.url || '').trim();
+    if (!isAllowedStatusUrl(url)) {
+      return sendJson(res, 400, { success: false, error: 'Only x.com / twitter.com status URLs are allowed' });
+    }
+
+    await mkdir(config.downloadDir, { recursive: true });
+    const startedAt = Date.now();
+    await runYtDlp(url, config.downloadDir);
+    const file = await findNewestMp4(config.downloadDir, startedAt);
+    if (!file) {
+      return sendJson(res, 500, { success: false, error: 'Download finished, but no MP4 file was found' });
+    }
+
+    sendJson(res, 200, {
+      success: true,
+      videoUrl: `http://${config.host}:${config.port}/files/${encodeURIComponent(file.name)}`,
+      filePath: file.path,
+      fileName: file.name,
+    });
+  } catch (error) {
+    sendJson(res, 500, { success: false, error: error?.message || String(error) });
+  }
+}
+
+async function handleFile(req, res, pathname, config) {
+  const encodedName = pathname.slice('/files/'.length);
+  const decodedName = decodeURIComponent(encodedName);
+  const fileName = path.basename(decodedName);
+  if (!fileName || fileName !== decodedName || path.extname(fileName).toLowerCase() !== '.mp4') {
+    return sendJson(res, 400, { success: false, error: 'Invalid filename' });
+  }
+
+  const filePath = path.join(config.downloadDir, fileName);
+  try {
+    const info = await stat(filePath);
+    if (!info.isFile()) throw new Error('Not a file');
+    res.writeHead(200, {
+      ...corsHeaders(),
+      'content-type': 'video/mp4',
+      'content-length': info.size,
+      'accept-ranges': 'bytes',
+      'cache-control': 'public, max-age=3600',
+    });
+    createReadStream(filePath).pipe(res);
+  } catch {
+    sendJson(res, 404, { success: false, error: 'File not found' });
+  }
+}
+
+function startServer(config) {
+  const server = http.createServer(async (req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Headers', 'content-type');
+    res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, corsHeaders());
+      return res.end();
+    }
+
+    const parsed = new URL(req.url || '/', `http://${req.headers.host || `${config.host}:${config.port}`}`);
+    if (req.method === 'GET' && parsed.pathname === '/health') {
+      return sendJson(res, 200, {
+        success: true,
+        status: 'ok',
+        service: 'aigc-vault-x-video-service',
+        downloadDir: config.downloadDir,
+      });
+    }
+    if (req.method === 'POST' && parsed.pathname === '/resolve-x-video') {
+      return handleResolve(req, res, config);
+    }
+    if (req.method === 'GET' && parsed.pathname.startsWith('/files/')) {
+      return handleFile(req, res, parsed.pathname, config);
+    }
+    sendJson(res, 404, { success: false, error: 'Not Found' });
+  });
+
+  server.listen(config.port, config.host, () => {
+    console.log(`AIGC Vault X video service listening at http://${config.host}:${config.port}`);
+    console.log(`Download directory: ${config.downloadDir}`);
+  });
+}
+
+function findExecutable(name) {
+  const candidates = [
+    `/opt/homebrew/bin/${name}`,
+    `/usr/local/bin/${name}`,
+    `/usr/bin/${name}`,
+  ];
+  return candidates.find(existsSync) || name;
+}
+
+function installLaunchAgent(config) {
+  if (process.platform !== 'darwin') {
+    console.error('Auto-start install currently supports macOS only.');
+    process.exit(1);
+  }
+
+  const launchAgentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const logDir = path.join(os.homedir(), 'Library', 'Logs');
+  const plistPath = path.join(launchAgentsDir, `${SERVICE_LABEL}.plist`);
+  const logPath = path.join(logDir, 'aigc-vault-x-video-service.log');
+  const errPath = path.join(logDir, 'aigc-vault-x-video-service.err.log');
+  const nodePath = findExecutable('node');
+  const currentScript = new URL(import.meta.url).pathname;
+  const command = [
+    JSON.stringify(nodePath),
+    JSON.stringify(currentScript),
+    '--host',
+    JSON.stringify(config.host),
+    '--port',
+    String(config.port),
+    '--download-dir',
+    JSON.stringify(config.downloadDir),
+  ].join(' ');
+
+  const escapedCommand = command.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  const plist = `<?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>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/zsh</string>
+    <string>-lc</string>
+    <string>${escapedCommand}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${errPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+</dict>
+</plist>
+`;
+
+  mkdirSync(launchAgentsDir, { recursive: true });
+  mkdirSync(logDir, { recursive: true });
+  writeFileSync(plistPath, plist);
+
+  try {
+    execFileSync('launchctl', ['bootout', `gui/${process.getuid()}`, plistPath], { stdio: 'ignore' });
+  } catch {}
+
+  execFileSync('launchctl', ['bootstrap', `gui/${process.getuid()}`, plistPath], { stdio: 'inherit' });
+  execFileSync('launchctl', ['enable', `gui/${process.getuid()}/${SERVICE_LABEL}`], { stdio: 'inherit' });
+  execFileSync('launchctl', ['kickstart', '-k', `gui/${process.getuid()}/${SERVICE_LABEL}`], { stdio: 'inherit' });
+
+  console.log('AIGC Vault X video service auto-start is installed.');
+  console.log(`Service URL: http://${config.host}:${config.port}`);
+  console.log(`Config: ${plistPath}`);
+  console.log(`Log: ${logPath}`);
+}
+
+function uninstallLaunchAgent() {
+  if (process.platform !== 'darwin') {
+    console.error('Auto-start uninstall currently supports macOS only.');
+    process.exit(1);
+  }
+
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+  try {
+    execFileSync('launchctl', ['bootout', `gui/${process.getuid()}`, plistPath], { stdio: 'inherit' });
+  } catch {}
+  try {
+    execFileSync('launchctl', ['disable', `gui/${process.getuid()}/${SERVICE_LABEL}`], { stdio: 'ignore' });
+  } catch {}
+  rmSync(plistPath, { force: true });
+  console.log('AIGC Vault X video service auto-start is removed.');
+}
+
+const config = parseArgs(process.argv.slice(2));
+
+if (config.command === 'help') printHelp();
+else if (config.command === 'install') installLaunchAgent(config);
+else if (config.command === 'uninstall') uninstallLaunchAgent();
+else startServer(config);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "aigc-vault-x-video-service",
+  "version": "1.0.0",
+  "description": "Local X/Twitter video resolver service for AIGC Vault.",
+  "type": "module",
+  "bin": {
+    "aigc-vault-x-video-service": "bin/aigc-vault-x-video-service.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/aigc-vault-x-video-service.mjs",
+    "check": "node --check bin/aigc-vault-x-video-service.mjs"
+  },
+  "keywords": [
+    "aigc-vault",
+    "x",
+    "twitter",
+    "yt-dlp",
+    "video"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}