@palettelab/cli 0.2.0 → 0.3.1

package/lib/commands/logs.js

@@ -0,0 +1,99 @@
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const { resolveEnvironment, parseFlags } = require("../environments")
+const { loadManifest } = require("../manifest")
+
+function readLastPublish(cwd) {
+  const p = path.join(cwd, ".palette", "last-publish.json")
+  if (!fs.existsSync(p)) return null
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"))
+  } catch {
+    return null
+  }
+}
+
+function getOpt(argv, name, def) {
+  const i = argv.indexOf(name)
+  if (i >= 0 && argv[i + 1]) return argv[i + 1]
+  return def
+}
+
+async function fetchLogs(env, pluginId, tail) {
+  const url = `${env.url}/api/v1/appstore/plugins/${encodeURIComponent(pluginId)}/logs?tail=${tail}`
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${env.token}` } })
+  if (!res.ok) {
+    const text = await res.text()
+    throw new Error(`GET ${url} → ${res.status}: ${text}`)
+  }
+  return res.json()
+}
+
+async function run(argv, { cwd }) {
+  const json = argv.includes("--json")
+  const follow = argv.includes("--follow") || argv.includes("-f")
+  const tail = parseInt(getOpt(argv, "--tail", "50"), 10) || 50
+
+  const positional = argv.filter((a) => !a.startsWith("-"))
+  let pluginId = positional[0]
+  const last = readLastPublish(cwd)
+  if (!pluginId) {
+    if (last && last.plugin_id) pluginId = last.plugin_id
+    else {
+      try {
+        pluginId = loadManifest(cwd).id
+      } catch {
+        // ignore
+      }
+    }
+  }
+  if (!pluginId) {
+    console.error("[palette] no plugin id provided and no manifest found.")
+    process.exit(1)
+  }
+
+  const { flags } = parseFlags(argv)
+  if (!flags.env && last && last.env) flags.env = last.env
+  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 "${env.name}". set $${env.token_env}.`)
+    process.exit(1)
+  }
+
+  let lastSeenId = 0
+  do {
+    let data
+    try {
+      data = await fetchLogs(env, pluginId, tail)
+    } catch (err) {
+      console.error(`[palette] ${err.message}`)
+      process.exit(1)
+    }
+    const events = data.events || []
+    const fresh = events.filter((e) => e.id > lastSeenId)
+    if (fresh.length) lastSeenId = Math.max(...fresh.map((e) => e.id))
+    if (json) {
+      for (const e of fresh) console.log(JSON.stringify(e))
+    } else {
+      for (const e of fresh) {
+        const ts = e.created_at
+        const tag = e.event_type.padEnd(11)
+        const route = e.route || "-"
+        const code = e.status_code != null ? `[${e.status_code}]` : ""
+        const err = e.error_message ? ` err=${e.error_message}` : ""
+        console.log(`${ts}  ${tag}  ${route} ${code}${err}`)
+      }
+    }
+    if (follow) await new Promise((r) => setTimeout(r, 3000))
+  } while (follow)
+}
+
+module.exports = run

package/lib/commands/package.js

@@ -0,0 +1,64 @@
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const crypto = require("crypto")
+const { loadManifest, validateManifest } = require("../manifest")
+const { bundleFrontend, bundleBackend } = require("../bundler")
+
+function sha256(buf) {
+  return crypto.createHash("sha256").update(buf).digest("hex")
+}
+
+async function run(argv, { cwd }) {
+  const json = argv.includes("--json")
+  const manifest = loadManifest(cwd)
+  const errors = validateManifest(manifest)
+  if (errors.length) {
+    console.error("[palette] manifest invalid:")
+    for (const e of errors) console.error(`  - ${e}`)
+    process.exit(1)
+  }
+
+  const distDir = path.join(cwd, "dist")
+  fs.mkdirSync(distDir, { recursive: true })
+
+  const frontend = manifest.frontend
+    ? await bundleFrontend(cwd, manifest.frontend.entry || "./frontend/src/index.tsx")
+    : null
+  const backend = manifest.backend ? await bundleBackend(cwd) : null
+
+  const out = path.join(distDir, `${manifest.id}-${manifest.version}.tar.gz`)
+  // Build a simple tar by piping through node-tar via spawn — avoid extra dep
+  // by writing files into a staging dir and shelling out to `tar`. The
+  // platform-dev image already ships with tar, and any developer running this
+  // CLI will have it too on macOS/Linux.
+  const stage = fs.mkdtempSync(path.join(require("os").tmpdir(), "palette-pkg-"))
+  fs.writeFileSync(path.join(stage, "palette-plugin.json"), JSON.stringify(manifest, null, 2))
+  if (frontend) fs.writeFileSync(path.join(stage, "frontend.mjs"), frontend)
+  if (backend) fs.writeFileSync(path.join(stage, "backend.tar.gz"), backend)
+
+  const { spawnSync } = require("child_process")
+  const r = spawnSync("tar", ["-czf", out, "-C", stage, "."], { stdio: "inherit" })
+  if (r.status !== 0) {
+    console.error("[palette] tar failed")
+    process.exit(1)
+  }
+
+  const buf = fs.readFileSync(out)
+  const result = {
+    id: manifest.id,
+    version: manifest.version,
+    path: out,
+    bytes: buf.length,
+    sha256: sha256(buf),
+  }
+  if (json) {
+    console.log(JSON.stringify(result, null, 2))
+  } else {
+    console.log(`[palette] packaged ${manifest.id}@${manifest.version} → ${out} (${buf.length} bytes)`)
+    console.log(`[palette] sha256: ${result.sha256}`)
+  }
+}
+
+module.exports = run

