vslides 1.0.4 → 1.0.6

package/README.md

@@ -0,0 +1,340 @@
+# vslides CLI
+
+Command-line interface for creating and managing Vercel Slides presentations.
+
+## Installation
+
+```bash
+npm install -g vslides
+```
+
+Or run directly with npx:
+
+```bash
+npx vslides <command>
+```
+
+## Quick Start
+
+```bash
+# First time: Login to save credentials (valid for 7 days)
+vslides login
+
+# Create a new presentation
+vslides init
+
+# Wait for sandbox to be ready
+vslides check --wait
+
+# Edit slides.md, then push changes
+vslides push
+
+# Open preview in browser
+vslides preview --open
+```
+
+## Authentication
+
+The CLI uses persistent authentication so you don't need to re-authenticate for every new presentation.
+
+### Commands
+
+#### `vslides login`
+
+Authenticate with your Vercel account. Opens a browser for OAuth authentication. Credentials are cached locally and valid for 7 days.
+
+```bash
+vslides login
+# Opens browser for Vercel OAuth
+# Credentials saved to ~/.vslides/auth.json
+```
+
+#### `vslides logout`
+
+Sign out and revoke your cached credentials.
+
+```bash
+vslides logout
+```
+
+#### `vslides whoami`
+
+Show your current authentication status.
+
+```bash
+vslides whoami
+# Output: Logged in as user@vercel.com
+#         Expires: 2/4/2026 (7 days remaining)
+
+# Validate token with server
+vslides whoami --validate
+```
+
+### How Authentication Works
+
+1. **First-time setup**: Run `vslides login` to authenticate via Vercel OAuth
+2. **Credentials cached**: Token stored in `~/.vslides/auth.json` (valid for 7 days)
+3. **Automatic use**: `vslides init` uses cached credentials to skip OAuth flow
+4. **Expiration**: After 7 days, run `vslides login` again
+
+### Security
+
+- Credentials stored in `~/.vslides/auth.json` with restricted permissions (600)
+- Directory `~/.vslides/` created with mode 700
+- Tokens can be revoked server-side via `vslides logout`
+- Only @vercel.com email addresses are authorized
+
+## Session Management
+
+#### `vslides init`
+
+Create a new presentation session. If you're logged in, the session is created immediately without OAuth. Otherwise, you'll need to authenticate in the browser.
+
+```bash
+vslides init
+# If logged in: Creates authenticated session immediately
+# If not logged in: Provides AUTH_URL for browser authentication
+```
+
+**Output files created:**
+- `.vslides.json` - Session configuration (do not commit)
+- `.vslides-guide.md` - Layout reference guide
+- `slides.md` - Your presentation (starter template if none exists)
+
+#### `vslides check`
+
+Check session status. Use `--wait` to poll until the sandbox is ready.
+
+```bash
+# Check current status
+vslides check
+
+# Wait for sandbox to be ready (60s timeout)
+vslides check --wait
+
+# Run in background
+vslides check --wait &
+```
+
+#### `vslides preview`
+
+Show or open the preview URL.
+
+```bash
+# Print preview URL
+vslides preview
+
+# Open in browser
+vslides preview --open
+```
+
+## Content Management
+
+#### `vslides push`
+
+Upload your local `slides.md` to the server.
+
+```bash
+# Push changes
+vslides push
+
+# Force push (bypass version check)
+vslides push --force
+```
+
+#### `vslides get`
+
+Download the current slides from the server.
+
+```bash
+vslides get
+```
+
+#### `vslides sync`
+
+Smart bidirectional sync. Checks for remote changes before pushing.
+
+```bash
+vslides sync
+```
+
+#### `vslides guide`
+
+Print the slide layout guide.
+
+```bash
+# Print cached guide
+vslides guide
+
+# Force refresh from server
+vslides guide --refresh
+```
+
+## Collaboration
+
+#### `vslides share`
+
+Get a join URL for collaborators.
+
+```bash
+vslides share
+# Output: JOIN_URL: https://...
+```
+
+#### `vslides join <url>`
+
+Join a shared session.
+
+```bash
+vslides join https://slidev-server.vercel.app/join/abc123
+```
+
+## Assets
+
+#### `vslides upload <file>`
+
+Upload an image or media file.
+
+```bash
+vslides upload logo.png
+# Output: Use in slides as:
+#   image: /assets/logo.png
+```
+
+Supported formats: `.jpg`, `.jpeg`, `.png`, `.gif`, `.svg`, `.webp`, `.ico`
+
+## Export
+
+#### `vslides export <format>`
+
+Export presentation to PDF or PPTX.
+
+```bash
+vslides export pdf
+vslides export pptx
+```
+
+## Version History
+
+#### `vslides history`
+
+List saved versions.
+
+```bash
+vslides history
+# Output:
+# VERSION  TIMESTAMP
+# 3        2026-01-28 10:30:00
+# 2        2026-01-28 10:15:00
+# 1        2026-01-28 10:00:00
+```
+
+#### `vslides revert <version>`
+
+Revert to a previous version.
+
+```bash
+vslides revert 2
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `VSLIDES_API_URL` | API server URL | `https://slidev-server.vercel.app` |
+
+### Files
+
+| File | Location | Description |
+|------|----------|-------------|
+| `auth.json` | `~/.vslides/` | Cached authentication credentials |
+| `.vslides.json` | Project directory | Session configuration |
+| `.vslides-guide.md` | Project directory | Layout reference guide |
+| `slides.md` | Project directory | Your presentation |
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | Conflict (version mismatch, not running) |
+| 2 | Authentication required |
+| 3 | Network error |
+| 4 | Validation error |
+
+## Troubleshooting
+
+### "Session expired" error
+
+Your authentication has expired. Run:
+
+```bash
+vslides login
+vslides init
+```
+
+### "Not authenticated" error
+
+You need to complete the OAuth flow:
+
+```bash
+vslides check --wait &
+# Open AUTH_URL in browser and authenticate
+```
+
+### Version conflict
+
+Another collaborator pushed changes. Run:
+
+```bash
+vslides get
+# Review changes in slides.md
+vslides push
+```
+
+Or use sync for automatic handling:
+
+```bash
+vslides sync
+```
+
+### Sandbox timeout
+
+Sessions expire after 45 minutes of inactivity. Create a new session:
+
+```bash
+rm .vslides.json
+vslides init
+```
+
+## Slide Format
+
+Slides use Markdown with YAML frontmatter:
+
+```markdown
+---
+title: My Presentation
+---
+
+---
+layout: 1-title
+variant: title
+---
+
+# Welcome
+
+Your presentation starts here
+
+---
+layout: 2-statement
+variant: large
+---
+
+# Make a Statement
+
+This is where your content goes
+```
+
+Run `vslides guide` for the complete layout reference.

