loudmouth-ai 0.1.0 → 0.2.0

package/extensions/tlon/src/channel.ts

@@ -1,379 +0,0 @@
-import type {
-  ChannelOutboundAdapter,
-  ChannelPlugin,
-  ChannelSetupInput,
-  ClawdbotConfig,
-} from "clawdbot/plugin-sdk";
-import {
-  applyAccountNameToChannelSection,
-  DEFAULT_ACCOUNT_ID,
-  normalizeAccountId,
-} from "clawdbot/plugin-sdk";
-
-import { resolveTlonAccount, listTlonAccountIds } from "./types.js";
-import { formatTargetHint, normalizeShip, parseTlonTarget } from "./targets.js";
-import { ensureUrbitConnectPatched, Urbit } from "./urbit/http-api.js";
-import { buildMediaText, sendDm, sendGroupMessage } from "./urbit/send.js";
-import { monitorTlonProvider } from "./monitor/index.js";
-import { tlonChannelConfigSchema } from "./config-schema.js";
-import { tlonOnboardingAdapter } from "./onboarding.js";
-
-const TLON_CHANNEL_ID = "tlon" as const;
-
-type TlonSetupInput = ChannelSetupInput & {
-  ship?: string;
-  url?: string;
-  code?: string;
-  groupChannels?: string[];
-  dmAllowlist?: string[];
-  autoDiscoverChannels?: boolean;
-};
-
-function applyTlonSetupConfig(params: {
-  cfg: ClawdbotConfig;
-  accountId: string;
-  input: TlonSetupInput;
-}): ClawdbotConfig {
-  const { cfg, accountId, input } = params;
-  const useDefault = accountId === DEFAULT_ACCOUNT_ID;
-  const namedConfig = applyAccountNameToChannelSection({
-    cfg,
-    channelKey: "tlon",
-    accountId,
-    name: input.name,
-  });
-  const base = namedConfig.channels?.tlon ?? {};
-
-  const payload = {
-    ...(input.ship ? { ship: input.ship } : {}),
-    ...(input.url ? { url: input.url } : {}),
-    ...(input.code ? { code: input.code } : {}),
-    ...(input.groupChannels ? { groupChannels: input.groupChannels } : {}),
-    ...(input.dmAllowlist ? { dmAllowlist: input.dmAllowlist } : {}),
-    ...(typeof input.autoDiscoverChannels === "boolean"
-      ? { autoDiscoverChannels: input.autoDiscoverChannels }
-      : {}),
-  };
-
-  if (useDefault) {
-    return {
-      ...namedConfig,
-      channels: {
-        ...namedConfig.channels,
-        tlon: {
-          ...base,
-          enabled: true,
-          ...payload,
-        },
-      },
-    };
-  }
-
-  return {
-    ...namedConfig,
-    channels: {
-      ...namedConfig.channels,
-      tlon: {
-        ...base,
-        enabled: base.enabled ?? true,
-        accounts: {
-          ...(base as { accounts?: Record<string, unknown> }).accounts,
-          [accountId]: {
-            ...((base as { accounts?: Record<string, Record<string, unknown>> }).accounts?.[
-              accountId
-            ] ?? {}),
-            enabled: true,
-            ...payload,
-          },
-        },
-      },
-    },
-  };
-}
-
-const tlonOutbound: ChannelOutboundAdapter = {
-  deliveryMode: "direct",
-  textChunkLimit: 10000,
-  resolveTarget: ({ to }) => {
-    const parsed = parseTlonTarget(to ?? "");
-    if (!parsed) {
-      return {
-        ok: false,
-        error: new Error(`Invalid Tlon target. Use ${formatTargetHint()}`),
-      };
-    }
-    if (parsed.kind === "dm") {
-      return { ok: true, to: parsed.ship };
-    }
-    return { ok: true, to: parsed.nest };
-  },
-  sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => {
-    const account = resolveTlonAccount(cfg as ClawdbotConfig, accountId ?? undefined);
-    if (!account.configured || !account.ship || !account.url || !account.code) {
-      throw new Error("Tlon account not configured");
-    }
-
-    const parsed = parseTlonTarget(to);
-    if (!parsed) {
-      throw new Error(`Invalid Tlon target. Use ${formatTargetHint()}`);
-    }
-
-    ensureUrbitConnectPatched();
-    const api = await Urbit.authenticate({
-      ship: account.ship.replace(/^~/, ""),
-      url: account.url,
-      code: account.code,
-      verbose: false,
-    });
-
-    try {
-      const fromShip = normalizeShip(account.ship);
-      if (parsed.kind === "dm") {
-        return await sendDm({
-          api,
-          fromShip,
-          toShip: parsed.ship,
-          text,
-        });
-      }
-      const replyId = (replyToId ?? threadId) ? String(replyToId ?? threadId) : undefined;
-      return await sendGroupMessage({
-        api,
-        fromShip,
-        hostShip: parsed.hostShip,
-        channelName: parsed.channelName,
-        text,
-        replyToId: replyId,
-      });
-    } finally {
-      try {
-        await api.delete();
-      } catch {
-        // ignore cleanup errors
-      }
-    }
-  },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId, replyToId, threadId }) => {
-    const mergedText = buildMediaText(text, mediaUrl);
-    return await tlonOutbound.sendText({
-      cfg,
-      to,
-      text: mergedText,
-      accountId,
-      replyToId,
-      threadId,
-    });
-  },
-};
-
-export const tlonPlugin: ChannelPlugin = {
-  id: TLON_CHANNEL_ID,
-  meta: {
-    id: TLON_CHANNEL_ID,
-    label: "Tlon",
-    selectionLabel: "Tlon (Urbit)",
-    docsPath: "/channels/tlon",
-    docsLabel: "tlon",
-    blurb: "Decentralized messaging on Urbit",
-    aliases: ["urbit"],
-    order: 90,
-  },
-  capabilities: {
-    chatTypes: ["direct", "group", "thread"],
-    media: false,
-    reply: true,
-    threads: true,
-  },
-  onboarding: tlonOnboardingAdapter,
-  reload: { configPrefixes: ["channels.tlon"] },
-  configSchema: tlonChannelConfigSchema,
-  config: {
-    listAccountIds: (cfg) => listTlonAccountIds(cfg as ClawdbotConfig),
-    resolveAccount: (cfg, accountId) => resolveTlonAccount(cfg as ClawdbotConfig, accountId ?? undefined),
-    defaultAccountId: () => "default",
-    setAccountEnabled: ({ cfg, accountId, enabled }) => {
-      const useDefault = !accountId || accountId === "default";
-      if (useDefault) {
-        return {
-          ...cfg,
-          channels: {
-            ...cfg.channels,
-            tlon: {
-              ...(cfg.channels?.tlon ?? {}),
-              enabled,
-            },
-          },
-        } as ClawdbotConfig;
-      }
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          tlon: {
-            ...(cfg.channels?.tlon ?? {}),
-            accounts: {
-              ...(cfg.channels?.tlon?.accounts ?? {}),
-              [accountId]: {
-                ...(cfg.channels?.tlon?.accounts?.[accountId] ?? {}),
-                enabled,
-              },
-            },
-          },
-        },
-      } as ClawdbotConfig;
-    },
-    deleteAccount: ({ cfg, accountId }) => {
-      const useDefault = !accountId || accountId === "default";
-      if (useDefault) {
-        const { ship, code, url, name, ...rest } = cfg.channels?.tlon ?? {};
-        return {
-          ...cfg,
-          channels: {
-            ...cfg.channels,
-            tlon: rest,
-          },
-        } as ClawdbotConfig;
-      }
-      const { [accountId]: removed, ...remainingAccounts } = cfg.channels?.tlon?.accounts ?? {};
-      return {
-        ...cfg,
-        channels: {
-          ...cfg.channels,
-          tlon: {
-            ...(cfg.channels?.tlon ?? {}),
-            accounts: remainingAccounts,
-          },
-        },
-      } as ClawdbotConfig;
-    },
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      ship: account.ship,
-      url: account.url,
-    }),
-  },
-  setup: {
-    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
-    applyAccountName: ({ cfg, accountId, name }) =>
-      applyAccountNameToChannelSection({
-        cfg: cfg as ClawdbotConfig,
-        channelKey: "tlon",
-        accountId,
-        name,
-      }),
-    validateInput: ({ cfg, accountId, input }) => {
-      const setupInput = input as TlonSetupInput;
-      const resolved = resolveTlonAccount(cfg as ClawdbotConfig, accountId ?? undefined);
-      const ship = setupInput.ship?.trim() || resolved.ship;
-      const url = setupInput.url?.trim() || resolved.url;
-      const code = setupInput.code?.trim() || resolved.code;
-      if (!ship) return "Tlon requires --ship.";
-      if (!url) return "Tlon requires --url.";
-      if (!code) return "Tlon requires --code.";
-      return null;
-    },
-    applyAccountConfig: ({ cfg, accountId, input }) =>
-      applyTlonSetupConfig({
-        cfg: cfg as ClawdbotConfig,
-        accountId,
-        input: input as TlonSetupInput,
-      }),
-  },
-  messaging: {
-    normalizeTarget: (target) => {
-      const parsed = parseTlonTarget(target);
-      if (!parsed) return target.trim();
-      if (parsed.kind === "dm") return parsed.ship;
-      return parsed.nest;
-    },
-    targetResolver: {
-      looksLikeId: (target) => Boolean(parseTlonTarget(target)),
-      hint: formatTargetHint(),
-    },
-  },
-  outbound: tlonOutbound,
-  status: {
-    defaultRuntime: {
-      accountId: "default",
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    collectStatusIssues: (accounts) => {
-      return accounts.flatMap((account) => {
-        if (!account.configured) {
-          return [
-            {
-              channel: TLON_CHANNEL_ID,
-              accountId: account.accountId,
-              kind: "config",
-              message: "Account not configured (missing ship, code, or url)",
-            },
-          ];
-        }
-        return [];
-      });
-    },
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      ship: snapshot.ship ?? null,
-      url: snapshot.url ?? null,
-    }),
-    probeAccount: async ({ account }) => {
-      if (!account.configured || !account.ship || !account.url || !account.code) {
-        return { ok: false, error: "Not configured" };
-      }
-      try {
-        ensureUrbitConnectPatched();
-        const api = await Urbit.authenticate({
-          ship: account.ship.replace(/^~/, ""),
-          url: account.url,
-          code: account.code,
-          verbose: false,
-        });
-        try {
-          await api.getOurName();
-          return { ok: true };
-        } finally {
-          await api.delete();
-        }
-      } catch (error: any) {
-        return { ok: false, error: error?.message ?? String(error) };
-      }
-    },
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      ship: account.ship,
-      url: account.url,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      probe,
-    }),
-  },
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      ctx.setStatus({
-        accountId: account.accountId,
-        ship: account.ship,
-        url: account.url,
-      });
-      ctx.log?.info(`[${account.accountId}] starting Tlon provider for ${account.ship ?? "tlon"}`);
-      return monitorTlonProvider({
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        accountId: account.accountId,
-      });
-    },
-  },
-};

