@chronicle.app/bluesky 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# @chronicle.app/bluesky
+
+Read your Bluesky follows, followers, and likes through the atproto API.
+
+```sh
+chronicle extract bluesky --type follows --handle you.bsky.social --password <app-password>
+chronicle extract bluesky --type followers,likes --handle you.bsky.social --access-token <token>
+```
+
+The extractor resolves the handle to a DID, looks up the account's PDS in the PLC directory, and logs in with the password unless `--access-token` is given. `--handle` and `--password` fall back to the `handle`/`clientId` and `password`/`clientSecret` fields of the stored `bluesky` credentials. Use an app password rather than your account password.
+
+Each kind is one record type:
+
+- `follows` (the default): accounts you follow. Each becomes a `FollowAction` from you to the account.
+- `followers`: accounts that follow you. Each becomes a `FollowAction` from the account to you.
+- `likes`: posts you liked. Each becomes a `LikeAction` on the `Post`, plus a `PublishAction` by the post's author at the time the post was written.
+
+Every action is keyed by its atproto record (`did:…/collection/rkey`) and timestamped with the record's `createdAt`, fetched from the repository for each item. Accounts are `Agent`s keyed by their DID, and your own account carries `sameAs: ['@me']`. A post's images become `ImageObject`s in `contains`, keyed by URL, with the image size and alt text when present.
+
+Tests run the extractors against a fake Bluesky server on 127.0.0.1, with explicit handle and password or token and an empty credential directory. They never reach the network or read the host's stored credentials.

package/dist/connectors/BlueskyExtractor.d.ts

