meetfy 1.0.1 → 1.0.3

package/README.md

@@ -1,158 +1,43 @@
-# Meetfy CLI
+<div align="center">
+  <h1>📆 meetfy</h1>
+  <h4>A CLI tool for creating instant meetings and reserving time in Google Calendar.</h4>
 
-A command-line tool for creating instant meetings and reserving 30 minutes in Google Calendar.
+  ![npm](https://img.shields.io/npm/v/meetfy) ![npm package minimized gzipped size (select exports)](https://img.shields.io/bundlejs/size/meetfy?color=green-light) ![npm](https://img.shields.io/npm/dw/meetfy)
 
-## Features
-
-- 🚀 Create instant meetings with Google Meet
-- 📅 Automatically reserve 30 minutes in your Google Calendar
-- 👥 Add participants via email
-- 🔐 Secure Google OAuth2 authentication
-- 💾 Persistent authentication tokens
-- 🎨 Beautiful CLI interface with colors and spinners
-
-## Installation
-
-1. Clone the repository:
-```bash
-git clone <repository-url>
-cd meetfy
-```
-
-2. Install dependencies:
-```bash
-npm install
-```
-
-3. Build the project:
-```bash
-npm run build
-```
+</div>
 
-4. Link globally (optional):
-```bash
-npm link
-```
-
-## Setup
-
-### 1. Google Calendar API Setup
-
-1. Go to [Google Cloud Console](https://console.cloud.google.com)
-2. Create a new project or select an existing one
-3. Enable the Google Calendar API:
-   - Go to "APIs & Services" → "Library"
-   - Search for "Google Calendar API"
-   - Click "Enable"
-4. Create OAuth 2.0 credentials:
-   - Go to "APIs & Services" → "Credentials"
-   - Click "Create Credentials" → "OAuth 2.0 Client IDs"
-   - Choose "Desktop application"
-   - Download the credentials file
-5. Rename the downloaded file to `credentials.json` and place it in the project root
-
-The `credentials.json` file should look like this:
-```json
-{
-  "installed": {
-    "client_id": "your-client-id.apps.googleusercontent.com",
-    "project_id": "your-project-id",
-    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-    "token_uri": "https://oauth2.googleapis.com/token",
-    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-    "client_secret": "your-client-secret",
-    "redirect_uris": ["http://localhost"]
-  }
-}
-```
-
-### 2. Authentication
-
-Run the authentication command:
-```bash
-npm run dev auth
-# or if linked globally:
-meetfy auth
-```
 
-Follow the authentication flow to authorize the application.
-
-## Usage
+## Features
+- 🎯 Create instant meetings and reserve time in Google Calendar.
+- 📝 Add participants to the meeting.
+- 🕒 Choose the duration of the meeting.
 
-### Create an Instant Meeting
 
-Basic usage:
-```bash
-npm run dev create
-# or if linked globally:
-meetfy create
-```
+## Install
 
-With options:
-```bash
-meetfy create -t "Team Standup" -d "Daily team sync" -p "john@example.com,jane@example.com"
+```sh
+npm i -g meetfy
 ```
 
-### Available Options
-
-- `-t, --title <title>`: Meeting title
-- `-d, --description <description>`: Meeting description
-- `-p, --participants <emails>`: Comma-separated list of participant emails
-
-### Authentication
+## Quickstart
 
-To authenticate or re-authenticate:
-```bash
-meetfy auth
+```sh
+npm i -g meetfy
+meetfy auth    # authenticate with Google Calendar
+meetfy create  # create a new meeting
+meetfy next    # show your next meeting
+meetfy logout  # log out
 ```
 
-## Development
+Use `--json` for machine-readable output (e.g. `meetfy --json next`).
 
-### Run in Development Mode
-```bash
-npm run dev
-```
-
-### Build for Production
-```bash
-npm run build
-```
+## Publishing (maintainers)
 
-### Run Built Version
-```bash
-npm start
+```sh
+pnpm run build   # build dist/index.js
+npm publish      # runs prepublishOnly (build) then publishes
 ```
 
-## Project Structure
-
-```
-src/
-├── features/
-│   ├── auth/
-│   │   └── authService.ts      # Google OAuth2 authentication
-│   └── meeting/
-│       └── meetingService.ts   # Meeting creation and calendar integration
-├── utils/
-│   └── cliUtils.ts            # CLI utilities and formatting
-└── index.ts                   # Main CLI entry point
-```
-
-## Features
-
-- **Instant Meeting Creation**: Creates meetings that start in 5 minutes
-- **30-Minute Duration**: Automatically sets 30-minute duration
-- **Google Meet Integration**: Includes Google Meet link in calendar events
-- **Participant Management**: Add participants via email addresses
-- **Calendar Reminders**: Sets up email and popup reminders
-- **Persistent Authentication**: Saves and reuses authentication tokens
-- **Interactive CLI**: User-friendly prompts and colorful output
-
-## Requirements
-
-- Node.js 18+
-- Google Calendar API access
-- Google OAuth2 credentials
-
 ## License
 
-ISC 
+MIT © [@eduardoborges](https://github.com/eduardoborges)

package/dist/index.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+
+
+// src/adapters/cli/index.ts
+import { Command } from "commander";
+
+// src/adapters/google/auth-adapter.ts
+import { google } from "googleapis";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// src/infrastructure/config.ts
+import Conf from "conf";
+function createConfig() {
+  return new Conf({
+    projectName: "meetfy",
+    configName: "meetfy-config"
+  });
+}
+
+// src/infrastructure/web-server.ts
+import express from "express";
+var HTML = `
+<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>Meetfy</title></head>
+<body style="font-family:system-ui;display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;margin:0;">
+  <h1>Meetfy</h1>
+  <p>You can close this window now.</p>
+</body>
+</html>`;
+function createCodeServer(port) {
+  return function getCode(onListening) {
+    const app = express();
+    return new Promise((resolve, reject) => {
+      app.get("/", (req, res) => {
+        const code = req.query.code;
+        if (code) {
+          resolve(code);
+          res.send(HTML);
+          server.close();
+        } else {
+          reject(new Error("No code in callback"));
+        }
+      });
+      const server = app.listen(port, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        onListening?.();
+      });
+    });
+  };
+}
+
+// src/adapters/google/auth-adapter.ts
+var SCOPES = [
+  "https://www.googleapis.com/auth/calendar",
+  "https://www.googleapis.com/auth/calendar.events"
+];
+var CREDENTIALS_PATH = join(process.cwd(), "credentials.json");
+function createGoogleAuthAdapter(redirectPort) {
+  const config = createConfig();
+  const getCodeServer = createCodeServer(redirectPort);
+  return {
+    async authenticate() {
+      try {
+        if (!existsSync(CREDENTIALS_PATH)) {
+          return { type: "no_credentials" };
+        }
+        const credentials = JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
+        const { client_secret: clientSecret, client_id: clientId } = credentials.installed || credentials.web;
+        const redirectUri = `http://localhost:${redirectPort}`;
+        const oAuth2Client = new google.auth.OAuth2(
+          clientId,
+          clientSecret,
+          redirectUri
+        );
+        const storedTokens = config.get("googleTokens");
+        if (storedTokens) {
+          oAuth2Client.setCredentials(storedTokens);
+          if (storedTokens.expiry_date && Date.now() > storedTokens.expiry_date) {
+            const { credentials: newTokens } = await oAuth2Client.refreshAccessToken();
+            oAuth2Client.setCredentials(newTokens);
+            config.set("googleTokens", newTokens);
+          }
+          return { type: "ok", client: oAuth2Client };
+        }
+        const authUrl = oAuth2Client.generateAuthUrl({
+          access_type: "offline",
+          scope: SCOPES
+        });
+        const fetchToken = async (callbacks) => {
+          try {
+            const code = await getCodeServer(callbacks.onWaiting);
+            const { tokens } = await oAuth2Client.getToken(code);
+            oAuth2Client.setCredentials(tokens);
+            config.set("googleTokens", tokens);
+            return oAuth2Client;
+          } catch {
+            return null;
+          }
+        };
+        return { type: "need_code", authUrl, fetchToken };
+      } catch {
+        return { type: "error", message: "Authentication failed" };
+      }
+    },
+    async logout() {
+      config.clear();
+    }
+  };
+}
+
+// src/adapters/google/calendar-adapter.ts
+import { google as google2 } from "googleapis";
+function createGoogleCalendarAdapter() {
+  return {
+    async createEvent(client, input) {
+      try {
+        const auth = client;
+        const calendar = google2.calendar({ version: "v3", auth });
+        const now = /* @__PURE__ */ new Date();
+        const startTime = new Date(now.getTime() + 5 * 60 * 1e3);
+        const endTime = new Date(startTime.getTime() + 30 * 60 * 1e3);
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const response = await calendar.events.insert({
+          calendarId: "primary",
+          requestBody: {
+            summary: input.title,
+            description: input.description,
+            start: { dateTime: startTime.toISOString(), timeZone: tz },
+            end: { dateTime: endTime.toISOString(), timeZone: tz },
+            attendees: input.participants.map((email) => ({ email: email.trim() })),
+            conferenceData: {
+              createRequest: {
+                requestId: `meetfy-${Date.now()}`,
+                conferenceSolutionKey: { type: "hangoutsMeet" }
+              }
+            },
+            reminders: {
+              useDefault: false,
+              overrides: [
+                { method: "email", minutes: 10 },
+                { method: "popup", minutes: 5 }
+              ]
+            }
+          },
+          conferenceDataVersion: 1,
+          sendUpdates: "all"
+        });
+        if (!response.data.id || !response.data.hangoutLink) return null;
+        return {
+          id: response.data.id,
+          title: input.title,
+          startTime: startTime.toLocaleString(),
+          endTime: endTime.toLocaleString(),
+          hangoutLink: response.data.hangoutLink
+        };
+      } catch {
+        return null;
+      }
+    },
+    async getNextEvent(client) {
+      try {
+        const auth = client;
+        const calendar = google2.calendar({ version: "v3", auth });
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const response = await calendar.events.list({
+          calendarId: "primary",
+          timeMin: now,
+          singleEvents: true,
+          orderBy: "startTime",
+          maxResults: 1
+        });
+        const event = response.data.items?.[0];
+        if (!event) return null;
+        const start = event.start?.dateTime || event.start?.date;
+        const end = event.end?.dateTime || event.end?.date;
+        if (!start || !end) return null;
+        return {
+          id: event.id ?? "",
+          title: event.summary ?? "Untitled",
+          startTime: new Date(start).toLocaleString(),
+          endTime: new Date(end).toLocaleString(),
+          hangoutLink: event.hangoutLink ?? void 0,
+          location: event.location ?? void 0
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/use-cases/authenticate.ts
+function makeAuthenticate(authGateway) {
+  return async function authenticate() {
+    return authGateway.authenticate();
+  };
+}
+
+// src/use-cases/logout.ts
+function makeLogout(authGateway) {
+  return async function logout() {
+    return authGateway.logout();
+  };
+}
+
+// src/use-cases/create-meeting.ts
+function makeCreateMeeting(authGateway, calendarGateway) {
+  return async function createMeeting(input) {
+    const auth = await authGateway.authenticate();
+    if (auth.type !== "ok") return null;
+    return calendarGateway.createEvent(auth.client, input);
+  };
+}
+
+// src/use-cases/get-next-meeting.ts
+function makeGetNextMeeting(authGateway, calendarGateway) {
+  return async function getNextMeeting() {
+    const auth = await authGateway.authenticate();
+    if (auth.type !== "ok") return null;
+    return calendarGateway.getNextEvent(auth.client);
+  };
+}
+
+// src/adapters/cli/format.ts
+var REDIRECT_URI = "http://localhost:3434";
+function formatWelcome() {
+  return [
+    "",
+    "  Meetfy \u2014 Instant Meeting Creator",
+    "  Create instant meetings and reserve time in Google Calendar",
+    ""
+  ].join("\n");
+}
+function formatMeeting(meeting) {
+  const lines = [
+    `  ${meeting.title}`,
+    `  \u{1F550} ${meeting.startTime} \u2013 ${meeting.endTime}`
+  ];
+  if (meeting.hangoutLink) lines.push(`  \u{1F517} ${meeting.hangoutLink}`);
+  if (meeting.location) lines.push(`  \u{1F4CD} ${meeting.location}`);
+  return lines.join("\n");
+}
+function formatAuthNoCredentials() {
+  return [
+    "\u26A0\uFE0F  Google Calendar credentials not found.",
+    "\u{1F4DD} Steps:",
+    "  1. Go to https://console.cloud.google.com",
+    "  2. Create/select project \u2192 Enable Google Calendar API",
+    "  3. Create OAuth 2.0 credentials (Web application)",
+    `  4. Add Authorized redirect URI: ${REDIRECT_URI}`,
+    "  5. Download credentials.json to project root",
+    "  6. Run: meetfy auth"
+  ].join("\n");
+}
+function formatAuthNeedCode(authUrl) {
+  return [
+    "\u{1F510} Authorize this app by visiting this URL:",
+    authUrl,
+    "",
+    "Press Enter to copy URL and open in browser."
+  ].join("\n");
+}
+function formatAuthWaiting() {
+  return "\u23F3 Waiting for code on port 3434...";
+}
+function formatAuthSuccess() {
+  return [
+    "\u2705 Authentication successful!",
+    "",
+    "Available commands:",
+    "  meetfy create   Create an instant meeting (30 min)",
+    "  meetfy next     Show your next meeting",
+    "  meetfy logout   Log out from Google"
+  ].join("\n");
+}
+function authErrorForJson(result) {
+  if (result.type === "no_credentials") return "no_credentials";
+  if (result.type === "error") return result.message;
+  return "auth_required";
+}
+
+// src/adapters/cli/prompts.ts
+import * as readline from "node:readline";
+function createReadlineInterface() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+function question(rl, prompt, defaultValue = "") {
+  return new Promise((resolve) => {
+    const p = defaultValue ? `${prompt} (${defaultValue}): ` : `${prompt}: `;
+    rl.question(p, (answer) => {
+      resolve(answer.trim() || defaultValue.trim());
+    });
+  });
+}
+function closeReadline(rl) {
+  rl.close();
+}
+
+// src/adapters/cli/browser.ts
+async function copyAndOpenUrl(url) {
+  const parts = [];
+  try {
+    const { default: clipboardy } = await import("clipboardy");
+    await clipboardy.write(url);
+    parts.push("URL copied to clipboard");
+  } catch {
+    parts.push("Could not copy");
+  }
+  try {
+    const open = (await import("open")).default;
+    await open(url);
+    parts.push("Opening in browser...");
+  } catch {
+    parts.push("Could not open browser");
+  }
+  return parts.join(". ");
+}
+
+// src/adapters/cli/index.ts
+var REDIRECT_PORT = 3434;
+function outputJson(obj) {
+  console.log(JSON.stringify(obj, null, 0));
+}
+function runCli() {
+  const authGateway = createGoogleAuthAdapter(REDIRECT_PORT);
+  const calendarGateway = createGoogleCalendarAdapter();
+  const authenticate = makeAuthenticate(authGateway);
+  const logout = makeLogout(authGateway);
+  const createMeeting = makeCreateMeeting(authGateway, calendarGateway);
+  const getNextMeeting = makeGetNextMeeting(authGateway, calendarGateway);
+  const program = new Command();
+  program.name("meetfy").description("CLI tool for creating instant meetings and reserving time in Google Calendar").version("1.0.0").option("--json", "Output result as JSON");
+  program.command("create").description("Create an instant meeting and reserve 30 minutes in your Google Calendar").option("-t, --title <title>", "Meeting title").option("-d, --description <description>", "Meeting description").option("-p, --participants <emails>", "Comma-separated list of participant emails").action(async (opts) => {
+    const json = program.opts().json;
+    if (json) {
+      const auth = await authenticate();
+      if (auth.type !== "ok") {
+        outputJson({ success: false, error: authErrorForJson(auth) });
+        process.exit(1);
+      }
+      const title2 = opts.title?.trim() || "Instant Meeting";
+      const description2 = opts.description?.trim() || "Instant meeting created via Meetfy CLI";
+      const participants2 = (opts.participants ?? "").split(",").map((e) => e.trim()).filter(Boolean);
+      const meeting2 = await createMeeting({ title: title2, description: description2, participants: participants2 });
+      if (meeting2) {
+        outputJson({ success: true, meeting: meeting2 });
+      } else {
+        outputJson({ success: false, error: "Failed to create meeting" });
+        process.exit(1);
+      }
+      return;
+    }
+    console.log(formatWelcome());
+    const rl = createReadlineInterface();
+    const title = opts.title?.trim() || await question(rl, "Meeting title", "Instant Meeting");
+    const description = opts.description?.trim() || await question(rl, "Meeting description", "Instant meeting created via Meetfy CLI");
+    const participantsStr = opts.participants ?? await question(rl, "Participant emails (comma-separated)", "");
+    closeReadline(rl);
+    const participants = participantsStr.split(",").map((e) => e.trim()).filter(Boolean);
+    console.log("\n\u23F3 Creating meeting...");
+    const meeting = await createMeeting({ title, description, participants });
+    if (meeting) {
+      console.log("\n\u2705 Meeting created successfully!");
+      console.log(`\u{1F4C5} ${meeting.title}`);
+      console.log(`\u{1F517} ${meeting.hangoutLink}`);
+      console.log(`\u23F0 ${meeting.startTime} \u2013 ${meeting.endTime}`);
+    } else {
+      console.error("\n\u274C Failed to create meeting. Run meetfy auth if needed.");
+      process.exit(1);
+    }
+  });
+  program.command("auth").description("Authenticate with Google Calendar").action(async () => {
+    const json = program.opts().json;
+    const auth = await authenticate();
+    if (json) {
+      if (auth.type === "ok") {
+        outputJson({ success: true });
+      } else if (auth.type === "need_code") {
+        outputJson({ success: false, authRequired: true, authUrl: auth.authUrl });
+        process.exit(1);
+      } else if (auth.type === "no_credentials") {
+        outputJson({ success: false, error: "no_credentials" });
+        process.exit(1);
+      } else {
+        outputJson({ success: false, error: auth.message });
+        process.exit(1);
+      }
+      return;
+    }
+    console.log(formatWelcome());
+    if (auth.type === "ok") {
+      console.log(formatAuthSuccess());
+      process.exit(0);
+    }
+    if (auth.type === "no_credentials") {
+      console.log(formatAuthNoCredentials());
+      process.exit(1);
+    }
+    if (auth.type === "error") {
+      console.error("\u274C", auth.message);
+      process.exit(1);
+    }
+    console.log(formatAuthNeedCode(auth.authUrl));
+    const rl = createReadlineInterface();
+    await new Promise((resolve) => {
+      rl.once("line", () => resolve());
+    });
+    await copyAndOpenUrl(auth.authUrl);
+    closeReadline(rl);
+    console.log("\n" + formatAuthWaiting());
+    const client = await auth.fetchToken({
+      onWaiting: () => {
+      }
+    });
+    if (client) {
+      console.log("\n" + formatAuthSuccess());
+    } else {
+      console.error("\n\u274C Failed to get token.");
+      process.exit(1);
+    }
+    process.exit(0);
+  });
+  program.command("logout").description("Logout from Google Calendar").action(async () => {
+    await logout();
+    if (program.opts().json) {
+      outputJson({ success: true });
+    } else {
+      console.log("\u2705 Logged out successfully!");
+    }
+  });
+  program.command("next").description("Show your next scheduled meeting").action(async () => {
+    const json = program.opts().json;
+    const meeting = await getNextMeeting();
+    if (json) {
+      const auth = await authenticate();
+      if (auth.type !== "ok") {
+        outputJson({ success: false, error: authErrorForJson(auth) });
+        process.exit(1);
+      }
+      outputJson({ success: true, meeting: meeting ?? null });
+      return;
+    }
+    console.log(formatWelcome());
+    if (!meeting) {
+      console.log("\u{1F4ED} No upcoming meetings found.");
+      return;
+    }
+    console.log("\u{1F4C5} Next meeting:\n");
+    console.log(formatMeeting(meeting));
+  });
+  program.parse();
+}
+
+// src/index.ts
+runCli();

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "meetfy",
-  "version": "1.0.1",
+  "version": "1.0.3",
+  "packageManager": "pnpm@10.31.0",
   "description": "CLI tool for creating instant meetings and reserving time in Google Calendar",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "meetfy": "./src/index.ts"
+    "meetfy": "./dist/index.js"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "dev": "tsx --no-deprecation src/index.ts",
-    "start": "tsx --no-deprecation src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "tsx src/index.ts",
+    "build": "node build.mjs",
+    "prepublishOnly": "pnpm run build",
     "lint": "eslint src/**/*.ts"
   },
+  "engines": {
+    "node": ">=18"
+  },
   "keywords": [
     "cli",
     "meeting",
@@ -22,30 +30,25 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "boxen": "^8.0.1",
-    "chalk": "^5.3.0",
+    "clipboardy": "^4.0.0",
     "commander": "^11.1.0",
     "conf": "^12.0.0",
     "express": "^5.1.0",
     "google-auth-library": "^9.0.0",
     "googleapis": "^128.0.0",
-    "inquirer": "^9.2.12",
-    "ora": "^7.0.1",
+    "open": "^10.2.0",
     "tsx": "^4.20.3",
     "typescript": "5.5"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",
-    "@types/inquirer": "^9.0.7",
     "@types/node": "^20.10.0",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
+    "esbuild": "^0.25.8",
     "eslint": "^8.57.1",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-typescript": "^18.0.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^4.6.2"
+    "eslint-plugin-import": "^2.32.0"
   }
-}
+}

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "extends": [
-    "airbnb-base",
-    "airbnb-typescript/base"
-  ],
-  "parserOptions": {
-    "project": "./tsconfig.json"
-  },
-  "rules": {
-    "import/prefer-default-export": "off",
-    "no-console": "off"
-  }
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const PORT_NUMBER = 3434;

package/src/index.ts

@@ -1,81 +0,0 @@
-#!/usr/bin/env tsx --no-deprecation
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { createInstantMeeting } from './services/meetingService.js';
-import { authenticateGoogle, logoutGoogle } from './services/authService.js';
-import { showWelcomeMessage } from './utils/cliUtils.js';
-
-const program = new Command();
-
-program
-  .name('meetfy')
-  .description('CLI tool for creating instant meetings and reserving time in Google Calendar')
-  .version('1.0.0');
-
-program
-  .command('create')
-  .description('Create an instant meeting and reserve 30 minutes in your Google Calendar')
-  .option('-t, --title <title>', 'Meeting title')
-  .option('-d, --description <description>', 'Meeting description')
-  .option('-p, --participants <emails>', 'Comma-separated list of participant emails')
-  .action(async (options) => {
-    try {
-      showWelcomeMessage();
-
-      // Authenticate with Google
-      const auth = await authenticateGoogle();
-      if (!auth) {
-        console.log(chalk.red('❌ Authentication failed. Please try again.'));
-        process.exit(1);
-      }
-
-      // Create instant meeting
-      const meeting = await createInstantMeeting(auth, options);
-
-      if (meeting) {
-        console.log(chalk.green('✅ Meeting created successfully!'));
-        console.log(chalk.cyan(`📅 Meeting ID: ${meeting.id}`));
-        console.log(chalk.cyan(`🔗 Join URL: ${meeting.hangoutLink}`));
-        console.log(chalk.cyan('⏰ Duration: 30 minutes'));
-        console.log(chalk.cyan(`📅 Start Time: ${meeting.startTime}`));
-      }
-    } catch (error) {
-      console.error(chalk.red('❌ Error creating meeting:'), error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('auth')
-  .description('Authenticate with Google Calendar')
-  .addHelpText('after', `
-    \nExamples:
-    \n  meetfy auth
-    \n  meetfy auth --help
-  `)
-  .action(async () => {
-    try {
-      showWelcomeMessage();
-      const auth = await authenticateGoogle();
-      if (auth) {
-        console.log(chalk.green('✅ Authentication successful!'));
-      } else {
-        console.log(chalk.red('❌ Authentication failed.'));
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(chalk.red('❌ Authentication error:'), error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('logout')
-  .description('Logout from Google Calendar')
-  .action(async () => {
-    await logoutGoogle();
-    console.log(chalk.green('✅ Logged out successfully!'));
-  });
-
-program.parse();

package/src/resources/index.html

@@ -1,50 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Document</title>
-  <style>
-    .container {
-      display: flex;
-      flex-direction: column;
-      height: 100vh;
-    }
-    .header {
-      background-color: #f00;
-      height: 100px;
-    }
-    .content {
-      display: grid;
-      grid-template-columns: 1fr;
-    }
-    .left {
-      background-color: #0f0;
-    }
-    .right {
-      background-color: #00f;
-    }
-    
-    @media (min-width: 768px) {
-      .content {
-        grid-template-columns: 300px 1fr;
-      }
-    }
-  </style>
-</head>
-<body>
-  <div class="container">
-    <div class="header">
-      <h1>Header</h1>
-    </div>
-    <div class="content">
-      <div class="left">
-        <h1>Left</h1>
-      </div>
-      <div class="right">
-        <h1>Right</h1>
-      </div>
-    </div>
-  </div>
-</body>
-</html>

package/src/services/authService.ts

@@ -1,104 +0,0 @@
-import { google } from 'googleapis';
-import { OAuth2Client } from 'google-auth-library';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-import config from './configService.js';
-import { getCodeServer } from './webServer.js';
-import { PORT_NUMBER } from '../constants.js';
-
-const SCOPES = [
-  'https://www.googleapis.com/auth/calendar',
-  'https://www.googleapis.com/auth/calendar.events',
-];
-
-const CREDENTIALS_PATH = join(process.cwd(), 'credentials.json');
-const REDIRECT_URI = `http://localhost:${PORT_NUMBER}/`;
-
-interface AuthTokens {
-  access_token: string;
-  refresh_token: string;
-  scope: string;
-  token_type: string;
-  expiry_date: number;
-}
-
-const getNewTokens = async (oAuth2Client: OAuth2Client): Promise<OAuth2Client | null> => {
-  try {
-    const authUrl = oAuth2Client.generateAuthUrl({
-      access_type: 'offline',
-      scope: SCOPES,
-    });
-
-    console.log(chalk.cyan('🔐 Authorize this app by visiting this url:'), chalk.blue(authUrl));
-
-    const code = await getCodeServer();
-
-    const { tokens } = await oAuth2Client.getToken(code);
-    oAuth2Client.setCredentials(tokens);
-
-    // Store tokens
-    config.set('googleTokens', tokens);
-
-    return oAuth2Client;
-  } catch (error) {
-    console.error(chalk.red('❌ Error getting tokens:'), error);
-    return null;
-  }
-};
-
-export const authenticateGoogle = async (): Promise<OAuth2Client | null> => {
-  try {
-    // Check if credentials file exists
-    if (!existsSync(CREDENTIALS_PATH)) {
-      console.log(chalk.yellow('⚠️  Google Calendar credentials not found.'));
-      console.log(chalk.cyan('📝 Please follow these steps:'));
-      console.log(chalk.cyan('1. Go to https://console.cloud.google.com'));
-      console.log(chalk.cyan('2. Create a new project or select existing one'));
-      console.log(chalk.cyan('3. Enable Google Calendar API'));
-      console.log(chalk.cyan('4. Create OAuth 2.0 credentials'));
-      console.log(chalk.cyan('5. Download credentials.json and place it in the project root'));
-      console.log(chalk.cyan('6. Run: meetfy auth'));
-      return null;
-    }
-
-    const credentials = JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf-8'));
-    const {
-      client_secret: clientSecret,
-      client_id: clientId,
-    } = credentials.installed || credentials.web;
-
-    const oAuth2Client = new google.auth.OAuth2(
-      clientId,
-      clientSecret,
-      REDIRECT_URI,
-    );
-
-    // Check if we have stored tokens
-    const storedTokens = config.get('googleTokens') as AuthTokens | undefined;
-
-    if (storedTokens) {
-      oAuth2Client.setCredentials(storedTokens);
-
-      // Check if token is expired
-      if (storedTokens.expiry_date && Date.now() > storedTokens.expiry_date) {
-        console.log(chalk.yellow('🔄 Token expired, refreshing...'));
-        const { credentials: newTokens } = await oAuth2Client.refreshAccessToken();
-        oAuth2Client.setCredentials(newTokens);
-        config.set('googleTokens', newTokens);
-      }
-
-      return oAuth2Client;
-    }
-
-    // Get new tokens
-    return await getNewTokens(oAuth2Client);
-  } catch (error) {
-    console.error(chalk.red('❌ Authentication error:'), error);
-    return null;
-  }
-};
-
-export const logoutGoogle = async () => {
-  config.clear();
-};

package/src/services/configService.ts

@@ -1,8 +0,0 @@
-import Conf from 'conf';
-
-const config = new Conf<any>({
-  projectName: 'meetfy',
-  configName: 'meetfy-config',
-});
-
-export default config;

package/src/services/meetingService.ts

@@ -1,139 +0,0 @@
-import { google } from 'googleapis';
-import { OAuth2Client } from 'google-auth-library';
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import ora from 'ora';
-
-interface MeetingOptions {
-  title?: string;
-  description?: string;
-  participants?: string;
-}
-
-interface MeetingResult {
-  id: string;
-  hangoutLink: string;
-  startTime: string;
-  endTime: string;
-  title: string;
-}
-
-const getMeetingDetails = async (options: MeetingOptions) => {
-  const questions = [];
-
-  if (!options.title) {
-    questions.push({
-      type: 'input',
-      name: 'title',
-      message: 'Meeting title:',
-      default: 'Instant Meeting',
-      validate: (input: string) => {
-        if (!input.trim()) {
-          return 'Please enter a meeting title';
-        }
-        return true;
-      },
-    });
-  }
-
-  if (!options.description) {
-    questions.push({
-      type: 'input',
-      name: 'description',
-      message: 'Meeting description (optional):',
-      default: 'Instant meeting created via Meetfy CLI',
-    });
-  }
-
-  if (!options.participants) {
-    questions.push({
-      type: 'input',
-      name: 'participants',
-      message: 'Participant emails (comma-separated, optional):',
-      default: '',
-    });
-  }
-
-  const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
-
-  return {
-    title: options.title || answers.title,
-    description: options.description || answers.description,
-    participants: (options.participants || answers.participants || '')
-      .split(',')
-      .filter((email: string) => email.trim() !== ''),
-  };
-};
-
-export const createInstantMeeting = async (
-  auth: OAuth2Client,
-  options: MeetingOptions,
-): Promise<MeetingResult | null> => {
-  try {
-    const calendar = google.calendar({ version: 'v3', auth });
-
-    // Get meeting details from user if not provided
-    const meetingDetails = await getMeetingDetails(options);
-
-    // Calculate meeting times (30 minutes from now)
-    const now = new Date();
-    const startTime = new Date(now.getTime() + 5 * 60 * 1000); // Start in 5 minutes
-    const endTime = new Date(startTime.getTime() + 30 * 60 * 1000); // 30 minutes duration
-
-    const spinner = ora('Creating meeting and reserving calendar...').start();
-
-    // Create calendar event
-    const event = {
-      summary: meetingDetails.title,
-      description: meetingDetails.description,
-      start: {
-        dateTime: startTime.toISOString(),
-        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      },
-      end: {
-        dateTime: endTime.toISOString(),
-        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      },
-      attendees: meetingDetails.participants.map((email: string) => ({ email: email.trim() })),
-      conferenceData: {
-        createRequest: {
-          requestId: `meetfy-${Date.now()}`,
-          conferenceSolutionKey: {
-            type: 'hangoutsMeet',
-          },
-        },
-      },
-      reminders: {
-        useDefault: false,
-        overrides: [
-          { method: 'email', minutes: 10 },
-          { method: 'popup', minutes: 5 },
-        ],
-      },
-    };
-
-    const response = await calendar.events.insert({
-      calendarId: 'primary',
-      requestBody: event,
-      conferenceDataVersion: 1,
-      sendUpdates: 'all',
-    });
-
-    spinner.succeed('Meeting created successfully!');
-
-    if (!response.data.id || !response.data.hangoutLink) {
-      throw new Error('Failed to create meeting with Google Meet link');
-    }
-
-    return {
-      id: response.data.id,
-      hangoutLink: response.data.hangoutLink,
-      startTime: startTime.toLocaleString(),
-      endTime: endTime.toLocaleString(),
-      title: meetingDetails.title,
-    };
-  } catch (error) {
-    console.error(chalk.red('❌ Error creating meeting:'), error);
-    return null;
-  }
-};

package/src/services/webServer.ts

@@ -1,54 +0,0 @@
-import http from 'node:http';
-import express, { Request, Response } from 'express';
-import chalk from 'chalk';
-import { PORT_NUMBER } from '../constants.js';
-
-const server = express();
-
-export const getCodeServer = async (): Promise<string> => new Promise<string>((resolve, reject) => {
-  let instance: http.Server;
-
-  server.get('/', (req: Request, res: Response) => {
-    console.log(req.query);
-
-    const { code } = req.query;
-    if (code) {
-      resolve(code as string);
-      res.send(`
-        <html>
-          <style>
-            body {
-              display: flex;
-              flex-direction: column;
-              align-items: center;
-              justify-content: center;
-              height: 100vh;
-              background-color: #f0f0f0;
-              font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-            }
-            h1 {
-              color: #000;
-            }
-            p {
-              color: #000;
-            }
-          </style>
-          <body>
-            <h1>Meetfy</h1>
-            <p>You can close this window now.</p>
-          </body>  
-        </html>
-      `);
-      instance.close();
-    } else {
-      reject(new Error('No code found'));
-    }
-  });
-
-  instance = server.listen(PORT_NUMBER, (error) => {
-    console.log(chalk.cyan(`🔐 Waiting for code on port ${PORT_NUMBER}...`));
-    if (error) {
-      console.error(error);
-    }
-  });
-});

package/src/utils/cliUtils.ts

@@ -1,14 +0,0 @@
-import boxen from 'boxen';
-import chalk from 'chalk';
-
-export const showWelcomeMessage = (): void => {
-  console.log(boxen('Meetfy', {
-    padding: 1,
-    margin: 0,
-    width: 40,
-    title: 'Instant Meeting Creator',
-    titleAlignment: 'center',
-    textAlignment: 'center',
-  }));
-  console.log(chalk.gray('Create instant meetings and reserve time in Google Calendar\n'));
-};

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "node16",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}