@palettelab/cli 0.3.0 → 0.3.2

package/lib/commands/init.js

@@ -9,6 +9,8 @@ const DEFAULT_TEMPLATE_REPO = "palette-lab/plugin-template"
 const TEMPLATE_REPO = process.env.PALETTE_TEMPLATE_REPO || DEFAULT_TEMPLATE_REPO
 const TEMPLATE_REF = process.env.PALETTE_TEMPLATE_REF || "main"
 
+const KNOWN_TEMPLATES = ["frontend-only", "dashboard", "agent-tool", "external-service", "database"]
+
 function toSlug(name) {
   return name
     .toLowerCase()
@@ -18,7 +20,6 @@ function toSlug(name) {
 }
 
 function fetchTemplate(destDir) {
-  // Try git first — works offline-ish if git is available.
   const git = spawnSync(
     "git",
     ["clone", "--depth=1", "--branch", TEMPLATE_REF, `https://github.com/${TEMPLATE_REPO}.git`, destDir],
@@ -31,10 +32,23 @@ function fetchTemplate(destDir) {
   return false
 }
 
-function copyLocalFallback(destDir) {
+function copyLocalFallback(destDir, template) {
+  if (template) {
+    const tplDir = path.resolve(__dirname, "..", "..", "template-fallback", "templates", template)
+    if (!fs.existsSync(tplDir)) return false
+    fs.cpSync(tplDir, destDir, { recursive: true })
+    return true
+  }
   const fallback = path.resolve(__dirname, "..", "..", "template-fallback")
   if (!fs.existsSync(fallback)) return false
-  fs.cpSync(fallback, destDir, { recursive: true })
+  // Skip the templates/ directory when copying default fallback.
+  fs.cpSync(fallback, destDir, {
+    recursive: true,
+    filter: (src) => {
+      const rel = path.relative(fallback, src)
+      return !rel.startsWith("templates")
+    },
+  })
   return true
 }
 
@@ -47,10 +61,24 @@ function rewriteManifest(destDir, slug, displayName) {
   fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n")
 }
 
+function getOpt(args, name) {
+  const i = args.indexOf(name)
+  if (i >= 0 && args[i + 1]) return args[i + 1]
+  return null
+}
+
 async function run(args, { cwd }) {
-  const name = args[0]
+  const positional = args.filter((a) => !a.startsWith("-"))
+  const name = positional[0]
   if (!name) {
-    console.error("[palette] usage: palette init <plugin-name>")
+    console.error("[pltt] usage: pltt init <plugin-name> [--template <name>]")
+    console.error(`[palette] templates: ${KNOWN_TEMPLATES.join(", ")}`)
+    process.exit(1)
+  }
+  const template = getOpt(args, "--template")
+  if (template && !KNOWN_TEMPLATES.includes(template)) {
+    console.error(`[palette] unknown template: ${template}`)
+    console.error(`[palette] templates: ${KNOWN_TEMPLATES.join(", ")}`)
     process.exit(1)
   }
   const slug = toSlug(name)
@@ -63,18 +91,21 @@ async function run(args, { cwd }) {
     process.exit(1)
   }
 
-  console.log(`[palette] creating plugin "${slug}" from ${TEMPLATE_REPO}@${TEMPLATE_REF}`)
+  if (template) {
+    console.log(`[palette] creating plugin "${slug}" from template "${template}"`)
+  } else {
+    console.log(`[palette] creating plugin "${slug}" from ${TEMPLATE_REPO}@${TEMPLATE_REF}`)
+  }
 
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "palette-tpl-"))
-  let ok = fetchTemplate(tmp)
-  if (!ok) {
-    console.warn("[palette] git clone failed, falling back to bundled template")
-    ok = copyLocalFallback(tmp)
+  let ok = false
+  if (!template) {
+    ok = fetchTemplate(tmp)
+    if (!ok) console.warn("[palette] git clone failed, falling back to bundled template")
   }
+  if (!ok) ok = copyLocalFallback(tmp, template)
   if (!ok) {
-    console.error(
-      "[palette] no template available — install git or ship template-fallback/ with the CLI",
-    )
+    console.error("[palette] no template available")
     process.exit(1)
   }
 
@@ -86,6 +117,7 @@ async function run(args, { cwd }) {
   console.log("[palette] next steps:")
   console.log(`  cd ${slug}`)
   console.log(`  npx @palettelab/cli dev`)
+  console.log(`  # or, after global install: pltt dev`)
 }
 
 module.exports = run

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