@palettelab/cli 0.3.9 → 0.3.11

package/README.md

@@ -123,10 +123,13 @@ pltt publish --env staging
 pltt publish --env production
 pltt publish --env production -y
 pltt publish --env staging --json
+pltt publish --env staging --ttl-hours 24
 ```
 
 Publishing first runs the same contract checks as `pltt test`. If preflight passes, it bundles frontend/backend artifacts, uploads them, creates a `pending_review` publish record, and prints review/preview URLs when the platform returns them.
 
+`--ttl-hours` sets an expiration on the preview URL. It is mainly used by `pltt dev --cloud`, which defaults previews to 24 hours.
+
 Environment config is read from `./palette.config.json`, `~/.palette/config.json`, or `PALETTE_<ENV>_URL` plus `PALETTE_<ENV>_TOKEN` / `PALETTE_PUBLISH_TOKEN`.
 
 ### `pltt status <publish-id>`

package/lib/commands/publish.js

@@ -191,6 +191,7 @@ async function run(argv, { cwd }) {
           env: env.name,
           url: env.url,
           preview_url: record.preview_url,
+          preview_expires_at: record.preview_expires_at,
           published_at: new Date().toISOString(),
         },
         null,
@@ -216,6 +217,9 @@ async function run(argv, { cwd }) {
   if (record.preview_url) {
     console.log(`[pltt] preview: ${record.preview_url}`)
   }
+  if (record.preview_expires_at) {
+    console.log(`[pltt] preview expires: ${record.preview_expires_at}`)
+  }
   console.log(`[pltt] once approved, live at ${env.url}${record.catalog_url}`)
   return record
 }

package/lib/commands/status.js

@@ -67,6 +67,7 @@ async function run(argv, { cwd }) {
   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}`)
+  if (data.preview_expires_at) console.log(`  expires:   ${data.preview_expires_at}`)
   console.log(`  published: ${data.published_at}`)
   if (data.report) {
     console.log(`  risk:      ${data.report.risk_score.toUpperCase()}`)

package/lib/commands/test.js

@@ -35,20 +35,27 @@ function reporter(json, results) {
   }
 }
 
+function localBackendSdkPath() {
+  const candidate = path.resolve(__dirname, "..", "..", "..", "backend")
+  return fs.existsSync(path.join(candidate, "palette_sdk")) ? candidate : null
+}
+
+function localBackendSdkPython() {
+  const sdkPath = localBackendSdkPath()
+  if (!sdkPath) return null
+  const candidate = path.join(sdkPath, ".venv", "bin", "python")
+  return fs.existsSync(candidate) ? candidate : null
+}
+
 function backendPython(cwd) {
   return (
     process.env.PALETTE_PYTHON ||
     (fs.existsSync(path.join(cwd, ".venv", "bin", "python"))
       ? path.join(cwd, ".venv", "bin", "python")
-      : "python3")
+      : localBackendSdkPython() || "python3")
   )
 }
 
-function localBackendSdkPath() {
-  const candidate = path.resolve(__dirname, "..", "..", "..", "backend")
-  return fs.existsSync(path.join(candidate, "palette_sdk")) ? candidate : null
-}
-
 function pythonEnv(extra = {}) {
   const paths = []
   if (extra.PYTHONPATH) paths.push(extra.PYTHONPATH)
@@ -76,6 +83,11 @@ function installPythonDependencies(cwd, out) {
   }
 
   const hostPython = backendPython(cwd)
+  if (hostPython === localBackendSdkPython()) {
+    out.ok("using local backend SDK virtualenv for backend import checks", { dependencies: deps })
+    return { python: hostPython, env: pythonEnv(), failures: 0, dependencies: deps }
+  }
+
   const venvDir = path.join(cwd, ".palette", "test-venv")
   const venvPython = path.join(venvDir, "bin", "python")
   const lockPath = path.join(venvDir, ".palette-deps-lock")

package/lib/ports.js

@@ -13,13 +13,38 @@ function canBindPort(port, host = "0.0.0.0") {
   })
 }
 
+function canConnectPort(port, host, timeoutMs = 250) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ port, host })
+    const done = (connected) => {
+      socket.removeAllListeners()
+      socket.destroy()
+      resolve(connected)
+    }
+    socket.setTimeout(timeoutMs)
+    socket.once("connect", () => done(true))
+    socket.once("timeout", () => done(false))
+    socket.once("error", () => done(false))
+  })
+}
+
+async function isPortAvailable(port, { bindHost = "0.0.0.0" } = {}) {
+  // Docker publishes host ports on localhost-facing addresses. A process bound
+  // only to 127.0.0.1 or ::1 can be missed by a single 0.0.0.0 bind probe on
+  // some host setups, so test the addresses users actually open in browsers.
+  for (const host of ["127.0.0.1", "::1", "localhost"]) {
+    if (await canConnectPort(port, host)) return false
+  }
+  return canBindPort(port, bindHost)
+}
+
 async function findFreePort(preferred, { host = "0.0.0.0", maxAttempts = 100 } = {}) {
   const start = Number(preferred)
   if (!Number.isInteger(start) || start <= 0 || start > 65535) {
     throw new Error(`invalid port: ${preferred}`)
   }
   for (let port = start; port < start + maxAttempts && port <= 65535; port++) {
-    if (await canBindPort(port, host)) return port
+    if (await isPortAvailable(port, { bindHost: host })) return port
   }
   throw new Error(`no free port found from ${start} to ${Math.min(start + maxAttempts - 1, 65535)}`)
 }
@@ -39,4 +64,4 @@ async function resolveDevPorts({
   }
 }
 
-module.exports = { canBindPort, findFreePort, resolveDevPorts }
+module.exports = { canBindPort, canConnectPort, isPortAvailable, findFreePort, resolveDevPorts }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palettelab/cli",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Developer CLI for building Palette platform plugins — no platform source access required.",
   "bin": {
     "pltt": "bin/pltt.js"