gloomberb 0.7.5 → 0.8.0

package/src/plugins/builtin/cloud/auth-commands.ts

@@ -0,0 +1,115 @@
+import type { GloomPluginContext } from "../../../types/plugin";
+import { apiClient } from "../../../api-client";
+import { chatController } from "../chat/controller";
+
+export function registerCloudAuthCommands(ctx: GloomPluginContext): void {
+  ctx.registerCommand({
+    id: "auth-login",
+    label: "Log In",
+    description: "Log in to your Gloomberb account",
+    keywords: ["login", "sign in", "auth", "account"],
+    category: "config",
+    wizardLayout: "form",
+    hidden: () => !!apiClient.getSessionToken(),
+    wizard: [
+      { key: "email", label: "Email", type: "text", placeholder: "email@example.com" },
+      { key: "password", label: "Password", type: "password", placeholder: "Your password" },
+      { key: "_validate", label: "Signing in...", type: "info", body: ["Connecting to Gloomberb...", "Logged in successfully!"] },
+    ],
+    execute: async (values) => {
+      if (!values?.email || !values?.password) {
+        throw new Error("Email and password are required");
+      }
+      const user = await apiClient.signIn(values.email, values.password);
+      if (!user.emailVerified) {
+        await apiClient.sendVerification().catch(() => {});
+      }
+      chatController.clearSession();
+      await chatController.refreshSession();
+      ctx.showPane("chat");
+    },
+  });
+
+  ctx.registerCommand({
+    id: "auth-signup",
+    label: "Sign Up",
+    description: "Create a Gloomberb account",
+    keywords: ["signup", "register", "create account"],
+    category: "config",
+    wizardLayout: "form",
+    hidden: () => !!apiClient.getSessionToken(),
+    wizard: [
+      { key: "email", label: "Email", type: "text", placeholder: "email@example.com" },
+      {
+        key: "username",
+        label: "Username",
+        type: "text",
+        placeholder: "3-30 chars, starts with letter",
+        body: ["Choose a username (3-30 characters, starts with a letter, alphanumeric and underscore only)"],
+      },
+      { key: "password", label: "Password", type: "password", placeholder: "Min 8 characters" },
+      { key: "confirmPassword", label: "Confirm Password", type: "password", placeholder: "Re-enter password" },
+      { key: "_validate", label: "Creating account...", type: "info", body: ["Registering with Gloomberb...", "Account created! Welcome to Gloomberb."] },
+    ],
+    execute: async (values) => {
+      if (!values?.email || !values?.username || !values?.password) {
+        throw new Error("All fields are required");
+      }
+      if (values.password !== values.confirmPassword) {
+        throw new Error("Passwords do not match");
+      }
+      await apiClient.signUp(values.email, values.username, values.username, values.password);
+      await apiClient.sendVerification();
+      chatController.clearSession();
+      await chatController.refreshSession();
+      ctx.showPane("chat");
+    },
+  });
+
+  ctx.registerCommand({
+    id: "auth-resend-verification",
+    label: "Resend Verification Email",
+    description: "Send another Gloom Cloud verification email",
+    keywords: ["verify", "verification", "resend", "email"],
+    category: "config",
+    hidden: () => {
+      const user = chatController.getSnapshot().user;
+      return !apiClient.getSessionToken() || !user || user.emailVerified;
+    },
+    execute: async () => {
+      await apiClient.sendVerification();
+      ctx.notify({ body: "Verification email sent.", type: "success" });
+    },
+  });
+
+  if (apiClient.getSessionToken()) {
+    void chatController.refreshSession().catch(() => {});
+  }
+
+  ctx.registerCommand({
+    id: "auth-logout",
+    label: "Logout",
+    description: "Log out of your Gloomberb account",
+    keywords: ["logout", "sign out"],
+    category: "config",
+    execute: async () => {
+      if (!apiClient.getSessionToken()) {
+        ctx.notify({ body: "Not logged in.", type: "error" });
+        return;
+      }
+      let signOutError: unknown = null;
+      try {
+        await apiClient.signOut();
+      } catch (error) {
+        signOutError = error;
+      }
+      await chatController.refreshSession();
+      await chatController.refreshMessages();
+      ctx.notify({
+        body: signOutError ? "Logged out locally. Cloud sign-out did not complete." : "Logged out.",
+        type: "info",
+      });
+    },
+    hidden: () => !apiClient.getSessionToken(),
+  });
+}

