@digitalpresence/cliclaw 0.4.2 → 0.5.0

package/src/commands/vercel.ts

@@ -0,0 +1,236 @@
+import { Command } from "commander";
+import { TokenStore } from "@digitalpresence/cliclaw-auth";
+import {
+  handleWhoami,
+  handleProjects, handleProject, handleProjectCreate, handleProjectDelete,
+  handleDeployments, handleDeployment, handleRedeploy, handlePromote, handleDeploymentDelete, handleBuildLogs,
+  handleDomains, handleDomain, handleDomainAdd, handleDomainRemove, handleDomainVerify,
+  handleEnvs, handleEnvGet, handleEnvCreate, handleEnvUpdate, handleEnvDelete,
+} from "../vercel/handlers.js";
+
+type TokenStoreFactory = () => TokenStore;
+
+export function registerVercelCommands(program: Command, getTokenStore: TokenStoreFactory): void {
+  let cached: TokenStore | null = null;
+  function resolve() {
+    if (!cached) cached = getTokenStore();
+    return cached;
+  }
+
+  const vercel = program.command("vercel").description("Vercel commands");
+
+  // --- Account ---
+
+  vercel
+    .command("whoami")
+    .description("Show authenticated user info")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleWhoami(resolve(), opts.account);
+    });
+
+  // --- Projects ---
+
+  vercel
+    .command("projects")
+    .description("List projects")
+    .option("--max-results <n>", "Maximum projects to return", "20")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleProjects(resolve(), opts.account, parseInt(opts.maxResults));
+    });
+
+  vercel
+    .command("project")
+    .description("Get project details")
+    .requiredOption("--project <id>", "Project ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleProject(resolve(), opts.account, opts.project);
+    });
+
+  vercel
+    .command("project-create")
+    .description("Create a project")
+    .requiredOption("--name <name>", "Project name")
+    .option("--framework <framework>", "Framework preset")
+    .option("--git-repo <owner/repo>", "Git repository (owner/repo)")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleProjectCreate(resolve(), opts.account, opts.name, opts.framework, opts.gitRepo);
+    });
+
+  vercel
+    .command("project-delete")
+    .description("Delete a project")
+    .requiredOption("--project <id>", "Project ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleProjectDelete(resolve(), opts.account, opts.project);
+    });
+
+  // --- Deployments ---
+
+  vercel
+    .command("deployments")
+    .description("List deployments")
+    .option("--project <id>", "Project ID")
+    .option("--max-results <n>", "Maximum deployments to return", "20")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDeployments(resolve(), opts.account, opts.project, parseInt(opts.maxResults));
+    });
+
+  vercel
+    .command("deployment")
+    .description("Get deployment details")
+    .requiredOption("--deployment-id <id>", "Deployment ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDeployment(resolve(), opts.account, opts.deploymentId);
+    });
+
+  vercel
+    .command("redeploy")
+    .description("Redeploy an existing deployment")
+    .requiredOption("--deployment-id <id>", "Deployment ID")
+    .option("--target <target>", "Deployment target (production/preview)")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleRedeploy(resolve(), opts.account, opts.deploymentId, opts.target);
+    });
+
+  vercel
+    .command("promote")
+    .description("Promote deployment to production")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--deployment-id <id>", "Deployment ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handlePromote(resolve(), opts.account, opts.project, opts.deploymentId);
+    });
+
+  vercel
+    .command("deployment-delete")
+    .description("Delete a deployment")
+    .requiredOption("--deployment-id <id>", "Deployment ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDeploymentDelete(resolve(), opts.account, opts.deploymentId);
+    });
+
+  vercel
+    .command("build-logs")
+    .description("Get build logs for a deployment")
+    .requiredOption("--deployment-id <id>", "Deployment ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleBuildLogs(resolve(), opts.account, opts.deploymentId);
+    });
+
+  // --- Domains ---
+
+  vercel
+    .command("domains")
+    .description("List domains")
+    .option("--max-results <n>", "Maximum domains to return", "20")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDomains(resolve(), opts.account, parseInt(opts.maxResults));
+    });
+
+  vercel
+    .command("domain")
+    .description("Get domain details")
+    .requiredOption("--domain <domain>", "Domain name")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDomain(resolve(), opts.account, opts.domain);
+    });
+
+  vercel
+    .command("domain-add")
+    .description("Add domain to project")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--domain <domain>", "Domain name")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDomainAdd(resolve(), opts.account, opts.project, opts.domain);
+    });
+
+  vercel
+    .command("domain-remove")
+    .description("Remove domain from project")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--domain <domain>", "Domain name")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDomainRemove(resolve(), opts.account, opts.project, opts.domain);
+    });
+
+  vercel
+    .command("domain-verify")
+    .description("Verify domain on project")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--domain <domain>", "Domain name")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleDomainVerify(resolve(), opts.account, opts.project, opts.domain);
+    });
+
+  // --- Environment Variables ---
+
+  vercel
+    .command("envs")
+    .description("List environment variables")
+    .requiredOption("--project <id>", "Project ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleEnvs(resolve(), opts.account, opts.project);
+    });
+
+  vercel
+    .command("env")
+    .description("Get environment variable")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--env-id <id>", "Environment variable ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleEnvGet(resolve(), opts.account, opts.project, opts.envId);
+    });
+
+  vercel
+    .command("env-create")
+    .description("Create environment variable")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--key <key>", "Variable key")
+    .requiredOption("--value <value>", "Variable value")
+    .requiredOption("--target <targets>", "Comma-separated deployment targets")
+    .option("--type <type>", "Variable type", "encrypted")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      const target = opts.target.split(",").map((t: string) => t.trim());
+      await handleEnvCreate(resolve(), opts.account, opts.project, opts.key, opts.value, target, opts.type);
+    });
+
+  vercel
+    .command("env-update")
+    .description("Update environment variable value")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--env-id <id>", "Environment variable ID")
+    .requiredOption("--value <value>", "New variable value")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleEnvUpdate(resolve(), opts.account, opts.project, opts.envId, opts.value);
+    });
+
+  vercel
+    .command("env-delete")
+    .description("Delete environment variable")
+    .requiredOption("--project <id>", "Project ID")
+    .requiredOption("--env-id <id>", "Environment variable ID")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+      await handleEnvDelete(resolve(), opts.account, opts.project, opts.envId);
+    });
+}

