py-serverless-kit 0.1.0__py3-none-any.whl

py_serverless_kit/core/describe.py

@@ -0,0 +1,112 @@
+"""Builds the deployment record that powers ``pskit info`` and the dashboard."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from .._version import __version__
+from ..config.schema import EventSpec, FunctionConfig
+from .project import Project
+
+RECORD_FILE = "deployment.json"
+
+
+def event_summary(ev: EventSpec) -> Dict[str, Any]:
+    c = ev.config
+    if ev.type == "http":
+        text = f"{c.method} {c.path}"
+        extra = {"method": c.method, "path": c.path, "auth": c.auth, "cors": bool(c.cors)}
+    elif ev.type == "schedule":
+        text = f"rate({c.rate})" if c.rate else f"cron({c.cron})"
+        extra = {"rate": c.rate, "cron": c.cron, "enabled": c.enabled}
+    elif ev.type == "queue":
+        text = f"queue {c.name} (batch {c.batch_size})"
+        extra = {"name": c.name, "batch_size": c.batch_size, "existing": c.existing}
+    elif ev.type == "storage":
+        filt = "".join(f" {k}={v}" for k, v in (("prefix", c.prefix), ("suffix", c.suffix)) if v)
+        text = f"bucket {c.bucket} [{', '.join(c.events)}]{filt}"
+        extra = {"bucket": c.bucket, "events": list(c.events), "prefix": c.prefix, "suffix": c.suffix}
+    else:
+        text = f"topic {c.name}"
+        extra = {"name": c.name, "existing": c.existing}
+    return {"type": ev.type, "summary": text, **extra}
+
+
+def function_record(project: Project, name: str, fn: FunctionConfig, out: Dict[str, Any]) -> Dict[str, Any]:
+    cfg = project.config
+    events = [event_summary(e) for e in fn.events]
+    url = out.get("url")
+    urls = []
+    for e in events:
+        if e["type"] == "http" and out.get("base_url"):
+            urls.append({"method": e["method"], "url": out["base_url"].rstrip("/") + e["path"]})
+    return {
+        "name": name,
+        "resource_name": project.provider.physical_name(cfg.service, cfg.provider.stage, name),
+        "handler": fn.handler,
+        "description": fn.description,
+        "kind": fn.kind,
+        "generated": fn.handler.startswith("py_serverless_kit."),
+        "runtime": cfg.runtime_of(fn),
+        "memory": cfg.memory_of(fn),
+        "timeout": cfg.timeout_of(fn),
+        "architecture": cfg.architecture_of(fn),
+        "events": events,
+        "environment_keys": sorted(set(cfg.provider.environment) | set(fn.environment)),
+        "id": out.get("id"),
+        "arn": out.get("arn"),
+        "url": url,
+        "urls": urls,
+        "console": out.get("console"),
+    }
+
+
+def build_record(
+    project: Project,
+    outputs: Optional[Dict[str, Any]] = None,
+    artifact: Optional[Dict[str, Any]] = None,
+    status: str = "deployed",
+) -> Dict[str, Any]:
+    outputs = outputs or {}
+    pskit_out = outputs.get("pskit") or {}
+    fn_out: Dict[str, Any] = pskit_out.get("functions") or {}
+    wf_out: Dict[str, Any] = pskit_out.get("workflows") or {}
+    cfg = project.config
+    functions: List[Dict[str, Any]] = []
+    for name, fn in sorted(cfg.functions.items()):
+        functions.append(function_record(project, name, fn, dict(fn_out.get(name) or {})))
+    workflows = []
+    for name, wf in sorted(cfg.workflows.items()):
+        out = dict(wf_out.get(name) or {})
+        workflows.append(
+            {
+                "name": name,
+                "description": wf.description,
+                "engine": project.engines.get(name, "native"),
+                "start_at": wf.start_at,
+                "states": {k: v.type for k, v in wf.states.items()},
+                "functions": sorted(set(wf.task_functions())),
+                "id": out.get("id"),
+                "url": out.get("url"),
+                "console": out.get("console"),
+            }
+        )
+    return {
+        "schema": 1,
+        "status": status,
+        "service": cfg.service,
+        "stage": cfg.provider.stage,
+        "provider": cfg.provider.name,
+        "provider_display": project.provider.display_name,
+        "provider_tier": project.provider.tier,
+        "region": project.region,
+        "endpoint": pskit_out.get("endpoint"),
+        "deployed_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "pskit_version": __version__,
+        "config_file": str(project.loaded.path.name),
+        "artifact": artifact or {},
+        "functions": functions,
+        "workflows": workflows,
+        "outputs": {k: v for k, v in outputs.items() if k != "pskit"},
+    }

py_serverless_kit/core/project.py

@@ -0,0 +1,147 @@
+"""A loaded project: config + provider + working directory, ready to build/deploy."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..config.loader import LoadedConfig, load_config
+from ..config.schema import EventSpec, FunctionConfig, HttpEvent, ServiceConfig
+from ..providers.base import HTTP, ORCHESTRATOR_HANDLER, Issue, Provider
+from ..providers.registry import get_provider
+from ..workflows import definition_dict
+
+WORK_DIR = ".pskit"
+
+
+def orchestrator_name(workflow: str) -> str:
+    return f"{workflow}-orchestrator"
+
+
+@dataclass
+class Project:
+    loaded: LoadedConfig
+    provider: Provider
+    config: ServiceConfig
+    engines: Dict[str, str] = field(default_factory=dict)
+
+    # ---------------------------------------------------------------- loading
+    @classmethod
+    def load(
+        cls,
+        config_path: Optional[str] = None,
+        *,
+        provider: Optional[str] = None,
+        stage: Optional[str] = None,
+        region: Optional[str] = None,
+        cwd: Optional[Path] = None,
+    ) -> Project:
+        loaded = load_config(config_path, provider=provider, stage=stage, region=region, cwd=cwd)
+        return cls.from_loaded(loaded)
+
+    @classmethod
+    def from_loaded(cls, loaded: LoadedConfig) -> Project:
+        prov = get_provider(loaded.config.provider.name)
+        config = loaded.config
+        if "runtime" not in (loaded.raw.get("provider") or {}):
+            # Not pinned by the user: pick what this cloud supports.
+            provider_cfg = config.provider.model_copy(update={"runtime": prov.default_runtime})
+            config = config.model_copy(update={"provider": provider_cfg})
+        config, engines = expand(config, prov)
+        return cls(loaded=loaded, provider=prov, config=config, engines=engines)
+
+    # ---------------------------------------------------------------- paths
+    @property
+    def root(self) -> Path:
+        return self.loaded.root
+
+    @property
+    def work_dir(self) -> Path:
+        return self.root / WORK_DIR / f"{self.config.provider.name}-{self.config.provider.stage}"
+
+    @property
+    def region(self) -> str:
+        return self.provider.region(self.config)
+
+    # ---------------------------------------------------------------- checks
+    def validate(self) -> List[Issue]:
+        issues = self.provider.validate(self.config)
+        source = (self.root / self.config.package.source).resolve()
+        if not source.is_dir():
+            issues.append(Issue("error", f"package.source {source} is not a directory", "package.source"))
+        for name, fn in self.config.functions.items():
+            if fn.handler == ORCHESTRATOR_HANDLER:
+                continue
+            module = fn.handler.replace(":", ".").rsplit(".", 1)[0]
+            rel = Path(*module.split("."))
+            if not ((source / rel).with_suffix(".py").is_file() or (source / rel / "__init__.py").is_file()):
+                issues.append(
+                    Issue("warning", f"handler module {module!r} not found under {source}", f"functions.{name}.handler")
+                )
+        return issues
+
+    # ---------------------------------------------------------------- bundle manifest
+    def bundle_manifest(self) -> Dict[str, Any]:
+        functions: Dict[str, Any] = {}
+        for name, fn in sorted(self.config.functions.items()):
+            routes = []
+            for ev in fn.events_of("http"):
+                cors = ev.cors_config
+                routes.append(
+                    {
+                        "method": ev.method,
+                        "path": ev.path,
+                        "cors": cors.model_dump() if cors is not None else None,
+                    }
+                )
+            functions[name] = {
+                "handler": fn.handler,
+                "routes": routes,
+                "timeout": self.config.timeout_of(fn),
+                "memory": self.config.memory_of(fn),
+                "resource_name": self.provider.physical_name(self.config.service, self.config.provider.stage, name),
+            }
+        workflows = {
+            name: {"orchestrator": orchestrator_name(name), "definition": definition_dict(wf)}
+            for name, wf in sorted(self.config.workflows.items())
+            if self.engines.get(name) == "embedded"
+        }
+        return {
+            "service": self.config.service,
+            "stage": self.config.provider.stage,
+            "provider": self.config.provider.name,
+            "region": self.region,
+            "functions": functions,
+            "workflows": workflows,
+        }
+
+
+def expand(config: ServiceConfig, provider: Provider) -> tuple[ServiceConfig, Dict[str, str]]:
+    """Add generated functions (embedded workflow orchestrators) to the config."""
+    engines: Dict[str, str] = {}
+    functions = dict(config.functions)
+    for name, wf in config.workflows.items():
+        try:
+            engine = provider.workflow_engine(wf)
+        except Exception:  # noqa: BLE001 - reported properly by Provider.validate
+            engine = "embedded"
+        engines[name] = engine
+        if engine != "embedded":
+            continue
+        orch = orchestrator_name(name)
+        if orch in functions:
+            continue
+        events: List[EventSpec] = []
+        if HTTP in provider.capabilities and wf.options.get("http", True):
+            events.append(EventSpec(type="http", config=HttpEvent(method="POST", path=f"/workflows/{name}")))
+        functions[orch] = FunctionConfig(
+            handler=ORCHESTRATOR_HANDLER,
+            description=f"Embedded orchestrator for workflow {name}",
+            timeout=min(wf.timeout or provider.max_timeout, provider.max_timeout),
+            events=events,
+            tags={"pskit-workflow": name},
+        )
+    if functions == config.functions:
+        return config, engines
+    return config.model_copy(update={"functions": functions}), engines

