@psychout98/tadaima 1.0.2 → 1.0.4

package/dist/service-GBG6YHQW.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-7TPZ4T2V.js";
+
+// src/service.ts
+import { writeFileSync, unlinkSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { platform, homedir } from "os";
+import { join, dirname } from "path";
+var SERVICE_NAME = "tadaima-agent";
+function installService() {
+  const os = platform();
+  if (os === "linux") {
+    installSystemd();
+  } else if (os === "darwin") {
+    installLaunchd();
+  } else if (os === "win32") {
+    installWindows();
+  } else {
+    console.log(`Unsupported platform: ${os}`);
+  }
+}
+function uninstallService() {
+  const os = platform();
+  if (os === "linux") {
+    uninstallSystemd();
+  } else if (os === "darwin") {
+    uninstallLaunchd();
+  } else if (os === "win32") {
+    uninstallWindows();
+  } else {
+    console.log(`Unsupported platform: ${os}`);
+  }
+}
+function installWindows() {
+  const execPath = process.execPath;
+  const scriptPath = process.argv[1];
+  const serviceName = "TadaimaAgent";
+  try {
+    execSync(
+      `sc create ${serviceName} binPath= "\\"${execPath}\\" \\"${scriptPath}\\" start" start= auto DisplayName= "Tadaima Agent"`
+    );
+    execSync(
+      `sc description ${serviceName} "Tadaima media download agent"`
+    );
+    execSync(
+      `sc failure ${serviceName} reset= 60 actions= restart/5000/restart/10000/restart/30000`
+    );
+    execSync(`sc start ${serviceName}`);
+    console.log(`Windows Service installed and started: ${serviceName}`);
+    console.log(`  Status: sc query ${serviceName}`);
+    console.log(`  Stop:   sc stop ${serviceName}`);
+    console.log("");
+    console.log(
+      "Note: The service runs as LocalSystem by default. If it needs access"
+    );
+    console.log(
+      "to user directories, configure it to run as your user account:"
+    );
+    console.log(
+      `  sc config ${serviceName} obj= ".\\USERNAME" password= "PASSWORD"`
+    );
+  } catch (err) {
+    console.error(
+      "Failed to install Windows Service. Try running as Administrator.",
+      err instanceof Error ? err.message : ""
+    );
+  }
+}
+function uninstallWindows() {
+  const serviceName = "TadaimaAgent";
+  try {
+    execSync(`sc stop ${serviceName}`);
+  } catch {
+  }
+  try {
+    execSync(`sc delete ${serviceName}`);
+    console.log(`Windows Service removed: ${serviceName}`);
+  } catch (err) {
+    console.error(
+      "Failed to uninstall Windows Service. Try running as Administrator.",
+      err instanceof Error ? err.message : ""
+    );
+  }
+}
+function installSystemd() {
+  const execPath = process.execPath;
+  const scriptPath = process.argv[1];
+  const user = process.env.USER ?? "root";
+  const unit = `[Unit]
+Description=Tadaima Agent
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${user}
+ExecStart=${execPath} ${scriptPath} start
+Restart=on-failure
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`;
+  const unitPath = `/etc/systemd/system/${SERVICE_NAME}.service`;
+  try {
+    writeFileSync(unitPath, unit);
+    execSync("systemctl daemon-reload");
+    execSync(`systemctl enable ${SERVICE_NAME}`);
+    execSync(`systemctl start ${SERVICE_NAME}`);
+    console.log(`Service installed and started: ${SERVICE_NAME}`);
+    console.log(`  Status: systemctl status ${SERVICE_NAME}`);
+    console.log(`  Logs:   journalctl -u ${SERVICE_NAME} -f`);
+  } catch (err) {
+    console.error(
+      "Failed to install service. Try running with sudo.",
+      err instanceof Error ? err.message : ""
+    );
+  }
+}
+function uninstallSystemd() {
+  const unitPath = `/etc/systemd/system/${SERVICE_NAME}.service`;
+  try {
+    execSync(`systemctl stop ${SERVICE_NAME}`).toString();
+  } catch {
+  }
+  try {
+    execSync(`systemctl disable ${SERVICE_NAME}`);
+    if (existsSync(unitPath)) unlinkSync(unitPath);
+    execSync("systemctl daemon-reload");
+    console.log(`Service removed: ${SERVICE_NAME}`);
+  } catch (err) {
+    console.error(
+      "Failed to uninstall service. Try running with sudo.",
+      err instanceof Error ? err.message : ""
+    );
+  }
+}
+function installLaunchd() {
+  const execPath = process.execPath;
+  const scriptPath = process.argv[1];
+  const label = `com.tadaima.agent`;
+  const plistPath = join(homedir(), "Library/LaunchAgents", `${label}.plist`);
+  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>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${execPath}</string>
+    <string>${scriptPath}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join(dirname(config.path), "logs", "tadaima.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(dirname(config.path), "logs", "tadaima.log")}</string>
+</dict>
+</plist>
+`;
+  try {
+    writeFileSync(plistPath, plist);
+    execSync(`launchctl load ${plistPath}`);
+    console.log(`Service installed and started: ${label}`);
+    console.log(`  Plist: ${plistPath}`);
+    console.log(`  Stop:  launchctl unload ${plistPath}`);
+  } catch (err) {
+    console.error(
+      "Failed to install service.",
+      err instanceof Error ? err.message : ""
+    );
+  }
+}
+function uninstallLaunchd() {
+  const label = `com.tadaima.agent`;
+  const plistPath = join(homedir(), "Library/LaunchAgents", `${label}.plist`);
+  try {
+    execSync(`launchctl unload ${plistPath}`);
+  } catch {
+  }
+  if (existsSync(plistPath)) {
+    unlinkSync(plistPath);
+    console.log(`Service removed: ${label}`);
+  } else {
+    console.log("Service not installed.");
+  }
+}
+export {
+  installService,
+  uninstallService
+};

package/dist/setup-OLV7C7ON.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-7TPZ4T2V.js";
+
+// src/setup.ts
+import prompts from "prompts";
+import { hostname, platform } from "os";
+function detectDeviceName() {
+  return hostname().toLowerCase().replace(/\.local$/, "");
+}
+function detectPlatform() {
+  const p = platform();
+  switch (p) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    default:
+      return p;
+  }
+}
+async function runSetup() {
+  console.log("\n  Tadaima Agent Setup\n");
+  const { relayUrl } = await prompts({
+    type: "text",
+    name: "relayUrl",
+    message: "Relay URL",
+    initial: config.get("relay") || "http://localhost:3000",
+    validate: (v) => v.startsWith("http") ? true : "Must start with http:// or https://"
+  });
+  if (!relayUrl) {
+    console.log("Setup cancelled.");
+    process.exit(0);
+  }
+  const { code } = await prompts({
+    type: "text",
+    name: "code",
+    message: "Pairing code (from web app)",
+    validate: (v) => v.length === 6 ? true : "Code must be 6 characters"
+  });
+  if (!code) {
+    console.log("Setup cancelled.");
+    process.exit(0);
+  }
+  const deviceName = detectDeviceName();
+  const devicePlatform = detectPlatform();
+  console.log(`
+  Pairing as "${deviceName}" (${devicePlatform})...`);
+  const res = await fetch(`${relayUrl}/api/devices/pair/claim`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      code: code.toUpperCase(),
+      name: deviceName,
+      platform: devicePlatform
+    })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ detail: res.statusText }));
+    console.error(`
+  Pairing failed: ${err.detail || err.error}`);
+    process.exit(1);
+  }
+  const { deviceId, deviceToken, rdApiKey, wsUrl } = await res.json();
+  const { moviesDir } = await prompts({
+    type: "text",
+    name: "moviesDir",
+    message: "Movies directory",
+    initial: config.get("directories.movies") || "/mnt/media/Movies",
+    validate: (v) => v.trim().length > 0 && v.startsWith("/") ? true : "Must be a non-empty absolute path"
+  });
+  const { tvDir } = await prompts({
+    type: "text",
+    name: "tvDir",
+    message: "TV Shows directory",
+    initial: config.get("directories.tv") || "/mnt/media/TV",
+    validate: (v) => v.trim().length > 0 && v.startsWith("/") ? true : "Must be a non-empty absolute path"
+  });
+  if (!moviesDir || !tvDir) {
+    console.log("Setup cancelled.");
+    process.exit(0);
+  }
+  config.set("relay", relayUrl);
+  config.set("deviceToken", deviceToken);
+  config.set("deviceId", deviceId);
+  config.set("deviceName", deviceName);
+  config.set("directories.movies", moviesDir || "/mnt/media/Movies");
+  config.set("directories.tv", tvDir || "/mnt/media/TV");
+  config.set("directories.staging", "/tmp/tadaima/staging");
+  config.set("realDebrid.apiKey", rdApiKey);
+  console.log(`
+  Connected! This device is now paired as "${deviceName}".`);
+  console.log(`  Config saved to: ${config.path}`);
+  console.log(`  WebSocket URL: ${wsUrl}
+`);
+}
+export {
+  runSetup
+};

package/dist/status-writer-RGH2PULB.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-7TPZ4T2V.js";
+
+// src/status-writer.ts
+import { writeFileSync, unlinkSync, renameSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+function getStatusPath() {
+  return join(dirname(config.path), "status.json");
+}
+function writeStatus(status) {
+  const statusPath = getStatusPath();
+  const tmpPath = statusPath + ".tmp";
+  try {
+    mkdirSync(dirname(statusPath), { recursive: true });
+    writeFileSync(tmpPath, JSON.stringify(status, null, 2));
+    renameSync(tmpPath, statusPath);
+  } catch {
+  }
+}
+function removeStatus() {
+  try {
+    unlinkSync(getStatusPath());
+  } catch {
+  }
+}
+export {
+  removeStatus,
+  writeStatus
+};

package/dist/tui-ZE4672PT.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-7TPZ4T2V.js";
+
+// src/tui.ts
+import { freemem } from "os";
+var TUI = class {
+  connected = false;
+  profileName = "";
+  version = "0.0.0";
+  interval = null;
+  recentCompleted = [];
+  constructor(version) {
+    this.version = version;
+    this.profileName = config.get("profileName") || "Unknown";
+  }
+  setConnected(connected) {
+    this.connected = connected;
+  }
+  addCompleted(title, size) {
+    this.recentCompleted.unshift({ title, size, completedAt: Date.now() });
+    if (this.recentCompleted.length > 5) this.recentCompleted.pop();
+  }
+  start() {
+    process.stdout.write("\x1B[?25l");
+    this.render();
+    this.interval = setInterval(() => this.render(), 1e3);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    process.stdout.write("\x1B[?25h");
+  }
+  render() {
+    const lines = [];
+    const status = this.connected ? "Connected" : "Disconnected";
+    lines.push("");
+    lines.push(
+      ` tadaima v${this.version} \u2014 ${status} to relay (${this.profileName})`
+    );
+    lines.push(` ${"\u2500".repeat(50)}`);
+    if (this.recentCompleted.length === 0) {
+      lines.push(` Waiting for downloads...`);
+    }
+    for (const entry of this.recentCompleted) {
+      const ago = formatTimeAgo(entry.completedAt);
+      lines.push(
+        ` \u2713 ${entry.title.padEnd(35)} ${formatSize(entry.size).padStart(10)}  \u305F\u3060\u3044\u307E \u2014 completed ${ago}`
+      );
+    }
+    lines.push(` ${"\u2500".repeat(50)}`);
+    const diskFree = formatSize(freemem());
+    lines.push(
+      ` ${diskFree} free`
+    );
+    lines.push("");
+    process.stdout.write("\x1B[2J\x1B[H");
+    process.stdout.write(lines.join("\n"));
+  }
+};
+function formatSize(bytes) {
+  const gb = bytes / (1024 * 1024 * 1024);
+  if (gb >= 1) return `${gb.toFixed(1)} GB`;
+  const mb = bytes / (1024 * 1024);
+  return `${mb.toFixed(0)} MB`;
+}
+function formatTimeAgo(timestamp) {
+  const diff = Date.now() - timestamp;
+  const secs = Math.floor(diff / 1e3);
+  if (secs < 60) return `${secs}s ago`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m ago`;
+  return `${Math.floor(mins / 60)}h ago`;
+}
+export {
+  TUI
+};

package/dist/updater-HXBNBU36.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import {
+  GITHUB_RELEASES_API,
+  getAssetNameForPlatform
+} from "./chunk-6O3GWKMO.js";
+import {
+  config
+} from "./chunk-7TPZ4T2V.js";
+
+// src/updater.ts
+import { createHash } from "crypto";
+import { createWriteStream, readFileSync, copyFileSync, chmodSync, renameSync } from "fs";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { dirname, join, extname } from "path";
+var cachedETag = "";
+async function checkViaRelay(currentVersion) {
+  const relayUrl = config.get("relay");
+  if (!relayUrl) return null;
+  try {
+    const res = await fetch(`${relayUrl}/api/version`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.latest && isNewer(data.latest, currentVersion)) {
+      return data.latest;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(currentVersion) {
+  const assetName = getAssetNameForPlatform();
+  if (!assetName) return null;
+  const relayLatest = await checkViaRelay(currentVersion);
+  if (relayLatest === null) {
+  }
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": `tadaima-agent/${currentVersion}`
+  };
+  if (cachedETag) {
+    headers["If-None-Match"] = cachedETag;
+  }
+  const res = await fetch(GITHUB_RELEASES_API, { headers });
+  if (res.status === 304) return null;
+  if (!res.ok) {
+    throw new Error(`GitHub API returned ${res.status}: ${res.statusText}`);
+  }
+  const etag = res.headers.get("etag");
+  if (etag) cachedETag = etag;
+  const data = await res.json();
+  const latestVersion = data.tag_name.replace(/^v/, "");
+  if (!isNewer(latestVersion, currentVersion)) return null;
+  const binaryAsset = data.assets.find((a) => a.name === assetName);
+  const checksumAsset = data.assets.find((a) => a.name === "checksums.sha256");
+  if (!binaryAsset || !checksumAsset) return null;
+  config.set("lastUpdateCheck", (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    version: latestVersion,
+    downloadUrl: binaryAsset.browser_download_url,
+    checksumUrl: checksumAsset.browser_download_url
+  };
+}
+async function applyUpdate(update) {
+  const configDir = dirname(config.path);
+  const ext = extname(process.execPath);
+  const tmpPath = join(configDir, `tadaima-agent-update-${update.version}${ext}`);
+  const backupPath = join(configDir, `tadaima-agent-previous${ext}`);
+  const binRes = await fetch(update.downloadUrl);
+  if (!binRes.ok || !binRes.body) {
+    throw new Error(`Failed to download binary: ${binRes.status}`);
+  }
+  const ws = createWriteStream(tmpPath);
+  await pipeline(Readable.fromWeb(binRes.body), ws);
+  const csRes = await fetch(update.checksumUrl);
+  if (!csRes.ok) {
+    throw new Error(`Failed to download checksums: ${csRes.status}`);
+  }
+  const checksumText = await csRes.text();
+  const assetName = getAssetNameForPlatform();
+  const expectedLine = checksumText.split("\n").find((l) => l.includes(assetName));
+  if (!expectedLine) {
+    throw new Error(`No checksum found for ${assetName}`);
+  }
+  const expectedHash = expectedLine.trim().split(/\s+/)[0].toLowerCase();
+  const actualHash = createHash("sha256").update(readFileSync(tmpPath)).digest("hex");
+  if (actualHash !== expectedHash) {
+    throw new Error(
+      `Checksum mismatch: expected ${expectedHash}, got ${actualHash}`
+    );
+  }
+  if (process.platform !== "win32") {
+    chmodSync(tmpPath, 493);
+  }
+  try {
+    copyFileSync(process.execPath, backupPath);
+    config.set("previousBinaryPath", backupPath);
+  } catch {
+  }
+  renameSync(tmpPath, process.execPath);
+  if (process.env.TADAIMA_DAEMON || isRunningAsService()) {
+    console.log(`Updated to v${update.version}. Exiting for service restart.`);
+    process.exit(0);
+  } else {
+    console.log(
+      `Update to v${update.version} downloaded. Restart to apply.`
+    );
+  }
+}
+function shouldCheckNow(trigger) {
+  const last = config.get("lastUpdateCheck");
+  if (!last) return true;
+  const elapsed = Date.now() - new Date(last).getTime();
+  const ONE_HOUR = 60 * 60 * 1e3;
+  const TWENTY_FOUR_HOURS = 24 * ONE_HOUR;
+  if (trigger === "startup") return elapsed > ONE_HOUR;
+  return elapsed > TWENTY_FOUR_HOURS;
+}
+function rollback() {
+  const prev = config.get("previousBinaryPath");
+  if (!prev) {
+    console.log("No previous binary to roll back to.");
+    return;
+  }
+  try {
+    copyFileSync(prev, process.execPath);
+    console.log(`Rolled back to previous binary from ${prev}.`);
+    console.log("Restart the agent to use the restored version.");
+  } catch (err) {
+    console.error(
+      "Rollback failed:",
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+function logUpdateAdvisory(currentVersion, latestVersion) {
+  console.log(`
+Tadaima v${latestVersion} is available (you have v${currentVersion}).`);
+  console.log("  npm:    npm update -g @tadaima/agent");
+  console.log("  Docker: docker compose pull && docker compose up -d\n");
+}
+function isNewer(latest, current) {
+  const [lMaj, lMin, lPatch] = latest.split(".").map(Number);
+  const [cMaj, cMin, cPatch] = current.split(".").map(Number);
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPatch > cPatch;
+}
+function isRunningAsService() {
+  return !!process.env.INVOCATION_ID || // systemd
+  process.ppid === 1 || // launchd (parent is launchd PID 1)
+  !!process.env.TADAIMA_SERVICE;
+}
+export {
+  applyUpdate,
+  checkForUpdate,
+  logUpdateAdvisory,
+  rollback,
+  shouldCheckNow
+};