@@ -0,0 +1,43 @@
+import { Extractor, Record } from '@chronicle.app/etl';
+import { z } from 'zod';
+import BlueskyProxy from '../utils/BlueskyProxy.js';
+import BlueskyTransformer from './BlueskyTransformer.js';
+export default abstract class BlueskyExtractor extends Extractor<typeof BlueskyExtractor> {
+    protected proxy: BlueskyProxy;
+    protected records: Record[];
+    static defaultTransformer: typeof BlueskyTransformer;
+    static source: string;
+    static delivery: "api";
+    static strategy: string;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        accessToken: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        handle: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        handle?: string | undefined;
+        accessToken?: string | undefined;
+        password?: string | undefined;
+        limit?: number | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+    }, {
+        handle?: string | undefined;
+        accessToken?: string | undefined;
+        password?: string | undefined;
+        limit?: number | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+    }>;
+    private agentProfile;
+    setup(): Promise<void>;
+    protected abstract extractRecords(): Promise<Record[]>;
+    protected defaultContext(): {
+        agent: any;
+    };
+    extract(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=BlueskyExtractor.d.ts.map

package/dist/connectors/BlueskyExtractor.js

@@ -0,0 +1,46 @@
+import { Extractor } from '@chronicle.app/etl';
+import { z } from 'zod';
+import BlueskyProxy from '../utils/BlueskyProxy.js';
+import BlueskyTransformer from './BlueskyTransformer.js';
+export default class BlueskyExtractor extends Extractor {
+    proxy;
+    records;
+    static defaultTransformer = BlueskyTransformer;
+    static source = 'bluesky';
+    static delivery = 'api';
+    static strategy = 'api';
+    static schema = Extractor.schema.extend({
+        accessToken: z.string().describe('Access token for account').optional(),
+        password: z
+            .string()
+            .describe('Password for account (auto-retrieved from stored credentials if not provided)')
+            .optional(),
+        handle: z
+            .string()
+            .describe('Bluesky handle (auto-retrieved from stored credentials if not provided)')
+            .optional(),
+    });
+    agentProfile;
+    async setup() {
+        const proxy = new BlueskyProxy({
+            accessToken: this.config.accessToken,
+            handle: this.config.handle,
+            password: this.config.password,
+        });
+        await proxy.initialize();
+        // Use the resolved handle from proxy after initialization
+        this.agentProfile = await proxy.getProfile(proxy.userDid || this.config.handle || '');
+        this.proxy = proxy;
+    }
+    defaultContext() {
+        return {
+            agent: this.agentProfile,
+        };
+    }
+    async *extract() {
+        const records = await this.extractRecords();
+        for await (const record of records) {
+            yield record;
+        }
+    }
+}

package/dist/connectors/BlueskyFollowerExtractor.d.ts

@@ -0,0 +1,10 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+import { Record } from '@chronicle.app/etl';
+export default class BlueskyFollowerExtractor extends BlueskyExtractor {
+    static description: string;
+    static recordTypes: string[];
+    /** The follower's follow record AT-URI — atproto's own address for it, stable in their repo. */
+    keyOf(record: Record): string | null;
+    extractRecords(): Promise<Record[]>;
+}
+//# sourceMappingURL=BlueskyFollowerExtractor.d.ts.map

package/dist/connectors/BlueskyFollowerExtractor.js

@@ -0,0 +1,16 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+export default class BlueskyFollowerExtractor extends BlueskyExtractor {
+    static description = 'Accounts following you';
+    static recordTypes = ['followers'];
+    /** The follower's follow record AT-URI — atproto's own address for it, stable in their repo. */
+    keyOf(record) {
+        return record.data.viewer?.followedBy ?? null;
+    }
+    async extractRecords() {
+        const followers = await this.proxy.getAllWithRecords('getFollowers', this.config, (follower) => follower.viewer.followedBy);
+        return followers.map((follower) => this.createRecord(follower.result, {
+            ...this.defaultContext(),
+            atprotoRecord: follower.record,
+        }));
+    }
+}

package/dist/connectors/BlueskyFollowsExtractor.d.ts

@@ -0,0 +1,11 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+import { Record } from '@chronicle.app/etl';
+export default class BlueskyFollowsExtractor extends BlueskyExtractor {
+    static description: string;
+    static recordTypes: string[];
+    static default: boolean;
+    /** The follow record's AT-URI — atproto's own address for it, identical through any tool. */
+    keyOf(record: Record): string | null;
+    extractRecords(): Promise<Record[]>;
+}
+//# sourceMappingURL=BlueskyFollowsExtractor.d.ts.map

package/dist/connectors/BlueskyFollowsExtractor.js

@@ -0,0 +1,14 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+export default class BlueskyFollowsExtractor extends BlueskyExtractor {
+    static description = 'Accounts you follow';
+    static recordTypes = ['follows'];
+    static default = true;
+    /** The follow record's AT-URI — atproto's own address for it, identical through any tool. */
+    keyOf(record) {
+        return record.data.viewer?.following ?? null;
+    }
+    async extractRecords() {
+        const follows = await this.proxy.getAllWithRecords('getFollows', this.config, (follow) => follow.viewer.following);
+        return follows.map((follow) => this.createRecord(follow.result, { ...this.defaultContext(), atprotoRecord: follow.record }));
+    }
+}

package/dist/connectors/BlueskyLikesExtractor.d.ts

@@ -0,0 +1,10 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+import { Record } from '@chronicle.app/etl';
+export default class BlueskyLikesExtractor extends BlueskyExtractor {
+    static description: string;
+    static recordTypes: string[];
+    /** The like record's AT-URI — atproto's own address for it, identical through any tool. */
+    keyOf(record: Record): string | null;
+    extractRecords(): Promise<Record[]>;
+}
+//# sourceMappingURL=BlueskyLikesExtractor.d.ts.map

package/dist/connectors/BlueskyLikesExtractor.js

@@ -0,0 +1,13 @@
+import BlueskyExtractor from './BlueskyExtractor.js';
+export default class BlueskyLikesExtractor extends BlueskyExtractor {
+    static description = 'Posts you liked';
+    static recordTypes = ['likes'];
+    /** The like record's AT-URI — atproto's own address for it, identical through any tool. */
+    keyOf(record) {
+        return record.data.post?.viewer?.like ?? null;
+    }
+    async extractRecords() {
+        const likes = await this.proxy.getAllWithRecords('getLikes', this.config, (like) => like.post.viewer.like);
+        return likes.map((like) => this.createRecord(like.result, { ...this.defaultContext(), atprotoRecord: like.record }));
+    }
+}

package/dist/connectors/BlueskyTransformer.d.ts

@@ -0,0 +1,14 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class BlueskyTransformer extends ChronicleTransformer {
+    /** DID of the authenticated account (the "me"), set per record from context. */
+    private meDid?;
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildFollow;
+    private buildLike;
+    private buildPublish;
+    private buildPost;
+    private buildUser;
+    private uriToId;
+}
+//# sourceMappingURL=BlueskyTransformer.d.ts.map

package/dist/connectors/BlueskyTransformer.js

@@ -0,0 +1,128 @@
+import { ChronicleTransformer, createImageObject } from '@chronicle.app/etl';
+export default class BlueskyTransformer extends ChronicleTransformer {
+    /** DID of the authenticated account (the "me"), set per record from context. */
+    meDid;
+    async transform(record) {
+        const type = record.extraction.recordType;
+        // record.context.agent is the authenticated account; remember its DID so the
+        // shared buildUser tags only the owner, not followed users/authors.
+        // Safe as a per-record field: transform builds synchronously below, with no
+        // await between this assignment and the buildUser calls.
+        this.meDid = record.context.agent?.did;
+        this.logger.debug('Transforming Bluesky record', { recordType: type });
+        const actions = [];
+        switch (type) {
+            case 'likes': {
+                actions.push(this.buildLike({
+                    post: record.data.post,
+                    agent: record.context.agent,
+                    timestamp: record.context.atprotoRecord.value.createdAt,
+                }), this.buildPublish({
+                    post: record.data.post,
+                }));
+                break;
+            }
+            case 'follows': {
+                actions.push(this.buildFollow({
+                    account: record.data,
+                    agent: record.context.agent,
+                    timestamp: record.context.atprotoRecord.value.createdAt,
+                    recordUri: record.data.viewer.following,
+                }));
+                break;
+            }
+            case 'followers': {
+                actions.push(this.buildFollow({
+                    account: record.context.agent,
+                    agent: record.data,
+                    timestamp: record.context.atprotoRecord.value.createdAt,
+                    recordUri: record.data.viewer.followedBy,
+                }));
+                break;
+            }
+            default: {
+                return [];
+            }
+        }
+        this.logger.verboseInfo(`Generated ${actions.length} actions from Bluesky ${type} record`);
+        return actions;
+    }
+    buildFollow({ account, agent, timestamp, recordUri, }) {
+        return {
+            '@type': 'FollowAction',
+            source: 'bluesky',
+            sourceId: this.uriToId(recordUri),
+            timestamp: new Date(timestamp),
+            '@key': ['@type', 'source', 'sourceId'],
+            agent: this.buildUser(agent),
+            object: this.buildUser(account),
+        };
+    }
+    buildLike({ post, agent, timestamp, }) {
+        return {
+            '@type': 'LikeAction',
+            source: 'bluesky',
+            sourceId: this.uriToId(post.viewer.like),
+            timestamp: new Date(timestamp),
+            '@key': ['@type', 'source', 'sourceId'],
+            agent: this.buildUser(agent),
+            object: this.buildPost(post),
+        };
+    }
+    buildPublish({ post }) {
+        return {
+            '@type': 'PublishAction',
+            source: 'bluesky',
+            sourceId: this.uriToId(post.uri),
+            timestamp: new Date(post.record.createdAt),
+            '@key': ['@type', 'source', 'sourceId'],
+            agent: this.buildUser(post.author),
+            object: this.buildPost(post),
+        };
+    }
+    buildPost(post) {
+        const posting = {
+            '@type': 'Post',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: 'bluesky',
+            sourceId: this.uriToId(post.uri),
+            body: post.record.text,
+            author: [this.buildUser(post.author)],
+        };
+        // Extract images from embed data - based on app.bsky.embed.images#view structure
+        // Put all images in the contains property instead of the image field
+        if (post.embed?.$type === 'app.bsky.embed.images#view' && post.embed.images?.length > 0) {
+            posting.contains = post.embed.images.map((img) => {
+                const imageOptions = {
+                    url: img.fullsize,
+                    width: img.aspectRatio?.width,
+                    height: img.aspectRatio?.height,
+                };
+                // Only include description if it's not empty
+                if (img.alt && img.alt.trim() !== '') {
+                    imageOptions.description = img.alt;
+                }
+                return createImageObject(imageOptions);
+            });
+        }
+        return posting;
+    }
+    buildUser(agentProfile) {
+        const agent = {
+            '@type': 'Agent',
+            source: 'bluesky',
+            sourceId: agentProfile.did,
+            '@key': ['@type', 'source', 'sourceId'],
+            name: agentProfile.displayName,
+            description: agentProfile.description,
+        };
+        // Tag the owner by identity (DID): this builder also constructs followed
+        // accounts and post authors, so match only the authenticated account.
+        if (this.meDid && agentProfile.did === this.meDid)
+            agent.sameAs = [...(agent.sameAs ?? []), '@me'];
+        return agent;
+    }
+    uriToId(uri) {
+        return uri.split('://').pop();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { default as BlueskyExtractor } from './connectors/BlueskyExtractor.js';
+export { default as BlueskyFollowerExtractor } from './connectors/BlueskyFollowerExtractor.js';
+export { default as BlueskyFollowsExtractor } from './connectors/BlueskyFollowsExtractor.js';
+export { default as BlueskyLikesExtractor } from './connectors/BlueskyLikesExtractor.js';
+export { default as BlueskyTransformer } from './connectors/BlueskyTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export { default as BlueskyExtractor } from './connectors/BlueskyExtractor.js';
+export { default as BlueskyFollowerExtractor } from './connectors/BlueskyFollowerExtractor.js';
+export { default as BlueskyFollowsExtractor } from './connectors/BlueskyFollowsExtractor.js';
+export { default as BlueskyLikesExtractor } from './connectors/BlueskyLikesExtractor.js';
+export { default as BlueskyTransformer } from './connectors/BlueskyTransformer.js';

package/dist/utils/BlueskyProxy.d.ts

@@ -0,0 +1,34 @@
+import { ApiProxy } from '@chronicle.app/etl';
+export default class BlueskyProxy extends ApiProxy {
+    private handle;
+    userDid?: string;
+    private pdsDomain?;
+    private password?;
+    constructor({ handle, accessToken, password }?: {
+        accessToken?: string;
+        handle?: string;
+        password?: string;
+    });
+    initialize(): Promise<void>;
+    handleToDid(handle: string): Promise<string>;
+    static didToPdsDomain(did: string): Promise<string>;
+    authenticate(handle: string, password: string): Promise<any>;
+    getFollowers({ limit }: {
+        limit?: number;
+    }): Promise<any[]>;
+    getFollows({ limit }: {
+        limit?: number;
+    }): Promise<any[]>;
+    getRecord(repo: string, collection: string, rkey: string): Promise<any>;
+    getAllWithRecords(fn: string, parameters: any, recordKeyFn: Function): Promise<any>;
+    getLikes({ limit }: {
+        limit?: number;
+    }): Promise<any[]>;
+    getAuthorFeed({ limit }: {
+        limit?: number;
+    }): Promise<any[]>;
+    getProfile(handle: string): Promise<any>;
+    private getAllPages;
+    private makeRPCRequest;
+}
+//# sourceMappingURL=BlueskyProxy.d.ts.map

package/dist/utils/BlueskyProxy.js

@@ -0,0 +1,191 @@
+import { ApiProxy } from '@chronicle.app/etl';
+import { resolveCredentials } from '@chronicle.app/auth';
+export default class BlueskyProxy extends ApiProxy {
+    handle;
+    userDid;
+    pdsDomain;
+    password;
+    constructor({ handle, accessToken, password } = {}) {
+        // No baseURL: every RPC names its PDS domain absolutely.
+        super();
+        this.handle = handle || '';
+        this.setAccessToken(accessToken);
+        this.password = password;
+    }
+    async initialize() {
+        // Load credentials if not provided
+        const { handle, password } = await resolveCredentials('bluesky', {
+            handle: { from: ['handle', 'clientId'], optional: true },
+            password: { from: ['password', 'clientSecret'], optional: true },
+        }, {
+            overrides: { handle: this.handle || undefined, password: this.password },
+        });
+        this.handle = handle || '';
+        this.password = password;
+        if (!this.handle) {
+            throw new Error('Bluesky handle is required.');
+        }
+        try {
+            this.userDid = await this.handleToDid(this.handle);
+            this.pdsDomain = await BlueskyProxy.didToPdsDomain(this.userDid);
+        }
+        catch {
+            throw new Error('Could not resolve handle to DID');
+        }
+        if (!this.accessToken) {
+            if (this.password) {
+                await this.authenticate(this.handle, this.password);
+            }
+            else {
+                throw new Error('Password is required.');
+            }
+        }
+    }
+    async handleToDid(handle) {
+        const response = await this.makeRPCRequest({
+            domain: 'https://bsky.social',
+            endpoint: 'com.atproto.identity.resolveHandle',
+            method: 'GET',
+            queryParams: {
+                handle,
+            },
+        });
+        const { did } = response;
+        if (!did) {
+            throw new Error('Could not resolve handle to DID');
+        }
+        return did;
+    }
+    static async didToPdsDomain(did) {
+        const [, type] = did.split(':');
+        try {
+            if (type === 'plc') {
+                const response = await fetch(`https://plc.directory/${did}`);
+                const json = await response.json();
+                const { service } = json;
+                const pdsService = service.find((service) => service.type === 'AtprotoPersonalDataServer');
+                return pdsService.serviceEndpoint;
+            }
+            // ???
+            return '';
+        }
+        catch {
+            throw new Error('Could not resolve DID to PDS domain');
+        }
+    }
+    async authenticate(handle, password) {
+        const response = await this.makeRPCRequest({
+            domain: 'https://bsky.social',
+            endpoint: 'com.atproto.server.createSession',
+            method: 'POST',
+            params: {
+                identifier: handle,
+                password,
+            },
+        });
+        this.setAccessToken(response.accessJwt);
+        return response;
+    }
+    async getFollowers({ limit }) {
+        const followers = await this.getAllPages({
+            endpoint: 'app.bsky.graph.getFollowers',
+            resultKey: 'followers',
+            queryParams: {
+                actor: this.userDid,
+            },
+            limit,
+        });
+        return followers;
+    }
+    async getFollows({ limit }) {
+        const followers = await this.getAllPages({
+            endpoint: 'app.bsky.graph.getFollows',
+            resultKey: 'follows',
+            queryParams: {
+                actor: this.userDid,
+            },
+            limit,
+        });
+        return followers;
+    }
+    async getRecord(repo, collection, rkey) {
+        const response = await this.makeRPCRequest({
+            endpoint: 'com.atproto.repo.getRecord',
+            method: 'GET',
+            queryParams: {
+                repo,
+                collection,
+                rkey,
+            },
+        });
+        return response;
+    }
+    async getAllWithRecords(fn, parameters, recordKeyFn) {
+        // @ts-ignore
+        const results = await this[fn](parameters);
+        const resultsWithRecords = await Promise.all(results.map(async (result) => {
+            const id = recordKeyFn(result).split('://').pop();
+            const [repo, collection, rkey] = id.split('/');
+            const record = await this.getRecord(repo, collection, rkey);
+            return { result, record };
+        }));
+        return resultsWithRecords;
+    }
+    async getLikes({ limit }) {
+        const likes = await this.getAllPages({
+            endpoint: 'app.bsky.feed.getActorLikes',
+            resultKey: 'feed',
+            queryParams: {
+                actor: this.userDid,
+            },
+            limit,
+        });
+        return likes;
+    }
+    async getAuthorFeed({ limit }) {
+        const posts = await this.getAllPages({
+            endpoint: 'app.bsky.feed.getAuthorFeed',
+            resultKey: 'feed',
+            queryParams: {
+                actor: this.userDid,
+            },
+            limit,
+        });
+        return posts;
+    }
+    async getProfile(handle) {
+        const endpoint = 'app.bsky.actor.getProfile';
+        const response = await this.makeRPCRequest({
+            endpoint,
+            method: 'GET',
+            queryParams: {
+                actor: handle,
+            },
+        });
+        return response;
+    }
+    async getAllPages({ endpoint, resultKey, queryParams, limit } = {}) {
+        return this.paginateCursor({
+            limit,
+            fetchPage: async (cursor) => {
+                const response = await this.makeRPCRequest({
+                    endpoint,
+                    method: 'GET',
+                    queryParams: {
+                        ...queryParams,
+                        ...(cursor ? { cursor } : {}),
+                    },
+                });
+                return { items: response[resultKey], cursor: response.cursor };
+            },
+        });
+    }
+    async makeRPCRequest({ domain = this.pdsDomain, endpoint, method, params, queryParams, }) {
+        return this.request({
+            url: `${domain}/xrpc/${endpoint}`,
+            method,
+            data: params,
+            params: queryParams,
+        });
+    }
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@chronicle.app/bluesky",
+  "version": "0.3.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [
+    "chronicle"
+  ],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle plugin for Bluesky follows, followers, and likes",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.3.0",
+    "@chronicle.app/schema": "0.3.0",
+    "@chronicle.app/tsconfig": "0.3.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/bluesky"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@chronicle.app/auth": "0.3.0",
+    "axios": "^1.7.9",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "bluesky": {
+        "strategies": {
+          "api": {
+            "delivery": "api",
+            "recordTypes": [
+              "followers",
+              "follows",
+              "likes"
+            ],
+            "default": true
+          }
+        }
+      }
+    }
+  }
+}