package/dist/cli.js

@@ -3074,6 +3074,65 @@ var {
   Help
 } = import_index.default;
 
+// src/lib/errors.ts
+var AuthExpiredError = class extends Error {
+  constructor(message = "Session expired. Please run `vslides login` to re-authenticate.") {
+    super(message);
+    this.name = "AuthExpiredError";
+  }
+};
+
+// src/lib/cli-auth.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_os = require("node:os");
+var AUTH_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".vslides");
+var AUTH_FILE = (0, import_node_path.join)(AUTH_DIR, "auth.json");
+function ensureAuthDir() {
+  if (!(0, import_node_fs.existsSync)(AUTH_DIR)) {
+    (0, import_node_fs.mkdirSync)(AUTH_DIR, { mode: 448 });
+  }
+}
+function getCachedAuth() {
+  if (!(0, import_node_fs.existsSync)(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs.readFileSync)(AUTH_FILE, "utf-8");
+    const auth = JSON.parse(content);
+    if (auth.version !== 1 || !auth.token || !auth.email || !auth.expiresAt) {
+      return null;
+    }
+    return auth;
+  } catch {
+    return null;
+  }
+}
+function isAuthValid(auth) {
+  return Date.now() < auth.expiresAt - 5 * 60 * 1e3;
+}
+function saveCLIAuth(token, email, expiresAt) {
+  ensureAuthDir();
+  const auth = {
+    version: 1,
+    token,
+    email,
+    expiresAt
+  };
+  (0, import_node_fs.writeFileSync)(AUTH_FILE, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
+  (0, import_node_fs.chmodSync)(AUTH_FILE, 384);
+}
+function clearCLIAuth() {
+  if ((0, import_node_fs.existsSync)(AUTH_FILE)) {
+    try {
+      (0, import_node_fs.writeFileSync)(AUTH_FILE, "{}");
+      const { unlinkSync } = require("node:fs");
+      unlinkSync(AUTH_FILE);
+    } catch {
+    }
+  }
+}
+
 // src/lib/api.ts
 var DEFAULT_URL = "https://slidev-server.vercel.app";
 var BASE_URL = process.env.VSLIDES_API_URL || DEFAULT_URL;
@@ -3086,7 +3145,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function request(path, options = {}) {
-  const { method = "GET", headers = {}, body } = options;
+  const { method = "GET", headers = {}, body, skipAuthCheck = false } = options;
   for (let i = 0; i < MAX_RETRIES; i++) {
     const response = await fetch(BASE_URL + path, {
       method,
@@ -3100,6 +3159,10 @@ async function request(path, options = {}) {
       await sleep(RETRY_DELAY);
       continue;
     }
+    if (response.status === 401 && !skipAuthCheck) {
+      clearCLIAuth();
+      throw new AuthExpiredError();
+    }
     let data;
     const contentType = response.headers.get("content-type") || "";
     if (contentType.includes("application/json")) {
@@ -3111,10 +3174,16 @@ async function request(path, options = {}) {
   }
   throw new Error("Sandbox failed to wake up after 5 minutes");
 }
-async function createSession() {
+async function createSession(options = {}) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.cliAuthToken) {
+    headers["X-CLI-Auth-Token"] = options.cliAuthToken;
+  }
   return request("/api/session", {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers,
     body: JSON.stringify({})
   });
 }
@@ -3184,6 +3253,10 @@ async function exportSlides(slug, token, format) {
       "X-Session-Token": token
     }
   });
+  if (response.status === 401) {
+    clearCLIAuth();
+    throw new AuthExpiredError();
+  }
   if (!response.ok) {
     const text = await response.text();
     return {
@@ -3231,34 +3304,52 @@ async function revertToVersion(slug, token, version) {
     body: JSON.stringify({ version })
   });
 }
+async function validateCLIAuth(token) {
+  return request("/api/auth/cli/validate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token }),
+    skipAuthCheck: true
+    // Don't clear auth on validation failure
+  });
+}
+async function revokeCLIAuth(token) {
+  return request("/api/auth/cli/revoke", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token }),
+    skipAuthCheck: true
+    // Don't clear auth on revoke failure
+  });
+}
 
 // src/lib/config.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 var CONFIG_FILE = ".vslides.json";
 var GUIDE_FILE = ".vslides-guide.md";
 var SLIDES_FILE = "slides.md";
 var UPSTREAM_FILE = "upstream.md";
 var GUIDE_CACHE_TTL = 24 * 60 * 60 * 1e3;
 function getConfigPath() {
-  return (0, import_node_path.join)(process.cwd(), CONFIG_FILE);
+  return (0, import_node_path2.join)(process.cwd(), CONFIG_FILE);
 }
 function getGuidePath() {
-  return (0, import_node_path.join)(process.cwd(), GUIDE_FILE);
+  return (0, import_node_path2.join)(process.cwd(), GUIDE_FILE);
 }
 function getSlidesPath() {
-  return (0, import_node_path.join)(process.cwd(), SLIDES_FILE);
+  return (0, import_node_path2.join)(process.cwd(), SLIDES_FILE);
 }
 function getUpstreamPath() {
-  return (0, import_node_path.join)(process.cwd(), UPSTREAM_FILE);
+  return (0, import_node_path2.join)(process.cwd(), UPSTREAM_FILE);
 }
 function readConfig() {
   const path = getConfigPath();
-  if (!(0, import_node_fs.existsSync)(path)) {
+  if (!(0, import_node_fs2.existsSync)(path)) {
     return null;
   }
   try {
-    const content = (0, import_node_fs.readFileSync)(path, "utf-8");
+    const content = (0, import_node_fs2.readFileSync)(path, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3266,7 +3357,7 @@ function readConfig() {
 }
 function writeConfig(config) {
   const path = getConfigPath();
-  (0, import_node_fs.writeFileSync)(path, JSON.stringify(config, null, 2) + "\n");
+  (0, import_node_fs2.writeFileSync)(path, JSON.stringify(config, null, 2) + "\n");
 }
 function updateConfig(updates) {
   const config = readConfig();
@@ -3277,18 +3368,18 @@ function updateConfig(updates) {
 }
 function readGuide() {
   const path = getGuidePath();
-  if (!(0, import_node_fs.existsSync)(path)) {
+  if (!(0, import_node_fs2.existsSync)(path)) {
     return null;
   }
-  return (0, import_node_fs.readFileSync)(path, "utf-8");
+  return (0, import_node_fs2.readFileSync)(path, "utf-8");
 }
 function writeGuide(content) {
   const path = getGuidePath();
-  (0, import_node_fs.writeFileSync)(path, content);
+  (0, import_node_fs2.writeFileSync)(path, content);
 }
 function isGuideFresh() {
   const path = getGuidePath();
-  if (!(0, import_node_fs.existsSync)(path)) {
+  if (!(0, import_node_fs2.existsSync)(path)) {
     return false;
   }
   try {
@@ -3299,22 +3390,22 @@ function isGuideFresh() {
   }
 }
 function slidesExist() {
-  return (0, import_node_fs.existsSync)(getSlidesPath());
+  return (0, import_node_fs2.existsSync)(getSlidesPath());
 }
 function readSlides() {
   const path = getSlidesPath();
-  if (!(0, import_node_fs.existsSync)(path)) {
+  if (!(0, import_node_fs2.existsSync)(path)) {
     return null;
   }
-  return (0, import_node_fs.readFileSync)(path, "utf-8");
+  return (0, import_node_fs2.readFileSync)(path, "utf-8");
 }
 function writeSlides(content) {
   const path = getSlidesPath();
-  (0, import_node_fs.writeFileSync)(path, content);
+  (0, import_node_fs2.writeFileSync)(path, content);
 }
 function writeUpstream(content) {
   const path = getUpstreamPath();
-  (0, import_node_fs.writeFileSync)(path, content);
+  (0, import_node_fs2.writeFileSync)(path, content);
 }
 function requireConfig() {
   const config = readConfig();
@@ -3418,6 +3509,40 @@ async function init() {
     }
     return;
   }
+  const cachedAuth = getCachedAuth();
+  if (cachedAuth && isAuthValid(cachedAuth)) {
+    const result2 = await createSession({ cliAuthToken: cachedAuth.token });
+    if (result2.ok && result2.data.authenticated && result2.data.token) {
+      const { slug: slug2, pollSecret: pollSecret2, previewUrl: previewUrl2, token } = result2.data;
+      writeConfig({
+        slug: slug2,
+        pollSecret: pollSecret2,
+        previewUrl: previewUrl2,
+        token
+      });
+      try {
+        const guideResult = await getGuide();
+        if (guideResult.ok && typeof guideResult.data === "string") {
+          writeGuide(guideResult.data);
+        }
+      } catch {
+      }
+      if (!slidesExist()) {
+        writeSlides(STARTER_SLIDES);
+        info("Created slides.md with starter template");
+      }
+      success(`Authenticated as ${cachedAuth.email}`);
+      url("PREVIEW_URL", previewUrl2);
+      newline();
+      info("Sandbox is starting in the background.");
+      instructions([
+        "Run: vslides check --wait (wait for sandbox to be ready)",
+        "Run: vslides push (upload your slides)"
+      ]);
+      return;
+    }
+    clearCLIAuth();
+  }
   const result = await createSession();
   if (!result.ok) {
     error(`Failed to create session: ${JSON.stringify(result.data)}`);
@@ -3438,8 +3563,10 @@ async function init() {
   }
   if (!slidesExist()) {
     writeSlides(STARTER_SLIDES);
+    info("Created slides.md with starter template");
   }
-  url("AUTH_URL", verifyUrl);
+  const authUrlWithCli = `${verifyUrl}?cliAuth=true`;
+  url("AUTH_URL", authUrlWithCli);
   url("PREVIEW_URL", previewUrl);
   instructions([
     "Run in background: vslides check --wait &",
@@ -3463,11 +3590,21 @@ async function check(options = {}) {
       error(`Failed to check session: ${JSON.stringify(result.data)}`);
       process.exit(ExitCode.NetworkError);
     }
-    const { status: sessionStatus, token } = result.data;
+    const { status: sessionStatus, token, cliAuthToken } = result.data;
     if (sessionStatus === "running") {
       if (token) {
         updateConfig({ token });
       }
+      if (cliAuthToken) {
+        try {
+          const validateResult = await validateCLIAuth(cliAuthToken);
+          if (validateResult.ok && validateResult.data.valid && validateResult.data.email && validateResult.data.expiresAt) {
+            saveCLIAuth(cliAuthToken, validateResult.data.email, validateResult.data.expiresAt);
+            info(`CLI auth token saved (valid for 7 days)`);
+          }
+        } catch {
+        }
+      }
       status("running");
       process.exit(ExitCode.Success);
     }
@@ -3488,7 +3625,7 @@ async function check(options = {}) {
 }
 
 // src/commands/join.ts
-async function join2(urlOrCode) {
+async function join3(urlOrCode) {
   let code = urlOrCode;
   if (urlOrCode.includes("/join/")) {
     const match = urlOrCode.match(/\/join\/([^/?]+)/);
@@ -3847,23 +3984,23 @@ async function sync() {
 }
 
 // src/commands/upload.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
 var ALLOWED_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".ico"];
 async function upload(file) {
   const { config: cfg, token } = requireToken();
-  if (!(0, import_node_fs2.existsSync)(file)) {
+  if (!(0, import_node_fs3.existsSync)(file)) {
     error(`File not found: ${file}`);
     process.exit(ExitCode.ValidationError);
   }
-  const ext = (0, import_node_path2.extname)(file).toLowerCase();
+  const ext = (0, import_node_path3.extname)(file).toLowerCase();
   if (!ALLOWED_EXTENSIONS.includes(ext)) {
     error(`Invalid file type: ${ext}`);
     info(`Allowed types: ${ALLOWED_EXTENSIONS.join(", ")}`);
     process.exit(ExitCode.ValidationError);
   }
-  const filename = (0, import_node_path2.basename)(file);
-  const content = (0, import_node_fs2.readFileSync)(file);
+  const filename = (0, import_node_path3.basename)(file);
+  const content = (0, import_node_fs3.readFileSync)(file);
   const result = await uploadAsset(cfg.slug, token, filename, content);
   if (!result.ok) {
     error(`Failed to upload: ${JSON.stringify(result.data)}`);
@@ -3877,7 +4014,7 @@ async function upload(file) {
 }
 
 // src/commands/export.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 async function exportSlides2(format) {
   if (format !== "pdf" && format !== "pptx") {
     error(`Invalid format: ${format}`);
@@ -3891,7 +4028,7 @@ async function exportSlides2(format) {
     process.exit(ExitCode.NetworkError);
   }
   const filename = result.filename || `slides.${format}`;
-  (0, import_node_fs3.writeFileSync)(filename, result.data);
+  (0, import_node_fs4.writeFileSync)(filename, result.data);
   info(`EXPORTED: ${filename}`);
 }
 
@@ -3940,19 +4077,128 @@ async function revert(version) {
   info(`REVERTED: Now at version ${newVersion} (content from version ${revertedFrom})`);
 }
 
+// src/commands/login.ts
+var POLL_INTERVAL2 = 2e3;
+var POLL_TIMEOUT2 = 12e4;
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function login() {
+  const cachedAuth = getCachedAuth();
+  if (cachedAuth && isAuthValid(cachedAuth)) {
+    const daysLeft = Math.ceil((cachedAuth.expiresAt - Date.now()) / (24 * 60 * 60 * 1e3));
+    info(`Already logged in as ${cachedAuth.email} (${daysLeft} days remaining)`);
+    info("Run `vslides logout` to sign out first.");
+    return;
+  }
+  const createResult = await createSession();
+  if (!createResult.ok) {
+    error(`Failed to create session: ${JSON.stringify(createResult.data)}`);
+    process.exit(ExitCode.NetworkError);
+  }
+  const { slug, pollSecret, verifyUrl } = createResult.data;
+  const authUrl = `${verifyUrl}?cliAuth=true`;
+  info("Please authenticate in your browser:");
+  url("AUTH_URL", authUrl);
+  newline();
+  info("Waiting for authentication...");
+  const startTime = Date.now();
+  while (true) {
+    const result = await getSession(slug, pollSecret);
+    if (!result.ok) {
+      error(`Failed to check session: ${JSON.stringify(result.data)}`);
+      process.exit(ExitCode.NetworkError);
+    }
+    const { status: sessionStatus, cliAuthToken } = result.data;
+    if (cliAuthToken && (sessionStatus === "authenticated" || sessionStatus === "running")) {
+      const validateResult = await validateCLIAuth(cliAuthToken);
+      if (validateResult.ok && validateResult.data.valid && validateResult.data.email && validateResult.data.expiresAt) {
+        saveCLIAuth(cliAuthToken, validateResult.data.email, validateResult.data.expiresAt);
+        newline();
+        success(`Logged in as ${validateResult.data.email} (valid for 7 days)`);
+        process.exit(ExitCode.Success);
+      }
+    }
+    if (Date.now() - startTime > POLL_TIMEOUT2) {
+      newline();
+      error("Timeout waiting for authentication");
+      instructions([
+        "Open the AUTH_URL in your browser",
+        "Sign in with your @vercel.com account",
+        "Run `vslides login` again"
+      ]);
+      process.exit(ExitCode.Conflict);
+    }
+    await sleep3(POLL_INTERVAL2);
+  }
+}
+
+// src/commands/logout.ts
+async function logout() {
+  const cachedAuth = getCachedAuth();
+  if (!cachedAuth) {
+    info("Not logged in");
+    return;
+  }
+  try {
+    await revokeCLIAuth(cachedAuth.token);
+  } catch {
+  }
+  clearCLIAuth();
+  success("Logged out successfully");
+}
+
+// src/commands/whoami.ts
+async function whoami(options = {}) {
+  const cachedAuth = getCachedAuth();
+  if (!cachedAuth) {
+    info("Not logged in");
+    instructions(["Run `vslides login` to authenticate"]);
+    process.exit(ExitCode.AuthRequired);
+  }
+  if (!isAuthValid(cachedAuth)) {
+    info(`Logged in as ${cachedAuth.email} (expired)`);
+    instructions(["Run `vslides login` to re-authenticate"]);
+    process.exit(ExitCode.AuthRequired);
+  }
+  if (options.validate) {
+    const result = await validateCLIAuth(cachedAuth.token);
+    if (!result.ok || !result.data.valid) {
+      info(`Logged in as ${cachedAuth.email} (invalid - token revoked)`);
+      instructions(["Run `vslides login` to re-authenticate"]);
+      process.exit(ExitCode.AuthRequired);
+    }
+  }
+  const daysLeft = Math.ceil((cachedAuth.expiresAt - Date.now()) / (24 * 60 * 60 * 1e3));
+  const expiresDate = new Date(cachedAuth.expiresAt).toLocaleDateString();
+  info(`Logged in as ${cachedAuth.email}`);
+  info(`Expires: ${expiresDate} (${daysLeft} day${daysLeft === 1 ? "" : "s"} remaining)`);
+}
+
 // src/cli.ts
 function wrapCommand(fn) {
   return (...args) => {
     fn(...args).catch((err) => {
+      if (err instanceof AuthExpiredError) {
+        error(err.message);
+        instructions([
+          "Run `vslides login` to re-authenticate",
+          "Then run `vslides init` to start a new session"
+        ]);
+        process.exit(ExitCode.AuthRequired);
+      }
       error(err.message);
       process.exit(ExitCode.NetworkError);
     });
   };
 }
 program.name("vslides").description("CLI for Vercel Slides API").version("1.0.0");
+program.command("login").description("Authenticate with Vercel (valid for 7 days)").action(wrapCommand(login));
+program.command("logout").description("Sign out and revoke credentials").action(wrapCommand(logout));
+program.command("whoami").description("Show current authentication status").option("--validate", "Validate token with server").action(wrapCommand((options) => whoami(options)));
 program.command("init").description("Create a new session").action(wrapCommand(init));
 program.command("check").description("Check session status").option("--wait", "Poll until running (60s timeout)").action(wrapCommand((options) => check(options)));
-program.command("join <url>").description("Join a shared session").action(wrapCommand(join2));
+program.command("join <url>").description("Join a shared session").action(wrapCommand(join3));
 program.command("share").description("Get join URL for collaborators").action(wrapCommand(share));
 program.command("preview").description("Print or open the preview URL").option("--open", "Open in browser").action(wrapCommand((options) => preview(options)));
 program.command("guide").description("Print the slide layout guide").option("--refresh", "Force fresh fetch").action(wrapCommand((options) => guide(options)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vslides",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "CLI for Vercel Slides API",
   "license": "MIT",
   "author": "Vercel",