OPML import subscribes you; export lists only your feeds

Import predated accounts: it only added URLs missing from config.toml
and subscribed nobody. Importing another account's export did nothing
("Imported 0 feed(s)"), and a genuinely new feed had no subscriber, so
it was never scanned. Web and CLI import now share subscribe_opml,
which subscribes the caller (the CLI: the first admin) to every feed in
the file and reports new vs already-subscribed.

Export wrote the whole catalogue to anyone signed in, including other
people's private feed URLs. It now lists only your own subscriptions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0173mGu6rK18Ne7UGTwAaVJV

src/main.rs

@@ -602,44 +602,91 @@ fn rm(ctx: &Ctx, config_path: &std::path::Path, feed: &str) -> Result<()> {
 }
 
 async fn import(ctx: &Ctx, config_path: &std::path::Path, file: &std::path::Path) -> Result<()> {
-    let mut cfg = (*ctx.cfg()).clone();
     let text = std::fs::read_to_string(file)
         .with_context(|| format!("reading {}", file.display()))?;
-    let doc = opml::OPML::from_str(&text).map_err(|e| anyhow::anyhow!("parsing OPML: {e}"))?;
+    // The CLI speaks for the operator, as the shared web token does.
+    let admin = ctx
+        .db
+        .users()?
+        .into_iter()
+        .find(|u| u.is_admin)
+        .ok_or_else(|| anyhow::anyhow!("no admin account to subscribe: ipx user add <name> --admin"))?;
+    let (added, had) = subscribe_opml(ctx, config_path, &text, admin.id)?;
+    println!("subscribed {} to {added} feed(s); {had} already there", admin.name);
+    Ok(())
+}
 
+/// Subscribes one person to every feed in an OPML document, for the CLI and the web alike.
+/// A feed already in the catalogue costs nothing; an unknown one is added under the OPML's
+/// title rather than refetching each. Returns (newly subscribed, already subscribed).
+///
+/// Before accounts, importing only added unknown URLs to config.toml. Once subscriptions
+/// decided what each person sees, that imported nothing at all for a feed someone else
+/// already had, and a new one had no subscriber, so it was never scanned.
+pub fn subscribe_opml(
+    ctx: &Ctx,
+    config_path: &std::path::Path,
+    xml: &str,
+    user_id: i64,
+) -> Result<(usize, usize)> {
+    let doc = opml::OPML::from_str(xml)
+        .map_err(|e| anyhow::anyhow!("that does not parse as OPML: {e}"))?;
     let mut found = vec![];
     collect_outlines(&doc.body.outlines, &mut found);
 
-    let mut added = 0;
+    let known = subscriptions(ctx)?;
+    let mut cfg = (*ctx.cfg()).clone();
+    let mut ids = vec![];
+    let mut grew = false;
     for (title, url) in found {
-        if cfg.feeds.values().any(|f| f.url == url) {
-            continue;
-        }
-        // Name it from the OPML title rather than refetching every feed.
-        let id = config::unique_slug(&title, &cfg.feeds);
-        cfg.feeds.insert(
-            id.clone(),
-            config::Feed {
-                url,
-                folder: None,
-                group: None,
-                media_types: None,
-                schedule: None,
-                keywords: vec![],
-                allow_explicit: false,
-                auto_download: true,
-                max_new_per_check: None,
-                username: None,
-                password: None,
-                password_env: None,
-            },
-        );
-        println!("added {id}");
-        added += 1;
+        let existing = known
+            .iter()
+            .find(|s| s.cfg.url == url)
+            .map(|s| s.id.clone())
+            // The same URL listed twice in one file.
+            .or_else(|| cfg.feeds.iter().find(|(_, f)| f.url == url).map(|(id, _)| id.clone()));
+        let id = match existing {
+            Some(id) => id,
+            None => {
+                let id = config::unique_slug(&title, &cfg.feeds);
+                cfg.feeds.insert(
+                    id.clone(),
+                    config::Feed {
+                        url,
+                        folder: None,
+                        group: None,
+                        media_types: None,
+                        schedule: None,
+                        keywords: vec![],
+                        allow_explicit: false,
+                        auto_download: true,
+                        max_new_per_check: None,
+                        username: None,
+                        password: None,
+                        password_env: None,
+                    },
+                );
+                grew = true;
+                id
+            }
+        };
+        ids.push(id);
     }
-    cfg.save(config_path)?;
-    println!("{added} feed(s) imported");
-    Ok(())
+    if grew {
+        cfg.save(config_path)?;
+        ctx.reload_cfg(config_path)?;
+    }
+
+    let (mut added, mut had) = (0, 0);
+    for id in ids {
+        if ctx.db.subscription(user_id, &id)?.is_some() {
+            had += 1;
+        } else {
+            ctx.db.subscribe(user_id, &id)?;
+            added += 1;
+        }
+    }
+    Ok((added, had))
 }
 
 /// OPML nests feeds inside folder outlines, so this walks the whole tree.