package/src/plugins/builtin/cloud/index.tsx

@@ -0,0 +1,11 @@
+import { ChatContent } from "../chat/content";
+import { createChatPane } from "../chat/pane";
+import { ChatStatusWidget } from "../chat/status-widget";
+import { createGloomberbCloudPlugin } from "./plugin";
+
+const ChatPane = createChatPane(ChatContent);
+
+export const gloomberbCloudPlugin = createGloomberbCloudPlugin({
+  ChatPane,
+  ChatStatusWidget,
+});

package/src/plugins/builtin/cloud/plugin.tsx

@@ -0,0 +1,185 @@
+import type { ComponentType, ReactNode } from "react";
+import type { GloomPlugin, PaneProps } from "../../../types/plugin";
+import { apiClient } from "../../../api-client";
+import { createGloomberbCloudCapabilities, createGloomberbCloudProvider } from "../../../sources/gloomberb-cloud";
+import { chatController } from "../chat/controller";
+import { registerCloudAuthCommands } from "./auth-commands";
+import { AccountManagementPane } from "../account-management/pane";
+import { BuildoutPane } from "../buildout/pane";
+import {
+  CONGRESS_TRADES_PANE_ID,
+  CongressTradesPane,
+} from "../congress-trades/pane";
+import { registerTwitterFeedFeature } from "../cloud-tweets";
+import {
+  buildDmCommandResults,
+  getLastVisitedChatChannelId,
+  hasOnlyDmUsernameArgs,
+  normalizeShortcutChannelId,
+  openDefaultChatFromCommand,
+  openDmTargetFromCommand,
+  parseDmUsernames,
+} from "../chat/channels";
+
+interface GloomberbCloudPluginComponents {
+  ChatPane: (props: PaneProps) => ReactNode;
+  ChatStatusWidget: ComponentType;
+}
+
+export function createGloomberbCloudPlugin({
+  ChatPane,
+  ChatStatusWidget,
+}: GloomberbCloudPluginComponents): GloomPlugin {
+  return {
+    id: "gloomberb-cloud",
+    name: "Gloom Cloud",
+    version: "1.0.0",
+    description: "Free market, macro, and chat services. Chat requires signup.",
+    toggleable: true,
+    order: 10,
+    capabilities: createGloomberbCloudCapabilities(createGloomberbCloudProvider()),
+    paneTemplates: [
+      {
+        id: "new-chat-pane",
+        paneId: "chat",
+        label: "New Chat Pane",
+        description: "Open another floating chat window",
+        keywords: ["new", "chat", "pane", "message"],
+        shortcut: { prefix: "CHAT", argPlaceholder: "channel", argKind: "text" },
+        createInstance: async (context, options) => {
+          const channelId = options?.arg
+            ? await chatController.resolveRequiredChannelId(normalizeShortcutChannelId(options.arg))
+            : await chatController.resolvePreferredChannelId(getLastVisitedChatChannelId(context.config));
+          return {
+            placement: "floating",
+            settings: { channelId },
+          };
+        },
+      },
+      {
+        id: "account-management-pane",
+        paneId: "account-management",
+        label: "Account Management",
+        description: "Edit your Gloom Cloud profile, password, and public portfolio sharing settings",
+        keywords: ["account", "profile", "cloud", "acm", "password", "settings"],
+        shortcut: { prefix: "ACM" },
+        createInstance: () => ({
+          placement: "floating",
+        }),
+      },
+      {
+        id: "buildout-pane",
+        paneId: "buildout",
+        label: "TheBuildout",
+        description: "Open TheBuildout infrastructure intelligence.",
+        keywords: ["tbo", "buildout", "thebuildout", "infrastructure", "sites", "intel"],
+        shortcut: { prefix: "TBO" },
+        createInstance: () => ({
+          placement: "floating",
+        }),
+      },
+      {
+        id: "congress-trades-pane",
+        paneId: CONGRESS_TRADES_PANE_ID,
+        label: "Congress Trades",
+        description: "Track newly disclosed House periodic transaction reports.",
+        keywords: ["congress", "house", "trades", "ptr", "stock", "disclosures"],
+        shortcut: { prefix: "CG" },
+        createInstance: () => ({
+          placement: "floating",
+        }),
+      },
+    ],
+
+    slots: {
+      "status:widget": () => <ChatStatusWidget />,
+    },
+
+    setup(ctx) {
+      chatController.attachPersistence(ctx.persistence, ctx.resume);
+      chatController.setNotifier(ctx.notify);
+
+      ctx.registerPane({
+        id: "chat",
+        name: "Chat",
+        icon: "C",
+        component: ChatPane,
+        defaultPosition: "right",
+        defaultMode: "floating",
+        defaultFloatingSize: { width: 80, height: 30 },
+      });
+
+      ctx.registerPane({
+        id: "account-management",
+        name: "ACM",
+        icon: "A",
+        component: AccountManagementPane,
+        defaultPosition: "right",
+        defaultMode: "floating",
+        defaultFloatingSize: { width: 72, height: 36 },
+      });
+
+      ctx.registerPane({
+        id: "buildout",
+        name: "TheBuildout",
+        icon: "T",
+        component: BuildoutPane,
+        defaultPosition: "right",
+        defaultMode: "floating",
+        defaultFloatingSize: { width: 110, height: 34 },
+      });
+
+      ctx.registerPane({
+        id: CONGRESS_TRADES_PANE_ID,
+        name: "Congress",
+        icon: "G",
+        component: CongressTradesPane,
+        defaultPosition: "right",
+        defaultMode: "floating",
+        defaultFloatingSize: { width: 112, height: 30 },
+      });
+
+      registerTwitterFeedFeature(ctx);
+
+      ctx.registerCommand({
+        id: "open-chat",
+        label: "Chat",
+        description: "Open chat",
+        keywords: ["chat", "message", "messages"],
+        category: "navigation",
+        shortcut: "CHAT",
+        execute: () => openDefaultChatFromCommand(ctx),
+      });
+
+      ctx.registerCommand({
+        id: "direct-message",
+        label: "DM",
+        description: "Open an existing DM or start a direct/group chat",
+        keywords: ["dm", "direct", "message", "group", "chat"],
+        category: "navigation",
+        shortcut: "DM",
+        shortcutArg: {
+          placeholder: "@username [@username...]",
+          kind: "text",
+          parse: (arg) => ({ participants: arg.trim() }),
+        },
+        buildResults: (arg) => buildDmCommandResults(ctx, arg),
+        execute: async (values) => {
+          const participants = values?.participants ?? values?.shortcut ?? "";
+          const usernames = parseDmUsernames(participants);
+          if (participants.trim() && !hasOnlyDmUsernameArgs(participants)) {
+            throw new Error("Use @username, or multiple usernames for a group chat.");
+          }
+          await openDmTargetFromCommand(ctx, usernames);
+        },
+      });
+
+      registerCloudAuthCommands(ctx);
+    },
+
+    dispose() {
+      chatController.dispose();
+      apiClient.dispose();
+    },
+  };
+}