package/extensions/tlon/src/config-schema.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { TlonAuthorizationSchema, TlonConfigSchema } from "./config-schema.js";
-
-describe("Tlon config schema", () => {
-  it("accepts channelRules with string keys", () => {
-    const parsed = TlonAuthorizationSchema.parse({
-      channelRules: {
-        "chat/~zod/test": {
-          mode: "open",
-          allowedShips: ["~zod"],
-        },
-      },
-    });
-
-    expect(parsed.channelRules?.["chat/~zod/test"]?.mode).toBe("open");
-  });
-
-  it("accepts accounts with string keys", () => {
-    const parsed = TlonConfigSchema.parse({
-      accounts: {
-        primary: {
-          ship: "~zod",
-          url: "https://example.com",
-          code: "code-123",
-        },
-      },
-    });
-
-    expect(parsed.accounts?.primary?.ship).toBe("~zod");
-  });
-});

package/extensions/tlon/src/config-schema.ts

@@ -1,43 +0,0 @@
-import { z } from "zod";
-import { buildChannelConfigSchema } from "clawdbot/plugin-sdk";
-
-const ShipSchema = z.string().min(1);
-const ChannelNestSchema = z.string().min(1);
-
-export const TlonChannelRuleSchema = z.object({
-  mode: z.enum(["restricted", "open"]).optional(),
-  allowedShips: z.array(ShipSchema).optional(),
-});
-
-export const TlonAuthorizationSchema = z.object({
-  channelRules: z.record(z.string(), TlonChannelRuleSchema).optional(),
-});
-
-export const TlonAccountSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  ship: ShipSchema.optional(),
-  url: z.string().optional(),
-  code: z.string().optional(),
-  groupChannels: z.array(ChannelNestSchema).optional(),
-  dmAllowlist: z.array(ShipSchema).optional(),
-  autoDiscoverChannels: z.boolean().optional(),
-  showModelSignature: z.boolean().optional(),
-});
-
-export const TlonConfigSchema = z.object({
-  name: z.string().optional(),
-  enabled: z.boolean().optional(),
-  ship: ShipSchema.optional(),
-  url: z.string().optional(),
-  code: z.string().optional(),
-  groupChannels: z.array(ChannelNestSchema).optional(),
-  dmAllowlist: z.array(ShipSchema).optional(),
-  autoDiscoverChannels: z.boolean().optional(),
-  showModelSignature: z.boolean().optional(),
-  authorization: TlonAuthorizationSchema.optional(),
-  defaultAuthorizedShips: z.array(ShipSchema).optional(),
-  accounts: z.record(z.string(), TlonAccountSchema).optional(),
-});
-
-export const tlonChannelConfigSchema = buildChannelConfigSchema(TlonConfigSchema);

