@palettelab/cli 0.3.39 → 0.3.41

package/README.md

@@ -467,14 +467,16 @@ pltt dev --platform
 
 By default this starts:
 
-- A small local app shell on the first available port starting at http://localhost:3000
-- A local FastAPI backend runner on the first available port starting at http://localhost:8000
+- A small local app shell on the first available port starting at http://localhost:7321
+- A local FastAPI backend runner on the first available port starting at http://localhost:8732
 - A mock Palette platform context for `usePlatform()`, OS language, toasts, org/user data, and authenticated API calls
 - A plugin-local SQLite database under `.palette/dev/` when `capabilities.database` or `database` is enabled
 
 Your frontend entry is bundled and watched. Your backend entry is loaded under
 `/api/v1/plugins/<your-id>/*` with a dev `PluginContext`, so normal SDK calls
-work without Docker or platform source.
+work without Docker or platform source. The terminal streams local frontend
+requests, frontend rebuilds, and backend process output while `pltt dev` is
+running.
 
 The simulator also provides the same language fields that Palette OS provides:
 `language`, `fallbackLanguage`, `supportedLanguages`, and `setLanguage()`.
@@ -487,9 +489,9 @@ local dev. The simulator imports `backend/api/models.py` when present and create
 tables from `palette_sdk.db.PluginBase.metadata`. Production installs still use
 the declared Alembic migrations and platform-managed Postgres/RLS.
 
-`3000` and `8000` are preferred defaults, not hard requirements. If either port is already in use, `pltt dev` automatically picks the next free port and prints the actual URLs.
+`7321` and `8732` are preferred defaults, not hard requirements. If either port is already in use, `pltt dev` automatically picks the next free port and prints the actual URLs.
 
-`pltt dev --sandbox` skips Docker and publishes a reviewable preview to a configured Palette sandbox. This is the payment-gateway-style flow: your app uses local SDKs, while real platform services such as login, Data Room, storage, database policies, logs, review, and publish lifecycle run in the hosted sandbox. It defaults to `--env staging` unless `--env` or `PALETTE_ENV` is set, adds a 24-hour preview TTL by default, and prints the preview/status/log commands returned by the platform.
+`pltt dev --sandbox` skips Docker and publishes a reviewable preview to a configured Palette sandbox. This is the payment-gateway-style flow: your app uses local SDKs, while real platform services such as login, Data Room, storage, database policies, logs, review, and publish lifecycle run in the hosted sandbox. It defaults to `--env staging` unless `--env` or `PALETTE_ENV` is set, adds a 24-hour preview TTL by default, prints the preview/status URLs, then tails hosted app logs in the same terminal. Set `PALETTE_DEV_LOG_TAIL` to change the initial hosted log tail size.
 
 For developer sandboxes where manual approval should not block OS testing, run the sandbox backend with `APPSTORE_AUTO_APPROVE_SANDBOX_PREVIEWS=true`. Preview publishes are still checked by the automated review gates; passing preview publishes are marked active and synced immediately so backend routes, installs, logs, permissions, and platform APIs can be tested in the OS without Docker.
 
@@ -508,9 +510,10 @@ Environment variables:
 | Name | Default | Purpose |
 |---|---|---|
 | `PALETTE_DEV_IMAGE` | `ghcr.io/palette-lab/platform-dev:latest` | Override the platform image for `--platform` |
-| `PALETTE_FRONTEND_PORT` | `3000` | Preferred starting host port for the frontend |
-| `PALETTE_BACKEND_PORT` | `8000` | Preferred starting host port for the backend |
+| `PALETTE_FRONTEND_PORT` | `7321` | Preferred starting host port for the frontend |
+| `PALETTE_BACKEND_PORT` | `8732` | Preferred starting host port for the backend |
 | `PALETTE_DEV_DATABASE_URL` | `.palette/dev/<plugin-id>.sqlite3` | Override the local dev database URL |
+| `PALETTE_DEV_LOG_TAIL` | `200` | Initial hosted log events shown by `pltt dev --sandbox` / `--cloud` |
 | `APPSTORE_AUTO_APPROVE_SANDBOX_PREVIEWS` | `false` | Backend setting for hosted sandboxes; auto-approve passing preview publishes so developers can test full OS behavior without manual review |
 
 ### `pltt secrets`

package/lib/commands/dev.js

@@ -4,11 +4,12 @@ const path = require("path")
 const { spawn, spawnSync } = require("child_process")
 const { loadManifest } = require("../manifest")
 const { watchFrontend } = require("../bundler")
-const { parseFlags } = require("../environments")
+const { parseFlags, resolveEnvironment } = require("../environments")
 const { resolveDevPorts } = require("../ports")
 const { startSimulator } = require("../dev-simulator")
 const { loadLocalEnv } = require("../secrets")
 const publish = require("./publish")
+const logs = require("./logs")
 
 const DEFAULT_PLATFORM_IMAGE = "ghcr.io/palette-lab/platform-dev:latest"
 const DEFAULT_IMAGE = process.env.PALETTE_DEV_IMAGE || DEFAULT_PLATFORM_IMAGE