package/src/plugins/builtin/cloud-tweets/footer.ts

@@ -0,0 +1,40 @@
+import { usePaneFooter } from "../../../components";
+import { formatTimeAgo } from "../../../utils/format";
+import {
+  TWITTER_FEED_PANE_ID,
+  type TwitterFeed,
+} from "./model";
+
+export function useTwitterFeedFooter({
+  activeFeed,
+  addFeed,
+  blurSearch,
+  focusSearch,
+  removeFeed,
+  searchFocused,
+}: {
+  activeFeed: TwitterFeed | null;
+  addFeed: () => void;
+  blurSearch: () => void;
+  focusSearch: () => void;
+  removeFeed: (feedId: string) => void;
+  searchFocused: boolean;
+}) {
+  usePaneFooter(TWITTER_FEED_PANE_ID, () => ({
+    info: activeFeed
+      ? [
+        { id: "mode", parts: [{ text: activeFeed.queryType, tone: "value" }] },
+        ...(activeFeed.lastSuccessAt ? [{ id: "last", parts: [{ text: `ran ${formatTimeAgo(new Date(activeFeed.lastSuccessAt))}`, tone: "muted" as const }] }] : []),
+      ]
+      : [],
+    hints: searchFocused
+      ? [
+        { id: "done", key: "Esc", label: "done", onPress: blurSearch },
+      ]
+      : [
+        { id: "new", key: "n", label: "ew", onPress: () => addFeed() },
+        { id: "search", key: "/", label: "search", onPress: focusSearch, disabled: !activeFeed },
+        { id: "delete", key: "d", label: "elete", onPress: activeFeed ? () => removeFeed(activeFeed.id) : undefined, disabled: !activeFeed },
+      ],
+  }), [activeFeed, addFeed, blurSearch, focusSearch, removeFeed, searchFocused]);
+}