package/extensions/tlon/src/monitor/discovery.ts

@@ -1,71 +0,0 @@
-import type { RuntimeEnv } from "clawdbot/plugin-sdk";
-
-import { formatChangesDate } from "./utils.js";
-
-export async function fetchGroupChanges(
-  api: { scry: (path: string) => Promise<unknown> },
-  runtime: RuntimeEnv,
-  daysAgo = 5,
-) {
-  try {
-    const changeDate = formatChangesDate(daysAgo);
-    runtime.log?.(`[tlon] Fetching group changes since ${daysAgo} days ago (${changeDate})...`);
-    const changes = await api.scry(`/groups-ui/v5/changes/${changeDate}.json`);
-    if (changes) {
-      runtime.log?.("[tlon] Successfully fetched changes data");
-      return changes;
-    }
-    return null;
-  } catch (error: any) {
-    runtime.log?.(`[tlon] Failed to fetch changes (falling back to full init): ${error?.message ?? String(error)}`);
-    return null;
-  }
-}
-
-export async function fetchAllChannels(
-  api: { scry: (path: string) => Promise<unknown> },
-  runtime: RuntimeEnv,
-): Promise<string[]> {
-  try {
-    runtime.log?.("[tlon] Attempting auto-discovery of group channels...");
-    const changes = await fetchGroupChanges(api, runtime, 5);
-
-    let initData: any;
-    if (changes) {
-      runtime.log?.("[tlon] Changes data received, using full init for channel extraction");
-      initData = await api.scry("/groups-ui/v6/init.json");
-    } else {
-      initData = await api.scry("/groups-ui/v6/init.json");
-    }
-
-    const channels: string[] = [];
-    if (initData && initData.groups) {
-      for (const groupData of Object.values(initData.groups as Record<string, any>)) {
-        if (groupData && typeof groupData === "object" && groupData.channels) {
-          for (const channelNest of Object.keys(groupData.channels)) {
-            if (channelNest.startsWith("chat/")) {
-              channels.push(channelNest);
-            }
-          }
-        }
-      }
-    }
-
-    if (channels.length > 0) {
-      runtime.log?.(`[tlon] Auto-discovered ${channels.length} chat channel(s)`);
-      runtime.log?.(
-        `[tlon] Channels: ${channels.slice(0, 5).join(", ")}${channels.length > 5 ? "..." : ""}`,
-      );
-    } else {
-      runtime.log?.("[tlon] No chat channels found via auto-discovery");
-      runtime.log?.("[tlon] Add channels manually to config: channels.tlon.groupChannels");
-    }
-
-    return channels;
-  } catch (error: any) {
-    runtime.log?.(`[tlon] Auto-discovery failed: ${error?.message ?? String(error)}`);
-    runtime.log?.("[tlon] To monitor group channels, add them to config: channels.tlon.groupChannels");
-    runtime.log?.("[tlon] Example: [\"chat/~host-ship/channel-name\"]");
-    return [];
-  }
-}

