Post to Bluesky

script

const content = draft.content
let bCredential;

function configureUser() {
    bCredential = Credential.createWithUsernamePassword("BlueskyAppPassword", "Bluesky credentials, add your username (e.g. flohgro.bsky.social) and your app password that you created before.")
	let result = bCredential.authorize()
	if(!result){
		console.log("setting/retrieving credential failed.")
		app.displayErrorMessage("setting/retrieving credential failed.")
	}
    return result
}

function authenticateAndPost() {

	let username = bCredential.getValue("username")

	let appPassword = bCredential.getValue("password")

    // Base URL for the Bluesky API
    const baseUrl = "https://bsky.social/xrpc/";

    // HTTP object for making requests
    const http = HTTP.create();

    // Step 1: Get the Bearer token (Session Token)
    const authRequest = {
        url: `${baseUrl}com.atproto.server.createSession`,
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        data: {
            identifier: username,
            password: appPassword,
        },
    };

    const authResponse = http.request(authRequest);



    if (authResponse.statusCode === 200) {
        const session = JSON.parse(authResponse.responseText);
        const bearerToken = session.accessJwt;
		const facets = createFacets(content);
		
        // Step 2: Create a post using the Bearer token
        const postContent = {
            repo: username,
            collection: "app.bsky.feed.post",
            record: {
                text: content,
                facets: facets,
                createdAt: new Date().toISOString(), // Current timestamp
            },
        };

        const postRequest = {
            url: `${baseUrl}com.atproto.repo.createRecord`,
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: `Bearer ${bearerToken}`,
            },
            data: postContent,
        };

        const postResponse = http.request(postRequest);

        if (postResponse.statusCode === 200) {
             const data = postResponse.responseText;

            console.log("Post created successfully:\n" + data);
            return true
        } else {
            app.displayErrorMessage("posting failed");
            const message = "Error: " + postResponse.statusCode + "\n\n" + postResponse.responseText;
            context.fail(message);
            return false
        }
    } else {
        app.displayErrorMessage("authentication failed")
        const message = "Error: " + authResponse.statusCode + "\n\n" + authResponse.responseText;
        context.fail(message);
        return false
    }
}


// actually run something - configure user and, exectue authenticate and post
if (configureUser()) {
        if(!authenticateAndPost()){
	        context.fail()
        }
} else {
	context.fail()
}

function extractLinks(text) {
//    const urlRegex = /https?:\/\/[^\s]+/g;
	const urlRegex = /((?:[a-z][\w-]+:(?:\/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»""'']))/g
    const matches = [];
    let match;
    while ((match = urlRegex.exec(text)) !== null) {
        const byteStart = computeByteOffset(text, match.index);
        const byteEnd = computeByteOffset(text, match.index + match[0].length);

        matches.push({
            byteStart,
            byteEnd,
            url: match[0],
        });
    }
    return matches;
}

function extractHashtags(text) {
    const hashtagRegex = /#[\w]+/g; // Matches hashtags like #example
    const matches = [];
    let match;
    while ((match = hashtagRegex.exec(text)) !== null) {
		const byteStart = computeByteOffset(text, match.index);
        const byteEnd = computeByteOffset(text, match.index + match[0].length);


        matches.push({
            //index: match.index,
            byteStart,
            byteEnd,
            hashtag: match[0],
            uri: `https://bsky.app/search?q=%23${encodeURIComponent(match[0].substring(1))}`,
        });
    }
    return matches;
}


function computeByteOffset(text, charIndex) {
    let byteLength = 0;

    for (let i = 0; i < charIndex; i++) {
        const codePoint = text.codePointAt(i); // Get the Unicode code point
        if (codePoint <= 0x007F) {
            // 1-byte sequence (ASCII)
            byteLength += 1;
        } else if (codePoint <= 0x07FF) {
            // 2-byte sequence
            byteLength += 2;
        } else if (codePoint <= 0xFFFF) {
            // 3-byte sequence
            byteLength += 3;
        } else {
            // 4-byte sequence (e.g., emojis, astral symbols)
            byteLength += 4;
            i++; // Skip the next index, as it’s part of the same surrogate pair
        }
    }

    return byteLength;
}


function createFacets(text) {
    const links = extractLinks(text).map(link => ({
        index: {
            byteStart: link.byteStart,
            byteEnd: link.byteEnd,
        },
        features: [
            {
                $type: "app.bsky.richtext.facet#link",
                uri: link.url,
            },
        ],
    }));

    const hashtags = extractHashtags(text).map(tag => ({
        index: {
            byteStart: tag.byteStart,
            byteEnd: tag.byteEnd,
        },
        features: [
            {
                $type: "app.bsky.richtext.facet#tag",
                tag: tag.hashtag.replace(/^#/, ''),
            },
        ],
    }));

    return [...links, ...hashtags];
}