package/src/plugins/builtin/cloud-tweets/index.ts

@@ -0,0 +1 @@
+export { registerTwitterFeedFeature } from "./registration";

package/src/plugins/builtin/cloud-tweets/keyboard.ts

@@ -0,0 +1,65 @@
+import { useShortcut } from "../../../react/input";
+import type { TwitterFeed } from "./model";
+
+export function useTwitterFeedKeyboard({
+  activeFeed,
+  addFeed,
+  blurSearch,
+  cycleFeeds,
+  focusSearch,
+  focused,
+  removeFeed,
+  searchFocused,
+}: {
+  activeFeed: TwitterFeed | null;
+  addFeed: () => void;
+  blurSearch: () => void;
+  cycleFeeds: (direction: -1 | 1) => void;
+  focusSearch: () => void;
+  focused: boolean;
+  removeFeed: (feedId: string) => void;
+  searchFocused: boolean;
+}) {
+  useShortcut((event) => {
+    if (!focused) return;
+
+    if (searchFocused) {
+      if (event.name === "escape") {
+        event.preventDefault?.();
+        event.stopPropagation?.();
+        blurSearch();
+      }
+      return;
+    }
+
+    if (event.name === "n") {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      addFeed();
+      return;
+    }
+    if (event.name === "/" || event.sequence === "/") {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      focusSearch();
+      return;
+    }
+    if (event.name === "d" && activeFeed) {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      removeFeed(activeFeed.id);
+      return;
+    }
+    if (event.name === "[") {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      cycleFeeds(-1);
+      return;
+    }
+    if (event.name === "]") {
+      event.preventDefault?.();
+      event.stopPropagation?.();
+      cycleFeeds(1);
+    }
+  }, { allowEditable: true });
+}

package/src/plugins/builtin/cloud-tweets/model.ts