package/lib/commands/publish.js

@@ -1,6 +1,8 @@
 "use strict"
 
 const crypto = require("crypto")
+const fs = require("fs")
+const path = require("path")
 const { loadManifest, validateManifest } = require("../manifest")
 const { bundleFrontend, bundleBackend } = require("../bundler")
 const {
@@ -85,9 +87,14 @@ async function run(argv, { cwd }) {
     `[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")
-  console.log(`[palette]     ${frontend.length} bytes`)
+  let frontend = null
+  if (manifest.frontend?.entry) {
+    console.log("[palette]   bundling frontend")
+    frontend = await bundleFrontend(cwd, manifest.frontend.entry)
+    console.log(`[palette]     ${frontend.length} bytes`)
+  } else {
+    console.log("[palette]   no frontend declared")
+  }
 
   console.log("[palette]   bundling backend")
   const backend = await bundleBackend(cwd)
@@ -107,15 +114,18 @@ async function run(argv, { cwd }) {
   })
 
   console.log("[palette]   uploading")
-  await Promise.all([
-    put(signed.frontend_upload_url, frontend, "application/javascript"),
+  const uploads = [
     put(signed.backend_upload_url, backend, "application/gzip"),
     put(
       signed.manifest_upload_url,
       Buffer.from(JSON.stringify(manifest, null, 2)),
       "application/json",
     ),
-  ])
+  ]
+  if (frontend) {
+    uploads.push(put(signed.frontend_upload_url, frontend, "application/javascript"))
+  }
+  await Promise.all(uploads)
 
   console.log("[palette]   finalizing")
   const record = await api("/api/v1/appstore/publish", {
@@ -129,10 +139,44 @@ async function run(argv, { cwd }) {
     },
   })
 
+  try {
+    const dir = path.join(cwd, ".palette")
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(
+      path.join(dir, "last-publish.json"),
+      JSON.stringify(
+        {
+          id: record.id,
+          plugin_id: record.plugin_id,
+          version: record.version,
+          env: env.name,
+          url: env.url,
+          preview_url: record.preview_url,
+          published_at: new Date().toISOString(),
+        },
+        null,
+        2,
+      ),
+    )
+  } catch (err) {
+    // best-effort
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify(record, null, 2))
+    return
+  }
+
   console.log(
     `[palette] published ${record.plugin_id}@${record.version} (status=${record.status})`,
   )
   console.log(`[palette] awaiting superadmin review on ${env.url}`)
+  if (record.review_url) {
+    console.log(`[palette] review queue: ${record.review_url}`)
+  }
+  if (record.preview_url) {
+    console.log(`[palette] preview: ${record.preview_url}`)
+  }
   console.log(`[palette] once approved, live at ${env.url}${record.catalog_url}`)
 }
 

package/lib/commands/status.js

@@ -0,0 +1,80 @@
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const { resolveEnvironment, parseFlags } = require("../environments")
+
+function readLastPublish(cwd) {
+  const p = path.join(cwd, ".palette", "last-publish.json")
+  if (!fs.existsSync(p)) return null
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"))
+  } catch {
+    return null
+  }
+}
+
+async function run(argv, { cwd }) {
+  const json = argv.includes("--json")
+  const positional = argv.filter((a) => !a.startsWith("-"))
+  const last = readLastPublish(cwd)
+  const publishId = positional[0] || (last && last.id)
+
+  if (!publishId) {
+    console.error(
+      "[palette] no publish id provided and no .palette/last-publish.json found.",
+    )
+    console.error("          usage: pltt status <publish-id> [--env <name>]")
+    process.exit(1)
+  }
+
+  const { flags } = parseFlags(argv)
+  if (!flags.env && last && last.env) flags.env = last.env
+
+  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}.`,
+    )
+    process.exit(1)
+  }
+
+  const url = `${env.url}/api/v1/appstore/publishes/${publishId}`
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${env.token}` },
+  })
+  if (!res.ok) {
+    const text = await res.text()
+    console.error(`[palette] GET ${url} → ${res.status}: ${text}`)
+    process.exit(1)
+  }
+  const data = await res.json()
+
+  if (json) {
+    console.log(JSON.stringify(data, null, 2))
+    return
+  }
+
+  console.log(`[palette] ${data.plugin_id}@${data.version}`)
+  console.log(`  status:    ${data.status}`)
+  if (data.review_decision) console.log(`  decision:  ${data.review_decision}`)
+  if (data.review_reason) console.log(`  reason:    ${data.review_reason}`)
+  if (data.preview_url) console.log(`  preview:   ${data.preview_url}`)
+  console.log(`  published: ${data.published_at}`)
+  if (data.report) {
+    console.log(`  risk:      ${data.report.risk_score.toUpperCase()}`)
+    console.log(
+      `    permissions=${data.report.permission_risk}, migrations=${data.report.migration_risk}, network=${data.report.external_network_risk}`,
+    )
+    console.log(`    bundle=${data.report.bundle_size_bytes} bytes, sandbox=${data.report.sandbox_enabled}`)
+  }
+}
+
+module.exports = run