@palettelab/cli 0.1.0 → 0.2.0

package/lib/cli.js

@@ -26,10 +26,16 @@ function printHelp() {
   for (const [name, { help }] of Object.entries(COMMANDS)) {
     console.log(`  ${name.padEnd(8)}  ${help}`)
   }
+  console.log("\nPublish flags:")
+  console.log("  --env <name>   Target environment from ~/.palette/config.json (default: local)")
+  console.log("  -y, --yes      Skip interactive confirmation for production pushes")
   console.log("\nExamples:")
-  console.log("  npx @palettelab/cli init my-app")
-  console.log("  cd my-app && npx @palettelab/cli dev")
-  console.log("  npx @palettelab/cli build")
+  console.log("  palette init my-app")
+  console.log("  cd my-app && palette dev")
+  console.log("  palette build")
+  console.log("  palette publish                      # default (local)")
+  console.log("  palette publish --env staging")
+  console.log("  palette publish --env production     # prompts for confirmation")
 }
 
 async function run(argv) {

package/lib/commands/publish.js

@@ -3,43 +3,35 @@
 const crypto = require("crypto")
 const { loadManifest, validateManifest } = require("../manifest")
 const { bundleFrontend, bundleBackend } = require("../bundler")
-
-const DEFAULT_PLATFORM_URL =
-  process.env.PALETTE_PLATFORM_URL || "https://platform.palette-lab.internal"
+const {
+  resolveEnvironment,
+  parseFlags,
+  confirmProduction,
+} = require("../environments")
 
 function sha256(buf) {
   return crypto.createHash("sha256").update(buf).digest("hex")
 }
 
-function token() {
-  const t = process.env.PALETTE_PUBLISH_TOKEN
-  if (!t) {
-    console.error(
-      "[palette] PALETTE_PUBLISH_TOKEN is required. Ask a superadmin to mint one for you via\n" +
-        "         POST /api/superadmin/publish-tokens — then `export PALETTE_PUBLISH_TOKEN=<token>`.",
-    )
-    process.exit(1)
-  }
-  return t
-}
-
-async function api(pathname, { method = "GET", body, headers = {} } = {}) {
-  const url = `${DEFAULT_PLATFORM_URL}${pathname}`
-  const res = await fetch(url, {
-    method,
-    headers: {
-      Authorization: `Bearer ${token()}`,
-      "Content-Type": "application/json",
-      ...headers,
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  })
-  if (!res.ok) {
-    const text = await res.text()
-    throw new Error(`${method} ${pathname} → ${res.status}: ${text}`)
+function makeApi(env) {
+  return async function api(pathname, { method = "GET", body, headers = {} } = {}) {
+    const url = `${env.url}${pathname}`
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${env.token}`,
+        "Content-Type": "application/json",
+        ...headers,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      throw new Error(`${method} ${pathname} → ${res.status}: ${text}`)
+    }
+    const ct = res.headers.get("content-type") || ""
+    return ct.includes("application/json") ? res.json() : res.text()
   }
-  const ct = res.headers.get("content-type") || ""
-  return ct.includes("application/json") ? res.json() : res.text()
 }
 
 async function put(url, buf, contentType) {
@@ -53,7 +45,34 @@ async function put(url, buf, contentType) {
   }
 }
 
-async function run(args, { cwd }) {
+async function run(argv, { cwd }) {
+  const { flags } = parseFlags(argv)
+
+  let env
+  try {
+    env = resolveEnvironment({ cwd, flags })
+  } catch (err) {
+    console.error(`[palette] ${err.message}`)
+    process.exit(1)
+  }
+
+  if (!env.token) {
+    console.error(
+      `[palette] no publish token for environment "${env.name}". ` +
+        `Set $${env.token_env} (or $PALETTE_PUBLISH_TOKEN as fallback).\n` +
+        `          Ask a superadmin to mint one via POST ${env.url}/api/superadmin/publish-tokens.`,
+    )
+    process.exit(1)
+  }
+
+  if (env.production_unconfirmed) {
+    const ok = await confirmProduction(env)
+    if (!ok) {
+      console.error("[palette] publish cancelled.")
+      process.exit(1)
+    }
+  }
+
   const manifest = loadManifest(cwd)
   const errors = validateManifest(manifest)
   if (errors.length) {
@@ -62,7 +81,9 @@ async function run(args, { cwd }) {
     process.exit(1)
   }
 
-  console.log(`[palette] publishing ${manifest.id}@${manifest.version}`)
+  console.log(
+    `[palette] publishing ${manifest.id}@${manifest.version} → ${env.name} (${env.url})`,
+  )
 
   console.log("[palette]   bundling frontend")
   const frontend = await bundleFrontend(cwd, manifest.frontend?.entry || "./frontend/src/index.tsx")
@@ -73,6 +94,7 @@ async function run(args, { cwd }) {
   console.log(`[palette]     ${backend.length} bytes`)
 
   const backendSha = sha256(backend)
+  const api = makeApi(env)
 
   console.log("[palette]   requesting signed URLs")
   const signed = await api("/api/v1/appstore/sign-upload", {
@@ -107,8 +129,11 @@ async function run(args, { cwd }) {
     },
   })
 
-  console.log(`[palette] published ${record.plugin_id}@${record.version}`)
-  console.log(`[palette] live at ${DEFAULT_PLATFORM_URL}${record.catalog_url}`)
+  console.log(
+    `[palette] published ${record.plugin_id}@${record.version} (status=${record.status})`,
+  )
+  console.log(`[palette] awaiting superadmin review on ${env.url}`)
+  console.log(`[palette] once approved, live at ${env.url}${record.catalog_url}`)
 }
 
 module.exports = run

package/lib/environments.js

@@ -0,0 +1,165 @@
+"use strict"
+
+/**
+ * Named environments for `palette publish`.
+ *
+ * Config is discovered in this order (first hit wins):
+ *   1. ./palette.config.json (plugin-repo-local override)
+ *   2. ~/.palette/config.json (per-user)
+ *   3. Built-in defaults (see DEFAULTS below)
+ *
+ * CLI env selection:
+ *   1. `--env <name>` flag
+ *   2. `PALETTE_ENV` env var
+ *   3. `default_environment` from config
+ *   4. "local"
+ *
+ * Each environment resolves to a platform URL and a publish token:
+ *   url        — absolute base URL of the target platform (no trailing slash)
+ *   token_env  — name of the env var holding the PALETTE_PUBLISH_TOKEN for this env
+ *   production — boolean; requires `--env production` flag AND interactive
+ *                confirmation (or `--yes` to skip). Keeps accidental prod
+ *                pushes from happening.
+ */
+
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const DEFAULTS = {
+  environments: {
+    local: {
+      url: "http://localhost:8000",
+      token_env: "PALETTE_LOCAL_TOKEN",
+      production: false,
+    },
+    staging: {
+      url: process.env.PALETTE_STAGING_URL || "",
+      token_env: "PALETTE_STAGING_TOKEN",
+      production: false,
+    },
+    production: {
+      url: process.env.PALETTE_PRODUCTION_URL || "",
+      token_env: "PALETTE_PROD_TOKEN",
+      production: true,
+    },
+  },
+  default_environment: "local",
+}
+
+function readJsonIfExists(p) {
+  try {
+    if (!fs.existsSync(p)) return null
+    return JSON.parse(fs.readFileSync(p, "utf8"))
+  } catch (err) {
+    console.error(`[palette] failed to parse ${p}: ${err.message}`)
+    return null
+  }
+}
+
+function loadConfig(cwd) {
+  const repoCfg = readJsonIfExists(path.join(cwd, "palette.config.json"))
+  if (repoCfg) return { ...DEFAULTS, ...repoCfg, environments: { ...DEFAULTS.environments, ...(repoCfg.environments || {}) } }
+  const userCfg = readJsonIfExists(path.join(os.homedir(), ".palette", "config.json"))
+  if (userCfg) return { ...DEFAULTS, ...userCfg, environments: { ...DEFAULTS.environments, ...(userCfg.environments || {}) } }
+  return DEFAULTS
+}
+
+/**
+ * Resolve the effective environment.
+ *
+ * Returns { name, url, token, production, production_unconfirmed }:
+ *   - name:  resolved environment name
+ *   - url:   platform URL
+ *   - token: publish token (may be "" if unset — caller decides whether to exit)
+ *   - production: boolean from config
+ *   - production_unconfirmed: true iff production AND --yes wasn't passed;
+ *     caller is expected to prompt.
+ */
+function resolveEnvironment({ cwd, flags }) {
+  const cfg = loadConfig(cwd)
+  const requested =
+    flags.env ||
+    process.env.PALETTE_ENV ||
+    cfg.default_environment ||
+    "local"
+
+  const envCfg = cfg.environments[requested]
+  if (!envCfg) {
+    const available = Object.keys(cfg.environments).join(", ")
+    throw new Error(
+      `unknown environment "${requested}". Available: ${available}. ` +
+        `Configure via ./palette.config.json or ~/.palette/config.json.`,
+    )
+  }
+
+  // Backward-compat: PALETTE_PLATFORM_URL / PALETTE_PUBLISH_TOKEN override
+  // per-env resolution when the user hasn't picked an env explicitly.
+  const useLegacy =
+    !flags.env &&
+    !process.env.PALETTE_ENV &&
+    process.env.PALETTE_PLATFORM_URL
+
+  const url = useLegacy
+    ? process.env.PALETTE_PLATFORM_URL
+    : envCfg.url
+
+  const token = useLegacy
+    ? process.env.PALETTE_PUBLISH_TOKEN || ""
+    : process.env[envCfg.token_env] || process.env.PALETTE_PUBLISH_TOKEN || ""
+
+  if (!url) {
+    throw new Error(
+      `environment "${requested}" has no url configured. Set it in ` +
+        `~/.palette/config.json or set PALETTE_${requested.toUpperCase()}_URL.`,
+    )
+  }
+
+  return {
+    name: requested,
+    url: url.replace(/\/+$/, ""),
+    token,
+    production: Boolean(envCfg.production),
+    production_unconfirmed: Boolean(envCfg.production) && !flags.yes,
+    token_env: envCfg.token_env,
+  }
+}
+
+/**
+ * Minimal arg parser — extracts `--env <name>`, `--yes`, `-y` from argv.
+ * Leaves positional args in `rest`.
+ */
+function parseFlags(argv) {
+  const flags = { env: undefined, yes: false }
+  const rest = []
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === "--env" || a === "-e") {
+      flags.env = argv[++i]
+    } else if (a.startsWith("--env=")) {
+      flags.env = a.slice("--env=".length)
+    } else if (a === "--yes" || a === "-y") {
+      flags.yes = true
+    } else {
+      rest.push(a)
+    }
+  }
+  return { flags, rest }
+}
+
+async function confirmProduction(env) {
+  return new Promise((resolve) => {
+    const readline = require("readline")
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    rl.question(
+      `\n[palette] You are about to publish to PRODUCTION (${env.url}).\n` +
+        `          Type the environment name ("${env.name}") to confirm, anything else cancels: `,
+      (answer) => {
+        rl.close()
+        resolve(answer.trim() === env.name)
+      },
+    )
+  })
+}
+
+module.exports = { resolveEnvironment, parseFlags, confirmProduction, loadConfig }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palettelab/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Developer CLI for building Palette platform plugins — no platform source access required.",
   "bin": {
     "palette": "./bin/palette.js"
@@ -10,6 +10,7 @@
     "lib",
     "platform-dev",
     "template-fallback",
+    "palette.config.example.json",
     "README.md"
   ],
   "engines": {

package/palette.config.example.json

@@ -0,0 +1,21 @@
+{
+  "_comment": "Copy to ./palette.config.json (per-plugin) or ~/.palette/config.json (per-user). Delete this comment line and entries you don't need.",
+  "default_environment": "local",
+  "environments": {
+    "local": {
+      "url": "http://localhost:8000",
+      "token_env": "PALETTE_LOCAL_TOKEN",
+      "production": false
+    },
+    "staging": {
+      "url": "https://staging.yourcompany.example",
+      "token_env": "PALETTE_STAGING_TOKEN",
+      "production": false
+    },
+    "production": {
+      "url": "https://app.yourcompany.example",
+      "token_env": "PALETTE_PROD_TOKEN",
+      "production": true
+    }
+  }
+}