@@ -0,0 +1,257 @@
+import type { DataTableColumn } from "../../../components";
+import type {
+  CloudTweetPayload,
+  CloudTweetQueryType,
+  CloudTweetSearchResponse,
+} from "../../../api-client";
+import { formatCompact, formatTimeAgo } from "../../../utils/format";
+import { normalizeTweetText } from "../../../utils/tweet-text";
+import { truncateWithEllipsis } from "../../../utils/text-wrap";
+import { toTimestampMillis } from "../../../utils/timestamp";
+import { collectUniqueTickerSymbols } from "../../../tickers/tokenizer";
+import { normalizedHttpUrl } from "../../../utils/url";
+
+export const DEFAULT_TWEET_HOURS = 6;
+export const DEFAULT_TWEET_LIMIT = 50;
+export const TWEET_SEARCH_SCHEMA_VERSION = 1;
+export const TWEET_SEARCH_DEBOUNCE_MS = 450;
+export const TWITTER_FEED_PANE_ID = "twitter-feed";
+export const TWITTER_FEED_LAUNCH_STATE_KEY = "twitter-feed-launch";
+export const TWITTER_FEED_LAUNCH_SCHEMA_VERSION = 1;
+
+const TWITTER_USERNAME_RE = /^[A-Za-z0-9_]{1,15}$/;
+
+type TweetColumnId = "time" | "author" | "text" | "tickers" | "likes" | "views";
+export type TweetColumn = DataTableColumn & { id: TweetColumnId };
+export type TweetSortColumnId = "time" | "likes" | "views";
+export type TweetSortDirection = "asc" | "desc";
+
+export interface TweetLoadState {
+  data: CloudTweetSearchResponse | null;
+  loading: boolean;
+  error: string | null;
+}
+
+export interface TwitterFeed {
+  id: string;
+  title: string;
+  query: string;
+  queryType: CloudTweetQueryType;
+  createdAt: number;
+  updatedAt: number;
+  lastSuccessAt: number | null;
+  lastError: string | null;
+}
+
+export interface PersistedTwitterFeedState {
+  feeds: TwitterFeed[];
+}
+
+export interface TwitterFeedLaunchRequest {
+  query: string;
+  targetPaneId: string | null;
+  nonce: string;
+  createdAt: number;
+  queryType?: CloudTweetQueryType;
+}
+
+export const EMPTY_FEED_STATE: PersistedTwitterFeedState = { feeds: [] };
+
+let nextTwitterFeedId = 1;
+
+function generateFeedId(): string {
+  return `${Date.now()}-${nextTwitterFeedId++}`;
+}
+
+export function deriveFeedTitle(query: string): string {
+  const tickers = collectUniqueTickerSymbols([query]);
+  if (tickers.length > 0) return tickers.slice(0, 3).map((ticker) => `$${ticker}`).join(" ");
+  return truncateWithEllipsis(query.replace(/\s+/g, " ").trim(), 24) || "New";
+}
+
+export function createFeed(query: string, queryType: CloudTweetQueryType): TwitterFeed {
+  const now = Date.now();
+  return {
+    id: generateFeedId(),
+    title: deriveFeedTitle(query),
+    query,
+    queryType,
+    createdAt: now,
+    updatedAt: now,
+    lastSuccessAt: null,
+    lastError: null,
+  };
+}
+
+export function normalizeFeedQuery(query: string): string {
+  return query.replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+export function normalizeTwitterUsername(username: string): string | null {
+  const normalized = username.trim().replace(/^@/, "");
+  return TWITTER_USERNAME_RE.test(normalized) ? normalized : null;
+}
+
+export function twitterUserSearchQuery(username: string): string {
+  return `from:${username}`;
+}
+
+export function normalizeFeeds(value: unknown): TwitterFeed[] {
+  const entries = Array.isArray((value as PersistedTwitterFeedState | undefined)?.feeds)
+    ? (value as PersistedTwitterFeedState).feeds
+    : [];
+  return entries
+    .filter((entry): entry is TwitterFeed => (
+      !!entry
+      && typeof entry === "object"
+      && typeof entry.id === "string"
+      && typeof entry.query === "string"
+    ))
+    .map((entry) => ({
+      ...entry,
+      title: typeof entry.title === "string" && entry.title.trim() ? entry.title : deriveFeedTitle(entry.query),
+      queryType: entry.queryType === "Top" ? "Top" : "Latest",
+      createdAt: typeof entry.createdAt === "number" ? entry.createdAt : Date.now(),
+      updatedAt: typeof entry.updatedAt === "number" ? entry.updatedAt : Date.now(),
+      lastSuccessAt: typeof entry.lastSuccessAt === "number" ? entry.lastSuccessAt : null,
+      lastError: typeof entry.lastError === "string" ? entry.lastError : null,
+    }));
+}
+
+export function formatRelativeShort(value: string): string {
+  return formatTimeAgo(value).replace(" ago", "").replace("just now", "<1m");
+}
+
+export function formatMetric(value: number | null | undefined): string {
+  if (value == null) return "-";
+  if (Math.abs(value) >= 1000) return formatCompact(value);
+  return String(value);
+}
+
+export function normalizeTweetDisplayText(value: string): string {
+  return normalizeTweetText(value, { preserveLineBreaks: true });
+}
+
+export function normalizeTweetCellText(value: string): string {
+  return normalizeTweetText(value);
+}
+
+export function tweetTickers(tweet: CloudTweetPayload): string[] {
+  return collectUniqueTickerSymbols([normalizeTweetDisplayText(tweet.text)]);
+}
+
+function tweetCreatedAtMs(tweet: CloudTweetPayload): number {
+  const ms = toTimestampMillis(tweet.createdAt);
+  return Number.isFinite(ms) ? ms : 0;
+}
+
+function compareNullableNumber(
+  left: number | null | undefined,
+  right: number | null | undefined,
+  sortDirection: TweetSortDirection,
+): number {
+  if (left == null && right == null) return 0;
+  if (left == null) return 1;
+  if (right == null) return -1;
+  const comparison = left - right;
+  return sortDirection === "asc" ? comparison : -comparison;
+}
+
+export function isTweetSortColumnId(columnId: string): columnId is TweetSortColumnId {
+  return columnId === "time" || columnId === "likes" || columnId === "views";
+}
+
+function compareTweets(
+  left: CloudTweetPayload,
+  right: CloudTweetPayload,
+  sortColumnId: TweetSortColumnId,
+  sortDirection: TweetSortDirection,
+): number {
+  let comparison = 0;
+  switch (sortColumnId) {
+    case "time":
+      comparison = tweetCreatedAtMs(left) - tweetCreatedAtMs(right);
+      if (comparison !== 0) {
+        return sortDirection === "asc" ? comparison : -comparison;
+      }
+      break;
+    case "likes":
+      comparison = compareNullableNumber(left.metrics.likes, right.metrics.likes, sortDirection);
+      break;
+    case "views":
+      comparison = compareNullableNumber(left.metrics.views, right.metrics.views, sortDirection);
+      break;
+  }
+
+  if (comparison !== 0) return comparison;
+
+  return tweetCreatedAtMs(right) - tweetCreatedAtMs(left);
+}
+
+export function sortedTweets(
+  tweets: CloudTweetPayload[],
+  sortColumnId: TweetSortColumnId,
+  sortDirection: TweetSortDirection,
+): CloudTweetPayload[] {
+  return [...tweets].sort((left, right) => compareTweets(left, right, sortColumnId, sortDirection));
+}
+
+function mediaImageUrl(value: unknown): string | null {
+  const directUrl = normalizedHttpUrl(value);
+  if (directUrl) return directUrl;
+  if (!value || typeof value !== "object") return null;
+
+  const record = value as Record<string, unknown>;
+  return normalizedHttpUrl(record.mediaUrl)
+    ?? normalizedHttpUrl(record.media_url_https)
+    ?? normalizedHttpUrl(record.media_url)
+    ?? normalizedHttpUrl(record.previewImageUrl)
+    ?? normalizedHttpUrl(record.preview_image_url)
+    ?? normalizedHttpUrl(record.url);
+}
+
+function nestedMedia(record: Record<string, unknown>, key: string): unknown {
+  const value = record[key];
+  return value && typeof value === "object" ? (value as Record<string, unknown>).media : undefined;
+}
+
+export function tweetImageUrls(tweet: CloudTweetPayload): string[] {
+  const record = tweet as unknown as Record<string, unknown>;
+  const candidates = [
+    record.media,
+    record.photos,
+    record.images,
+    nestedMedia(record, "entities"),
+    nestedMedia(record, "extendedEntities"),
+    nestedMedia(record, "extended_entities"),
+  ];
+  const urls = new Set<string>();
+  for (const candidate of candidates) {
+    const entries = Array.isArray(candidate) ? candidate : candidate == null ? [] : [candidate];
+    for (const entry of entries) {
+      const url = mediaImageUrl(entry);
+      if (url) urls.add(url);
+    }
+  }
+  return [...urls];
+}
+
+export function buildTweetColumns(width: number): TweetColumn[] {
+  const timeWidth = 7;
+  const authorWidth = 16;
+  const tickersWidth = 24;
+  const likesWidth = 7;
+  const viewsWidth = 8;
+  const textWidth = Math.max(
+    20,
+    width - timeWidth - authorWidth - tickersWidth - likesWidth - viewsWidth - 9,
+  );
+  return [
+    { id: "time", label: "TIME", width: timeWidth, align: "left" },
+    { id: "author", label: "AUTHOR", width: authorWidth, align: "left" },
+    { id: "text", label: "TWEET", width: textWidth, align: "left" },
+    { id: "tickers", label: "TICKERS", width: tickersWidth, align: "left" },
+    { id: "likes", label: "LIKES", width: likesWidth, align: "right" },
+    { id: "views", label: "VIEWS", width: viewsWidth, align: "right" },
+  ];
+}