package/src/vercel/api.ts

@@ -0,0 +1,89 @@
+import { TokenStore } from "@digitalpresence/cliclaw-auth";
+import { outputAuthRequired, outputError } from "../lib/output.js";
+
+const VERCEL_API = "https://api.vercel.com";
+
+export function getToken(tokenStore: TokenStore, account: string): string {
+  const tokenKey = `vercel:${account}`;
+  const creds = tokenStore.get(tokenKey);
+  if (!creds?.access_token) {
+    outputAuthRequired("vercel");
+  }
+  return creds.access_token as string;
+}
+
+export async function vercelFetch(
+  token: string,
+  path: string,
+  options: RequestInit = {},
+  teamId?: string,
+): Promise<unknown> {
+  let url = path.startsWith("http") ? path : `${VERCEL_API}${path}`;
+  if (teamId) {
+    const separator = url.includes("?") ? "&" : "?";
+    url = `${url}${separator}teamId=${teamId}`;
+  }
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    outputError("vercel_api_error", `${res.status} ${res.statusText}: ${body}`);
+  }
+
+  return res.json();
+}
+
+export async function vercelFetchPaginated(
+  token: string,
+  path: string,
+  arrayKey: string,
+  maxResults: number,
+  teamId?: string,
+): Promise<unknown[]> {
+  const results: unknown[] = [];
+  const separator = path.includes("?") ? "&" : "?";
+  let url: string | null = `${path}${separator}limit=${Math.min(maxResults, 100)}`;
+
+  while (url && results.length < maxResults) {
+    let fullUrl = url.startsWith("http") ? url : `${VERCEL_API}${url}`;
+    if (teamId) {
+      const sep = fullUrl.includes("?") ? "&" : "?";
+      fullUrl = `${fullUrl}${sep}teamId=${teamId}`;
+    }
+    const res: Response = await fetch(fullUrl, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      outputError("vercel_api_error", `${res.status} ${res.statusText}: ${body}`);
+    }
+
+    const data = (await res.json()) as Record<string, unknown>;
+    const items = data[arrayKey];
+    results.push(...(Array.isArray(items) ? items : []));
+
+    const pagination = data.pagination as { next?: number } | undefined;
+    if (pagination?.next) {
+      const basePath: string = url!.split("?")[0];
+      const existingParams: string = url!.includes("?") ? url!.split("?")[1] : "";
+      const params: URLSearchParams = new URLSearchParams(existingParams);
+      params.set("until", String(pagination.next));
+      url = `${basePath}?${params.toString()}`;
+    } else {
+      url = null;
+    }
+  }
+
+  return results.slice(0, maxResults);
+}

package/src/vercel/handlers.ts

