fluncle 0.39.0 → 0.41.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.41.0".trim() ? "0.41.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.39.0".trim() ? "0.39.0".trim() : "0.1.0";
+  currentVersion2 = "0.41.0".trim() ? "0.41.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`);
@@ -4003,11 +4215,19 @@ 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 backfillLastfmCommand(limit, dryRun, cursor) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  return adminApiPost(`/api/admin/backfill/lastfm?${params.toString()}`);
 }
-async function backfillDiscogsCommand(limit, dryRun) {
-  return adminApiPost(`/api/admin/backfill/discogs?limit=${limit}&dryRun=${dryRun}`);
+async function backfillDiscogsCommand(limit, dryRun, cursor) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  return adminApiPost(`/api/admin/backfill/discogs?${params.toString()}`);
 }
 async function vehiclesCommand(limit) {
   const tracks = await fetchAdminTracks({ hasVideo: true, max: limit, order: "desc" });
@@ -5096,6 +5316,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({
@@ -5136,7 +5358,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
@@ -5376,30 +5598,80 @@ async function runPreviewArchiveBackfill(options, previewArchiveBackfillCommand2
 }
 async function runBackfillLastfm(options, backfillLastfmCommand2) {
   const limit = parseListLimit(options.limit);
-  const result = await backfillLastfmCommand2(limit, options.dryRun);
+  const loved = [];
+  const failed = [];
+  let cursor;
+  let dryRun = options.dryRun;
+  while (loved.length + failed.length < limit) {
+    const remaining = limit - (loved.length + failed.length);
+    const result = await backfillLastfmCommand2(remaining, options.dryRun, cursor);
+    dryRun = result.dryRun;
+    loved.push(...result.loved);
+    failed.push(...result.failed);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "Would love" : "Loved";
+      console.log(`  \u2026${verb2.toLowerCase()} ${result.lovedCount}; ${result.failedCount} failed`);
+    }
+    if (result.nextCursor === null) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
   if (options.json) {
-    printJson(result);
+    printJson({
+      dryRun,
+      failed,
+      failedCount: failed.length,
+      loved,
+      lovedCount: loved.length,
+      ok: true
+    });
     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) {
+  const verb = dryRun ? "Would love" : "Loved";
+  console.log(`${verb} ${loved.length} finding(s) on Last.fm; ${failed.length} failed.`);
+  for (const logId of loved) {
     console.log(`  ${logId}`);
   }
-  for (const item of result.failed) {
+  for (const item of failed) {
     console.log(`  ${item.logId}: ${item.error}`);
   }
 }
 async function runBackfillDiscogs(options, backfillDiscogsCommand2) {
   const limit = parseListLimit(options.limit);
-  const result = await backfillDiscogsCommand2(limit, options.dryRun);
+  const resolved = [];
+  const unresolved = [];
+  let cursor;
+  let dryRun = options.dryRun;
+  while (resolved.length + unresolved.length < limit) {
+    const remaining = limit - (resolved.length + unresolved.length);
+    const result = await backfillDiscogsCommand2(remaining, options.dryRun, cursor);
+    dryRun = result.dryRun;
+    resolved.push(...result.resolved);
+    unresolved.push(...result.unresolved);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would resolve" : "resolved";
+      console.log(`  \u2026${verb2} ${result.resolvedCount}; ${result.unresolvedCount} unresolved`);
+    }
+    if (result.nextCursor === null) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
   if (options.json) {
-    printJson(result);
+    printJson({
+      dryRun,
+      ok: true,
+      resolved,
+      resolvedCount: resolved.length,
+      unresolved,
+      unresolvedCount: unresolved.length
+    });
     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 verb = dryRun ? "Would resolve" : "Resolved";
+  console.log(`${verb} ${resolved.length} Discogs release id(s); ${unresolved.length} unresolved.`);
+  for (const item of resolved) {
     const master = item.masterId ? ` (master ${item.masterId})` : "";
     console.log(`  ${item.logId}: release ${item.releaseId}${master}`);
   }
@@ -5452,13 +5724,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) {
@@ -5485,8 +5757,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
@@ -5495,7 +5767,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.39.0"
+  "version": "0.41.0"
 }