py_serverless_kit/dashboard/__init__.py

@@ -0,0 +1,3 @@
+from .generator import collect_records, local_record, render_html, write_dashboard
+
+__all__ = ["collect_records", "local_record", "render_html", "write_dashboard"]

py_serverless_kit/dashboard/generator.py

@@ -0,0 +1,65 @@
+"""Generate the deployment dashboard: one self-contained ``index.html``.
+
+The page lists every deployment found under ``.pskit/*/deployment.json`` (all
+providers and stages of the project) with functions, triggers, endpoints,
+resource identifiers and workflows. It has no external dependencies, so it can
+be opened from disk, served by ``pskit dashboard --serve``, or uploaded to any
+static host / bucket.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..core.describe import RECORD_FILE, build_record
+from ..core.project import WORK_DIR, Project
+
+TEMPLATE = Path(__file__).with_name("template.html")
+
+
+def collect_records(root: Path) -> List[Dict[str, Any]]:
+    records: List[Dict[str, Any]] = []
+    base = root / WORK_DIR
+    if not base.is_dir():
+        return records
+    for path in sorted(base.glob(f"*/{RECORD_FILE}")):
+        try:
+            records.append(json.loads(path.read_text("utf-8")))
+        except (OSError, ValueError):
+            continue
+    records.sort(key=lambda r: (r.get("service", ""), r.get("provider", ""), r.get("stage", "")))
+    return records
+
+
+def local_record(project: Project) -> Dict[str, Any]:
+    """A record built from config only (nothing deployed yet / local dev)."""
+    return build_record(project, outputs=None, status="local")
+
+
+def render_html(records: List[Dict[str, Any]], title: str = "Serverless dashboard") -> str:
+    payload = json.dumps(
+        {"generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds"), "deployments": records},
+        default=str,
+    )
+    # Make the JSON safe inside a <script> element.
+    payload = payload.replace("</", "<\\/").replace("<!--", "<\\!--")
+    template = TEMPLATE.read_text("utf-8")
+    return template.replace("{{TITLE}}", html.escape(title)).replace("{{DATA}}", payload)
+
+
+def write_dashboard(
+    root: Path,
+    records: Optional[List[Dict[str, Any]]] = None,
+    output: Optional[Path] = None,
+    title: Optional[str] = None,
+) -> Path:
+    records = collect_records(root) if records is None else records
+    out = output or (root / WORK_DIR / "dashboard" / "index.html")
+    out.parent.mkdir(parents=True, exist_ok=True)
+    services = sorted({r.get("service", "") for r in records if r.get("service")})
+    out.write_text(render_html(records, title or (" / ".join(services) or "Serverless") + " dashboard"), "utf-8")
+    return out

py_serverless_kit/dashboard/template.html

@@ -0,0 +1,248 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{{TITLE}}</title>
+<style>
+  :root {
+    --bg: #f6f7f9; --panel: #ffffff; --text: #1d2330; --muted: #5d6677; --line: #e3e6ec;
+    --accent: #3b5bdb; --accent-soft: #e7ecff; --ok: #2b8a3e; --ok-soft: #e6f4ea;
+    --warn: #b35c00; --warn-soft: #fff1e0; --off: #868e96; --off-soft: #f1f3f5;
+    --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+      --bg: #12151c; --panel: #1a1f29; --text: #e6e9ef; --muted: #98a2b3; --line: #2a3140;
+      --accent: #8ea6ff; --accent-soft: #232c4a; --ok: #69db7c; --ok-soft: #1d3324;
+      --warn: #ffb057; --warn-soft: #3a2a17; --off: #adb5bd; --off-soft: #262b35;
+    }
+  }
+  :root[data-theme="dark"] {
+    --bg: #12151c; --panel: #1a1f29; --text: #e6e9ef; --muted: #98a2b3; --line: #2a3140;
+    --accent: #8ea6ff; --accent-soft: #232c4a; --ok: #69db7c; --ok-soft: #1d3324;
+    --warn: #ffb057; --warn-soft: #3a2a17; --off: #adb5bd; --off-soft: #262b35;
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--text);
+         font: 14px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
+  header { padding: 20px 16px 8px; max-width: 1280px; margin: 0 auto; }
+  h1 { margin: 0; font-size: 22px; }
+  .sub { color: var(--muted); font-size: 13px; }
+  main { max-width: 1280px; margin: 0 auto; padding: 8px 16px 48px; }
+  .toolbar { display: flex; gap: 8px; flex-wrap: wrap; margin: 12px 0 16px; }
+  .toolbar input, .toolbar select, .toolbar button {
+    font: inherit; color: var(--text); background: var(--panel); border: 1px solid var(--line);
+    border-radius: 8px; padding: 7px 10px; }
+  .toolbar input { flex: 1 1 240px; min-width: 0; }
+  .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; margin-bottom: 18px; }
+  .card { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 12px 14px; }
+  .card b { display: block; font-size: 22px; }
+  .card span { color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: .04em; }
+  section.dep { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; margin-bottom: 18px; overflow: hidden; }
+  .dep-head { padding: 14px 16px; border-bottom: 1px solid var(--line); display: flex; flex-wrap: wrap; gap: 8px 16px; align-items: center; }
+  .dep-head h2 { margin: 0; font-size: 17px; }
+  .meta { color: var(--muted); font-size: 12px; display: flex; flex-wrap: wrap; gap: 4px 14px; }
+  .meta code { font-family: var(--mono); }
+  .badge { display: inline-block; font-size: 11px; font-weight: 600; padding: 2px 8px; border-radius: 999px;
+           background: var(--accent-soft); color: var(--accent); white-space: nowrap; }
+  .badge.ok { background: var(--ok-soft); color: var(--ok); }
+  .badge.warn { background: var(--warn-soft); color: var(--warn); }
+  .badge.off { background: var(--off-soft); color: var(--off); }
+  .table-wrap { overflow-x: auto; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { text-align: left; padding: 9px 12px; border-bottom: 1px solid var(--line); vertical-align: top; }
+  th { font-size: 11px; text-transform: uppercase; letter-spacing: .05em; color: var(--muted); font-weight: 600; }
+  tr:last-child td { border-bottom: none; }
+  td.name b { display: block; }
+  td.rt .mono { white-space: nowrap; }
+  td.name small, .mono { font-family: var(--mono); font-size: 12px; color: var(--muted); overflow-wrap: anywhere; }
+  .chip { display: inline-block; font-family: var(--mono); font-size: 12px; padding: 1px 7px; margin: 0 4px 4px 0;
+          border: 1px solid var(--line); border-radius: 6px; white-space: nowrap; }
+  .chip.http { border-color: var(--accent); color: var(--accent); }
+  a { color: var(--accent); text-decoration: none; word-break: break-all; }
+  a:hover { text-decoration: underline; }
+  button.copy { font: inherit; font-size: 11px; color: var(--muted); background: none; border: 1px solid var(--line);
+                border-radius: 6px; padding: 0 6px; margin-left: 4px; cursor: pointer; }
+  details summary { cursor: pointer; color: var(--muted); font-size: 12px; }
+  .sect-title { padding: 10px 16px 0; font-size: 12px; text-transform: uppercase; letter-spacing: .05em; color: var(--muted); font-weight: 600; }
+  .empty { padding: 40px 16px; text-align: center; color: var(--muted); }
+  .flow { font-family: var(--mono); font-size: 12px; }
+  @media (max-width: 720px) {
+    thead { display: none; }
+    tr { display: block; border-bottom: 1px solid var(--line); padding: 6px 0; }
+    td { display: block; border: none; padding: 4px 16px; }
+    td[data-label]::before { content: attr(data-label) ": "; color: var(--muted); font-size: 11px; text-transform: uppercase; }
+  }
+</style>
+</head>
+<body>
+<header>
+  <h1 id="title">{{TITLE}}</h1>
+  <div class="sub" id="generated"></div>
+</header>
+<main>
+  <div class="cards" id="cards"></div>
+  <div class="toolbar">
+    <input id="q" type="search" placeholder="Filter by function, trigger, URL, handler…" aria-label="Filter">
+    <select id="provider" aria-label="Provider"><option value="">All providers</option></select>
+    <select id="stage" aria-label="Stage"><option value="">All stages</option></select>
+    <button id="theme" type="button" title="Toggle theme">◐ Theme</button>
+  </div>
+  <div id="deployments"></div>
+</main>
+<script type="application/json" id="data">{{DATA}}</script>
+<script>
+(function () {
+  "use strict";
+  var DATA = JSON.parse(document.getElementById("data").textContent);
+  var deps = DATA.deployments || [];
+
+  function h(tag, attrs) {
+    var el = document.createElement(tag);
+    if (attrs) Object.keys(attrs).forEach(function (k) {
+      if (k === "text") el.textContent = attrs[k];
+      else if (k === "class") el.className = attrs[k];
+      else if (attrs[k] !== null && attrs[k] !== undefined) el.setAttribute(k, attrs[k]);
+    });
+    for (var i = 2; i < arguments.length; i++) {
+      var c = arguments[i];
+      if (c === null || c === undefined || c === false) continue;
+      if (Array.isArray(c)) c.forEach(function (x) { if (x) el.appendChild(typeof x === "string" ? document.createTextNode(x) : x); });
+      else el.appendChild(typeof c === "string" ? document.createTextNode(c) : c);
+    }
+    return el;
+  }
+  function safeUrl(u) { return /^https?:\/\//i.test(u || "") ? u : null; }
+  function link(u, label) { var s = safeUrl(u); return s ? h("a", { href: s, target: "_blank", rel: "noopener", text: label || u }) : h("span", { class: "mono", text: u || "—" }); }
+  function copyBtn(value) {
+    var b = h("button", { class: "copy", type: "button", title: "Copy", text: "copy" });
+    b.addEventListener("click", function () {
+      if (navigator.clipboard) navigator.clipboard.writeText(value).then(function () { b.textContent = "copied"; setTimeout(function () { b.textContent = "copy"; }, 1200); });
+    });
+    return b;
+  }
+  function statusBadge(s) {
+    var cls = s === "deployed" ? "ok" : s === "removed" ? "off" : "warn";
+    return h("span", { class: "badge " + cls, text: s || "unknown" });
+  }
+  function kindBadge(k) { return h("span", { class: "badge" + (k === "invoke-only" ? " off" : ""), text: k }); }
+
+  var gen = document.getElementById("generated");
+  gen.textContent = "Generated " + new Date(DATA.generated_at).toLocaleString() + " · py-serverless-kit";
+
+  // filters
+  var providers = {}, stages = {};
+  deps.forEach(function (d) { providers[d.provider] = d.provider_display || d.provider; stages[d.stage] = 1; });
+  var pSel = document.getElementById("provider"), sSel = document.getElementById("stage");
+  Object.keys(providers).sort().forEach(function (p) { pSel.appendChild(h("option", { value: p, text: providers[p] })); });
+  Object.keys(stages).sort().forEach(function (s) { sSel.appendChild(h("option", { value: s, text: s })); });
+
+  function cards(list) {
+    var fns = 0, http = 0, wfs = 0, prov = {};
+    list.forEach(function (d) {
+      prov[d.provider] = 1; wfs += (d.workflows || []).length;
+      (d.functions || []).forEach(function (f) { fns++; if ((f.events || []).some(function (e) { return e.type === "http"; })) http++; });
+    });
+    var el = document.getElementById("cards"); el.textContent = "";
+    [["Deployments", list.length], ["Functions", fns], ["HTTP functions", http], ["Workflows", wfs], ["Providers", Object.keys(prov).length]]
+      .forEach(function (c) { el.appendChild(h("div", { class: "card" }, h("b", { text: String(c[1]) }), h("span", { text: c[0] }))); });
+  }
+
+  function fnMatches(f, q) {
+    if (!q) return true;
+    var hay = [f.name, f.resource_name, f.handler, f.kind, f.url, f.id, f.arn, f.description]
+      .concat((f.events || []).map(function (e) { return e.summary; }))
+      .concat((f.urls || []).map(function (u) { return u.url; })).join(" ").toLowerCase();
+    return hay.indexOf(q) !== -1;
+  }
+
+  function functionRow(f) {
+    var endpoints = [];
+    (f.urls || []).forEach(function (u) { endpoints.push(h("div", null, h("span", { class: "chip http", text: u.method }), link(u.url))); });
+    if (!endpoints.length && f.url) endpoints.push(h("div", null, link(f.url)));
+    var ident = f.arn || f.id;
+    return h("tr", null,
+      h("td", { class: "name", "data-label": "Function" },
+        h("b", { text: f.name }), h("small", { text: f.resource_name || "" }),
+        f.generated ? h("span", { class: "badge off", text: "generated" }) : null),
+      h("td", { "data-label": "Type" }, kindBadge(f.kind)),
+      h("td", { "data-label": "Triggers" }, (f.events || []).length
+        ? (f.events || []).map(function (e) { return h("span", { class: "chip" + (e.type === "http" ? " http" : ""), title: e.type, text: e.summary }); })
+        : h("span", { class: "mono", text: "direct invoke" })),
+      h("td", { "data-label": "Runtime", class: "rt" }, h("div", { class: "mono", text: f.runtime + " · " + f.architecture }),
+        h("div", { class: "mono", text: f.memory + " MB · " + f.timeout + " s" })),
+      h("td", { "data-label": "Endpoint" }, endpoints.length ? endpoints : h("span", { class: "mono", text: "—" })),
+      h("td", { "data-label": "Resource" },
+        ident ? h("div", null, h("span", { class: "mono", text: ident }), copyBtn(ident)) : h("span", { class: "mono", text: "not deployed" }),
+        f.console ? h("div", null, link(f.console, "Open in console ↗")) : null,
+        h("details", null, h("summary", { text: "details" }),
+          h("div", { class: "mono", text: "handler: " + f.handler }),
+          f.description ? h("div", { class: "mono", text: f.description }) : null,
+          (f.environment_keys || []).length ? h("div", { class: "mono", text: "env: " + f.environment_keys.join(", ") }) : null))
+    );
+  }
+
+  function workflowTable(d) {
+    if (!(d.workflows || []).length) return null;
+    var rows = d.workflows.map(function (w) {
+      var states = Object.keys(w.states || {}).map(function (s) { return s + (w.states[s] ? " (" + w.states[s] + ")" : ""); }).join(" → ");
+      return h("tr", null,
+        h("td", { class: "name", "data-label": "Workflow" }, h("b", { text: w.name }), h("small", { text: w.description || "" })),
+        h("td", { "data-label": "Engine" }, h("span", { class: "badge" + (w.engine === "native" ? " ok" : " warn"), text: w.engine })),
+        h("td", { "data-label": "States", class: "flow" }, states),
+        h("td", { "data-label": "Functions" }, (w.functions || []).map(function (f) { return h("span", { class: "chip", text: f }); })),
+        h("td", { "data-label": "Resource" }, w.id ? h("div", null, h("span", { class: "mono", text: w.id }), copyBtn(w.id)) : h("span", { class: "mono", text: "—" }),
+          w.console ? h("div", null, link(w.console, "Open in console ↗")) : null));
+    });
+    return [h("div", { class: "sect-title", text: "Workflows" }),
+      h("div", { class: "table-wrap" }, h("table", null,
+        h("thead", null, h("tr", null, ["Workflow", "Engine", "States", "Functions", "Resource"].map(function (t) { return h("th", { text: t }); }))),
+        h("tbody", null, rows)))];
+  }
+
+  function render() {
+    var q = document.getElementById("q").value.trim().toLowerCase();
+    var p = pSel.value, s = sSel.value;
+    var list = deps.filter(function (d) { return (!p || d.provider === p) && (!s || d.stage === s); });
+    cards(list);
+    var root = document.getElementById("deployments"); root.textContent = "";
+    if (!list.length) {
+      root.appendChild(h("div", { class: "empty" }, "No deployments found. Run ", h("code", { text: "pskit deploy" }), " and then ", h("code", { text: "pskit dashboard" }), "."));
+      return;
+    }
+    list.forEach(function (d) {
+      var fns = (d.functions || []).filter(function (f) { return fnMatches(f, q); });
+      if (q && !fns.length) return;
+      var art = d.artifact || {};
+      root.appendChild(h("section", { class: "dep" },
+        h("div", { class: "dep-head" },
+          h("h2", { text: d.service + " · " + d.stage }),
+          h("span", { class: "badge", text: d.provider_display || d.provider }),
+          d.provider_tier && d.provider_tier !== "stable" ? h("span", { class: "badge warn", text: d.provider_tier }) : null,
+          statusBadge(d.status),
+          h("div", { class: "meta" },
+            h("span", null, "region ", h("code", { text: d.region || "—" })),
+            h("span", null, "updated ", h("code", { text: d.deployed_at ? new Date(d.deployed_at).toLocaleString() : "—" })),
+            art.sha256 ? h("span", null, "artifact ", h("code", { text: art.sha256.slice(0, 12) })) : null,
+            d.endpoint ? h("span", null, "endpoint ", link(d.endpoint)) : null,
+            h("span", null, "pskit ", h("code", { text: d.pskit_version || "?" })))),
+        h("div", { class: "sect-title", text: "Functions (" + fns.length + ")" }),
+        h("div", { class: "table-wrap" }, h("table", null,
+          h("thead", null, h("tr", null, ["Function", "Type", "Triggers", "Runtime", "Endpoint", "Resource"].map(function (t) { return h("th", { text: t }); }))),
+          h("tbody", null, fns.map(functionRow)))),
+        workflowTable(d)));
+    });
+  }
+
+  ["q", "provider", "stage"].forEach(function (id) { document.getElementById(id).addEventListener("input", render); });
+  document.getElementById("theme").addEventListener("click", function () {
+    var root = document.documentElement;
+    var dark = root.getAttribute("data-theme") ? root.getAttribute("data-theme") === "dark" : window.matchMedia("(prefers-color-scheme: dark)").matches;
+    root.setAttribute("data-theme", dark ? "light" : "dark");
+  });
+  render();
+})();
+</script>
+</body>
+</html>

py_serverless_kit/local/__init__.py

@@ -0,0 +1,3 @@
+from .runner import LocalRunner, build_event, http_event, parse_data
+
+__all__ = ["LocalRunner", "build_event", "http_event", "parse_data"]