@@ -0,0 +1,369 @@
+import type { TokenStore } from "@digitalpresence/cliclaw-auth";
+import { getToken, vercelFetch, vercelFetchPaginated } from "./api.js";
+import { outputJson, outputError } from "../lib/output.js";
+
+// --- Account ---
+
+export async function handleWhoami(tokenStore: TokenStore, account: string): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const user = await vercelFetch(token, "/v2/user");
+    outputJson(user);
+  } catch (err) {
+    outputError("whoami_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Projects ---
+
+export async function handleProjects(
+  tokenStore: TokenStore,
+  account: string,
+  maxResults: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const projects = await vercelFetchPaginated(token, "/v9/projects", "projects", maxResults);
+    outputJson(projects);
+  } catch (err) {
+    outputError("projects_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleProject(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const project = await vercelFetch(token, `/v9/projects/${projectId}`);
+    outputJson(project);
+  } catch (err) {
+    outputError("project_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleProjectCreate(
+  tokenStore: TokenStore,
+  account: string,
+  name: string,
+  framework?: string,
+  gitRepo?: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const payload: Record<string, unknown> = { name };
+    if (framework) payload.framework = framework;
+    if (gitRepo) payload.gitRepository = { type: "github", repo: gitRepo };
+    const project = await vercelFetch(token, "/v9/projects", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    outputJson(project);
+  } catch (err) {
+    outputError("project_create_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleProjectDelete(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(token, `/v9/projects/${projectId}`, { method: "DELETE" });
+    outputJson(result);
+  } catch (err) {
+    outputError("project_delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Deployments ---
+
+export async function handleDeployments(
+  tokenStore: TokenStore,
+  account: string,
+  projectId?: string,
+  maxResults?: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const path = projectId ? `/v6/deployments?projectId=${projectId}` : "/v6/deployments";
+    const deployments = await vercelFetchPaginated(
+      token,
+      path,
+      "deployments",
+      maxResults ?? 20,
+    );
+    outputJson(deployments);
+  } catch (err) {
+    outputError("deployments_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDeployment(
+  tokenStore: TokenStore,
+  account: string,
+  deploymentId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const deployment = await vercelFetch(token, `/v13/deployments/${deploymentId}`);
+    outputJson(deployment);
+  } catch (err) {
+    outputError("deployment_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleRedeploy(
+  tokenStore: TokenStore,
+  account: string,
+  deploymentId: string,
+  target?: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const payload: Record<string, unknown> = { deploymentId };
+    if (target) payload.target = target;
+    const result = await vercelFetch(token, "/v13/deployments", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    outputJson(result);
+  } catch (err) {
+    outputError("redeploy_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handlePromote(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  deploymentId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(
+      token,
+      `/v10/projects/${projectId}/promote/${deploymentId}`,
+      { method: "POST" },
+    );
+    outputJson(result);
+  } catch (err) {
+    outputError("promote_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDeploymentDelete(
+  tokenStore: TokenStore,
+  account: string,
+  deploymentId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(token, `/v13/deployments/${deploymentId}`, {
+      method: "DELETE",
+    });
+    outputJson(result);
+  } catch (err) {
+    outputError("deployment_delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleBuildLogs(
+  tokenStore: TokenStore,
+  account: string,
+  deploymentId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const logs = await vercelFetch(token, `/v2/deployments/${deploymentId}/events`);
+    outputJson(logs);
+  } catch (err) {
+    outputError("build_logs_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Domains ---
+
+export async function handleDomains(
+  tokenStore: TokenStore,
+  account: string,
+  maxResults?: number,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const domains = await vercelFetchPaginated(
+      token,
+      "/v5/domains",
+      "domains",
+      maxResults ?? 20,
+    );
+    outputJson(domains);
+  } catch (err) {
+    outputError("domains_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDomain(
+  tokenStore: TokenStore,
+  account: string,
+  domain: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const data = await vercelFetch(token, `/v5/domains/${domain}`);
+    outputJson(data);
+  } catch (err) {
+    outputError("domain_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDomainAdd(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  domain: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(token, `/v9/projects/${projectId}/domains`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: domain }),
+    });
+    outputJson(result);
+  } catch (err) {
+    outputError("domain_add_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDomainRemove(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  domain: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(token, `/v9/projects/${projectId}/domains/${domain}`, {
+      method: "DELETE",
+    });
+    outputJson(result);
+  } catch (err) {
+    outputError("domain_remove_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleDomainVerify(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  domain: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(
+      token,
+      `/v9/projects/${projectId}/domains/${domain}/verify`,
+      { method: "POST" },
+    );
+    outputJson(result);
+  } catch (err) {
+    outputError("domain_verify_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+// --- Environment Variables ---
+
+export async function handleEnvs(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const data = await vercelFetch(token, `/v10/projects/${projectId}/env`);
+    outputJson((data as Record<string, unknown>).envs);
+  } catch (err) {
+    outputError("envs_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleEnvGet(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  envId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const env = await vercelFetch(token, `/v10/projects/${projectId}/env/${envId}`);
+    outputJson(env);
+  } catch (err) {
+    outputError("env_get_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleEnvCreate(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  key: string,
+  value: string,
+  target: string[],
+  type?: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const env = await vercelFetch(token, `/v10/projects/${projectId}/env`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ key, value, target, type: type || "encrypted" }),
+    });
+    outputJson(env);
+  } catch (err) {
+    outputError("env_create_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleEnvUpdate(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  envId: string,
+  value: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const env = await vercelFetch(token, `/v10/projects/${projectId}/env/${envId}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ value }),
+    });
+    outputJson(env);
+  } catch (err) {
+    outputError("env_update_failed", err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function handleEnvDelete(
+  tokenStore: TokenStore,
+  account: string,
+  projectId: string,
+  envId: string,
+): Promise<void> {
+  const token = getToken(tokenStore, account);
+  try {
+    const result = await vercelFetch(token, `/v10/projects/${projectId}/env/${envId}`, {
+      method: "DELETE",
+    });
+    outputJson(result);
+  } catch (err) {
+    outputError("env_delete_failed", err instanceof Error ? err.message : String(err));
+  }
+}