@yektoo/cli 0.1.0

package/README.md

@@ -0,0 +1,361 @@
+# Yekto CLI & MCP Server
+
+Manage your [Yektoo](https://yektoo.com) customer support helpdesk from the terminal — or let AI agents do it for you.
+
+```
+npm install -g @yektoo/cli
+yektoo login
+yektoo inbox --status open
+```
+
+---
+
+## What's Included
+
+| Package | Purpose |
+|---|---|
+| **`@yektoo/cli`** | Terminal commands for managing your helpdesk |
+| **`@yektoo/mcp-server`** | MCP server that gives AI agents access to your helpdesk |
+
+Both packages share the same authentication — log in once with the CLI, and the MCP server uses the same session.
+
+---
+
+## Quick Start
+
+### 1. Install
+
+```bash
+# Install globally
+npm install -g @yektoo/cli
+
+# Or run without installing
+npx @yektoo/cli login
+```
+
+### 2. Log In
+
+```bash
+yektoo login
+# Enter your Yektooo email and password when prompted
+
+# Or non-interactive (for CI/scripts)
+yektoo login -e you@company.com -p yourpassword
+```
+
+### 3. Start Using
+
+```bash
+yektoo inbox                           # List all conversations
+yektoo inbox --status open             # Open tickets only
+yektoo read <email-id>                 # Read a conversation thread
+yektoo reply <email-id> "Your order has shipped!"
+yektoo close <email-id>                # Close the ticket
+```
+
+---
+
+## CLI Commands
+
+### Authentication
+
+| Command | Description |
+|---|---|
+| `yektoo login` | Log in with email and password (interactive) |
+| `yektoo login -e EMAIL -p PASS` | Log in non-interactively |
+| `yektoo logout` | Clear stored session |
+| `yektoo whoami` | Show current user and business |
+
+### Accounts
+
+| Command | Description |
+|---|---|
+| `yektoo email-accounts` | List connected IMAP / Outlook email accounts |
+| `yektoo shopify-accounts` | List Shopify stores and their linked email accounts |
+
+### Inbox & Conversations
+
+| Command | Description |
+|---|---|
+| `yektoo inbox` | List all conversations (newest first, 20 per page) |
+| `yektoo inbox --status open` | Filter by status: `open`, `resolved`, `pending` |
+| `yektoo inbox --store <id>` | Filter by email account |
+| `yektoo inbox --search "refund"` | Search by subject or sender |
+| `yektoo inbox --tag <id>` | Filter by tag (use `list-tags` to find IDs) |
+| `yektoo inbox --tag <id1> <id2>` | Filter by multiple tags (OR logic) |
+| `yektoo inbox --from 2026-03-01 --to 2026-03-31` | Filter by date range |
+| `yektoo inbox --page 2` | Go to page 2 |
+| `yektoo inbox --limit 50` | Show 50 results per page |
+| `yektoo open-tickets --store <id>` | Open tickets for a specific email account |
+| `yektoo read <email-id>` | Read full conversation thread (emails + replies + notes) |
+
+### Actions
+
+| Command | Description |
+|---|---|
+| `yektoo reply <email-id> "message"` | Send a reply (auto-routes to IMAP or Outlook) |
+| `yektoo reply-and-close <email-id> "message"` | Reply and close the ticket in one step |
+| `yektoo close <email-id>` | Close/resolve a ticket (entire thread) |
+| `yektoo open <email-id>` | Reopen a closed ticket |
+| `yektoo note <email-id> "internal note"` | Add an internal note (not visible to customer) |
+
+### Customer & Shopify
+
+| Command | Description |
+|---|---|
+| `yektoo customer <email>` | Look up a customer in Shopify — profile, orders, tracking |
+
+### Tags & Templates
+
+| Command | Description |
+|---|---|
+| `yektoo list-tags` | List all email tags (AI Auto Tags + custom) |
+| `yektoo list-templates` | List all reply templates |
+| `yektoo get-template <id>` | View full template content and detected variables |
+
+### Reports
+
+| Command | Description |
+|---|---|
+| `yektoo csat` | CSAT survey report (last 30 days) |
+| `yektoo csat --days 90` | CSAT report for last 90 days |
+
+### Help
+
+| Command | Description |
+|---|---|
+| `yektoo guide` | Detailed usage guide with examples |
+| `yektoo --help` | List all commands |
+| `yektoo <command> --help` | Help for a specific command |
+
+---
+
+## JSON Output
+
+Every command supports `--json` for machine-readable output:
+
+```bash
+# Pipe to jq
+yektoo --json inbox --status open | jq '.[].id'
+
+# Use in scripts
+OPEN_COUNT=$(yektoo --json inbox --status open | jq 'length')
+echo "You have $OPEN_COUNT open tickets"
+
+# Get customer data as JSON
+yektoo --json customer john@example.com
+```
+
+---
+
+## Examples
+
+### Daily workflow
+
+```bash
+# Check open tickets
+yektoo inbox --status open
+
+# Read a ticket
+yektoo read abc123-def456
+
+# Look up the customer
+yektoo customer jane@example.com
+
+# Reply and close
+yektoo reply-and-close abc123-def456 "Your refund has been processed. Have a great day!"
+```
+
+### Filter by tag
+
+```bash
+# List available tags
+yektoo list-tags
+
+# Show all refund-related conversations
+yektoo inbox --tag aeb5a381-fea0-444f-950e-e66b54559d42
+
+# Combine filters
+yektoo inbox --status open --tag <urgent-tag-id> --store <store-id>
+```
+
+### Use templates
+
+```bash
+# Browse templates
+yektoo list-templates
+
+# View a template's content
+yektoo get-template 3adcdc58-7df4-4480-b19a-8b7d6f881b8a
+
+# Use the template content in a reply
+yektoo reply <email-id> "$(yektoo --json get-template <template-id> | jq -r '.content')"
+```
+
+### Date range queries
+
+```bash
+# Last week's conversations
+yektoo inbox --from 2026-03-25 --to 2026-03-31
+
+# Open tickets from this month
+yektoo inbox --status open --from 2026-04-01
+```
+
+---
+
+## MCP Server for AI Agents
+
+The MCP server lets AI agents (Claude, Cursor, Windsurf, etc.) interact with your helpdesk using natural language.
+
+### Setup
+
+**Prerequisite:** Log in with the CLI first (one-time):
+
+```bash
+npx @yektoo/cli login
+```
+
+Then add the MCP server to your AI tool:
+
+#### Claude Desktop
+
+Edit `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "yektoo": {
+      "command": "npx",
+      "args": ["-y", "@yektoo/mcp-server"]
+    }
+  }
+}
+```
+
+#### Cursor
+
+Edit `.cursor/mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "yektoo": {
+      "command": "npx",
+      "args": ["-y", "@yektoo/mcp-server"]
+    }
+  }
+}
+```
+
+#### Claude Code (pi)
+
+Edit `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "yektoo": {
+      "command": "npx",
+      "args": ["-y", "@yektoo/mcp-server"]
+    }
+  }
+}
+```
+
+#### Windsurf
+
+Edit `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "yektoo": {
+      "command": "npx",
+      "args": ["-y", "@yektoo/mcp-server"]
+    }
+  }
+}
+```
+
+After adding the config, restart the AI tool. The Yektoo tools will be available immediately.
+
+### Available MCP Tools
+
+| Tool | Description | Parameters |
+|---|---|---|
+| `list_email_accounts` | Connected IMAP/Outlook accounts | — |
+| `list_shopify_accounts` | Shopify stores + linked email accounts | — |
+| `list_conversations` | Threaded inbox with filters | `store_id?`, `status?`, `search?`, `date_from?`, `date_to?`, `tag_ids?`, `limit?`, `page?` |
+| `list_open_tickets` | Open tickets for an email account | `store_id`, `search?`, `date_from?`, `date_to?`, `tag_ids?`, `limit?`, `page?` |
+| `read_thread` | Full conversation timeline | `email_id` |
+| `send_reply` | Send a reply to a customer | `email_id`, `content` |
+| `reply_and_close` | Reply and close in one step | `email_id`, `content` |
+| `close_ticket` | Resolve/close entire thread | `email_id` |
+| `reopen_ticket` | Reopen a closed ticket | `email_id` |
+| `add_note` | Add internal note (invisible to customer) | `email_id`, `content` |
+| `lookup_customer` | Shopify customer lookup | `customer_email` |
+| `list_tags` | Email tags (AI Auto Tags + custom) | — |
+| `list_templates` | Reply templates | — |
+| `get_template` | Full template content + variables | `template_id` |
+| `get_csat_report` | CSAT survey report | `days?` |
+
+### What AI Agents Can Do
+
+Once connected, you can ask your AI agent things like:
+
+- *"Show me all open tickets"*
+- *"Read the conversation with jane@example.com"*
+- *"Reply to this customer saying their order shipped with tracking number 123456"*
+- *"Close all resolved tickets tagged as 'refund'"*
+- *"Look up this customer's Shopify orders"*
+- *"What's our CSAT score this month?"*
+- *"Use the 'shipping delay' template to reply to this ticket"*
+
+---
+
+## Troubleshooting
+
+### "Not logged in"
+
+Run `yektoo login` to authenticate. Your session persists across terminal sessions.
+
+### "Session expired"
+
+Run `yektoo login` again to refresh your tokens.
+
+### "No business found"
+
+Your Yektoo account isn't associated with a business. Log in to [app.yektoo.com](https://app.yektoo.com) and complete the setup.
+
+### MCP server not showing tools
+
+1. Make sure you ran `npx @yektoo/cli login` first
+2. Restart your AI tool after editing the config
+3. Check that the config file path is correct for your OS
+
+### Reply not delivered
+
+Replies are queued and processed asynchronously (same as the web app). Check your Yektooo inbox in a few seconds — the reply will appear in the thread once delivered.
+
+---
+
+## Development
+
+```bash
+# CLI
+cd cli
+npm install
+npm run dev -- inbox --status open    # Run in dev mode
+
+# MCP Server
+cd mcp-server
+npm install
+npm run dev                           # Run in dev mode
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,733 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { createInterface } from "readline";
+
+// src/client.ts
+import { createClient } from "@supabase/supabase-js";
+import Conf from "conf";
+var SUPABASE_URL = "https://vjkofswgtffzyeuiainf.supabase.co";
+var SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZqa29mc3dndGZmenlldWlhaW5mIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDgwMDA3MzYsImV4cCI6MjA2MzU3NjczNn0.7SqqkSgvxF5zXz8Bdq1BzdNN0Hv_H9vty2aZsaz_T5s";
+var config = new Conf({
+  projectName: "yektoo-cli",
+  encryptionKey: "yektoo-cli-v1"
+  // conf encrypts values at rest with this key
+});
+var _client = null;
+function getClient() {
+  if (_client) return _client;
+  const accessToken = config.get("accessToken");
+  const refreshToken = config.get("refreshToken");
+  if (!accessToken || !refreshToken) {
+    throw new Error("Not logged in. Run `yektoo login` first.");
+  }
+  _client = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    auth: {
+      autoRefreshToken: true,
+      persistSession: false
+      // We manage persistence ourselves via conf
+    }
+  });
+  _client.auth.setSession({ access_token: accessToken, refresh_token: refreshToken });
+  return _client;
+}
+async function login(email, password) {
+  const client = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    auth: { autoRefreshToken: false, persistSession: false }
+  });
+  const { data, error } = await client.auth.signInWithPassword({ email, password });
+  if (error) throw new Error(`Login failed: ${error.message}`);
+  if (!data.session) throw new Error("Login failed: no session returned");
+  const { data: profile } = await client.from("user_profiles").select("business_id").eq("user_id", data.user.id).single();
+  config.set("accessToken", data.session.access_token);
+  config.set("refreshToken", data.session.refresh_token);
+  config.set("userId", data.user.id);
+  config.set("email", data.user.email || email);
+  config.set("businessId", profile?.business_id || void 0);
+  _client = null;
+  return { userId: data.user.id, email: data.user.email || email };
+}
+function logout() {
+  config.clear();
+  _client = null;
+}
+function getStoredUser() {
+  const userId = config.get("userId");
+  const email = config.get("email");
+  if (!userId || !email) return null;
+  return { userId, email, businessId: config.get("businessId") };
+}
+function getSupabaseUrl() {
+  return SUPABASE_URL;
+}
+async function getAuthHeader() {
+  const client = getClient();
+  const { data } = await client.auth.getSession();
+  if (!data.session?.access_token) throw new Error("Session expired. Run `yektoo login` again.");
+  return {
+    "Authorization": `Bearer ${data.session.access_token}`,
+    "Content-Type": "application/json",
+    "apikey": SUPABASE_ANON_KEY
+  };
+}
+
+// src/format.ts
+import chalk from "chalk";
+var _format = "table";
+function setOutputFormat(format) {
+  _format = format;
+}
+function getOutputFormat() {
+  return _format;
+}
+function printData(data, options) {
+  if (_format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (options?.title) {
+    console.log(chalk.bold(`
+${options.title}`));
+    console.log(chalk.gray("\u2500".repeat(60)));
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log(chalk.gray("  No results."));
+      return;
+    }
+    console.table(data);
+  } else {
+    for (const [key, value] of Object.entries(data)) {
+      console.log(`  ${chalk.gray(key + ":")} ${value}`);
+    }
+  }
+  console.log();
+}
+function printSuccess(message) {
+  if (_format === "json") {
+    console.log(JSON.stringify({ success: true, message }));
+  } else {
+    console.log(chalk.green("\u2713") + " " + message);
+  }
+}
+function printError(message) {
+  if (_format === "json") {
+    console.error(JSON.stringify({ success: false, error: message }));
+  } else {
+    console.error(chalk.red("\u2717") + " " + message);
+  }
+}
+function truncate(str, maxLen = 60) {
+  if (!str) return "";
+  const clean = str.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+  return clean.length > maxLen ? clean.slice(0, maxLen - 1) + "\u2026" : clean;
+}
+function formatDate(dateStr) {
+  if (!dateStr) return "";
+  const d = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - d.getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+  return d.toISOString().slice(0, 10);
+}
+
+// src/index.ts
+import chalk2 from "chalk";
+var program = new Command();
+program.name("yektoo").description("Yektoo CLI \u2014 manage your customer support helpdesk").version("0.1.0").option("--json", "Output as JSON (for piping and AI agents)").hook("preAction", (thisCommand) => {
+  if (thisCommand.opts().json) setOutputFormat("json");
+});
+program.command("login").description("Log in with your Yektoo account").option("-e, --email <email>", "Account email").option("-p, --password <password>", "Account password").action(async (opts) => {
+  try {
+    let email = opts.email;
+    let password = opts.password;
+    if (!email || !password) {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      const ask = (q, hidden = false) => new Promise((resolve) => {
+        if (hidden) {
+          process.stderr.write(q);
+          let input = "";
+          process.stdin.setRawMode?.(true);
+          process.stdin.resume();
+          process.stdin.setEncoding("utf8");
+          const onData = (ch) => {
+            if (ch === "\n" || ch === "\r") {
+              process.stdin.setRawMode?.(false);
+              process.stdin.removeListener("data", onData);
+              process.stderr.write("\n");
+              resolve(input);
+            } else if (ch === "\x7F" || ch === "\b") {
+              input = input.slice(0, -1);
+            } else if (ch === "") {
+              process.exit(0);
+            } else {
+              input += ch;
+            }
+          };
+          process.stdin.on("data", onData);
+        } else {
+          rl.question(q, (answer) => resolve(answer));
+        }
+      });
+      if (!email) email = await ask("Email: ");
+      if (!password) password = await ask("Password: ", true);
+      rl.close();
+    }
+    const result = await login(email, password);
+    printSuccess(`Logged in as ${result.email}`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out and clear stored session").action(() => {
+  logout();
+  printSuccess("Logged out");
+});
+program.command("whoami").description("Show current authenticated user").action(() => {
+  const user = getStoredUser();
+  if (!user) {
+    printError("Not logged in. Run `yektoo login` first.");
+    process.exit(1);
+  }
+  printData({ email: user.email, userId: user.userId, businessId: user.businessId || "(not set)" });
+});
+program.command("email-accounts").description("List connected email accounts (IMAP and Outlook)").action(async () => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user?.businessId) throw new Error("No business found. Please log in again.");
+    const { data, error } = await client.from("stores").select("id, name, email, platform, connection_method, connected").eq("business_id", user.businessId).order("name");
+    if (error) throw new Error(error.message);
+    const rows = (data || []).map((s) => ({
+      id: s.id,
+      name: s.name || "(unnamed)",
+      email: s.email,
+      type: s.connection_method === "imap" ? "IMAP" : s.platform === "imap" ? "IMAP" : "Outlook",
+      connected: s.connected ? "\u2713" : "\u2717"
+    }));
+    printData(rows, { title: "Email Accounts" });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("shopify-accounts").description("List connected Shopify stores and their linked email accounts").action(async () => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user?.businessId) throw new Error("No business found. Please log in again.");
+    const { data: shopifyStores, error } = await client.from("shopify_stores").select(`
+          id,
+          shop_domain,
+          created_at,
+          associated_email_store_id,
+          store:store_id ( id, name, connected )
+        `).order("created_at", { ascending: false });
+    if (error) throw new Error(error.message);
+    const rows = await Promise.all(
+      (shopifyStores || []).map(async (ss) => {
+        let linkedEmail = "(none)";
+        if (ss.associated_email_store_id) {
+          const { data: emailStore } = await client.from("stores").select("name, email").eq("id", ss.associated_email_store_id).single();
+          if (emailStore) {
+            linkedEmail = `${emailStore.name || ""} (${emailStore.email})`.trim();
+          }
+        }
+        return {
+          id: ss.id,
+          domain: ss.shop_domain,
+          name: ss.store?.name || "(unnamed)",
+          connected: ss.store?.connected ? "\u2713" : "\u2717",
+          linkedEmailAccount: linkedEmail
+        };
+      })
+    );
+    printData(rows, { title: "Shopify Accounts" });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("inbox").description("List conversations (threaded email view)").option("-s, --store <storeId>", "Filter by store ID").option("--status <status>", "Filter by status: open, resolved, pending", "all").option("-n, --limit <number>", "Number of results per page", "20").option("-p, --page <number>", "Page number", "1").option("--search <query>", "Search by subject or sender").option("--from <date>", "Filter from date (e.g. 2026-03-01)").option("--to <date>", "Filter to date (e.g. 2026-03-31)").option("--tag <tagIds...>", "Filter by tag ID(s) \u2014 use list-tags to find IDs").action(async (opts) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user?.businessId) throw new Error("No business found.");
+    const page = parseInt(opts.page) || 1;
+    const limit = parseInt(opts.limit) || 20;
+    const tags = opts.tag && opts.tag.length > 0 ? opts.tag : null;
+    const { data, error } = await client.rpc("get_threaded_emails_v5", {
+      p_user_id: user.userId,
+      p_store_filter: opts.store || "all",
+      p_status: opts.status || "all",
+      p_search: opts.search || "",
+      p_date_from: opts.from || null,
+      p_date_to: opts.to || null,
+      p_page: page,
+      p_page_size: limit,
+      p_sort_by: "date",
+      p_sort_order: "desc",
+      p_assigned_to: "all",
+      p_read_status: "all",
+      p_priority: null,
+      p_tags: tags,
+      p_folder_source: "inbox"
+    });
+    if (error) throw new Error(error.message);
+    const rows = (data || []).map((r) => ({
+      id: r.latest_email_id,
+      from: truncate(r.latest_email_from, 30),
+      subject: truncate(r.thread_subject || r.latest_email_subject, 45),
+      status: r.latest_email_status,
+      date: formatDate(r.latest_email_date),
+      msgs: r.thread_email_count,
+      unread: r.thread_has_unread ? "\u25CF" : ""
+    }));
+    const total = (data || []).length > 0 ? data[0].total_threads : 0;
+    const totalPages = Math.ceil(total / limit);
+    printData(rows, { title: `Inbox (page ${page}/${totalPages}, ${total} total)` });
+    if (page < totalPages) {
+      console.log(chalk2.gray(`  \u2192 Next page: yektoo inbox --page ${page + 1}${opts.store ? " --store " + opts.store : ""}${opts.status !== "all" ? " --status " + opts.status : ""}`));
+      console.log();
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("open-tickets").description("List open tickets for a specific email account").option("-s, --store <storeId>", "Filter by email account ID (required)").option("-n, --limit <number>", "Number of results per page", "20").option("-p, --page <number>", "Page number", "1").option("--search <query>", "Search by subject or sender").option("--from <date>", "Filter from date (e.g. 2026-03-01)").option("--to <date>", "Filter to date (e.g. 2026-03-31)").option("--tag <tagIds...>", "Filter by tag ID(s) \u2014 use list-tags to find IDs").action(async (opts) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user?.businessId) throw new Error("No business found.");
+    if (!opts.store) {
+      const { data: stores } = await client.from("stores").select("id, name, email").eq("business_id", user.businessId).eq("connected", true).order("name");
+      printError("Please specify an email account with --store <id>");
+      if (stores?.length) {
+        printData(
+          stores.map((s) => ({ id: s.id, name: s.name, email: s.email })),
+          { title: "Available email accounts" }
+        );
+      }
+      process.exit(1);
+    }
+    const tags = opts.tag && opts.tag.length > 0 ? opts.tag : null;
+    const { data, error } = await client.rpc("get_threaded_emails_v5", {
+      p_user_id: user.userId,
+      p_store_filter: opts.store,
+      p_status: "open",
+      p_search: opts.search || "",
+      p_date_from: opts.from || null,
+      p_date_to: opts.to || null,
+      p_page: parseInt(opts.page) || 1,
+      p_page_size: parseInt(opts.limit) || 20,
+      p_sort_by: "date",
+      p_sort_order: "desc",
+      p_assigned_to: "all",
+      p_read_status: "all",
+      p_priority: null,
+      p_tags: tags,
+      p_folder_source: "inbox"
+    });
+    if (error) throw new Error(error.message);
+    const rows = (data || []).map((r) => ({
+      id: r.latest_email_id,
+      from: truncate(r.latest_email_from, 30),
+      subject: truncate(r.thread_subject || r.latest_email_subject, 45),
+      date: formatDate(r.latest_email_date),
+      msgs: r.thread_email_count,
+      unread: r.thread_has_unread ? "\u25CF" : ""
+    }));
+    const page = parseInt(opts.page) || 1;
+    const limit = parseInt(opts.limit) || 20;
+    const total = (data || []).length > 0 ? data[0].total_threads : 0;
+    const totalPages = Math.ceil(total / limit);
+    printData(rows, { title: `Open Tickets (page ${page}/${totalPages}, ${total} total)` });
+    if (page < totalPages) {
+      console.log(chalk2.gray(`  \u2192 Next page: yektoo open-tickets --store ${opts.store} --page ${page + 1}`));
+      console.log();
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("read <emailId>").description("Read a conversation thread (emails + replies + notes)").action(async (emailId) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user) throw new Error("Not logged in.");
+    const { data: emailData, error: emailErr } = await client.from("emails").select("id, thread_id, subject, from, recipient, status, date").eq("id", emailId).single();
+    if (emailErr || !emailData) throw new Error("Email not found");
+    const { data, error } = await client.rpc("get_email_thread_complete", {
+      p_email_id: emailId,
+      p_user_id: user.userId,
+      p_thread_id: emailData.thread_id
+    });
+    if (error) throw new Error(error.message);
+    if (!data || data.length === 0) throw new Error("Thread not found");
+    const result = data[0];
+    const threadEmails = result.thread_emails || [];
+    const replies = result.replies || [];
+    const notes = result.notes || [];
+    const timeline = [
+      ...threadEmails.map((e) => ({
+        type: "email",
+        from: e.from,
+        date: e.date,
+        content: truncate(e.content, 200),
+        direction: e.direction
+      })),
+      ...replies.map((r) => ({
+        type: "reply",
+        from: r.from || "(agent)",
+        date: r.sent_at,
+        content: truncate(r.content, 200),
+        direction: "outbound"
+      })),
+      ...notes.map((n) => ({
+        type: "note",
+        from: "(internal)",
+        date: n.created_at,
+        content: truncate(n.content, 200),
+        direction: "internal"
+      }))
+    ].sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime());
+    printData(
+      {
+        id: emailData.id,
+        subject: emailData.subject,
+        status: emailData.status,
+        from: emailData.from,
+        date: emailData.date,
+        messages: timeline.length
+      },
+      { title: "Thread" }
+    );
+    printData(timeline, { title: "Timeline" });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("reply <emailId> <content>").description("Send a reply to a conversation").action(async (emailId, content) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user) throw new Error("Not logged in.");
+    const { data: email, error: emailErr } = await client.from("emails").select("id, store_id, stores(id, platform, connection_method, business_id, email)").eq("id", emailId).single();
+    if (emailErr || !email) throw new Error("Email not found");
+    const store = email.stores;
+    if (!store) throw new Error("Store not found for this email");
+    if (store.business_id !== user.businessId) throw new Error("Access denied: email does not belong to your business");
+    const isImap = store.platform === "imap" || store.connection_method === "imap";
+    const functionType = isImap ? "send-email-imap" : "send-email";
+    const { error: queueError } = await client.from("email_send_queue").insert({
+      business_id: store.business_id,
+      store_id: store.id,
+      user_id: user.userId,
+      function_type: functionType,
+      payload: {
+        emailId,
+        content,
+        attachments: [],
+        isScheduledSend: true,
+        originalUserId: user.userId
+      }
+    });
+    if (queueError) throw new Error(`Failed to queue reply: ${queueError.message}`);
+    printSuccess(`Reply queued for delivery via ${functionType}`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("close <emailId>").description("Resolve/close a ticket (closes entire thread)").action(async (emailId) => {
+  try {
+    const client = getClient();
+    const { data, error } = await client.rpc("mark_thread_resolved", {
+      p_email_id: emailId
+    });
+    if (error) throw new Error(error.message);
+    const result = data?.[0];
+    if (!result || result.updated_count === 0) throw new Error("Email not found or already resolved");
+    printSuccess(`Closed thread: ${result.updated_count} email(s) marked as resolved`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("open <emailId>").description("Reopen a ticket").action(async (emailId) => {
+  try {
+    const client = getClient();
+    const { error } = await client.from("emails").update({ status: "open" }).eq("id", emailId);
+    if (error) throw new Error(error.message);
+    printSuccess("Ticket reopened");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("reply-and-close <emailId> <content>").description("Send a reply and close the ticket in one step").action(async (emailId, content) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user) throw new Error("Not logged in.");
+    const { data: email, error: emailErr } = await client.from("emails").select("id, store_id, stores(id, platform, connection_method, business_id, email)").eq("id", emailId).single();
+    if (emailErr || !email) throw new Error("Email not found");
+    const store = email.stores;
+    if (!store) throw new Error("Store not found for this email");
+    if (store.business_id !== user.businessId) throw new Error("Access denied: email does not belong to your business");
+    const isImap = store.platform === "imap" || store.connection_method === "imap";
+    const functionType = isImap ? "send-email-imap" : "send-email";
+    const { error: queueError } = await client.from("email_send_queue").insert({
+      business_id: store.business_id,
+      store_id: store.id,
+      user_id: user.userId,
+      function_type: functionType,
+      payload: {
+        emailId,
+        content,
+        attachments: [],
+        isScheduledSend: true,
+        originalUserId: user.userId
+      }
+    });
+    if (queueError) throw new Error(`Failed to queue reply: ${queueError.message}`);
+    const { data: closeData, error: closeError } = await client.rpc("mark_thread_resolved", {
+      p_email_id: emailId
+    });
+    if (closeError) throw new Error(`Reply queued but close failed: ${closeError.message}`);
+    const result = closeData?.[0];
+    printSuccess(`Reply queued via ${functionType} and ticket closed (${result?.updated_count || 1} email(s) resolved)`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("note <emailId> <content>").description("Add an internal note to a conversation").action(async (emailId, content) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user) throw new Error("Not logged in.");
+    const { error } = await client.from("internal_notes").insert({
+      email_id: emailId,
+      user_id: user.userId,
+      content
+    });
+    if (error) throw new Error(error.message);
+    printSuccess("Internal note added");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("list-tags").description("List all email tags (AI Auto Tags and custom tags)").action(async () => {
+  try {
+    const client = getClient();
+    const { data, error } = await client.from("email_tags").select("id, name, color, description, tag_type, created_at").order("name");
+    if (error) throw new Error(error.message);
+    const rows = (data || []).map((t) => ({
+      id: t.id,
+      name: t.name,
+      type: t.tag_type || "custom",
+      color: t.color,
+      description: t.description || ""
+    }));
+    printData(rows, { title: `Tags (${rows.length})` });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("list-templates").description("List all reply templates").action(async () => {
+  try {
+    const client = getClient();
+    const { data, error } = await client.from("reply_templates").select("id, name, content, created_at").order("created_at", { ascending: false });
+    if (error) throw new Error(error.message);
+    const rows = (data || []).map((t) => ({
+      id: t.id,
+      name: t.name,
+      preview: truncate(t.content, 60),
+      created: formatDate(t.created_at)
+    }));
+    printData(rows, { title: `Reply Templates (${rows.length})` });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("get-template <templateId>").description("Get the full content of a reply template").action(async (templateId) => {
+  try {
+    const client = getClient();
+    const { data, error } = await client.from("reply_templates").select("id, name, content, created_at").eq("id", templateId).single();
+    if (error || !data) throw new Error("Template not found");
+    const plainContent = data.content.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\n{3,}/g, "\n\n").trim();
+    printData({
+      id: data.id,
+      name: data.name,
+      created: formatDate(data.created_at),
+      variables: (data.content.match(/\{\{[a-z_]+\}\}/gi) || []).join(", ") || "(none)"
+    }, { title: "Template" });
+    if (getOutputFormat() === "json") {
+      printData({ content: plainContent, html: data.content });
+    } else {
+      console.log(chalk2.gray("\u2500".repeat(60)));
+      console.log(plainContent);
+      console.log(chalk2.gray("\u2500".repeat(60)));
+      console.log();
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("customer <email>").description("Look up a customer in Shopify (orders, spend, tracking)").action(async (customerEmail) => {
+  try {
+    const headers = await getAuthHeader();
+    const url = `${getSupabaseUrl()}/functions/v1/shopify-lookup?email=${encodeURIComponent(customerEmail)}`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({}));
+      throw new Error(err.error || `HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.found || !data.stores?.length) {
+      printError(`No Shopify customer found for ${customerEmail}`);
+      process.exit(0);
+    }
+    for (const entry of data.stores) {
+      printData({
+        store: entry.store?.name || "(unknown)",
+        name: `${entry.customer?.firstName || ""} ${entry.customer?.lastName || ""}`.trim(),
+        email: entry.customer?.email,
+        phone: entry.customer?.phone || "(none)",
+        orders: entry.customer?.ordersCount,
+        totalSpent: entry.customer?.totalSpent
+      }, { title: `Customer \u2014 ${entry.store?.name || "Shopify"}` });
+      if (entry.orders?.length) {
+        const orderRows = entry.orders.slice(0, 5).map((o) => ({
+          order: `#${o.number}`,
+          date: formatDate(o.date),
+          total: o.totalPrice,
+          status: o.fulfillmentStatus || "unfulfilled",
+          tracking: o.tracking?.number || ""
+        }));
+        printData(orderRows, { title: "Recent Orders" });
+      }
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("csat").description("View CSAT survey report").option("-d, --days <number>", "Number of days to report on", "30").action(async (opts) => {
+  try {
+    const client = getClient();
+    const user = getStoredUser();
+    if (!user?.businessId) throw new Error("No business found.");
+    const { data, error } = await client.rpc("get_csat_report", {
+      p_business_id: user.businessId,
+      p_days: parseInt(opts.days) || 30
+    });
+    if (error) throw new Error(error.message);
+    if (!data) throw new Error("No CSAT data available");
+    const summary = data.summary;
+    printData({
+      avgRating: summary.avg_rating ? `${summary.avg_rating} / 5` : "\u2014",
+      responseRate: summary.response_rate != null ? `${summary.response_rate}%` : "\u2014",
+      sent: summary.total_sent,
+      responded: summary.total_responded,
+      distribution: `\u26051:${summary.distribution["1"]} \u26052:${summary.distribution["2"]} \u26053:${summary.distribution["3"]} \u26054:${summary.distribution["4"]} \u26055:${summary.distribution["5"]}`
+    }, { title: `CSAT Report (last ${opts.days} days)` });
+    if (data.by_agent?.length) {
+      const agentRows = data.by_agent.map((a) => ({
+        agent: a.agent_name,
+        avgRating: a.avg_rating ? a.avg_rating.toFixed(1) : "\u2014",
+        responded: `${a.responded}/${a.total_sent}`
+      }));
+      printData(agentRows, { title: "By Agent" });
+    }
+    if (data.recent?.length) {
+      const recentRows = data.recent.slice(0, 10).map((r) => ({
+        customer: truncate(r.customer_email, 30),
+        rating: "\u2605".repeat(r.rating),
+        comment: truncate(r.comment, 40) || "\u2014",
+        date: formatDate(r.responded_at)
+      }));
+      printData(recentRows, { title: "Recent Responses" });
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("guide").description("Show detailed usage guide with examples").action(() => {
+  const guide = `
+${chalk2.bold("Yektoo CLI \u2014 Customer Support Helpdesk")}
+${chalk2.gray("Manage your inbox, tickets, and customers from the terminal.")}
+
+${chalk2.bold.underline("Authentication")}
+  ${chalk2.cyan("yektoo login")}                              Log in with email and password
+  ${chalk2.cyan("yektoo login -e you@co.com -p pass")}        Non-interactive login
+  ${chalk2.cyan("yektoo logout")}                             Clear stored session
+  ${chalk2.cyan("yektoo whoami")}                             Show current user and business
+
+${chalk2.bold.underline("Accounts")}
+  ${chalk2.cyan("yektoo email-accounts")}                     List connected IMAP / Outlook accounts
+  ${chalk2.cyan("yektoo shopify-accounts")}                   List Shopify stores and linked email accounts
+
+${chalk2.bold.underline("Inbox & Conversations")}
+  ${chalk2.cyan("yektoo inbox")}                              List all conversations (newest first)
+  ${chalk2.cyan("yektoo inbox --status open")}                Only open tickets
+  ${chalk2.cyan("yektoo inbox --store <id> --limit 10")}      Filter by store, limit results
+  ${chalk2.cyan('yektoo inbox --search "refund"')}            Search by subject or sender
+  ${chalk2.cyan("yektoo open-tickets --store <id>")}          List open tickets for a specific email account
+  ${chalk2.cyan("yektoo read <email-id>")}                    Read full thread (emails + replies + notes)
+
+${chalk2.bold.underline("Actions")}
+  ${chalk2.cyan('yektoo reply <email-id> "message"')}         Send a reply (auto-routes IMAP vs Outlook)
+  ${chalk2.cyan('yektoo reply-and-close <email-id> "msg"')}   Reply and close the ticket in one step
+  ${chalk2.cyan("yektoo close <email-id>")}                   Close/resolve a ticket (entire thread)
+  ${chalk2.cyan("yektoo open <email-id>")}                    Reopen a closed ticket
+  ${chalk2.cyan('yektoo note <email-id> "internal note"')}    Add an internal note (not visible to customer)
+
+${chalk2.bold.underline("Customer & Shopify")}
+  ${chalk2.cyan("yektoo customer john@example.com")}          Look up Shopify customer, orders, tracking
+
+${chalk2.bold.underline("Templates")}
+  ${chalk2.cyan("yektoo list-templates")}                     List all reply templates
+  ${chalk2.cyan("yektoo get-template <id>")}                  View full template content and variables
+
+${chalk2.bold.underline("Reports")}
+  ${chalk2.cyan("yektoo csat")}                               CSAT survey report (last 30 days)
+  ${chalk2.cyan("yektoo csat --days 90")}                     CSAT report for last 90 days
+
+${chalk2.bold.underline("Options")}
+  ${chalk2.cyan("--json")}                                   Output as JSON (for piping to other tools / AI agents)
+  ${chalk2.cyan("--help")}                                   Show help for any command
+
+${chalk2.bold.underline("Examples")}
+  ${chalk2.gray("# View open tickets, then read and reply to one")}
+  ${chalk2.cyan("yektoo inbox --status open")}
+  ${chalk2.cyan("yektoo read abc123-def456")}
+  ${chalk2.cyan('yektoo reply abc123-def456 "Your order has shipped!"')}
+
+  ${chalk2.gray("# Look up a customer and close their ticket")}
+  ${chalk2.cyan("yektoo customer jane@example.com")}
+  ${chalk2.cyan('yektoo reply-and-close abc123 "Issue resolved. Your refund is on the way."')}
+
+  ${chalk2.gray("# Pipe JSON to jq for scripting")}
+  ${chalk2.cyan('yektoo --json inbox --status open | jq ".[].id"')}
+`;
+  console.log(guide);
+});
+program.parse();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@yektoo/cli",
+  "version": "0.1.0",
+  "description": "Yekto CLI — manage your customer support helpdesk from the terminal",
+  "type": "module",
+  "bin": {
+    "yektoo": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.49.0",
+    "commander": "^13.0.0",
+    "chalk": "^5.4.0",
+    "conf": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "yektoo",
+    "helpdesk",
+    "customer-support",
+    "cli",
+    "mcp"
+  ],
+  "license": "MIT"
+}