@neopress/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,681 @@
+// ../sdk/dist/errors.js
+var NeopressApiError = class extends Error {
+  code;
+  status;
+  response;
+  constructor(code, message, status, response) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.response = response;
+    this.name = "NeopressApiError";
+  }
+};
+
+// ../sdk/dist/endpoints/pages.js
+var PagesEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/pages`;
+  }
+  async list(params) {
+    const qs = new URLSearchParams();
+    if (params?.page)
+      qs.set("page", String(params.page));
+    if (params?.limit)
+      qs.set("limit", String(params.limit));
+    if (params?.status)
+      qs.set("status", params.status);
+    if (params?.fields)
+      qs.set("fields", params.fields.join(","));
+    const query = qs.toString();
+    return this.client.getList(`${this.basePath}${query ? `?${query}` : ""}`);
+  }
+  async get(pageId) {
+    const res = await this.client.get(`${this.basePath}/${pageId}`);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async update(pageId, data) {
+    const res = await this.client.patch(`${this.basePath}/${pageId}`, data);
+    return res.data;
+  }
+  async delete(pageId) {
+    await this.client.delete(`${this.basePath}/${pageId}`);
+  }
+  async compile(pageId) {
+    const res = await this.client.post(`${this.basePath}/${pageId}/compile`);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/collections.js
+var CollectionsEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/collections`;
+  }
+  async list() {
+    const res = await this.client.get(this.basePath);
+    return res.data;
+  }
+  async get(collectionId) {
+    const res = await this.client.get(`${this.basePath}/${collectionId}`);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async update(collectionId, data) {
+    const res = await this.client.patch(`${this.basePath}/${collectionId}`, data);
+    return res.data;
+  }
+  async delete(collectionId) {
+    await this.client.delete(`${this.basePath}/${collectionId}`);
+  }
+  async getSchema(collectionId) {
+    const res = await this.client.get(`${this.basePath}/${collectionId}/schema`);
+    return res.data;
+  }
+  async updateSchema(collectionId, schema) {
+    const res = await this.client.patch(`${this.basePath}/${collectionId}/schema`, { schema });
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/entries.js
+var EntriesEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(collectionId, params) {
+    const qs = new URLSearchParams();
+    if (params?.page)
+      qs.set("page", String(params.page));
+    if (params?.limit)
+      qs.set("limit", String(params.limit));
+    if (params?.status)
+      qs.set("status", params.status);
+    if (params?.locale)
+      qs.set("locale", params.locale);
+    const query = qs.toString();
+    return this.client.getList(`${this.client.siteBasePath}/collections/${collectionId}/entries${query ? `?${query}` : ""}`);
+  }
+  async get(entryId) {
+    const res = await this.client.get(`${this.client.siteBasePath}/entries/${entryId}`);
+    return res.data;
+  }
+  async create(collectionId, data) {
+    const res = await this.client.post(`${this.client.siteBasePath}/collections/${collectionId}/entries`, data);
+    return res.data;
+  }
+  async update(entryId, data) {
+    const res = await this.client.patch(`${this.client.siteBasePath}/entries/${entryId}`, data);
+    return res.data;
+  }
+  async delete(entryId) {
+    await this.client.delete(`${this.client.siteBasePath}/entries/${entryId}`);
+  }
+  async publish(entryId) {
+    const res = await this.client.post(`${this.client.siteBasePath}/entries/${entryId}/publish`);
+    return res.data;
+  }
+  async unpublish(entryId) {
+    const res = await this.client.post(`${this.client.siteBasePath}/entries/${entryId}/unpublish`);
+    return res.data;
+  }
+  async listVersions(entryId) {
+    const res = await this.client.get(`${this.client.siteBasePath}/entries/${entryId}/versions`);
+    return res.data;
+  }
+  async pinVersion(entryId, versionId) {
+    const res = await this.client.post(`${this.client.siteBasePath}/entries/${entryId}/versions/${versionId}/pin`);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/forms.js
+var FormsEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/forms`;
+  }
+  async list() {
+    const res = await this.client.get(this.basePath);
+    return res.data;
+  }
+  async get(formId) {
+    const res = await this.client.get(`${this.basePath}/${formId}`);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async update(formId, data) {
+    const res = await this.client.patch(`${this.basePath}/${formId}`, data);
+    return res.data;
+  }
+  async delete(formId) {
+    await this.client.delete(`${this.basePath}/${formId}`);
+  }
+  async publish(formId) {
+    const res = await this.client.post(`${this.basePath}/${formId}/publish`);
+    return res.data;
+  }
+  async listResponses(formId, params) {
+    const qs = new URLSearchParams();
+    if (params?.page)
+      qs.set("page", String(params.page));
+    if (params?.limit)
+      qs.set("limit", String(params.limit));
+    const query = qs.toString();
+    return this.client.getList(`${this.basePath}/${formId}/responses${query ? `?${query}` : ""}`);
+  }
+  async deleteResponse(formId, responseId) {
+    await this.client.delete(`${this.basePath}/${formId}/responses/${responseId}`);
+  }
+};
+
+// ../sdk/dist/endpoints/assets.js
+var AssetsEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/assets`;
+  }
+  async list(params) {
+    const qs = new URLSearchParams();
+    if (params?.page)
+      qs.set("page", String(params.page));
+    if (params?.limit)
+      qs.set("limit", String(params.limit));
+    const query = qs.toString();
+    return this.client.getList(`${this.basePath}${query ? `?${query}` : ""}`);
+  }
+  async get(assetId) {
+    const res = await this.client.get(`${this.basePath}/${assetId}`);
+    return res.data;
+  }
+  async register(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async update(assetId, data) {
+    const res = await this.client.patch(`${this.basePath}/${assetId}`, data);
+    return res.data;
+  }
+  async delete(assetId) {
+    await this.client.delete(`${this.basePath}/${assetId}`);
+  }
+  async presign(data) {
+    const res = await this.client.post(`${this.basePath}/presign`, data);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/site.js
+var SiteEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const res = await this.client.get("/api/v1/sites");
+    return res.data;
+  }
+  async get() {
+    const res = await this.client.get(this.client.siteBasePath);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post("/api/v1/sites", data);
+    return res.data;
+  }
+  async update(data) {
+    const res = await this.client.patch(this.client.siteBasePath, data);
+    return res.data;
+  }
+  async getLayout() {
+    const res = await this.client.get(`${this.client.siteBasePath}/layout`);
+    return res.data;
+  }
+  async updateLayout(data) {
+    const res = await this.client.patch(`${this.client.siteBasePath}/layout`, data);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/redirects.js
+var RedirectsEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/redirects`;
+  }
+  async list() {
+    const res = await this.client.get(this.basePath);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async update(ruleId, data) {
+    const res = await this.client.patch(`${this.basePath}/${ruleId}`, data);
+    return res.data;
+  }
+  async delete(ruleId) {
+    await this.client.delete(`${this.basePath}/${ruleId}`);
+  }
+};
+
+// ../sdk/dist/endpoints/publish.js
+var PublishEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async preview() {
+    const res = await this.client.get(`${this.client.siteBasePath}/publish`);
+    return res.data;
+  }
+  async site() {
+    const res = await this.client.post(`${this.client.siteBasePath}/publish`);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/endpoints/entry-references.js
+var EntryReferencesEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/entry-references`;
+  }
+  async list(params) {
+    const qs = new URLSearchParams();
+    if (params?.fromEntryId)
+      qs.set("fromEntryId", String(params.fromEntryId));
+    if (params?.toEntryId)
+      qs.set("toEntryId", String(params.toEntryId));
+    const query = qs.toString();
+    const res = await this.client.get(`${this.basePath}${query ? `?${query}` : ""}`);
+    return res.data;
+  }
+  async create(data) {
+    const res = await this.client.post(this.basePath, data);
+    return res.data;
+  }
+  async delete(referenceId) {
+    await this.client.delete(`${this.basePath}/${referenceId}`);
+  }
+};
+
+// ../sdk/dist/endpoints/analytics.js
+var RESERVED_ANALYTICS_PARAMS = /* @__PURE__ */ new Set([
+  "pipe",
+  "site",
+  "site_id",
+  "timezone",
+  "token",
+  "q"
+]);
+function setQueryValue(qs, key, value) {
+  if (value === void 0)
+    return;
+  qs.set(key, String(value));
+}
+function appendCommonAnalyticsParams(qs, params) {
+  setQueryValue(qs, "date_from", params?.dateFrom);
+  setQueryValue(qs, "date_to", params?.dateTo);
+  setQueryValue(qs, "timezone", params?.timezone);
+  setQueryValue(qs, "limit", params?.limit);
+  for (const [key, value] of Object.entries(params?.params ?? {})) {
+    if (RESERVED_ANALYTICS_PARAMS.has(key))
+      continue;
+    setQueryValue(qs, key, value);
+  }
+}
+var AnalyticsEndpoint = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  get basePath() {
+    return `${this.client.siteBasePath}/analytics`;
+  }
+  async query(params) {
+    const qs = new URLSearchParams();
+    qs.set("pipe", params.pipe);
+    appendCommonAnalyticsParams(qs, params);
+    const res = await this.client.get(`${this.basePath}/query?${qs.toString()}`);
+    return res.data;
+  }
+  async pageviews(params) {
+    return this.query({ pipe: "get_pageviews", ...params });
+  }
+  async summary(params) {
+    return this.query({ pipe: "get_engagement_summary", ...params });
+  }
+  async topPages(params) {
+    return this.query({ pipe: "get_top_pages", ...params });
+  }
+  async trafficSources(params) {
+    return this.query({ pipe: "get_traffic_sources", ...params });
+  }
+  async formAnalytics(params) {
+    return this.query({ pipe: "get_form_analytics", ...params });
+  }
+  async crawlerSummary(params) {
+    return this.query({ pipe: "get_crawler_summary", ...params });
+  }
+  async searchConsole(params) {
+    const qs = new URLSearchParams();
+    qs.set("date_from", params.dateFrom);
+    qs.set("date_to", params.dateTo);
+    if (params.dimensions)
+      qs.set("dimensions", params.dimensions.join(","));
+    if (params.queryFilter)
+      qs.set("query_filter", params.queryFilter);
+    if (params.pageFilter)
+      qs.set("page_filter", params.pageFilter);
+    if (params.rowLimit)
+      qs.set("row_limit", String(params.rowLimit));
+    const res = await this.client.get(`${this.basePath}/search-console?${qs.toString()}`);
+    return res.data;
+  }
+};
+
+// ../sdk/dist/client.js
+var NeopressClient = class {
+  baseUrl;
+  accessToken;
+  siteId;
+  timeout;
+  pages;
+  collections;
+  entries;
+  forms;
+  assets;
+  site;
+  redirects;
+  publish;
+  entryReferences;
+  analytics;
+  constructor(options) {
+    this.baseUrl = (options.baseUrl || "https://app.neopress.ai").replace(/\/$/, "");
+    this.accessToken = options.accessToken || "";
+    this.siteId = options.siteId;
+    this.timeout = options.timeout ?? 3e4;
+    this.pages = new PagesEndpoint(this);
+    this.collections = new CollectionsEndpoint(this);
+    this.entries = new EntriesEndpoint(this);
+    this.forms = new FormsEndpoint(this);
+    this.assets = new AssetsEndpoint(this);
+    this.site = new SiteEndpoint(this);
+    this.redirects = new RedirectsEndpoint(this);
+    this.publish = new PublishEndpoint(this);
+    this.entryReferences = new EntryReferencesEndpoint(this);
+    this.analytics = new AnalyticsEndpoint(this);
+  }
+  get siteBasePath() {
+    return `/api/v1/sites/${this.siteId}`;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Authorization": `Bearer ${this.accessToken}`
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err?.name === "AbortError") {
+        throw new NeopressApiError("TIMEOUT", `Request timed out: ${method} ${path}`, 0);
+      }
+      throw new NeopressApiError("CONNECTION_ERROR", `Cannot connect to ${this.baseUrl} \u2014 is the dev server running?`, 0);
+    }
+    clearTimeout(timeout);
+    const json = await response.json();
+    if (!response.ok) {
+      const err = json?.error || {};
+      throw new NeopressApiError(err.code || "UNKNOWN", err.message || response.statusText, response.status, json);
+    }
+    return json;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async getList(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/utils/token-store.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "neopress");
+var TOKENS_FILE = join(CONFIG_DIR, "tokens.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadSession() {
+  try {
+    return JSON.parse(readFileSync(TOKENS_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveSession(session) {
+  ensureConfigDir();
+  writeFileSync(TOKENS_FILE, JSON.stringify(session, null, 2) + "\n");
+  try {
+    chmodSync(TOKENS_FILE, 384);
+  } catch {
+  }
+}
+function clearSession() {
+  saveSession({});
+}
+
+// src/utils/supabase-config.ts
+function getSupabaseConfig() {
+  return {
+    url: process.env.NEOPRESS_SUPABASE_URL || "https://gxrfyjmsmiakirmtzkmv.supabase.co",
+    anonKey: process.env.NEOPRESS_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd4cmZ5am1zbWlha2lybXR6a212Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjIxNDM2MzQsImV4cCI6MjA3NzcxOTYzNH0.Xzx6Xg5O1EBXZ64_5BP7KhsVyafJ0GI-62HcDpq6WRk"
+  };
+}
+
+// src/utils/token-refresh.ts
+var REFRESH_BUFFER_SECONDS = 60;
+async function refreshAccessToken(refreshToken) {
+  const { url, anonKey } = getSupabaseConfig();
+  const response = await fetch(`${url}/auth/v1/token?grant_type=refresh_token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "apikey": anonKey
+    },
+    body: JSON.stringify({
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`Token refresh failed: ${err}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Math.floor(Date.now() / 1e3) + data.expires_in,
+    userId: data.user?.id || ""
+  };
+}
+async function getValidAccessToken() {
+  const session = loadSession();
+  if (!session.tokens) return null;
+  const now = Math.floor(Date.now() / 1e3);
+  if (session.tokens.expiresAt > now + REFRESH_BUFFER_SECONDS) {
+    return session.tokens.accessToken;
+  }
+  try {
+    const newTokens = await refreshAccessToken(session.tokens.refreshToken);
+    saveSession({ ...session, tokens: newTokens });
+    return newTokens.accessToken;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/output.ts
+var jsonMode = false;
+function fail(message, code = 1) {
+  if (jsonMode) {
+    console.error(JSON.stringify({ ok: false, error: message }));
+  } else {
+    console.error(`Error: ${message}`);
+  }
+  process.exit(code);
+}
+
+// src/utils/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+var PROJECT_CONFIG = ".neopressrc.json";
+var WORKSPACE_CONFIG = ".neopress/config.json";
+function readProjectConfig() {
+  let config = {};
+  for (const file of [PROJECT_CONFIG, WORKSPACE_CONFIG]) {
+    try {
+      const parsed = JSON.parse(readFileSync2(file, "utf-8"));
+      config = {
+        ...config,
+        ...typeof parsed.siteId === "number" ? { siteId: parsed.siteId } : {},
+        ...typeof parsed.baseUrl === "string" ? { baseUrl: parsed.baseUrl } : {}
+      };
+    } catch {
+    }
+  }
+  return config;
+}
+function writeWorkspaceConfig(next) {
+  mkdirSync2(dirname(WORKSPACE_CONFIG), { recursive: true });
+  writeFileSync2(WORKSPACE_CONFIG, JSON.stringify(next, null, 2) + "\n", "utf-8");
+}
+function getAccessToken() {
+  return process.env.NEOPRESS_ACCESS_TOKEN || loadSession().tokens?.accessToken;
+}
+function getSiteId() {
+  const envSiteId = process.env.NEOPRESS_SITE_ID;
+  if (envSiteId) return parseInt(envSiteId, 10);
+  const projectConfig = readProjectConfig();
+  if (projectConfig.siteId) return projectConfig.siteId;
+  return loadSession().activeSiteId;
+}
+function getBaseUrl() {
+  return process.env.NEOPRESS_BASE_URL || readProjectConfig().baseUrl || "https://app.neopress.ai";
+}
+function setActiveSiteId(siteId) {
+  const session = loadSession();
+  saveSession({ ...session, activeSiteId: siteId });
+  if (existsSync2(".neopress") || existsSync2(WORKSPACE_CONFIG)) {
+    writeWorkspaceConfig({ ...readProjectConfig(), siteId });
+  }
+}
+
+// src/utils/client.ts
+function getClient(siteIdOverride) {
+  const session = loadSession();
+  const accessToken = process.env.NEOPRESS_ACCESS_TOKEN || session.tokens?.accessToken;
+  const siteId = siteIdOverride ?? getSiteId();
+  if (!siteId) {
+    fail("No site selected. Run `neopress sites use <siteId>` or set NEOPRESS_SITE_ID.");
+  }
+  if (accessToken) {
+    return new NeopressClient({
+      accessToken,
+      siteId,
+      baseUrl: getBaseUrl()
+    });
+  }
+  fail("Not authenticated. Run `neopress login` or set NEOPRESS_ACCESS_TOKEN.");
+}
+async function getClientAsync(siteIdOverride) {
+  const siteId = siteIdOverride ?? getSiteId();
+  if (!siteId) {
+    fail("No site selected. Run `neopress sites use <siteId>` or set NEOPRESS_SITE_ID.");
+  }
+  if (process.env.NEOPRESS_ACCESS_TOKEN) {
+    return new NeopressClient({
+      accessToken: process.env.NEOPRESS_ACCESS_TOKEN,
+      siteId,
+      baseUrl: getBaseUrl()
+    });
+  }
+  const accessToken = await getValidAccessToken();
+  if (!accessToken) {
+    fail("Session expired. Run `neopress login` again.");
+  }
+  return new NeopressClient({
+    accessToken,
+    siteId,
+    baseUrl: getBaseUrl()
+  });
+}
+export {
+  clearSession,
+  getAccessToken,
+  getBaseUrl,
+  getClient,
+  getClientAsync,
+  getSiteId,
+  getValidAccessToken,
+  loadSession,
+  saveSession,
+  setActiveSiteId
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@neopress/cli",
+  "version": "0.1.0",
+  "description": "Neopress CLI — manage your Neopress site from the terminal",
+  "type": "module",
+  "bin": {
+    "neopress": "./dist/bin.cjs"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "commander": "^13.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0",
+    "@neopress/sdk": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit"
+  }
+}