package/extensions/tlon/src/monitor/history.ts

@@ -1,87 +0,0 @@
-import type { RuntimeEnv } from "clawdbot/plugin-sdk";
-
-import { extractMessageText } from "./utils.js";
-
-export type TlonHistoryEntry = {
-  author: string;
-  content: string;
-  timestamp: number;
-  id?: string;
-};
-
-const messageCache = new Map<string, TlonHistoryEntry[]>();
-const MAX_CACHED_MESSAGES = 100;
-
-export function cacheMessage(channelNest: string, message: TlonHistoryEntry) {
-  if (!messageCache.has(channelNest)) {
-    messageCache.set(channelNest, []);
-  }
-  const cache = messageCache.get(channelNest);
-  if (!cache) return;
-  cache.unshift(message);
-  if (cache.length > MAX_CACHED_MESSAGES) {
-    cache.pop();
-  }
-}
-
-export async function fetchChannelHistory(
-  api: { scry: (path: string) => Promise<unknown> },
-  channelNest: string,
-  count = 50,
-  runtime?: RuntimeEnv,
-): Promise<TlonHistoryEntry[]> {
-  try {
-    const scryPath = `/channels/v4/${channelNest}/posts/newest/${count}/outline.json`;
-    runtime?.log?.(`[tlon] Fetching history: ${scryPath}`);
-
-    const data: any = await api.scry(scryPath);
-    if (!data) return [];
-
-    let posts: any[] = [];
-    if (Array.isArray(data)) {
-      posts = data;
-    } else if (data.posts && typeof data.posts === "object") {
-      posts = Object.values(data.posts);
-    } else if (typeof data === "object") {
-      posts = Object.values(data);
-    }
-
-    const messages = posts
-      .map((item) => {
-        const essay = item.essay || item["r-post"]?.set?.essay;
-        const seal = item.seal || item["r-post"]?.set?.seal;
-
-        return {
-          author: essay?.author || "unknown",
-          content: extractMessageText(essay?.content || []),
-          timestamp: essay?.sent || Date.now(),
-          id: seal?.id,
-        } as TlonHistoryEntry;
-      })
-      .filter((msg) => msg.content);
-
-    runtime?.log?.(`[tlon] Extracted ${messages.length} messages from history`);
-    return messages;
-  } catch (error: any) {
-    runtime?.log?.(`[tlon] Error fetching channel history: ${error?.message ?? String(error)}`);
-    return [];
-  }
-}
-
-export async function getChannelHistory(
-  api: { scry: (path: string) => Promise<unknown> },
-  channelNest: string,
-  count = 50,
-  runtime?: RuntimeEnv,
-): Promise<TlonHistoryEntry[]> {
-  const cache = messageCache.get(channelNest) ?? [];
-  if (cache.length >= count) {
-    runtime?.log?.(`[tlon] Using cached messages (${cache.length} available)`);
-    return cache.slice(0, count);
-  }
-
-  runtime?.log?.(
-    `[tlon] Cache has ${cache.length} messages, need ${count}, fetching from scry...`,
-  );
-  return await fetchChannelHistory(api, channelNest, count, runtime);
-}