@@ -102,8 +103,22 @@ async function run(args, { cwd }) {
       console.log(`[pltt] preview URL: ${record.preview_url}`)
     }
     if (!json && record?.id) {
-      console.log(`[pltt] status: pltt status ${record.id} --env ${flags.env || process.env.PALETTE_ENV || "staging"}`)
-      console.log("[pltt] logs:   pltt logs --follow")
+      const envName = flags.env || process.env.PALETTE_ENV || "staging"
+      console.log(`[pltt] status: pltt status ${record.id} --env ${envName}`)
+      const logPluginId = record.plugin_id || loadManifest(cwd).id
+      console.log(`[pltt] logs:   streaming hosted app logs for ${logPluginId} (Ctrl+C to stop)`)
+      try {
+        const env = resolveEnvironment({ cwd, flags: { ...flags, env: envName } })
+        await logs.streamPluginLogs({
+          env,
+          pluginId: logPluginId,
+          tail: Number(process.env.PALETTE_DEV_LOG_TAIL || "200") || 200,
+          follow: true,
+        })
+      } catch (err) {
+        console.warn(`[pltt] could not stream hosted logs: ${err instanceof Error ? err.message : String(err)}`)
+        console.warn(`[pltt] run manually: pltt logs ${logPluginId} --follow --env ${envName}`)
+      }
     }
     return
   }

package/lib/commands/doctor.js

@@ -5,13 +5,13 @@ const path = require("path")
 const { spawnSync } = require("child_process")
 const { loadManifest, validateManifest } = require("../manifest")
 const { bundleFrontend } = require("../bundler")
-const { resolveDevPorts } = require("../ports")
+const { DEFAULT_BACKEND_DEV_PORT, DEFAULT_FRONTEND_DEV_PORT, resolveDevPorts } = require("../ports")
 const { declaredSecrets, loadLocalEnv } = require("../secrets")
 
 const DEFAULT_IMAGE =
   process.env.PALETTE_DEV_IMAGE || "ghcr.io/palette-lab/platform-dev:latest"
