@atproto/api 0.10.1 → 0.11.0-next.0

package/dist/bsky-agent.js

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BskyAgent = void 0;
+const syntax_1 = require("@atproto/syntax");
+const agent_1 = require("./agent");
+const client_1 = require("./client");
+const FEED_VIEW_PREF_DEFAULTS = {
+    hideReplies: false,
+    hideRepliesByUnfollowed: false,
+    hideRepliesByLikeCount: 0,
+    hideReposts: false,
+    hideQuotePosts: false,
+};
+const THREAD_VIEW_PREF_DEFAULTS = {
+    sort: 'oldest',
+    prioritizeFollowedUsers: true,
+};
+class BskyAgent extends agent_1.AtpAgent {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "getTimeline", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getTimeline(params, opts)
+        });
+        Object.defineProperty(this, "getAuthorFeed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getAuthorFeed(params, opts)
+        });
+        Object.defineProperty(this, "getActorLikes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getActorLikes(params, opts)
+        });
+        Object.defineProperty(this, "getPostThread", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getPostThread(params, opts)
+        });
+        Object.defineProperty(this, "getPost", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params) => this.api.app.bsky.feed.post.get(params)
+        });
+        Object.defineProperty(this, "getPosts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getPosts(params, opts)
+        });
+        Object.defineProperty(this, "getLikes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getLikes(params, opts)
+        });
+        Object.defineProperty(this, "getRepostedBy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.feed.getRepostedBy(params, opts)
+        });
+        Object.defineProperty(this, "getFollows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.graph.getFollows(params, opts)
+        });
+        Object.defineProperty(this, "getFollowers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.graph.getFollowers(params, opts)
+        });
+        Object.defineProperty(this, "getProfile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.actor.getProfile(params, opts)
+        });
+        Object.defineProperty(this, "getProfiles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.actor.getProfiles(params, opts)
+        });
+        Object.defineProperty(this, "getSuggestions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.actor.getSuggestions(params, opts)
+        });
+        Object.defineProperty(this, "searchActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.actor.searchActors(params, opts)
+        });
+        Object.defineProperty(this, "searchActorsTypeahead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.actor.searchActorsTypeahead(params, opts)
+        });
+        Object.defineProperty(this, "listNotifications", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.notification.listNotifications(params, opts)
+        });
+        Object.defineProperty(this, "countUnreadNotifications", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.api.app.bsky.notification.getUnreadCount(params, opts)
+        });
+    }
+    get app() {
+        return this.api.app;
+    }
+    async post(record) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        record.createdAt = record.createdAt || new Date().toISOString();
+        return this.api.app.bsky.feed.post.create({ repo: this.session.did }, record);
+    }
+    async deletePost(postUri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        const postUrip = new syntax_1.AtUri(postUri);
+        return await this.api.app.bsky.feed.post.delete({
+            repo: postUrip.hostname,
+            rkey: postUrip.rkey,
+        });
+    }
+    async like(uri, cid) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        return await this.api.app.bsky.feed.like.create({ repo: this.session.did }, {
+            subject: { uri, cid },
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteLike(likeUri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        const likeUrip = new syntax_1.AtUri(likeUri);
+        return await this.api.app.bsky.feed.like.delete({
+            repo: likeUrip.hostname,
+            rkey: likeUrip.rkey,
+        });
+    }
+    async repost(uri, cid) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        return await this.api.app.bsky.feed.repost.create({ repo: this.session.did }, {
+            subject: { uri, cid },
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteRepost(repostUri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        const repostUrip = new syntax_1.AtUri(repostUri);
+        return await this.api.app.bsky.feed.repost.delete({
+            repo: repostUrip.hostname,
+            rkey: repostUrip.rkey,
+        });
+    }
+    async follow(subjectDid) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        return await this.api.app.bsky.graph.follow.create({ repo: this.session.did }, {
+            subject: subjectDid,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteFollow(followUri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        const followUrip = new syntax_1.AtUri(followUri);
+        return await this.api.app.bsky.graph.follow.delete({
+            repo: followUrip.hostname,
+            rkey: followUrip.rkey,
+        });
+    }
+    async upsertProfile(updateFn) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        let retriesRemaining = 5;
+        while (retriesRemaining >= 0) {
+            // fetch existing
+            const existing = await this.com.atproto.repo
+                .getRecord({
+                repo: this.session.did,
+                collection: 'app.bsky.actor.profile',
+                rkey: 'self',
+            })
+                .catch((_) => undefined);
+            // run the update
+            const updated = await updateFn(existing?.data.value);
+            if (updated) {
+                updated.$type = 'app.bsky.actor.profile';
+            }
+            // validate the record
+            const validation = client_1.AppBskyActorProfile.validateRecord(updated);
+            if (!validation.success) {
+                throw validation.error;
+            }
+            try {
+                // attempt the put
+                await this.com.atproto.repo.putRecord({
+                    repo: this.session.did,
+                    collection: 'app.bsky.actor.profile',
+                    rkey: 'self',
+                    record: updated,
+                    swapRecord: existing?.data.cid || null,
+                });
+            }
+            catch (e) {
+                if (retriesRemaining > 0 &&
+                    e instanceof client_1.ComAtprotoRepoPutRecord.InvalidSwapError) {
+                    // try again
+                    retriesRemaining--;
+                    continue;
+                }
+                else {
+                    throw e;
+                }
+            }
+            break;
+        }
+    }
+    async mute(actor) {
+        return this.api.app.bsky.graph.muteActor({ actor });
+    }
+    async unmute(actor) {
+        return this.api.app.bsky.graph.unmuteActor({ actor });
+    }
+    async muteModList(uri) {
+        return this.api.app.bsky.graph.muteActorList({
+            list: uri,
+        });
+    }
+    async unmuteModList(uri) {
+        return this.api.app.bsky.graph.unmuteActorList({
+            list: uri,
+        });
+    }
+    async blockModList(uri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        return await this.api.app.bsky.graph.listblock.create({ repo: this.session.did }, {
+            subject: uri,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async unblockModList(uri) {
+        if (!this.session) {
+            throw new Error('Not logged in');
+        }
+        const listInfo = await this.api.app.bsky.graph.getList({
+            list: uri,
+            limit: 1,
+        });
+        if (!listInfo.data.list.viewer?.blocked) {
+            return;
+        }
+        const { rkey } = new syntax_1.AtUri(listInfo.data.list.viewer.blocked);
+        return await this.api.app.bsky.graph.listblock.delete({
+            repo: this.session.did,
+            rkey,
+        });
+    }
+    async updateSeenNotifications(seenAt) {
+        seenAt = seenAt || new Date().toISOString();
+        return this.api.app.bsky.notification.updateSeen({
+            seenAt,
+        });
+    }
+    async getPreferences() {
+        const prefs = {
+            feeds: {
+                saved: undefined,
+                pinned: undefined,
+            },
+            feedViewPrefs: {
+                home: {
+                    ...FEED_VIEW_PREF_DEFAULTS,
+                },
+            },
+            threadViewPrefs: { ...THREAD_VIEW_PREF_DEFAULTS },
+            adultContentEnabled: false,
+            contentLabels: {},
+            birthDate: undefined,
+            interests: {
+                tags: [],
+            },
+            mutedWords: [],
+            hiddenPosts: [],
+        };
+        const res = await this.app.bsky.actor.getPreferences({});
+        for (const pref of res.data.preferences) {
+            if (client_1.AppBskyActorDefs.isAdultContentPref(pref) &&
+                client_1.AppBskyActorDefs.validateAdultContentPref(pref).success) {
+                prefs.adultContentEnabled = pref.enabled;
+            }
+            else if (client_1.AppBskyActorDefs.isContentLabelPref(pref) &&
+                client_1.AppBskyActorDefs.validateAdultContentPref(pref).success) {
+                let value = pref.visibility;
+                if (value === 'show') {
+                    value = 'ignore';
+                }
+                if (value === 'ignore' || value === 'warn' || value === 'hide') {
+                    prefs.contentLabels[pref.label] = value;
+                }
+            }
+            else if (client_1.AppBskyActorDefs.isSavedFeedsPref(pref) &&
+                client_1.AppBskyActorDefs.validateSavedFeedsPref(pref).success) {
+                prefs.feeds.saved = pref.saved;
+                prefs.feeds.pinned = pref.pinned;
+            }
+            else if (client_1.AppBskyActorDefs.isPersonalDetailsPref(pref) &&
+                client_1.AppBskyActorDefs.validatePersonalDetailsPref(pref).success) {
+                if (pref.birthDate) {
+                    prefs.birthDate = new Date(pref.birthDate);
+                }
+            }
+            else if (client_1.AppBskyActorDefs.isFeedViewPref(pref) &&
+                client_1.AppBskyActorDefs.validateFeedViewPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, feed, ...v } = pref;
+                prefs.feedViewPrefs[pref.feed] = { ...FEED_VIEW_PREF_DEFAULTS, ...v };
+            }
+            else if (client_1.AppBskyActorDefs.isThreadViewPref(pref) &&
+                client_1.AppBskyActorDefs.validateThreadViewPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.threadViewPrefs = { ...prefs.threadViewPrefs, ...v };
+            }
+            else if (client_1.AppBskyActorDefs.isInterestsPref(pref) &&
+                client_1.AppBskyActorDefs.validateInterestsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.interests = { ...prefs.interests, ...v };
+            }
+            else if (client_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+                client_1.AppBskyActorDefs.validateMutedWordsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.mutedWords = v.items;
+            }
+            else if (client_1.AppBskyActorDefs.isHiddenPostsPref(pref) &&
+                client_1.AppBskyActorDefs.validateHiddenPostsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.hiddenPosts = v.items;
+            }
+        }
+        return prefs;
+    }
+    async setSavedFeeds(saved, pinned) {
+        return updateFeedPreferences(this, () => ({
+            saved,
+            pinned,
+        }));
+    }
+    async addSavedFeed(v) {
+        return updateFeedPreferences(this, (saved, pinned) => ({
+            saved: [...saved.filter((uri) => uri !== v), v],
+            pinned,
+        }));
+    }
+    async removeSavedFeed(v) {
+        return updateFeedPreferences(this, (saved, pinned) => ({
+            saved: saved.filter((uri) => uri !== v),
+            pinned: pinned.filter((uri) => uri !== v),
+        }));
+    }
+    async addPinnedFeed(v) {
+        return updateFeedPreferences(this, (saved, pinned) => ({
+            saved: [...saved.filter((uri) => uri !== v), v],
+            pinned: [...pinned.filter((uri) => uri !== v), v],
+        }));
+    }
+    async removePinnedFeed(v) {
+        return updateFeedPreferences(this, (saved, pinned) => ({
+            saved,
+            pinned: pinned.filter((uri) => uri !== v),
+        }));
+    }
+    async setAdultContentEnabled(v) {
+        await updatePreferences(this, (prefs) => {
+            let adultContentPref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isAdultContentPref(pref) &&
+                client_1.AppBskyActorDefs.validateAdultContentPref(pref).success);
+            if (adultContentPref) {
+                adultContentPref.enabled = v;
+            }
+            else {
+                adultContentPref = {
+                    $type: 'app.bsky.actor.defs#adultContentPref',
+                    enabled: v,
+                };
+            }
+            return prefs
+                .filter((pref) => !client_1.AppBskyActorDefs.isAdultContentPref(pref))
+                .concat([adultContentPref]);
+        });
+    }
+    async setContentLabelPref(key, value) {
+        // TEMP update old value
+        if (value === 'show') {
+            value = 'ignore';
+        }
+        await updatePreferences(this, (prefs) => {
+            let labelPref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isContentLabelPref(pref) &&
+                client_1.AppBskyActorDefs.validateAdultContentPref(pref).success &&
+                pref.label === key);
+            if (labelPref) {
+                labelPref.visibility = value;
+            }
+            else {
+                labelPref = {
+                    $type: 'app.bsky.actor.defs#contentLabelPref',
+                    label: key,
+                    visibility: value,
+                };
+            }
+            return prefs
+                .filter((pref) => !client_1.AppBskyActorDefs.isContentLabelPref(pref) || pref.label !== key)
+                .concat([labelPref]);
+        });
+    }
+    async setPersonalDetails({ birthDate, }) {
+        birthDate = birthDate instanceof Date ? birthDate.toISOString() : birthDate;
+        await updatePreferences(this, (prefs) => {
+            let personalDetailsPref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isPersonalDetailsPref(pref) &&
+                client_1.AppBskyActorDefs.validatePersonalDetailsPref(pref).success);
+            if (personalDetailsPref) {
+                personalDetailsPref.birthDate = birthDate;
+            }
+            else {
+                personalDetailsPref = {
+                    $type: 'app.bsky.actor.defs#personalDetailsPref',
+                    birthDate,
+                };
+            }
+            return prefs
+                .filter((pref) => !client_1.AppBskyActorDefs.isPersonalDetailsPref(pref))
+                .concat([personalDetailsPref]);
+        });
+    }
+    async setFeedViewPrefs(feed, pref) {
+        await updatePreferences(this, (prefs) => {
+            const existing = prefs.findLast((pref) => client_1.AppBskyActorDefs.isFeedViewPref(pref) &&
+                client_1.AppBskyActorDefs.validateFeedViewPref(pref).success &&
+                pref.feed === feed);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !client_1.AppBskyActorDefs.isFeedViewPref(pref) || p.feed !== feed)
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#feedViewPref', feed }]);
+        });
+    }
+    async setThreadViewPrefs(pref) {
+        await updatePreferences(this, (prefs) => {
+            const existing = prefs.findLast((pref) => client_1.AppBskyActorDefs.isThreadViewPref(pref) &&
+                client_1.AppBskyActorDefs.validateThreadViewPref(pref).success);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !client_1.AppBskyActorDefs.isThreadViewPref(p))
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#threadViewPref' }]);
+        });
+    }
+    async setInterestsPref(pref) {
+        await updatePreferences(this, (prefs) => {
+            const existing = prefs.findLast((pref) => client_1.AppBskyActorDefs.isInterestsPref(pref) &&
+                client_1.AppBskyActorDefs.validateInterestsPref(pref).success);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !client_1.AppBskyActorDefs.isInterestsPref(p))
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#interestsPref' }]);
+        });
+    }
+    async upsertMutedWords(mutedWords) {
+        await updateMutedWords(this, mutedWords, 'upsert');
+    }
+    async updateMutedWord(mutedWord) {
+        await updateMutedWords(this, [mutedWord], 'update');
+    }
+    async removeMutedWord(mutedWord) {
+        await updateMutedWords(this, [mutedWord], 'remove');
+    }
+    async hidePost(postUri) {
+        await updateHiddenPost(this, postUri, 'hide');
+    }
+    async unhidePost(postUri) {
+        await updateHiddenPost(this, postUri, 'unhide');
+    }
+}
+exports.BskyAgent = BskyAgent;
+/**
+ * This function updates the preferences of a user and allows for a callback function to be executed
+ * before the update.
+ * @param cb - cb is a callback function that takes in a single parameter of type
+ * AppBskyActorDefs.Preferences and returns either a boolean or void. This callback function is used to
+ * update the preferences of the user. The function is called with the current preferences as an
+ * argument and if the callback returns false, the preferences are not updated.
+ */
+async function updatePreferences(agent, cb) {
+    const res = await agent.app.bsky.actor.getPreferences({});
+    const newPrefs = cb(res.data.preferences);
+    if (newPrefs === false) {
+        return;
+    }
+    await agent.app.bsky.actor.putPreferences({
+        preferences: newPrefs,
+    });
+}
+/**
+ * A helper specifically for updating feed preferences
+ */
+async function updateFeedPreferences(agent, cb) {
+    let res;
+    await updatePreferences(agent, (prefs) => {
+        let feedsPref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isSavedFeedsPref(pref) &&
+            client_1.AppBskyActorDefs.validateSavedFeedsPref(pref).success);
+        if (feedsPref) {
+            res = cb(feedsPref.saved, feedsPref.pinned);
+            feedsPref.saved = res.saved;
+            feedsPref.pinned = res.pinned;
+        }
+        else {
+            res = cb([], []);
+            feedsPref = {
+                $type: 'app.bsky.actor.defs#savedFeedsPref',
+                saved: res.saved,
+                pinned: res.pinned,
+            };
+        }
+        return prefs
+            .filter((pref) => !client_1.AppBskyActorDefs.isSavedFeedsPref(pref))
+            .concat([feedsPref]);
+    });
+    return res;
+}
+/**
+ * A helper specifically for updating muted words preferences
+ */
+async function updateMutedWords(agent, mutedWords, action) {
+    const sanitizeMutedWord = (word) => ({
+        value: word.value.replace(/^#/, ''),
+        targets: word.targets,
+    });
+    await updatePreferences(agent, (prefs) => {
+        let mutedWordsPref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+            client_1.AppBskyActorDefs.validateMutedWordsPref(pref).success);
+        if (mutedWordsPref && client_1.AppBskyActorDefs.isMutedWordsPref(mutedWordsPref)) {
+            if (action === 'upsert' || action === 'update') {
+                for (const word of mutedWords) {
+                    let foundMatch = false;
+                    for (const existingItem of mutedWordsPref.items) {
+                        if (existingItem.value === sanitizeMutedWord(word).value) {
+                            existingItem.targets =
+                                action === 'upsert'
+                                    ? Array.from(new Set([...existingItem.targets, ...word.targets]))
+                                    : word.targets;
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+                    if (action === 'upsert' && !foundMatch) {
+                        mutedWordsPref.items.push(sanitizeMutedWord(word));
+                    }
+                }
+            }
+            else if (action === 'remove') {
+                for (const word of mutedWords) {
+                    for (let i = 0; i < mutedWordsPref.items.length; i++) {
+                        const existing = mutedWordsPref.items[i];
+                        if (existing.value === sanitizeMutedWord(word).value) {
+                            mutedWordsPref.items.splice(i, 1);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // if the pref doesn't exist, create it
+            if (action === 'upsert') {
+                mutedWordsPref = {
+                    items: mutedWords.map(sanitizeMutedWord),
+                };
+            }
+        }
+        return prefs
+            .filter((p) => !client_1.AppBskyActorDefs.isMutedWordsPref(p))
+            .concat([
+            { ...mutedWordsPref, $type: 'app.bsky.actor.defs#mutedWordsPref' },
+        ]);
+    });
+}
+async function updateHiddenPost(agent, postUri, action) {
+    await updatePreferences(agent, (prefs) => {
+        let pref = prefs.findLast((pref) => client_1.AppBskyActorDefs.isHiddenPostsPref(pref) &&
+            client_1.AppBskyActorDefs.validateHiddenPostsPref(pref).success);
+        if (pref && client_1.AppBskyActorDefs.isHiddenPostsPref(pref)) {
+            pref.items =
+                action === 'hide'
+                    ? Array.from(new Set([...pref.items, postUri]))
+                    : pref.items.filter((uri) => uri !== postUri);
+        }
+        else {
+            if (action === 'hide') {
+                pref = {
+                    $type: 'app.bsky.actor.defs#hiddenPostsPref',
+                    items: [postUri],
+                };
+            }
+        }
+        return prefs
+            .filter((p) => !client_1.AppBskyActorDefs.isInterestsPref(p))
+            .concat([{ ...pref, $type: 'app.bsky.actor.defs#hiddenPostsPref' }]);
+    });
+}
+//# sourceMappingURL=bsky-agent.js.map