@andocorp/cli 0.1.0

package/src/index.ts

@@ -0,0 +1,466 @@
+#!/usr/bin/env bun
+import { getStringFlag, hasFlag, parseArgs } from "./args.js";
+import {
+  getConversationLabel,
+  getWorkspaceLabel,
+  isChannel,
+  resolveConversation,
+  resolveWorkspace,
+} from "./cli-helpers.js";
+import { createAndoCliClient } from "./client.js";
+import { getConfigPath, readSavedConfig, saveConfig } from "./config.js";
+import { promptLine } from "./components/prompt-line.js";
+import { formatDateTime, formatMessageLine } from "./format.js";
+import { buildHelpText } from "./help.js";
+import { createInteractiveApp } from "./interactive.js";
+import { Membership, Message, ParsedArgs } from "./types.js";
+
+const DEFAULT_CONVEX_URL = "https://quick-caiman-763.convex.cloud";
+const LOGIN_REQUIRED_ERROR = `OAuth session is required. Run "ando login" first.`;
+
+function getConfiguredConvexUrl(parsedArgs: ParsedArgs, savedConvexUrl?: string | null) {
+  return (
+    getStringFlag(parsedArgs, "convex-url") ??
+    process.env.ANDO_CONVEX_URL ??
+    process.env.VITE_CONVEX_URL ??
+    process.env.NEXT_PUBLIC_CONVEX_URL ??
+    savedConvexUrl ??
+    DEFAULT_CONVEX_URL
+  );
+}
+
+async function loadConfig(parsedArgs: ParsedArgs) {
+  const savedConfig = await readSavedConfig();
+  const convexUrl = getConfiguredConvexUrl(parsedArgs, savedConfig?.convexUrl ?? null);
+  const sessionToken =
+    process.env.ANDO_SESSION_JWT ??
+    savedConfig?.sessionToken ??
+    null;
+
+  if (sessionToken == null || sessionToken.trim() === "") {
+    throw new Error(LOGIN_REQUIRED_ERROR);
+  }
+
+  const anonymousClient = createAndoCliClient({ convexUrl });
+  const refreshedSessionToken = await anonymousClient.refreshSessionJwt(sessionToken);
+
+  if (refreshedSessionToken == null || refreshedSessionToken.trim() === "") {
+    throw new Error(LOGIN_REQUIRED_ERROR);
+  }
+
+  if (
+    savedConfig?.sessionToken !== refreshedSessionToken ||
+    savedConfig.convexUrl !== convexUrl
+  ) {
+    await saveConfig({
+      convexUrl,
+      sessionToken: refreshedSessionToken,
+    });
+  }
+
+  return {
+    convexUrl,
+    sessionToken: refreshedSessionToken,
+  };
+}
+
+async function ensureConfig(parsedArgs: ParsedArgs, command: string | undefined) {
+  try {
+    return await loadConfig(parsedArgs);
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message === LOGIN_REQUIRED_ERROR &&
+      command !== "login"
+    ) {
+      await runLogin(parsedArgs);
+      return await loadConfig(parsedArgs);
+    }
+
+    throw error;
+  }
+}
+
+function printJson(value: unknown) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+function printHelp() {
+  process.stdout.write(`${buildHelpText()}\n`);
+}
+
+async function runLogin(parsedArgs: ParsedArgs) {
+  const savedConfig = await readSavedConfig();
+  const convexUrl = getConfiguredConvexUrl(parsedArgs, savedConfig?.convexUrl ?? null);
+  const email = getStringFlag(parsedArgs, "email") ?? (await promptLine("Email: "));
+
+  if (email.trim() === "") {
+    throw new Error("login requires an email address.");
+  }
+
+  const client = createAndoCliClient({ convexUrl });
+  await client.sendEmailOtp({ email });
+  process.stdout.write(`Sent OTP to ${email}\n`);
+
+  const code =
+    getStringFlag(parsedArgs, "code") ?? (await promptLine("Verification code: "));
+  if (code.trim() === "") {
+    throw new Error("login requires a verification code.");
+  }
+
+  const discovery = await client.discoverWorkspaces({
+    email,
+    code,
+  });
+
+  if (discovery.requires_workspace_creation || discovery.workspaces.length === 0) {
+    throw new Error("No existing workspaces matched this login. Create one in the web app first.");
+  }
+
+  let workspaceQuery = getStringFlag(parsedArgs, "workspace", "w") ?? null;
+  if (workspaceQuery == null && discovery.workspaces.length > 1) {
+    process.stdout.write("Workspaces:\n");
+    discovery.workspaces.forEach((workspace, index) => {
+      process.stdout.write(`  [${index + 1}] ${getWorkspaceLabel(workspace)}\n`);
+    });
+    const answer = await promptLine("Select workspace: ");
+    const asIndex = Number.parseInt(answer, 10);
+    if (Number.isFinite(asIndex) && asIndex >= 1 && asIndex <= discovery.workspaces.length) {
+      workspaceQuery = discovery.workspaces[asIndex - 1]?.id ?? null;
+    } else {
+      workspaceQuery = answer;
+    }
+  }
+
+  const workspace = resolveWorkspace(discovery.workspaces, workspaceQuery);
+  const response = await client.selectWorkspace({
+    workspace_id: workspace.id,
+    intermediate_session_token: discovery.intermediate_session_token,
+  });
+
+  await saveConfig({
+    convexUrl,
+    sessionToken: response.session_jwt,
+  });
+
+  process.stdout.write(`Saved CLI session to ${getConfigPath()}\n`);
+  process.stdout.write(`Selected workspace: ${workspace.name}\n`);
+}
+
+function printMemberships(memberships: Membership[]) {
+  const sortedMemberships = [...memberships].sort((left, right) => {
+    const leftDate = new Date(
+      left.conversation.last_message_at ?? left.conversation.updated_at
+    ).getTime();
+    const rightDate = new Date(
+      right.conversation.last_message_at ?? right.conversation.updated_at
+    ).getTime();
+
+    return rightDate - leftDate;
+  });
+
+  for (const membership of sortedMemberships) {
+    const lastActivity = formatDateTime(
+      membership.conversation.last_message_at ?? membership.conversation.updated_at
+    );
+    process.stdout.write(
+      `${getConversationLabel(membership)}\t${membership.conversation.id}\t${lastActivity}\n`
+    );
+  }
+}
+
+function printMessages(
+  messages: Message[],
+  currentMemberId?: string | null
+) {
+  for (const message of messages) {
+    process.stdout.write(
+      `${message.id}\t${formatMessageLine(message, { currentMemberId })}\n`
+    );
+  }
+}
+
+async function runInteractiveCommand(client: ReturnType<typeof createAndoCliClient>) {
+  const me = await client.getMe();
+  if (me == null) {
+    throw new Error("Failed to fetch user details. Please sign in again with \"ando login\".");
+  }
+
+  process.stdout.write(
+    `Signed in as ${me.display_name ?? me.email ?? me.id} (${me.workspace.name})\n`
+  );
+  const app = createInteractiveApp({ client, currentMemberId: me.id });
+  await app.run();
+}
+
+async function runListChannelsCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  jsonFlag: boolean
+) {
+  const memberships = (await client.getAllMemberships()).filter(isChannel);
+  if (jsonFlag) {
+    printJson(memberships);
+    return;
+  }
+
+  printMemberships(memberships);
+}
+
+async function runListDmsCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  jsonFlag: boolean
+) {
+  const memberships = (await client.getAllMemberships()).filter(
+    (membership) => !isChannel(membership)
+  );
+  if (jsonFlag) {
+    printJson(memberships);
+    return;
+  }
+
+  printMemberships(memberships);
+}
+
+async function runListMessagesCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  parsedArgs: ParsedArgs,
+  jsonFlag: boolean
+) {
+  const channelQuery = getStringFlag(parsedArgs, "channel", "c");
+  const dmQuery = getStringFlag(parsedArgs, "dm", "d");
+  const conversationQuery = getStringFlag(parsedArgs, "conversation");
+  const limitValue = getStringFlag(parsedArgs, "n", "n") ?? getStringFlag(parsedArgs, "limit");
+  const limit = limitValue == null ? 10 : Number.parseInt(limitValue, 10);
+
+  const query = channelQuery ?? dmQuery ?? conversationQuery;
+  if (query == null) {
+    throw new Error("list-messages requires --channel, --dm, or --conversation.");
+  }
+
+  const memberships = await client.getAllMemberships();
+  const membership = resolveConversation(memberships, {
+    allowChannels: dmQuery == null,
+    allowDms: channelQuery == null,
+    query,
+  });
+  const response = await client.getConversationMessages(membership.conversation.id, limit);
+
+  if (jsonFlag) {
+    printJson(response.items);
+    return;
+  }
+
+  const me = await client.getMe();
+  if (me == null) {
+    throw new Error("Failed to fetch user details. Please sign in again with \"ando login\".");
+  }
+  printMessages(response.items, me.id);
+}
+
+async function runThreadCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  parsedArgs: ParsedArgs,
+  jsonFlag: boolean
+) {
+  const messageId = getStringFlag(parsedArgs, "message-id", "m");
+  if (messageId == null) {
+    throw new Error("thread requires --message-id.");
+  }
+
+  const root = await client.getMessage(messageId);
+  if (root == null) {
+    throw new Error(`Message ${messageId} was not found.`);
+  }
+
+  const threadRootId = root.thread_root_id ?? root.id;
+  const threadRoot = root.thread_root_id == null ? root : await client.getMessage(threadRootId);
+  const replies = await client.getThreadReplies(threadRootId);
+
+  if (jsonFlag) {
+    printJson({
+      root: threadRoot,
+      replies,
+    });
+    return;
+  }
+
+  const me = await client.getMe();
+  if (me == null) {
+    throw new Error("Failed to fetch user details. Please sign in again with \"ando login\".");
+  }
+  if (threadRoot != null) {
+    process.stdout.write(
+      `ROOT\t${threadRoot.id}\t${formatMessageLine(threadRoot, {
+        currentMemberId: me.id,
+      })}\n`
+    );
+  }
+
+  for (const reply of replies) {
+    process.stdout.write(
+      `REPLY\t${reply.id}\t${formatMessageLine(reply, {
+        currentMemberId: me.id,
+      })}\n`
+    );
+  }
+}
+
+async function runPostMessageCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  parsedArgs: ParsedArgs,
+  jsonFlag: boolean
+) {
+  const channelQuery = getStringFlag(parsedArgs, "channel", "c");
+  const dmQuery = getStringFlag(parsedArgs, "dm", "d");
+  const conversationQuery = getStringFlag(parsedArgs, "conversation");
+  const text = getStringFlag(parsedArgs, "text", "t");
+
+  if (text == null || text.trim() === "") {
+    throw new Error("post-message requires --text.");
+  }
+
+  const query = channelQuery ?? dmQuery ?? conversationQuery;
+  if (query == null) {
+    throw new Error("post-message requires --channel, --dm, or --conversation.");
+  }
+
+  const memberships = await client.getAllMemberships();
+  const membership = resolveConversation(memberships, {
+    allowChannels: dmQuery == null,
+    allowDms: channelQuery == null,
+    query,
+  });
+
+  const message = await client.postMessage({
+    conversationId: membership.conversation.id,
+    markdownContent: text,
+  });
+
+  if (jsonFlag) {
+    printJson(message);
+    return;
+  }
+
+  process.stdout.write(`Posted ${message.id} to ${getConversationLabel(membership)}\n`);
+}
+
+async function runReplyCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  parsedArgs: ParsedArgs,
+  jsonFlag: boolean
+) {
+  const messageId = getStringFlag(parsedArgs, "message-id", "m");
+  const text = getStringFlag(parsedArgs, "text", "t");
+  if (messageId == null) {
+    throw new Error("reply requires --message-id.");
+  }
+  if (text == null || text.trim() === "") {
+    throw new Error("reply requires --text.");
+  }
+
+  const message = await client.getMessage(messageId);
+  if (message == null) {
+    throw new Error(`Message ${messageId} was not found.`);
+  }
+
+  const reply = await client.postMessage({
+    conversationId: message.conversation_id,
+    markdownContent: text,
+    threadRootId: message.thread_root_id ?? message.id,
+  });
+
+  if (jsonFlag) {
+    printJson(reply);
+    return;
+  }
+
+  process.stdout.write(`Posted reply ${reply.id}\n`);
+}
+
+async function runReactCommand(
+  client: ReturnType<typeof createAndoCliClient>,
+  parsedArgs: ParsedArgs,
+  jsonFlag: boolean
+) {
+  const messageId = getStringFlag(parsedArgs, "message-id", "m");
+  const emoji = getStringFlag(parsedArgs, "emoji", "e");
+  if (messageId == null) {
+    throw new Error("react requires --message-id.");
+  }
+  if (emoji == null || emoji.trim() === "") {
+    throw new Error("react requires --emoji.");
+  }
+
+  const result = await client.addReaction(messageId, emoji);
+  if (jsonFlag) {
+    printJson(result.data);
+    return;
+  }
+
+  process.stdout.write(`Added reaction ${emoji} to ${messageId}\n`);
+}
+
+async function runCommand() {
+  const parsedArgs = parseArgs(process.argv.slice(2));
+  const command = parsedArgs.positionals[0];
+
+  if (command === "help" || hasFlag(parsedArgs, "help", "h")) {
+    printHelp();
+    return;
+  }
+
+  if (command === "login") {
+    await runLogin(parsedArgs);
+    return;
+  }
+
+  const client = createAndoCliClient(await ensureConfig(parsedArgs, command));
+  const jsonFlag = hasFlag(parsedArgs, "json");
+
+  if (command == null) {
+    await runInteractiveCommand(client);
+    return;
+  }
+
+  if (command === "list-channels") {
+    await runListChannelsCommand(client, jsonFlag);
+    return;
+  }
+
+  if (command === "list-dms") {
+    await runListDmsCommand(client, jsonFlag);
+    return;
+  }
+
+  if (command === "list-messages") {
+    await runListMessagesCommand(client, parsedArgs, jsonFlag);
+    return;
+  }
+
+  if (command === "thread") {
+    await runThreadCommand(client, parsedArgs, jsonFlag);
+    return;
+  }
+
+  if (command === "post-message") {
+    await runPostMessageCommand(client, parsedArgs, jsonFlag);
+    return;
+  }
+
+  if (command === "reply") {
+    await runReplyCommand(client, parsedArgs, jsonFlag);
+    return;
+  }
+
+  if (command === "react") {
+    await runReactCommand(client, parsedArgs, jsonFlag);
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+void runCommand().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});