@teamclaw/feishu-agent 1.0.0

package/src/cli/commands/calendar.ts

@@ -0,0 +1,305 @@
+import { Command } from "commander";
+import { FeishuClient } from "../../core/client";
+import { CalendarManager } from "../../core/calendar";
+import { ContactManager } from "../../core/contact";
+import { loadContactCache } from "../../core/config";
+import { FeishuConfig } from "../../types";
+
+interface CalendarOptions {
+  calendarId?: string;
+  summary?: string;
+  start?: string;
+  end?: string;
+  attendee?: string[];
+  attendeeName?: string[];
+  eventId?: string;
+}
+
+export function createCalendarCommands(program: Command, config: FeishuConfig) {
+  program
+    .command("list")
+    .description("List all calendars")
+    .action(async () => {
+      await handleListCalendars(config);
+    });
+
+  program
+    .command("events")
+    .description("List events in a calendar")
+    .option("--calendar-id <string>", "Specify calendar ID")
+    .action(async (options: CalendarOptions) => {
+      await handleListEvents(config, options.calendarId);
+    });
+
+  program
+    .command("create")
+    .description("Create a new event")
+    .requiredOption("--summary <string>", "Event title")
+    .requiredOption("--start <string>", "Event start time")
+    .requiredOption("--end <string>", "Event end time")
+    .option("--attendee <ids...>", "User IDs (union_id) to invite")
+    .option("--attendee-name <names...>", "Contact names to invite")
+    .option("--calendar-id <string>", "Specify calendar ID")
+    .action(async (options: CalendarOptions) => {
+      await handleCreateEvent(config, options);
+    });
+
+  program
+    .command("delete")
+    .description("Delete an event")
+    .requiredOption("--event-id <string>", "Event ID")
+    .option("--calendar-id <string>", "Specify calendar ID")
+    .action(async (options: CalendarOptions) => {
+      await handleDeleteEvent(config, options);
+    });
+}
+
+async function handleListCalendars(config: FeishuConfig) {
+  if (!config.appId || !config.appSecret) {
+    console.error("Error: FEISHU_APP_ID and FEISHU_APP_SECRET must be set.");
+    process.exit(1);
+  }
+  if (!config.userAccessToken) {
+    console.error("Error: User authorization required.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const calendarManager = new CalendarManager(client);
+
+  console.log("\n📅 Your Calendars\n");
+  console.log("=".repeat(60));
+
+  const calendars = await calendarManager.listCalendars();
+
+  if (!calendars.calendar_list || calendars.calendar_list.length === 0) {
+    console.log("No calendars found.");
+    return;
+  }
+
+  const primary = calendars.calendar_list.filter(c => c.type === "primary");
+  const subscribed = calendars.calendar_list.filter(c => c.type === "shared" || c.type === "exchange");
+  const other = calendars.calendar_list.filter(c => c.type !== "primary" && c.type !== "shared" && c.type !== "exchange");
+
+  if (primary.length > 0) {
+    console.log("\n【Primary】");
+    primary.forEach(c => {
+      console.log(`  • ${c.summary}`);
+      console.log(`    ID: ${c.calendar_id}`);
+      console.log(`    Role: ${c.role}`);
+    });
+  }
+
+  if (subscribed.length > 0) {
+    console.log("\n【Subscribed】");
+    subscribed.forEach(c => {
+      console.log(`  • ${c.summary}`);
+      console.log(`    ID: ${c.calendar_id}`);
+      console.log(`    Role: ${c.role}`);
+    });
+  }
+
+  if (other.length > 0) {
+    console.log("\n【Other】");
+    other.forEach(c => {
+      console.log(`  • ${c.summary} (${c.type})`);
+      console.log(`    ID: ${c.calendar_id}`);
+      console.log(`    Role: ${c.role}`);
+    });
+  }
+
+  console.log("\n" + "=".repeat(60));
+  console.log(`Total: ${calendars.calendar_list.length} calendar(s)\n`);
+
+  if (primary.length > 0) {
+    console.log(`Tip: Use --calendar-id "${primary[0].calendar_id}" to list events.`);
+  }
+}
+
+async function handleListEvents(config: FeishuConfig, calendarId?: string) {
+  if (!config.appId || !config.appSecret || !config.userAccessToken) {
+    console.error("Error: Authorization required. Run 'feishu-agent auth'.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const calendarManager = new CalendarManager(client);
+
+  if (!calendarId) {
+    const calendars = await calendarManager.listCalendars();
+    const primary = calendars.calendar_list?.find(c => c.type === "primary");
+    if (primary) {
+      calendarId = primary.calendar_id;
+      console.log(`Using primary calendar: ${primary.summary}\n`);
+    }
+  }
+
+  if (!calendarId) {
+    console.error("Error: No calendar available.");
+    process.exit(1);
+  }
+
+  console.log(`\n📅 Events\n`);
+  console.log("=".repeat(60));
+
+  const events = await calendarManager.listEvents(calendarId);
+  if (!events.items || events.items.length === 0) {
+    console.log("No events found.");
+    return;
+  }
+
+  const activeEvents = events.items.filter(e => e.status !== "cancelled");
+  if (activeEvents.length === 0) {
+    console.log("No active events found.");
+    return;
+  }
+
+  const contactCache = await loadContactCache();
+
+  for (const e of activeEvents) {
+    const start = e.start_time.timestamp
+      ? new Date(parseInt(e.start_time.timestamp) * 1000).toLocaleString()
+      : e.start_time.date;
+    const end = e.end_time.timestamp
+      ? new Date(parseInt(e.end_time.timestamp) * 1000).toLocaleString()
+      : e.end_time.date;
+
+    console.log(`\n📅 ${e.summary || "(No title)"}`);
+    console.log(`   🕐 ${start} - ${end}`);
+    console.log(`   ID: ${e.event_id}`);
+    if (e.status && e.status !== "confirmed") {
+      console.log(`   Status: ${e.status}`);
+    }
+
+    try {
+      const attendees = await calendarManager.getEventAttendees(calendarId, e.event_id);
+      if (attendees && attendees.length > 0) {
+        const attendeeDisplay = attendees.map(a => {
+          if (a.type === "user" && a.user_id) {
+            // Lookup attendee name from cache by open_id or union_id
+            for (const [unionId, entry] of Object.entries(contactCache)) {
+              if (entry.open_id === a.user_id || unionId === a.user_id) {
+                return `${entry.name}${a.is_optional ? " (optional)" : ""}`;
+              }
+            }
+            return `${a.user_id}${a.is_optional ? " (optional)" : ""}`;
+          }
+          if (a.type === "chat") return `Chat: ${a.chat_id}`;
+          if (a.type === "third_party" && a.third_party_email) {
+            return `${a.third_party_email} (external)`;
+          }
+          return a.type;
+        });
+        console.log(`   👥 Attendees: ${attendeeDisplay.join(", ")}`);
+      }
+    } catch (err) {
+      // Ignore errors
+    }
+  }
+
+  console.log("\n" + "=".repeat(60));
+  console.log(`Total: ${activeEvents.length} event(s)\n`);
+}
+
+async function handleCreateEvent(config: FeishuConfig, options: CalendarOptions) {
+  if (!config.appId || !config.appSecret || !config.userAccessToken) {
+    console.error("Error: Authorization required.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const calendarManager = new CalendarManager(client);
+  const contactManager = new ContactManager(client);
+
+  const { summary, start, end, attendee, attendeeName, calendarId } = options;
+
+  if (!summary || !start || !end) {
+    console.error("Error: --summary, --start, and --end are required.");
+    process.exit(1);
+  }
+
+  // Resolve attendee names to union_ids
+  let attendeeUserIds: string[] = attendee || [];
+  if (attendeeName && attendeeName.length > 0) {
+    console.log("\n🔍 Resolving attendee names...");
+    for (const name of attendeeName) {
+      const results = await contactManager.searchUser(name);
+      if (results.length === 0) {
+        console.error(`Error: No contact found for "${name}".`);
+        process.exit(1);
+      }
+      if (results.length > 1) {
+        console.log(`  Multiple matches for "${name}":`);
+        results.forEach((r, i) => {
+          console.log(`    ${i + 1}. ${r.name} (${r.email || r.union_id})`);
+        });
+        console.log("  Using the first match.");
+      }
+      attendeeUserIds.push(results[0].union_id);
+      console.log(`  ✓ "${name}" -> ${results[0].name} (${results[0].union_id})`);
+    }
+  }
+
+  // Get calendar
+  let targetCalendarId = calendarId;
+  if (!targetCalendarId) {
+    const calendars = await calendarManager.listCalendars();
+    const primary = calendars.calendar_list?.find(c => c.type === "primary");
+    if (primary) targetCalendarId = primary.calendar_id;
+  }
+
+  if (!targetCalendarId) {
+    console.error("Error: No calendar available.");
+    process.exit(1);
+  }
+
+  const startTimestamp = Math.floor(new Date(start).getTime() / 1000).toString();
+  const endTimestamp = Math.floor(new Date(end).getTime() / 1000).toString();
+
+  const event = await calendarManager.createEvent(targetCalendarId, {
+    summary,
+    startTime: { timestamp: startTimestamp },
+    endTime: { timestamp: endTimestamp },
+    attendeeUserIds: attendeeUserIds.length > 0 ? attendeeUserIds : undefined,
+  });
+
+  console.log("\n✅ Event created!");
+  console.log(`   Title: ${summary}`);
+  console.log(`   Time: ${new Date(parseInt(startTimestamp) * 1000).toLocaleString()} - ${new Date(parseInt(endTimestamp) * 1000).toLocaleString()}`);
+  console.log(`   Calendar ID: ${targetCalendarId}`);
+  if (attendeeUserIds.length > 0) {
+    console.log(`   Attendees: ${attendeeUserIds.join(", ")}`);
+  }
+}
+
+async function handleDeleteEvent(config: FeishuConfig, options: CalendarOptions) {
+  if (!config.appId || !config.appSecret || !config.userAccessToken) {
+    console.error("Error: Authorization required.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const calendarManager = new CalendarManager(client);
+
+  const { eventId, calendarId } = options;
+  let targetCalendarId = calendarId;
+
+  if (!targetCalendarId) {
+    const calendars = await calendarManager.listCalendars();
+    const primary = calendars.calendar_list?.find(c => c.type === "primary");
+    if (primary) targetCalendarId = primary.calendar_id;
+  }
+
+  if (!targetCalendarId) {
+    console.error("Error: No calendar available.");
+    process.exit(1);
+  }
+
+  if (!eventId) {
+    console.error("Error: --event-id is required.");
+    process.exit(1);
+  }
+
+  await calendarManager.deleteEvent(targetCalendarId, eventId);
+  console.log(`\n✅ Event deleted: ${eventId}\n`);
+}

package/src/cli/commands/config.ts

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+import { saveGlobalConfig, getConfigPath } from "../../core/config";
+import { FeishuConfig } from "../../types";
+
+export function createConfigCommands(program: Command) {
+  program
+    .command("set")
+    .description("Set a config value")
+    .argument("<key>", "Config key (appId or appSecret)")
+    .argument("<value>", "Config value")
+    .action(async (key: string, value: string) => {
+      if (key !== "appId" && key !== "appSecret") {
+        console.error("Error: Key must be 'appId' or 'appSecret'.");
+        process.exit(1);
+      }
+
+      await saveGlobalConfig({ [key]: value });
+      console.log(`Updated global config: ${key} = ${value}`);
+    });
+
+  program
+    .command("get")
+    .description("Get a config value")
+    .argument("<key>", "Config key")
+    .action(async (key: string) => {
+      const file = Bun.file(getConfigPath());
+      if (await file.exists()) {
+        const config = await file.json();
+        console.log(config[key] || "(not set)");
+      } else {
+        console.log("(not set)");
+      }
+    });
+
+  program
+    .command("list")
+    .description("List all config values")
+    .action(async () => {
+      const f = Bun.file(getConfigPath());
+      if (await f.exists()) {
+        const c = await f.json();
+        console.log("Global Configuration:");
+        console.log(JSON.stringify(c, null, 2));
+      } else {
+        console.log("Global Configuration: (empty)");
+      }
+    });
+}

package/src/cli/commands/contact.ts

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import { FeishuClient } from "../../core/client";
+import { ContactManager } from "../../core/contact";
+import { FeishuConfig } from "../../types";
+
+interface ContactOptions {
+  dept?: string;
+}
+
+export function createContactCommands(program: Command, config: FeishuConfig) {
+  program
+    .command("list")
+    .description("List users in a department")
+    .option("--dept <string>", "Department ID", "0")
+    .action(async (options: ContactOptions) => {
+      await handleList(config, options.dept);
+    });
+
+  program
+    .command("search")
+    .description("Search users by name or email")
+    .argument("<query>", "Search query")
+    .action(async (query: string) => {
+      await handleSearch(config, query);
+    });
+}
+
+async function handleList(config: FeishuConfig, dept: string = "0") {
+  if (!config.appId || !config.appSecret) {
+    console.error("Error: Credentials required.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const contactManager = new ContactManager(client);
+
+  console.log(`Fetching users for department: ${dept}`);
+  const users = await contactManager.listUsers(dept);
+
+  if (users.length > 0) {
+    users.forEach((u) => {
+      console.log(`- Name: ${u.name}${u.email ? ` (${u.email})` : ''}`);
+      if (u.user_id && u.union_id && u.user_id !== u.union_id) {
+        console.log(`  ID: ${u.user_id} / UnionID: ${u.union_id}`);
+      } else if (u.user_id) {
+        console.log(`  ID: ${u.user_id}`);
+      } else if (u.union_id) {
+        console.log(`  UnionID: ${u.union_id}`);
+      }
+      console.log("");
+    });
+    console.log(`Total: ${users.length} users`);
+  } else {
+    console.log("No users found.");
+  }
+}
+
+async function handleSearch(config: FeishuConfig, query: string) {
+  if (!config.appId || !config.appSecret) {
+    console.error("Error: Credentials required.");
+    process.exit(1);
+  }
+
+  if (!query) {
+    console.error("Error: search query is required.");
+    process.exit(1);
+  }
+
+  const client = new FeishuClient(config);
+  const contactManager = new ContactManager(client);
+
+  console.log(`Searching for users matching: '${query}'`);
+  const users = await contactManager.searchUser(query);
+
+  if (users.length > 0) {
+    users.forEach((u) => {
+      console.log(`- Name: ${u.name}${u.email ? ` (${u.email})` : ''}`);
+      if (u.user_id && u.union_id && u.user_id !== u.union_id) {
+        console.log(`  ID: ${u.user_id} / UnionID: ${u.union_id}`);
+      } else if (u.user_id) {
+        console.log(`  ID: ${u.user_id}`);
+      } else if (u.union_id) {
+        console.log(`  UnionID: ${u.union_id}`);
+      }
+    });
+    console.log(`Total: ${users.length} matching users`);
+  } else {
+    console.log("No matching users found.");
+  }
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,128 @@
+import { loadConfig, FeishuConfig } from "../../core/config";
+import { FeishuClient } from "../../core/client";
+import { IntrospectionEngine } from "../../core/introspection";
+import { writeFile, mkdir } from "fs/promises";
+
+export async function initCommand(args: string[], cliOptions?: Partial<FeishuConfig>) {
+  const target = args[0];
+
+  // If no target provided, go straight to interactive mode
+  if (!target) {
+    await initInteractive(undefined, cliOptions);
+    return;
+  }
+
+  // Check if it's a Folder URL
+  if (target.includes("/drive/folder/")) {
+    console.warn("That looks like a Folder URL. Please provide a Base URL (多维表格).");
+    await initInteractive(undefined, cliOptions);
+    return;
+  }
+
+  const baseToken = extractBaseToken(target);
+  if (baseToken) {
+    await initInteractive(target, cliOptions);
+  } else {
+    // Treat as local path (scaffolding) - for now just log
+    console.log(`Initializing in local path: ${target}`);
+    // TODO: Implement local scaffolding logic if needed
+  }
+}
+
+async function initInteractive(initialTarget?: string, cliOptions?: Partial<FeishuConfig>) {
+  let baseToken: string | null = null;
+
+  if (initialTarget) {
+    baseToken = extractBaseToken(initialTarget);
+  }
+
+  while (!baseToken) {
+    const input = prompt("Please enter the Feishu Base URL (or Base Token): ");
+    
+    if (!input) {
+      console.error("Error: Base Token is required.");
+      process.exit(1);
+    }
+
+    baseToken = extractBaseToken(input);
+
+    if (!baseToken) {
+      console.error("Invalid input. Could not extract Base Token.");
+      console.log("To find your Base URL: Open the Base (多维表格) in your browser and copy the link. It usually looks like: https://.../base/basexxxxxx");
+    }
+  }
+
+  console.log(`Detected Base Token: ${baseToken}`);
+  await runIntrospection(baseToken, cliOptions);
+}
+
+async function runIntrospection(baseToken: string, cliOptions?: Partial<FeishuConfig>) {
+  // Load configuration
+  const config = await loadConfig(cliOptions);
+
+  // Get App Credentials
+  let appId = config.appId;
+  if (!appId) {
+    const input = prompt("Enter Feishu App ID:");
+    if (!input) {
+      console.error("Error: App ID is required.");
+      process.exit(1);
+    }
+    appId = input;
+  }
+
+  let appSecret = config.appSecret;
+  if (!appSecret) {
+    const input = prompt("Enter Feishu App Secret:");
+    if (!input) {
+      console.error("Error: App Secret is required.");
+      process.exit(1);
+    }
+    appSecret = input;
+  }
+
+  console.log("Fetching schema...");
+  
+  const client = new FeishuClient({
+    appId,
+    appSecret,
+  });
+
+  try {
+    const engine = new IntrospectionEngine(client);
+    const schema = await engine.introspect(baseToken, (msg) => console.log(msg));
+
+    await mkdir(".feishu_agent", { recursive: true });
+    await writeFile(".feishu_agent/schema.json", JSON.stringify(schema, null, 2));
+    console.log("Success! Schema saved to .feishu_agent/schema.json");
+
+    // Create .env if it doesn't exist
+    const envFile = Bun.file(".env");
+    if (!(await envFile.exists())) {
+        const envContent = `FEISHU_APP_ID=${appId}\nFEISHU_APP_SECRET=${appSecret}\n`;
+        await writeFile(".env", envContent);
+        console.log("Created .env file with credentials.");
+    } else {
+        console.log(".env file already exists, skipping creation.");
+    }
+
+  } catch (error) {
+    console.error("Failed to fetch schema:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function extractBaseToken(input: string): string | null {
+  // 1. Try to match URL pattern: .../base/<token>...
+  const urlMatch = input.match(/\/base\/([a-zA-Z0-9]+)/);
+  if (urlMatch) {
+    return urlMatch[1];
+  }
+
+  // 2. check if input itself looks like a token (starts with 'base' or 'app')
+  if (/^(base|app)[a-zA-Z0-9]+$/.test(input)) {
+    return input;
+  }
+
+  return null;
+}