viagen 0.0.2 → 0.0.3

package/README.md

@@ -36,6 +36,35 @@ viagen({
 
 All options are optional. Defaults shown above.
 
+## Sandbox
+
+Deploy your dev server to a remote Vercel Sandbox:
+
+```bash
+npx viagen sandbox
+```
+
+This creates an isolated microVM, uploads your project, installs dependencies, and starts the dev server. All endpoints are protected with token-based auth.
+
+**Prerequisites:** `ANTHROPIC_API_KEY` in `.env` + Vercel auth (`vercel link && vercel env pull` or set `VERCEL_TOKEN`, `VERCEL_TEAM_ID`, `VERCEL_PROJECT_ID`).
+
+```bash
+npx viagen sandbox stop <sandboxId>   # Stop a running sandbox
+```
+
+## CLI (coming soon)
+
+`npx viagen setup` — interactive setup that uses the Vercel CLI under the hood to log in, pick a team, link a project, and write all the credentials to `.env` so `npx viagen sandbox` just works.
+
+## Auth
+
+Set `VIAGEN_AUTH_TOKEN` in `.env` to protect all endpoints. When set:
+
+- Browser: visit `?token=<token>` to set a session cookie
+- API: use `Authorization: Bearer <token>` header
+
+Auth is automatic when deploying via `npx viagen sandbox`.
+
 ## Endpoints
 
 **`POST /via/chat`** — Send a message, get a streamed response.
@@ -72,6 +101,6 @@ You can also open the chat UI directly at `http://localhost:5173/via/ui`.
 
 ```bash
 npm install
-npm run dev        # Playground dev server
+npm run dev        # Dev server
 npm run build      # Build with tsup
 ```

package/dist/cli.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join2 } from "path";
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+
+// src/sandbox.ts
+import { randomUUID } from "crypto";
+import { readFileSync, readdirSync } from "fs";
+import { join, relative } from "path";
+import { Sandbox } from "@vercel/sandbox";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".viagen",
+  ".next",
+  ".nuxt"
+]);
+var SKIP_FILES = /* @__PURE__ */ new Set([".env", ".env.local"]);
+function collectFiles(dir, base) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") && SKIP_DIRS.has(entry.name)) continue;
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = join(dir, entry.name);
+    const relPath = relative(base, fullPath);
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, base));
+    } else if (entry.isFile()) {
+      if (SKIP_FILES.has(entry.name)) continue;
+      files.push({ path: relPath, content: readFileSync(fullPath) });
+    }
+  }
+  return files;
+}
+function extractHost(httpsUrl) {
+  try {
+    return new URL(httpsUrl).host;
+  } catch {
+    return "github.com";
+  }
+}
+async function deploySandbox(opts) {
+  const token = randomUUID();
+  const useGit = !!opts.git;
+  const sandbox = await Sandbox.create({
+    runtime: "node22",
+    ports: [5173],
+    ...opts.git ? {
+      source: {
+        type: "git",
+        url: opts.git.remoteUrl,
+        username: "x-access-token",
+        password: opts.git.token,
+        revision: opts.git.branch
+      }
+    } : {}
+  });
+  try {
+    if (useGit && opts.git) {
+      await sandbox.runCommand("git", [
+        "config",
+        "--global",
+        "user.name",
+        opts.git.userName
+      ]);
+      await sandbox.runCommand("git", [
+        "config",
+        "--global",
+        "user.email",
+        opts.git.userEmail
+      ]);
+      await sandbox.runCommand("bash", [
+        "-c",
+        `echo 'https://x-access-token:${opts.git.token}@${extractHost(opts.git.remoteUrl)}' > ~/.git-credentials`
+      ]);
+      await sandbox.runCommand("git", [
+        "config",
+        "--global",
+        "credential.helper",
+        "store"
+      ]);
+      if (opts.overlayFiles && opts.overlayFiles.length > 0) {
+        await sandbox.writeFiles(opts.overlayFiles);
+      }
+    } else {
+      const files = collectFiles(opts.cwd, opts.cwd);
+      if (files.length > 0) {
+        await sandbox.writeFiles(files);
+      }
+    }
+    const envLines = [
+      `ANTHROPIC_API_KEY=${opts.apiKey}`,
+      `VIAGEN_AUTH_TOKEN=${token}`
+    ];
+    if (opts.git) {
+      envLines.push(`GITHUB_TOKEN=${opts.git.token}`);
+    }
+    await sandbox.writeFiles([
+      {
+        path: ".env",
+        content: Buffer.from(envLines.join("\n"))
+      }
+    ]);
+    const install = await sandbox.runCommand("npm", ["install"]);
+    if (install.exitCode !== 0) {
+      const stderr = await install.stderr();
+      throw new Error(
+        `npm install failed (exit ${install.exitCode}): ${stderr}`
+      );
+    }
+    await sandbox.runCommand({
+      cmd: "npm",
+      args: ["run", "dev", "--", "--host", "0.0.0.0"],
+      detached: true
+    });
+    const baseUrl = sandbox.domain(5173);
+    const url = `${baseUrl}?token=${token}`;
+    return {
+      url,
+      token,
+      sandboxId: sandbox.sandboxId,
+      mode: useGit ? "git" : "upload"
+    };
+  } catch (err) {
+    await sandbox.stop().catch(() => {
+    });
+    throw err;
+  }
+}
+async function stopSandbox(sandboxId) {
+  const sandbox = await Sandbox.get({ sandboxId });
+  await sandbox.stop();
+}
+
+// src/cli.ts
+function loadDotenv(dir) {
+  const envPath = join2(dir, ".env");
+  if (!existsSync(envPath)) return {};
+  const vars = {};
+  const content = readFileSync2(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const val = trimmed.slice(idx + 1).trim();
+    vars[key] = val;
+  }
+  return vars;
+}
+function openBrowser(url) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      execSync(`open "${url}"`);
+    } else if (platform === "linux") {
+      execSync(`xdg-open "${url}"`);
+    } else if (platform === "win32") {
+      execSync(`start "${url}"`);
+    }
+  } catch {
+  }
+}
+function git(cwd, args) {
+  return execSync(`git ${args}`, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+}
+function sshToHttps(url) {
+  if (url.startsWith("https://")) return url;
+  if (url.startsWith("http://")) return url.replace(/^http:\/\//, "https://");
+  const shorthand = url.match(/^[\w.-]+@([\w.-]+):([\w./_-]+)$/);
+  if (shorthand) return `https://${shorthand[1]}/${shorthand[2]}`;
+  const sshUrl = url.match(/^ssh:\/\/[\w.-]+@([\w.-]+)\/([\w./_-]+)$/);
+  if (sshUrl) return `https://${sshUrl[1]}/${sshUrl[2]}`;
+  return url;
+}
+function getGitInfo(cwd) {
+  try {
+    git(cwd, "rev-parse --is-inside-work-tree");
+  } catch {
+    return null;
+  }
+  try {
+    const remoteUrlRaw = git(cwd, "remote get-url origin");
+    const branch = git(cwd, "branch --show-current");
+    const userName = git(cwd, "config user.name");
+    const userEmail = git(cwd, "config user.email");
+    const status = git(cwd, "status --porcelain");
+    const remoteUrl = sshToHttps(remoteUrlRaw);
+    if (!remoteUrl || !branch) return null;
+    return { remoteUrl, branch, userName, userEmail, isDirty: status.length > 0 };
+  } catch {
+    return null;
+  }
+}
+function promptUser(question) {
+  if (!process.stdin.isTTY) return Promise.resolve("");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (command === "sandbox") {
+    const subcommand = args[1];
+    if (subcommand === "stop") {
+      const sandboxId = args[2];
+      if (!sandboxId) {
+        console.error("Usage: viagen sandbox stop <sandboxId>");
+        process.exit(1);
+      }
+      console.log(`Stopping sandbox ${sandboxId}...`);
+      await stopSandbox(sandboxId);
+      console.log("Sandbox stopped.");
+      return;
+    }
+    const cwd = process.cwd();
+    const dotenv = loadDotenv(cwd);
+    for (const [key, val] of Object.entries(dotenv)) {
+      if (!process.env[key]) process.env[key] = val;
+    }
+    const env = { ...dotenv, ...process.env };
+    const apiKey = env["ANTHROPIC_API_KEY"];
+    if (!apiKey) {
+      console.error("Error: ANTHROPIC_API_KEY not found.");
+      console.error("Set it in .env or as an environment variable.");
+      process.exit(1);
+    }
+    const hasOidc = !!env["VERCEL_OIDC_TOKEN"];
+    const hasToken = !!env["VERCEL_TOKEN"] && !!env["VERCEL_TEAM_ID"] && !!env["VERCEL_PROJECT_ID"];
+    if (!hasOidc && !hasToken) {
+      console.error("Error: Vercel authentication not configured.");
+      console.error("");
+      console.error("Option 1: Run `vercel link && vercel env pull`");
+      console.error(
+        "Option 2: Set VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID"
+      );
+      process.exit(1);
+    }
+    const githubToken = env["GITHUB_TOKEN"];
+    const gitInfo = getGitInfo(cwd);
+    let deployGit;
+    let overlayFiles;
+    if (gitInfo && githubToken) {
+      if (gitInfo.isDirty) {
+        console.log("");
+        console.log("Your working tree has uncommitted changes.");
+        console.log("");
+        console.log("  1) Clone from remote (clean) \u2014 full git, can push");
+        console.log("  2) Upload local files \u2014 includes changes, no git");
+        console.log("  3) Clone + overlay \u2014 git history + your local changes (default)");
+        console.log("");
+        let answer = await promptUser("Choose mode [1/2/3]: ");
+        if (!answer || answer === "3") {
+          deployGit = {
+            remoteUrl: gitInfo.remoteUrl,
+            branch: gitInfo.branch,
+            userName: gitInfo.userName,
+            userEmail: gitInfo.userEmail,
+            token: githubToken
+          };
+          overlayFiles = collectFiles(cwd, cwd);
+        } else if (answer === "1") {
+          deployGit = {
+            remoteUrl: gitInfo.remoteUrl,
+            branch: gitInfo.branch,
+            userName: gitInfo.userName,
+            userEmail: gitInfo.userEmail,
+            token: githubToken
+          };
+        } else {
+          console.log("Note: Sandbox is ephemeral \u2014 changes can't be pushed.");
+        }
+      } else {
+        deployGit = {
+          remoteUrl: gitInfo.remoteUrl,
+          branch: gitInfo.branch,
+          userName: gitInfo.userName,
+          userEmail: gitInfo.userEmail,
+          token: githubToken
+        };
+      }
+    } else if (gitInfo && !githubToken) {
+      console.log("Note: No GITHUB_TOKEN set \u2014 changes from the sandbox can't be saved.");
+    } else {
+      console.log("Note: Not a git repo \u2014 sandbox will use file upload (ephemeral).");
+    }
+    console.log("");
+    console.log("Creating sandbox...");
+    if (deployGit) {
+      console.log(`  Repo:   ${deployGit.remoteUrl}`);
+      console.log(`  Branch: ${deployGit.branch}`);
+    }
+    const result = await deploySandbox({ cwd, apiKey, git: deployGit, overlayFiles });
+    console.log("");
+    console.log("Sandbox deployed!");
+    console.log("");
+    console.log(`  URL:        ${result.url}`);
+    console.log(`  Sandbox ID: ${result.sandboxId}`);
+    console.log(`  Mode:       ${result.mode === "git" ? "git clone (can push)" : "file upload (ephemeral)"}`);
+    console.log(`  Token:      ${result.token}`);
+    console.log("");
+    console.log(`Stop with: npx viagen sandbox stop ${result.sandboxId}`);
+    openBrowser(result.url);
+  } else {
+    console.log("viagen \u2014 Claude Code in your Vite dev server");
+    console.log("");
+    console.log("Usage:");
+    console.log("  viagen <command>");
+    console.log("");
+    console.log("Commands:");
+    console.log("  sandbox           Deploy your project to a Vercel Sandbox");
+    console.log("  sandbox stop <id> Stop a running sandbox");
+    console.log("  help              Show this help message");
+    console.log("");
+    console.log("Getting started:");
+    console.log("  1. npm install viagen");
+    console.log("  2. Add viagen() to your vite.config.ts plugins");
+    console.log("  3. Set ANTHROPIC_API_KEY in .env");
+    console.log("  4. npm run dev");
+    console.log("");
+    console.log("Environment variables (.env):");
+    console.log("  ANTHROPIC_API_KEY   Required. Your Anthropic API key.");
+    console.log("  GITHUB_TOKEN        Optional. Enables git commit+push from sandbox.");
+    console.log("  VIAGEN_AUTH_TOKEN   Optional. Protects all endpoints with token auth.");
+    console.log("  VERCEL_TOKEN        Required for sandbox. Vercel access token.");
+    console.log("  VERCEL_TEAM_ID      Required for sandbox. From .vercel/project.json (orgId).");
+    console.log("  VERCEL_PROJECT_ID   Required for sandbox. From .vercel/project.json (projectId).");
+    console.log("");
+    console.log("Docs: http://localhost:5173/via/docs (when dev server is running)");
+  }
+}
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -1,5 +1,42 @@
 import { Plugin } from 'vite';
 
+interface GitInfo {
+    /** HTTPS remote URL (transformed from SSH if needed). */
+    remoteUrl: string;
+    /** Branch to check out. */
+    branch: string;
+    /** Git user name for commits. */
+    userName: string;
+    /** Git user email for commits. */
+    userEmail: string;
+    /** GitHub PAT (or other host token) for auth. */
+    token: string;
+}
+interface DeploySandboxOptions {
+    /** Project directory to upload (used in file-upload mode). */
+    cwd: string;
+    /** Anthropic API key to inject into sandbox .env. */
+    apiKey: string;
+    /** If provided, clone the repo instead of uploading files. */
+    git?: GitInfo;
+    /** Dirty files to overlay on top of a git clone. */
+    overlayFiles?: {
+        path: string;
+        content: Buffer;
+    }[];
+}
+interface DeploySandboxResult {
+    /** Full URL with auth token in query string. */
+    url: string;
+    /** Auth token for API access. */
+    token: string;
+    /** Sandbox ID for later management. */
+    sandboxId: string;
+    /** Deployment mode used. */
+    mode: "git" | "upload";
+}
+declare function deploySandbox(opts: DeploySandboxOptions): Promise<DeploySandboxResult>;
+
 interface ViagenOptions {
     /** Toggle button placement. Default: 'bottom-right' */
     position?: "bottom-right" | "bottom-left" | "top-right" | "top-left";
@@ -12,6 +49,7 @@ interface ViagenOptions {
     /** Inject the toggle button + chat panel into pages. Default: true */
     ui?: boolean;
 }
+
 declare function viagen(options?: ViagenOptions): Plugin;
 
-export { type ViagenOptions, viagen as default, viagen };
+export { type GitInfo, type ViagenOptions, viagen as default, deploySandbox, viagen };