cloudseeding / utils / declaration.ts

import { bsky } from "../utils/bsky.ts";
import type { AutonomyDeclarationRecord } from "./types.ts";
import { Lexicons } from "@atproto/lexicon";

export const AUTONOMY_DECLARATION_LEXICON = {
  "lexicon": 1,
  "id": "studio.voyager.account.autonomy",
  "defs": {
    "main": {
      "type": "record",
      "key": "literal:self",
      "record": {
        "type": "object",
        "properties": {
          "automationLevel": {
            "type": "string",
            "knownValues": [
              "human",
              "assisted",
              "collaborative",
              "automated",
            ],
            "description":
              "Level of automation in account management and content creation",
          },
          "usesGenerativeAI": {
            "type": "boolean",
            "description":
              "Whether this account uses generative AI (LLMs, image generation, etc.) to create content",
          },
          "description": {
            "type": "string",
            "maxGraphemes": 300,
            "description":
              "Plain language explanation of how this account is automated and what it does",
          },
          "responsibleParty": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "knownValues": [
                  "person",
                  "organization",
                ],
                "description":
                  "Whether the responsible party is a person or organization",
              },
              "name": {
                "type": "string",
                "maxGraphemes": 100,
                "description": "Name of the person or organization responsible",
              },
              "contact": {
                "type": "string",
                "maxLength": 300,
                "description":
                  "Contact information (email, URL, handle, or DID)",
              },
              "did": {
                "type": "string",
                "format": "did",
                "description":
                  "DID of the responsible party if they have an ATProto identity",
              },
            },
            "description":
              "Information about who is accountable for this account's automated behavior",
          },
          "disclosureUrl": {
            "type": "string",
            "format": "uri",
            "description":
              "URL with additional information about this account's automation",
          },
          "createdAt": {
            "type": "string",
            "format": "datetime",
            "description": "Timestamp when this declaration was created",
          },
        },
        "required": [
          "createdAt",
        ],
      },
      "description":
        "Declaration of automation and AI usage for transparency and accountability",
    },
  },
};

export const createAutonomyDeclarationRecord = async () => {
  const automationLevel = Deno.env.get("AUTOMATION_LEVEL")?.toLowerCase();
  const projectDescription = Deno.env.get("PROJECT_DESCRIPTION");
  const disclosureUrl = Deno.env.get("DISCLOSURE_URL");

  const responsiblePartyType = Deno.env.get("RESPONSIBLE_PARTY_TYPE")
    ?.toLowerCase();
  const responsiblePartyName = Deno.env.get("RESPONSIBLE_PARTY_NAME");
  const responsiblePartyContact = Deno.env.get("RESPONSIBLE_PARTY_CONTACT");
  const responsiblePartyBsky = Deno.env.get("RESPONSIBLE_PARTY_BSKY");

  const declarationRecord: AutonomyDeclarationRecord = {
    $type: "studio.voyager.account.autonomy",
    usesGenerativeAI: true, // Always true for this project
    automationLevel: (automationLevel === "assisted" ||
        automationLevel === "collaborative" ||
        automationLevel === "automated")
      ? automationLevel
      : "automated", // Default to automated if not specified or invalid
    createdAt: new Date().toISOString(),
  };

  // Add description if provided
  if (projectDescription?.trim()) {
    declarationRecord.description = projectDescription.trim();
  }

  // Add disclosure URL if provided
  if (disclosureUrl?.trim()) {
    declarationRecord.disclosureUrl = disclosureUrl.trim();
  }

  // Build responsible party object if any fields are provided
  if (
    responsiblePartyType ||
    responsiblePartyName ||
    responsiblePartyContact ||
    responsiblePartyBsky
  ) {
    declarationRecord.responsibleParty = {};

    // Add type if provided and valid
    if (
      responsiblePartyType === "person" ||
      responsiblePartyType === "organization"
    ) {
      declarationRecord.responsibleParty.type = responsiblePartyType;
    }

    // Add name if provided
    if (responsiblePartyName?.trim()) {
      declarationRecord.responsibleParty.name = responsiblePartyName.trim();
    }

    // Add contact if provided
    if (responsiblePartyContact?.trim()) {
      declarationRecord.responsibleParty.contact = responsiblePartyContact
        .trim();
    }

    // Handle DID or Handle from RESPONSIBLE_PARTY_BSKY
    if (responsiblePartyBsky?.trim()) {
      const bskyIdentifier = responsiblePartyBsky.trim();

      // Check if it's a DID (starts with "did:")
      if (bskyIdentifier.startsWith("did:")) {
        declarationRecord.responsibleParty.did = bskyIdentifier;
      } else {
        // Assume it's a handle and resolve to DID
        try {
          const authorData = await bsky.getProfile({ actor: bskyIdentifier });
          declarationRecord.responsibleParty.did = authorData.data.did;
        } catch (error) {
          console.warn(
            `Failed to resolve DID for identifier ${bskyIdentifier}:`,
            error,
          );
          // Continue without DID rather than failing
        }
      }
    }
  }

  return declarationRecord;
};

export const submitAutonomyDeclarationRecord = async () => {
  const lex = new Lexicons();

  try {
    lex.add(AUTONOMY_DECLARATION_LEXICON as any);
    const record = await createAutonomyDeclarationRecord();

    lex.assertValidRecord(
      "studio.voyager.account.autonomy",
      record,
    );

    const repo = bsky.session?.did;
    if (!repo) {
      throw new Error("Not logged in - no DID available");
    }

    // Check if record already exists
    let exists = false;
    try {
      await bsky.com.atproto.repo.getRecord({
        repo,
        collection: "studio.voyager.account.autonomy",
        rkey: "self",
      });
      exists = true;
      console.log("Existing autonomy declaration found - updating...");
    } catch (error: any) {
      // Handle "record not found" errors (status 400 with error: "RecordNotFound")
      const isNotFound =
        error?.status === 400 && error?.error === "RecordNotFound" ||
        error?.status === 404 ||
        error?.message?.includes("not found") ||
        error?.message?.includes("Could not locate record");

      if (isNotFound) {
        console.log("No existing autonomy declaration found - creating new...");
      } else {
        // Re-throw if it's not a "not found" error
        throw error;
      }
    }

    // Create or update the record
    const result = await bsky.com.atproto.repo.putRecord({
      repo,
      collection: "studio.voyager.account.autonomy",
      rkey: "self",
      record,
    });

    console.log(
      `Autonomy declaration ${exists ? "updated" : "created"} successfully:`,
      result,
    );
    return result;
  } catch (error) {
    console.error("Error submitting autonomy declaration record:", error);
    throw error;
  }
};