-const FRONTEND_PORT = Number(process.env.PALETTE_FRONTEND_PORT || "3000")
-const BACKEND_PORT = Number(process.env.PALETTE_BACKEND_PORT || "8000")
+const FRONTEND_PORT = Number(process.env.PALETTE_FRONTEND_PORT || DEFAULT_FRONTEND_DEV_PORT)
+const BACKEND_PORT = Number(process.env.PALETTE_BACKEND_PORT || DEFAULT_BACKEND_DEV_PORT)
 
 function ok(message) {
   console.log(`OK   ${message}`)

package/lib/commands/logs.js

@@ -31,6 +31,39 @@ async function fetchLogs(env, pluginId, tail) {
   return res.json()
 }
 
+function formatLogEvent(e) {
+  const ts = e.created_at
+  const tag = String(e.event_type || "event").padEnd(11)
+  const route = e.route || "-"
+  const code = e.status_code != null ? `[${e.status_code}]` : ""
+  const err = e.error_message ? ` err=${e.error_message}` : ""
+  return `${ts}  ${tag}  ${route} ${code}${err}`
+}
+
+async function streamPluginLogs({
+  env,
+  pluginId,
+  tail = 50,
+  follow = false,
+  json = false,
+  intervalMs = 3000,
+  log = console.log,
+}) {
+  let lastSeenId = 0
+  do {
+    const data = await fetchLogs(env, pluginId, tail)
+    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) log(JSON.stringify(e))
+    } else {
+      for (const e of fresh) log(formatLogEvent(e))
+    }
+    if (follow) await new Promise((r) => setTimeout(r, intervalMs))
+  } while (follow)
+}
+
 async function run(argv, { cwd }) {
   const json = argv.includes("--json")
   const follow = argv.includes("--follow") || argv.includes("-f")
@@ -68,32 +101,15 @@ async function run(argv, { cwd }) {
     process.exit(1)
   }
 
-  let lastSeenId = 0
-  do {
-    let data
-    try {
-      data = await fetchLogs(env, pluginId, tail)
-    } catch (err) {
-      console.error(`[pltt] ${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)
+  try {
+    await streamPluginLogs({ env, pluginId, tail, follow, json })
+  } catch (err) {
+    console.error(`[pltt] ${err.message}`)
+    process.exit(1)
+  }
 }
 
 module.exports = run
+module.exports.fetchLogs = fetchLogs
+module.exports.formatLogEvent = formatLogEvent
+module.exports.streamPluginLogs = streamPluginLogs

package/lib/dev-simulator.js

@@ -242,6 +242,7 @@ function startBackend(cwd, devDir, manifest, backendPort) {
   if (sdkPath) {
     env.PYTHONPATH = [sdkPath, env.PYTHONPATH].filter(Boolean).join(path.delimiter)
   }
+  console.log(`[pltt] backend logs: ${backendEntry} via uvicorn on http://localhost:${backendPort}`)
   const child = spawn(
     python,
     ["-m", "uvicorn", `${path.basename(runner, ".py")}:app`, "--host", "127.0.0.1", "--port", String(backendPort), "--reload", "--reload-dir", path.dirname(absEntry)],
@@ -444,10 +445,12 @@ async function startFrontend(cwd, devDir, manifest, frontendPort, backendPort) {
   const server = http.createServer((req, res) => {
     const url = new URL(req.url || "/", `http://127.0.0.1:${frontendPort}`)
     if (url.pathname === "/simulator.js") {
+      console.log(`[pltt] frontend GET ${url.pathname} -> 200`)
       res.writeHead(200, { "Content-Type": "text/javascript; charset=utf-8", "Cache-Control": "no-store" })
       res.end(fs.readFileSync(bundlePath))
       return
     }
+    console.log(`[pltt] frontend GET ${url.pathname} -> 200`)
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" })
     res.end(indexHtml(manifest))
   })
@@ -467,6 +470,7 @@ async function startSimulator({ cwd, frontendPort, backendPort }) {
   console.log("[pltt] running local SDK simulator (no Docker)")
   console.log(`[pltt] app:     http://localhost:${frontendPort}/`)
   if (backend) console.log(`[pltt] backend: http://localhost:${backendPort}/api/v1/plugins/${manifest.id}`)
+  console.log("[pltt] logs:    streaming frontend requests, frontend bundle rebuilds, and backend output")
   console.log("[pltt] use `pltt dev --platform` for full Docker platform parity")
 
   const stop = async () => {

package/lib/environments.js

@@ -29,7 +29,7 @@ const path = require("path")
 const DEFAULTS = {
   environments: {
     local: {
-      url: "http://localhost:8000",
+      url: "http://localhost:8732",
       token_env: "PALETTE_LOCAL_TOKEN",
       production: false,
     },

package/lib/ports.js

@@ -2,6 +2,9 @@
 
 const net = require("net")
 
+const DEFAULT_FRONTEND_DEV_PORT = 7321
+const DEFAULT_BACKEND_DEV_PORT = 8732
+
 function canBindPort(port, host = "0.0.0.0") {
   return new Promise((resolve) => {
     const server = net.createServer()
@@ -50,8 +53,8 @@ async function findFreePort(preferred, { host = "0.0.0.0", maxAttempts = 100 } =
 }
 
 async function resolveDevPorts({
-  frontend = process.env.PALETTE_FRONTEND_PORT || 3000,
-  backend = process.env.PALETTE_BACKEND_PORT || 8000,
+  frontend = process.env.PALETTE_FRONTEND_PORT || DEFAULT_FRONTEND_DEV_PORT,
+  backend = process.env.PALETTE_BACKEND_PORT || DEFAULT_BACKEND_DEV_PORT,
   host = "0.0.0.0",
 } = {}) {
   const frontendPort = await findFreePort(frontend, { host })
@@ -65,4 +68,12 @@ async function resolveDevPorts({
   }
 }
 
-module.exports = { canBindPort, canConnectPort, isPortAvailable, findFreePort, resolveDevPorts }
+module.exports = {
+  DEFAULT_FRONTEND_DEV_PORT,
+  DEFAULT_BACKEND_DEV_PORT,
+  canBindPort,
+  canConnectPort,
+  isPortAvailable,
+  findFreePort,
+  resolveDevPorts,
+}

package/package.json

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

package/platform-dev/docker-compose.yml

@@ -10,8 +10,8 @@ services:
   platform:
     image: ${PALETTE_DEV_IMAGE:-ghcr.io/palette-lab/platform-dev:latest}
     ports:
-      - "${PALETTE_FRONTEND_PORT:-3000}:3000"
-      - "${PALETTE_BACKEND_PORT:-8000}:8000"
+      - "${PALETTE_FRONTEND_PORT:-7321}:3000"
+      - "${PALETTE_BACKEND_PORT:-8732}:8000"
     environment:
       PALETTE_DEV_MODE: "1"
       NEXT_PUBLIC_PALETTE_DEV_MODE: "1"
@@ -19,9 +19,9 @@ services:
       DATABASE_URL: "postgresql+asyncpg://postgres:postgres@postgres:5432/app"
       REDIS_URL: "redis://redis:6379/0"
       JWT_SECRET: "dev-secret-do-not-use-in-prod"
-      FRONTEND_URL: "http://localhost:${PALETTE_FRONTEND_PORT:-3000}"
-      BACKEND_BASE_URL: "http://localhost:${PALETTE_BACKEND_PORT:-8000}"
-      NEXT_PUBLIC_API_URL: "http://localhost:${PALETTE_BACKEND_PORT:-8000}"
+      FRONTEND_URL: "http://localhost:${PALETTE_FRONTEND_PORT:-7321}"
+      BACKEND_BASE_URL: "http://localhost:${PALETTE_BACKEND_PORT:-8732}"
+      NEXT_PUBLIC_API_URL: "http://localhost:${PALETTE_BACKEND_PORT:-8732}"
       STORAGE_BACKEND: "local"
       LOCAL_STORAGE_DIR: "/srv/storage"
       # Disable optional features that need real credentials