fluncle 0.38.0 → 0.40.0

package/bin/fluncle.mjs

@@ -2497,9 +2497,234 @@ var require_main = __commonJS((exports, module) => {
   module.exports = DotenvModule;
 });
 
+// src/output.ts
+function printJson2(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+var CliError2;
+var init_output = __esm(() => {
+  CliError2 = class CliError2 extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "CliError";
+      this.code = code;
+    }
+  };
+});
+
+// src/version.ts
+function normalizeVersion(version) {
+  return version?.trim().replace(/^v/i, "");
+}
+function compareVersions(left, right) {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  for (let index = 0;index < 3; index += 1) {
+    const difference = leftParts[index] - rightParts[index];
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+}
+function parseVersion(version) {
+  const parts = version.split(".").map((part) => Number.parseInt(part, 10));
+  return [
+    Number.isInteger(parts[0]) ? parts[0] : 0,
+    Number.isInteger(parts[1]) ? parts[1] : 0,
+    Number.isInteger(parts[2]) ? parts[2] : 0
+  ];
+}
+var currentVersion;
+var init_version = __esm(() => {
+  init_output();
+  currentVersion = "0.40.0".trim() ? "0.40.0".trim() : "0.1.0";
+});
+
+// src/update-notifier.ts
+var exports_update_notifier = {};
+__export(exports_update_notifier, {
+  updateCommand: () => updateCommand,
+  shouldNotify: () => shouldNotify,
+  notifyIfUpdateAvailable: () => notifyIfUpdateAvailable,
+  detectInstallMethod: () => detectInstallMethod
+});
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir, platform } from "node:os";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+async function notifyIfUpdateAvailable(args) {
+  try {
+    if (!shouldNotify(args)) {
+      return;
+    }
+    const latestVersion = await resolveLatestVersion();
+    if (!latestVersion) {
+      return;
+    }
+    if (compareVersions(latestVersion, currentVersion) <= 0) {
+      return;
+    }
+    process.stderr.write(`
+${buildNotice(currentVersion, latestVersion)}
+`);
+  } catch {}
+}
+function shouldNotify(args) {
+  if (process.env.FLUNCLE_NO_UPDATE_NOTIFIER === "1") {
+    return false;
+  }
+  if (process.env.CI) {
+    return false;
+  }
+  if (process.stderr.isTTY !== true) {
+    return false;
+  }
+  if (args.includes("--json")) {
+    return false;
+  }
+  const command = firstPositional(args);
+  if (command === "version" || command === "about" || command === "help") {
+    return false;
+  }
+  if (args.includes("--help") || args.includes("-h") || args.includes("--version")) {
+    return false;
+  }
+  return true;
+}
+function firstPositional(args) {
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--env") {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    return arg;
+  }
+  return;
+}
+async function resolveLatestVersion() {
+  const cached = await readCache();
+  if (cached && Date.now() - cached.checkedAt < cacheTtlMs) {
+    return cached.latestVersion;
+  }
+  const fetched = await fetchLatestVersion();
+  if (!fetched) {
+    return cached?.latestVersion;
+  }
+  await writeCache({ checkedAt: Date.now(), latestVersion: fetched });
+  return fetched;
+}
+async function fetchLatestVersion() {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+  try {
+    const response = await fetch(registryUrl, {
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json",
+        "User-Agent": `fluncle/${currentVersion}`
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return;
+    }
+    const body = await response.json();
+    return normalizeVersion(body["dist-tags"]?.latest);
+  } catch {
+    return;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readCache() {
+  try {
+    const raw = await readFile(cacheFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.checkedAt !== "number" || typeof parsed.latestVersion !== "string") {
+      return;
+    }
+    return { checkedAt: parsed.checkedAt, latestVersion: parsed.latestVersion };
+  } catch {
+    return;
+  }
+}
+async function writeCache(state) {
+  try {
+    const file = cacheFilePath();
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(state), "utf8");
+  } catch {}
+}
+function cacheFilePath() {
+  const base = process.env.XDG_CACHE_HOME?.trim() || platform() === "win32" && process.env.LOCALAPPDATA?.trim() || join(homedir(), ".config");
+  return join(base, "fluncle", "update-check.json");
+}
+function buildNotice(current, latest) {
+  const method = detectInstallMethod({ entry: entryPath(), execPath: process.execPath || "" });
+  const command = updateCommand(method);
+  return [`Update available: fluncle ${current} → ${latest}`, `Run: ${command}`].join(`
+`);
+}
+function updateCommand(method) {
+  if (method === "homebrew") {
+    return "brew upgrade fluncle";
+  }
+  if (method === "binary") {
+    return `curl -fsSL https://www.fluncle.com/cli/latest.sh | sh  (or ${releasesUrl})`;
+  }
+  return "npm i -g fluncle@latest";
+}
+function detectInstallMethod(launch) {
+  const { entry, execPath } = launch;
+  const haystack = `${execPath}
+${entry}`.toLowerCase();
+  if (isHomebrewPath(haystack)) {
+    return "homebrew";
+  }
+  if (isCompiledBinary(execPath, entry)) {
+    return "binary";
+  }
+  if (entry.endsWith(".mjs") || entry.endsWith(".js") || entry.endsWith(".cjs") || haystack.includes(`${sep}node_modules${sep}`) || haystack.includes("/node_modules/")) {
+    return "npm";
+  }
+  return "npm";
+}
+function isHomebrewPath(haystack) {
+  return haystack.includes("/cellar/") || haystack.includes("/homebrew/") || haystack.includes("/.linuxbrew/") || haystack.includes("/usr/local/cellar/") || haystack.includes("homebrew");
+}
+function isCompiledBinary(execPath, entry) {
+  const exec = execPath.toLowerCase();
+  const base = exec.split(/[\\/]/).pop() ?? "";
+  if (!base.startsWith("fluncle")) {
+    return false;
+  }
+  return entry === "" || entry === execPath;
+}
+function entryPath() {
+  const fromArgv = process.argv[1] ?? "";
+  if (fromArgv) {
+    return fromArgv;
+  }
+  try {
+    return fileURLToPath(import.meta.url);
+  } catch {
+    return "";
+  }
+}
+var registryUrl = "https://registry.npmjs.org/fluncle", releasesUrl = "https://github.com/mauricekleine/fluncle/releases/latest", cacheTtlMs, fetchTimeoutMs = 1500;
+var init_update_notifier = __esm(() => {
+  init_version();
+  cacheTtlMs = 24 * 60 * 60 * 1000;
+});
+
 // src/env.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 function loadEnv(keys) {
   loadConfig();
   const missing = keys.filter((key) => !process.env[key]);
@@ -2517,7 +2742,7 @@ function loadConfig() {
   if (loadedProfile === profile) {
     return;
   }
-  import_dotenv2.config({ path: join(homedir(), `.config/fluncle/.env.${profile}`) });
+  import_dotenv2.config({ path: join2(homedir2(), `.config/fluncle/.env.${profile}`) });
   loadedProfile = profile;
 }
 function getEnvProfile() {
@@ -2536,22 +2761,6 @@ var init_env = __esm(() => {
   envProfiles2 = ["local", "production"];
 });
 
-// src/output.ts
-function printJson2(value) {
-  console.log(JSON.stringify(value, null, 2));
-}
-var CliError2;
-var init_output = __esm(() => {
-  CliError2 = class CliError2 extends Error {
-    code;
-    constructor(code, message) {
-      super(message);
-      this.name = "CliError";
-      this.code = code;
-    }
-  };
-});
-
 // src/api.ts
 async function publicApiGet(path) {
   return apiRequest(path);
@@ -3715,7 +3924,10 @@ var init_about = __esm(() => {
 // src/version.ts
 var exports_version = {};
 __export(exports_version, {
-  versionCommand: () => versionCommand
+  versionCommand: () => versionCommand,
+  normalizeVersion: () => normalizeVersion2,
+  currentVersion: () => currentVersion2,
+  compareVersions: () => compareVersions2
 });
 async function versionCommand(options) {
   const result = options.check ? await buildVersionCheck() : buildCurrentVersion();
@@ -3730,46 +3942,46 @@ async function versionCommand(options) {
 }
 function buildCurrentVersion() {
   return {
-    currentVersion,
-    message: `fluncle ${currentVersion}`
+    currentVersion: currentVersion2,
+    message: `fluncle ${currentVersion2}`
   };
 }
 async function buildVersionCheck() {
   const response = await fetch(latestReleaseUrl, {
     headers: {
-      "User-Agent": `fluncle/${currentVersion}`
+      "User-Agent": `fluncle/${currentVersion2}`
     }
   });
   if (response.status === 404) {
     return {
-      currentVersion,
-      message: `fluncle ${currentVersion}. No GitHub release found yet.`
+      currentVersion: currentVersion2,
+      message: `fluncle ${currentVersion2}. No GitHub release found yet.`
     };
   }
   if (!response.ok) {
     throw new Error(`Update check failed: ${response.status} ${response.statusText}`);
   }
   const release = await response.json();
-  const latestVersion = normalizeVersion(release.tag_name);
+  const latestVersion = normalizeVersion2(release.tag_name);
   if (!latestVersion) {
     throw new Error("Update check failed: latest release did not include a tag");
   }
-  const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+  const updateAvailable = compareVersions2(latestVersion, currentVersion2) > 0;
   const releaseUrl = `https://github.com/mauricekleine/fluncle/releases/latest`;
   return {
-    currentVersion,
+    currentVersion: currentVersion2,
     latestVersion,
-    message: updateAvailable ? `fluncle ${currentVersion}. Update available: ${latestVersion}. Run: curl -fsSL https://www.fluncle.com/cli/latest.sh | sh` : `fluncle ${currentVersion}. You are up to date.`,
+    message: updateAvailable ? `fluncle ${currentVersion2}. Update available: ${latestVersion}. Run: curl -fsSL https://www.fluncle.com/cli/latest.sh | sh` : `fluncle ${currentVersion2}. You are up to date.`,
     releaseUrl,
     updateAvailable
   };
 }
-function normalizeVersion(version) {
+function normalizeVersion2(version) {
   return version?.trim().replace(/^v/i, "");
 }
-function compareVersions(left, right) {
-  const leftParts = parseVersion(left);
-  const rightParts = parseVersion(right);
+function compareVersions2(left, right) {
+  const leftParts = parseVersion2(left);
+  const rightParts = parseVersion2(right);
   for (let index = 0;index < 3; index += 1) {
     const difference = leftParts[index] - rightParts[index];
     if (difference !== 0) {
@@ -3778,7 +3990,7 @@ function compareVersions(left, right) {
   }
   return 0;
 }
-function parseVersion(version) {
+function parseVersion2(version) {
   const parts = version.split(".").map((part) => Number.parseInt(part, 10));
   return [
     Number.isInteger(parts[0]) ? parts[0] : 0,
@@ -3786,10 +3998,10 @@ function parseVersion(version) {
     Number.isInteger(parts[2]) ? parts[2] : 0
   ];
 }
-var currentVersion, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
-var init_version = __esm(() => {
+var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
+var init_version2 = __esm(() => {
   init_output();
-  currentVersion = "0.38.0".trim() ? "0.38.0".trim() : "0.1.0";
+  currentVersion2 = "0.40.0".trim() ? "0.40.0".trim() : "0.1.0";
 });
 
 // src/commands/track.ts
@@ -3855,10 +4067,10 @@ async function readManifestFields(renderPath) {
   } catch {}
   return {};
 }
-async function trackDraftCommand(idOrLogId, platform) {
-  return adminApiPost(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/social/${platform}/draft`);
+async function trackDraftCommand(idOrLogId, platform2) {
+  return adminApiPost(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/social/${platform2}/draft`);
 }
-async function trackSocialUpdateCommand(idOrLogId, platform, options) {
+async function trackSocialUpdateCommand(idOrLogId, platform2, options) {
   const body = { status: options.status };
   if (options.url !== undefined) {
     body.url = options.url;
@@ -3866,7 +4078,7 @@ async function trackSocialUpdateCommand(idOrLogId, platform, options) {
   if (options.scheduledFor !== undefined) {
     body.scheduledFor = options.scheduledFor;
   }
-  return adminApiPatch(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/social/${platform}`, body);
+  return adminApiPatch(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/social/${platform2}`, body);
 }
 async function trackSocialShowCommand(idOrLogId) {
   return adminApiGet(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/social`);
@@ -3960,7 +4172,9 @@ __export(exports_admin_tracks, {
   vehiclesCommand: () => vehiclesCommand,
   queueCommand: () => queueCommand,
   enrichSweepCommand: () => enrichSweepCommand,
-  enrichQueueCommand: () => enrichQueueCommand
+  enrichQueueCommand: () => enrichQueueCommand,
+  backfillLastfmCommand: () => backfillLastfmCommand,
+  backfillDiscogsCommand: () => backfillDiscogsCommand
 });
 async function fetchAdminTracks(options) {
   const { hasVideo, max, order, status } = options;
@@ -4001,6 +4215,12 @@ async function enrichQueueCommand(limit) {
 async function enrichSweepCommand(limit) {
   return adminApiPost(`/api/admin/enrich-sweep?limit=${limit}`);
 }
+async function backfillLastfmCommand(limit, dryRun) {
+  return adminApiPost(`/api/admin/backfill/lastfm?limit=${limit}&dryRun=${dryRun}`);
+}
+async function backfillDiscogsCommand(limit, dryRun) {
+  return adminApiPost(`/api/admin/backfill/discogs?limit=${limit}&dryRun=${dryRun}`);
+}
 async function vehiclesCommand(limit) {
   const tracks = await fetchAdminTracks({ hasVideo: true, max: limit, order: "desc" });
   return tracks.map((track) => ({
@@ -5088,6 +5308,8 @@ async function main(args = process.argv.slice(2)) {
     }
     process.exit(1);
   }
+  const { notifyIfUpdateAvailable: notifyIfUpdateAvailable2 } = await Promise.resolve().then(() => (init_update_notifier(), exports_update_notifier));
+  await notifyIfUpdateAvailable2(args);
 }
 function configureCommand(command) {
   return command.exitOverride().addHelpCommand(false).configureOutput({
@@ -5128,7 +5350,7 @@ function addMetaCommands(program2) {
     aboutCommand2();
   });
   program2.command("version").description("Print or check the version").option("--check", "Check the latest GitHub release", false).option("--json", "Print JSON", false).action(async (options) => {
-    const { versionCommand: versionCommand2 } = await Promise.resolve().then(() => (init_version(), exports_version));
+    const { versionCommand: versionCommand2 } = await Promise.resolve().then(() => (init_version2(), exports_version));
     await versionCommand2({
       check: options.check,
       json: options.json
@@ -5289,6 +5511,14 @@ function addAdminCommands(program2) {
     const { previewArchiveBackfillCommand: previewArchiveBackfillCommand2 } = await Promise.resolve().then(() => (init_preview_archive(), exports_preview_archive));
     await runPreviewArchiveBackfill(options, previewArchiveBackfillCommand2);
   });
+  backfill.command("lastfm").description("Love already-published findings on Last.fm (idempotent; a no-op until configured)").option("--dry-run", "Resolve the set but fire no loves; just report what would be loved", false).option("--limit <limit>", "Max findings to love", "50").option("--json", "Print JSON", false).action(async (options) => {
+    const { backfillLastfmCommand: backfillLastfmCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runBackfillLastfm(options, backfillLastfmCommand2);
+  });
+  backfill.command("discogs").description("Resolve missing Discogs release ids for published findings (high-confidence only)").option("--dry-run", "Resolve but write nothing; just report what would be resolved", false).option("--limit <limit>", "Max findings to resolve", "50").option("--json", "Print JSON", false).action(async (options) => {
+    const { backfillDiscogsCommand: backfillDiscogsCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runBackfillDiscogs(options, backfillDiscogsCommand2);
+  });
 }
 async function runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCommand2) {
   if (!idOrLogId || !options.file || !options.source || !options.mime) {
@@ -5358,6 +5588,36 @@ async function runPreviewArchiveBackfill(options, previewArchiveBackfillCommand2
     console.log(`  ${item.logId}: ${item.source}`);
   }
 }
+async function runBackfillLastfm(options, backfillLastfmCommand2) {
+  const limit = parseListLimit(options.limit);
+  const result = await backfillLastfmCommand2(limit, options.dryRun);
+  if (options.json) {
+    printJson(result);
+    return;
+  }
+  const verb = result.dryRun ? "Would love" : "Loved";
+  console.log(`${verb} ${result.lovedCount} finding(s) on Last.fm; ${result.failedCount} failed.`);
+  for (const logId of result.loved) {
+    console.log(`  ${logId}`);
+  }
+  for (const item of result.failed) {
+    console.log(`  ${item.logId}: ${item.error}`);
+  }
+}
+async function runBackfillDiscogs(options, backfillDiscogsCommand2) {
+  const limit = parseListLimit(options.limit);
+  const result = await backfillDiscogsCommand2(limit, options.dryRun);
+  if (options.json) {
+    printJson(result);
+    return;
+  }
+  const verb = result.dryRun ? "Would resolve" : "Resolved";
+  console.log(`${verb} ${result.resolvedCount} Discogs release id(s); ${result.unresolvedCount} unresolved.`);
+  for (const item of result.resolved) {
+    const master = item.masterId ? ` (master ${item.masterId})` : "";
+    console.log(`  ${item.logId}: release ${item.releaseId}${master}`);
+  }
+}
 async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing id. Usage: fluncle admin track video <track_id|log_id> (--dir <dir> | --footage <file> [--footage-silent <file>] [--poster <file>] [--cover <file>] [--note <file>] [--composition <file>] [--props <file>] [--render <file>])");
@@ -5406,13 +5666,13 @@ async function runTrackDraft(idOrLogId, options, trackDraftCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing id. Usage: fluncle admin track draft <track_id|log_id> [--platform tiktok]");
   }
-  const platform = options.platform ?? "tiktok";
-  const result = await trackDraftCommand2(idOrLogId, platform);
+  const platform2 = options.platform ?? "tiktok";
+  const result = await trackDraftCommand2(idOrLogId, platform2);
   if (options.json) {
     printJson(result);
     return;
   }
-  console.log(`Pushed ${platform} draft for ${result.trackId} (post ${result.externalId})`);
+  console.log(`Pushed ${platform2} draft for ${result.trackId} (post ${result.externalId})`);
 }
 async function runTrackSocial(idOrLogId, options, trackSocialShowCommand2, trackSocialUpdateCommand2) {
   if (!idOrLogId) {
@@ -5439,8 +5699,8 @@ async function runTrackSocial(idOrLogId, options, trackSocialShowCommand2, track
   if (options.status === "published" && !options.url) {
     throw new Error("Publishing requires --url <post-url>");
   }
-  const platform = options.platform ?? "tiktok";
-  const result = await trackSocialUpdateCommand2(idOrLogId, platform, {
+  const platform2 = options.platform ?? "tiktok";
+  const result = await trackSocialUpdateCommand2(idOrLogId, platform2, {
     scheduledFor: options.scheduledFor,
     status: options.status,
     url: options.url
@@ -5449,7 +5709,7 @@ async function runTrackSocial(idOrLogId, options, trackSocialShowCommand2, track
     printJson(result);
     return;
   }
-  console.log(`${platform} \u2192 ${options.status} for ${result.trackId}`);
+  console.log(`${platform2} \u2192 ${options.status} for ${result.trackId}`);
 }
 async function runTrackGet(idOrLogId, options, trackGetCommand2) {
   if (!idOrLogId) {

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.38.0"
+  "version": "0.40.0"
 }