systemlink-cli 1.4.8__tar.gz → 1.5.0__tar.gz

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemlink-cli
-Version: 1.4.8
+Version: 1.5.0
 Summary: SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates.
 License-File: LICENSE
 Author: Fred Visser

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "systemlink-cli"
-version = "1.4.8"
+version = "1.5.0"
 description = "SystemLink Integrator CLI - cross-platform CLI for SystemLink workflows and templates."
 authors = ["Fred Visser <fred.visser@emerson.com>"]
 packages = [{ include = "slcli" }]

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/slcli/_version.py

@@ -1,4 +1,4 @@
 """Version information for slcli."""
 
 # This file is auto-generated. Do not edit manually.
-__version__ = "1.4.8"
+__version__ = "1.5.0"

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/slcli/skills/slcli/SKILL.md

@@ -665,18 +665,25 @@ slcli workitem create \
 Scaffold, package, and publish custom web applications to SystemLink.
 
 ```bash
-slcli webapp init [--template html|angular] [--directory DIR]  # Scaffold a new project
-slcli webapp pack [--directory DIR] [-o OUTPUT_FILE]     # Package webapp into a .zip
+slcli webapp init <DIRECTORY>                      # Scaffold the Angular starter
+slcli webapp manifest init <DIRECTORY> [OPTIONS]  # Create manifest.json + nipkg.config.json
+slcli webapp pack [FOLDER] [--config FILE] [-o OUTPUT_FILE]  # Package a webapp into a .nipkg
 slcli webapp list [-w WORKSPACE] [-t INT] [-f json]
 slcli webapp get <WEBAPP_ID> [-f json]
-slcli webapp publish --file PATH [--workspace NAME]      # Upload and publish a webapp
+slcli webapp publish PATH [--workspace NAME]             # Upload and publish a webapp
 slcli webapp delete <WEBAPP_ID>
 slcli webapp open <WEBAPP_ID>                            # Open webapp URL in browser
 ```
 
-Templates:
-- `html` (default) — minimal index.html
-- `angular` — Nimble Angular project with `PROMPTS.md`, `README.md`, and bundled AI skills installed into `.agents/skills/`
+`webapp init` creates the SystemLink Angular starter, not a generic HTML app. The starter installs
+project-scoped skills into `.agents/skills/` and creates `PROMPTS.md` plus `START_HERE.md` so an
+AI assistant can bootstrap the Angular workspace in place with the same Nimble/SystemLink
+conventions described by the `systemlink-webapp` skill.
+
+`webapp manifest init` writes `manifest.json` and `nipkg.config.json` using the Plugin Manager
+field names (`section`, `maintainer`, `homepage`, `xbPlugin`, `slPluginManagerTags`,
+`slPluginManagerMinServerVersion`). `webapp pack --config ...` consumes that metadata and writes
+the matching control-file fields into the generated `.nipkg`.
 
 ### skill — AI skill installation
 
@@ -693,7 +700,7 @@ Client paths:
 
 Notes:
 - `agents` is the default client in interactive mode.
-- `webapp init --template angular` installs project-scoped skills into `.agents/skills/` by default.
+- `webapp init` installs project-scoped skills into `.agents/skills/` by default.
 
 ### example — Built-in example resource provisioning
 

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/slcli/skills/systemlink-webapp/SKILL.md

@@ -19,6 +19,14 @@ SystemLink webapps are Angular Single-Page Applications built with the Nimble de
 connected to SystemLink REST APIs, and deployed via `slcli webapp publish`. This skill captures
 every gotcha learned from building and deploying real apps.
 
+If the user is starting from scratch, prefer `slcli webapp init <app-dir>` first.
+That command lays down the SystemLink starter layer (`.agents/skills/`, `PROMPTS.md`, and
+`START_HERE.md`) while Angular CLI remains responsible for generating the Angular workspace.
+
+When the user wants to package the app for Plugin Manager submission, prefer
+`slcli webapp manifest init <app-dir> ...` to generate `manifest.json` and `nipkg.config.json`
+with the current Plugin Manager field names, then use `slcli webapp pack --config ...`.
+
 ---
 
 ## Step 1: Understand what the user needs
@@ -34,15 +42,49 @@ You do NOT need to ask about Angular version or Nimble versions — always use A
 
 ---
 
-## Step 2: Scaffold the Angular project
+## Step 2: Bootstrap the Angular workspace
+
+When the project was created with `slcli webapp init`, generate Angular in the existing starter
+directory so the starter files and bundled skills remain at the project root.
 
 ```bash
-npx -y @angular/cli@20 new <app-name> --routing --style=scss --skip-git --no-standalone
-cd <app-name>
+npx -y @angular/cli@20 new <app-name> --directory . --routing --style=scss --skip-git --no-standalone --defaults --force
 npm install @ni/nimble-angular
 ```
 
-> Use `--no-standalone` to generate an NgModule-based app. SystemLink webapps work best with NgModule because it makes it easy to register all Nimble modules in one place.
+> Use `--no-standalone` to generate an NgModule-based app. SystemLink webapps work best with
+> NgModule because it makes it easy to register all Nimble modules in one place.
+
+If the user has not run `slcli webapp init` yet and they want a new SystemLink webapp, tell them
+to do that first unless they explicitly want a manual setup.
+
+### Starter shell expectations
+
+Before building feature-specific pages, establish a reusable shell that is aligned with other
+SystemLink apps:
+
+- Root `nimble-theme-provider` that mirrors the host shell theme
+- Responsive page header with title, summary text, and an action area
+- Shared loading, error, and empty states instead of one-off page-specific handling
+- Route-backed top-level navigation only when the app truly has multiple views
+- Reusable API helpers and service-layer code rather than fetch logic embedded in templates
+
+Use Nimble layout tokens and spacing rules consistently across the shell and feature pages:
+
+- Prefer Nimble spacing tokens over ad-hoc pixel values: `smallPadding` for tight inline gaps,
+  `mediumPadding` for default control spacing, `standardPadding` for section padding, and
+  `largePadding` between major content regions.
+- Stack controls vertically with a column layout, `mediumPadding` gap, and `standardPadding`
+  around the control group.
+- Use `mediumPadding` or `standardPadding` gaps for side-by-side controls; prefer CSS grid for
+  aligned multi-column layouts.
+- Inside accordion panels, keep a column layout with `mediumPadding` gaps and
+  `standardPadding` bottom padding.
+- Treat `controlHeight` (32px), `controlSlimHeight` (24px), and `labelHeight` (16px) as the
+  baseline sizing tokens for controls and labels.
+- Separate major sections with `largePadding` and subsections with `standardPadding`.
+
+See [references/layout-patterns.md](references/layout-patterns.md) for the detailed layout guide.
 
 ---
 

systemlink_cli-1.5.0/slcli/skills/systemlink-webapp/references/layout-patterns.md

@@ -0,0 +1,71 @@
+# Layout Patterns
+
+Guidance for spacing between controls vertically and horizontally within Nimble-based
+SystemLink webapps.
+
+## Spacing tokens
+
+Use Nimble design tokens for consistent spacing between controls.
+
+| Token             | Value | Usage                                                  |
+| ----------------- | ----- | ------------------------------------------------------ |
+| `smallPadding`    | 4px   | Tight spacing for icon margins and inline element gaps |
+| `mediumPadding`   | 8px   | Default spacing between stacked controls               |
+| `standardPadding` | 16px  | Section padding and content block margin               |
+| `largePadding`    | 24px  | Separation between major layout sections               |
+
+## Control heights
+
+| Token               | Value | Usage                           |
+| ------------------- | ----- | ------------------------------- |
+| `controlHeight`     | 32px  | Standard height for controls    |
+| `controlSlimHeight` | 24px  | Compact control variants        |
+| `labelHeight`       | 16px  | Height of labels above controls |
+
+## Vertical stacking
+
+When stacking controls vertically, such as text fields, number fields, and checkboxes:
+
+- Use `mediumPadding` (8px) as the gap between controls in a flex column.
+- Use `standardPadding` (16px) for content padding around the group.
+- Labels above controls add `labelHeight` (16px) to the effective row height.
+
+```html
+<div
+  style="display: flex; flex-direction: column; gap: var(--ni-nimble-medium-padding);"
+>
+  <nimble-text-field>Label 1</nimble-text-field>
+  <nimble-text-field>Label 2</nimble-text-field>
+</div>
+```
+
+## Horizontal layout
+
+When placing controls side by side:
+
+- Use `mediumPadding` (8px) or `standardPadding` (16px) as the gap.
+- Prefer CSS grid with equal columns for aligned layouts.
+
+```html
+<div
+  style="display: grid; grid-template-columns: 1fr 1fr; gap: var(--ni-nimble-medium-padding);"
+>
+  <nimble-checkbox>Option A</nimble-checkbox>
+  <nimble-checkbox>Option B</nimble-checkbox>
+</div>
+```
+
+## Accordion content
+
+Inside accordion item content panels:
+
+- Use `flex-direction: column` with `mediumPadding` (8px) gap between controls.
+- Indent content by the icon width plus padding so it aligns with the header text.
+- Use `standardPadding` (16px) for bottom padding before the next section.
+
+## Section spacing
+
+Between major sections or groups of controls:
+
+- Use `largePadding` (24px) between distinct content areas.
+- Use `standardPadding` (16px) for subsections within a group.

{systemlink_cli-1.4.8 → systemlink_cli-1.5.0}/slcli/webapp_click.py

@@ -5,6 +5,7 @@ management (list, get, delete, publish, open).
 """
 
 import io
+import re
 import sys
 import tarfile
 import tempfile
@@ -25,14 +26,49 @@ from .utils import (
     get_base_url,
     get_web_url,
     get_headers,
+    load_json_file,
     get_ssl_verify,
     get_workspace_id_with_fallback,
     get_workspace_map,
     handle_api_error,
     sanitize_filename,
+    save_json_file,
 )
 from .workspace_utils import get_effective_workspace, get_workspace_display_name
 
+_PACKAGE_PATTERN = re.compile(r"^[a-z0-9][a-z0-9._-]*$")
+_VERSION_PATTERN = re.compile(r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$")
+_MAINTAINER_PATTERN = re.compile(r"^[^<>]+\s<[^<>@\s]+@[^<>@\s]+>$")
+_XB_PLUGIN_VALUES = ("webapp", "notebook", "dashboard", "routine", "bundle")
+_MAX_PACKAGE_LENGTH = 100
+_MAX_DISPLAY_NAME_LENGTH = 200
+_MAX_DESCRIPTION_LENGTH = 5000
+_ALLOWED_PLUGIN_MANAGER_KEYS = {
+    "buildCommand",
+    "buildDir",
+    "description",
+    "displayName",
+    "homepage",
+    "iconFile",
+    "license",
+    "maintainer",
+    "nipkgFile",
+    "package",
+    "section",
+    "slPluginManagerMinServerVersion",
+    "slPluginManagerTags",
+    "version",
+    "xbPlugin",
+}
+_LEGACY_MANIFEST_KEY_MAP = {
+    "appStoreCategory": "section",
+    "appStoreType": "xbPlugin",
+    "appStoreAuthor": "maintainer",
+    "appStoreRepo": "homepage",
+    "appStoreTags": "slPluginManagerTags",
+    "appStoreMinServerVersion": "slPluginManagerMinServerVersion",
+}
+
 
 def _get_webapp_base_url() -> str:
     return f"{get_base_url()}/niapp/v1"
@@ -127,7 +163,130 @@ def _fetch_webapps_page(
     return items, cont, total
 
 
-def _pack_folder_to_nipkg(folder: Path, output: Optional[Path] = None) -> Path:
+def _default_nipkg_filename(package_name: str, version: str) -> str:
+    """Return the canonical Plugin Manager package filename."""
+    return f"{package_name}_{version}_all.nipkg"
+
+
+def _default_display_name(package_name: str) -> str:
+    """Return a display name derived from a package identifier."""
+    words = re.split(r"[._-]+", package_name)
+    return " ".join(word.capitalize() for word in words if word)
+
+
+def _default_angular_build_dir(directory: Path) -> str:
+    """Return the default Angular production output path for a starter directory."""
+    return f"dist/{_default_angular_project_name(directory)}/browser"
+
+
+def _normalize_plugin_manager_metadata(raw_metadata: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize legacy App Store keys to Plugin Manager keys."""
+    metadata = dict(raw_metadata)
+    for old_key, new_key in _LEGACY_MANIFEST_KEY_MAP.items():
+        if old_key in metadata and new_key not in metadata:
+            metadata[new_key] = metadata[old_key]
+    for old_key in _LEGACY_MANIFEST_KEY_MAP:
+        metadata.pop(old_key, None)
+    return metadata
+
+
+def _validate_plugin_manager_metadata(
+    raw_metadata: Dict[str, Any], require_build_dir: bool = False
+) -> Dict[str, str]:
+    """Validate and normalize Plugin Manager manifest metadata."""
+    from urllib.parse import urlparse
+
+    metadata = _normalize_plugin_manager_metadata(raw_metadata)
+    unexpected_keys = sorted(set(metadata) - _ALLOWED_PLUGIN_MANAGER_KEYS)
+
+    package_name = str(metadata.get("package", "")).strip()
+    version = str(metadata.get("version", "")).strip()
+    display_name = str(metadata.get("displayName", "")).strip()
+    description = str(metadata.get("description", "")).strip()
+    section = str(metadata.get("section", "")).strip()
+    maintainer = str(metadata.get("maintainer", "")).strip()
+    homepage = str(metadata.get("homepage", "")).strip()
+    license_name = str(metadata.get("license", "")).strip()
+    xb_plugin = str(metadata.get("xbPlugin", "")).strip()
+    tags = str(metadata.get("slPluginManagerTags", "")).strip()
+    min_server_version = str(metadata.get("slPluginManagerMinServerVersion", "")).strip()
+    nipkg_file = str(metadata.get("nipkgFile", "")).strip()
+    build_dir = str(metadata.get("buildDir", "")).strip()
+    build_command = str(metadata.get("buildCommand", "")).strip()
+    icon_file = str(metadata.get("iconFile", "")).strip()
+
+    errors: List[str] = []
+
+    if unexpected_keys:
+        errors.append("unexpected field(s): " + ", ".join(unexpected_keys))
+
+    if not package_name or not _PACKAGE_PATTERN.match(package_name) or len(package_name) < 3:
+        errors.append("package must match ^[a-z0-9][a-z0-9._-]*$ and be at least 3 characters")
+    elif len(package_name) > _MAX_PACKAGE_LENGTH:
+        errors.append(f"package must be at most {_MAX_PACKAGE_LENGTH} characters")
+    if not version or not _VERSION_PATTERN.match(version):
+        errors.append("version must be strict semver in MAJOR.MINOR.PATCH format")
+    if not display_name or len(display_name) < 3:
+        errors.append("displayName must be at least 3 characters")
+    elif len(display_name) > _MAX_DISPLAY_NAME_LENGTH:
+        errors.append(f"displayName must be at most {_MAX_DISPLAY_NAME_LENGTH} characters")
+    if not description or len(description) < 20:
+        errors.append("description must be at least 20 characters")
+    elif len(description) > _MAX_DESCRIPTION_LENGTH:
+        errors.append(f"description must be at most {_MAX_DESCRIPTION_LENGTH} characters")
+    if not section or len(section) < 2:
+        errors.append("section must be at least 2 characters")
+    if not maintainer or not _MAINTAINER_PATTERN.match(maintainer):
+        errors.append("maintainer must be in the format 'Name <email@example.com>'")
+    if homepage:
+        parsed_homepage = urlparse(homepage)
+        if not parsed_homepage.scheme or not parsed_homepage.netloc:
+            errors.append("homepage must be a valid absolute URI")
+    if not license_name or len(license_name) < 2:
+        errors.append("license must be at least 2 characters")
+    if xb_plugin not in _XB_PLUGIN_VALUES:
+        errors.append(f"xbPlugin must be one of: {', '.join(_XB_PLUGIN_VALUES)}")
+    if nipkg_file and not nipkg_file.endswith(".nipkg"):
+        errors.append("nipkgFile must end with .nipkg")
+    if require_build_dir and not build_dir:
+        errors.append("buildDir is required when packing from config without a folder argument")
+
+    if errors:
+        click.echo("✗ Invalid plugin manager metadata:", err=True)
+        for error in errors:
+            click.echo(f"  - {error}", err=True)
+        sys.exit(ExitCodes.INVALID_INPUT)
+
+    validated: Dict[str, str] = {
+        "package": package_name,
+        "version": version,
+        "displayName": display_name,
+        "description": description,
+        "section": section,
+        "maintainer": maintainer,
+        "license": license_name,
+        "xbPlugin": xb_plugin,
+        "nipkgFile": nipkg_file or _default_nipkg_filename(package_name, version),
+    }
+    if homepage:
+        validated["homepage"] = homepage
+    if tags:
+        validated["slPluginManagerTags"] = tags
+    if min_server_version:
+        validated["slPluginManagerMinServerVersion"] = min_server_version
+    if build_dir:
+        validated["buildDir"] = build_dir
+    if build_command:
+        validated["buildCommand"] = build_command
+    if icon_file:
+        validated["iconFile"] = icon_file
+
+    return validated
+
+
+def _pack_folder_to_nipkg(
+    folder: Path, output: Optional[Path] = None, metadata: Optional[Dict[str, str]] = None
+) -> Path:
     """Pack a folder into a .nipkg (ar) file and return the output path.
 
     The .nipkg produced by this helper uses a Debian-style ar layout with
@@ -140,8 +299,28 @@ def _pack_folder_to_nipkg(folder: Path, output: Optional[Path] = None) -> Path:
     if not folder.exists() or not folder.is_dir():
         raise click.ClickException(f"Folder not found: {folder}")
 
+    if metadata is not None:
+        package_name = metadata["package"]
+        version = metadata["version"]
+        architecture = "all"
+    else:
+        package_name = sanitize_filename(folder.name)
+        version = "1.0.0"
+        architecture = "all"
+        if "_" in folder.name:
+            first, rest = folder.name.split("_", 1)
+            package_name = sanitize_filename(first)
+            rest_parts = rest.split("_")
+            if rest_parts:
+                version = rest_parts[0]
+            if len(rest_parts) > 1:
+                architecture = "_".join(rest_parts[1:])
+
     if output is None:
-        output = folder.with_suffix(".nipkg")
+        if metadata is not None:
+            output = folder.parent / metadata["nipkgFile"]
+        else:
+            output = folder.with_suffix(".nipkg")
 
     # Ensure parent exists
     output.parent.mkdir(parents=True, exist_ok=True)
@@ -150,26 +329,36 @@ def _pack_folder_to_nipkg(folder: Path, output: Optional[Path] = None) -> Path:
     # - control.tar.gz (contains a control file with package metadata)
     # - data.tar.gz (contains the payload files)
 
-    # Derive package metadata from folder name where possible.
-    pkg_name = sanitize_filename(folder.name)
-    version = "1.0.0"
-    architecture = "all"
-    if "_" in folder.name:
-        first, rest = folder.name.split("_", 1)
-        pkg_name = sanitize_filename(first)
-        rest_parts = rest.split("_")
-        if rest_parts:
-            version = rest_parts[0]
-        if len(rest_parts) > 1:
-            architecture = "_".join(rest_parts[1:])
-
-    control_fields = {
-        "Package": pkg_name,
-        "Version": version,
-        "Architecture": architecture,
-        "Maintainer": "slcli <no-reply@example.com>",
-        "Description": f"Package created by slcli for {pkg_name}",
-    }
+    if metadata is not None:
+        control_fields = {
+            "Package": metadata["package"],
+            "Version": metadata["version"],
+            "Architecture": architecture,
+            "Description": metadata["description"],
+            "Section": metadata["section"],
+            "Maintainer": metadata["maintainer"],
+            "XB-DisplayName": metadata["displayName"],
+            "XB-DisplayVersion": metadata["version"],
+            "XB-Plugin": metadata["xbPlugin"],
+            "XB-UserVisible": "yes",
+            "XB-SlPluginManagerLicense": metadata["license"],
+        }
+        if metadata.get("homepage"):
+            control_fields["Homepage"] = metadata["homepage"]
+        if metadata.get("slPluginManagerTags"):
+            control_fields["XB-SlPluginManagerTags"] = metadata["slPluginManagerTags"]
+        if metadata.get("slPluginManagerMinServerVersion"):
+            control_fields["XB-SlPluginManagerMinServerVersion"] = metadata[
+                "slPluginManagerMinServerVersion"
+            ]
+    else:
+        control_fields = {
+            "Package": package_name,
+            "Version": version,
+            "Architecture": architecture,
+            "Maintainer": "slcli <no-reply@example.com>",
+            "Description": f"Package created by slcli for {package_name}",
+        }
 
     control_lines = [f"{k}: {v}" for k, v in control_fields.items()]
     control_content = ("\n".join(control_lines) + "\n").encode("utf-8")
@@ -248,79 +437,123 @@ def _pack_folder_to_nipkg(folder: Path, output: Optional[Path] = None) -> Path:
 # ── Template scaffolding helpers ──────────────────────────────────────────
 
 
-def _init_html_template(directory: Path, force: bool) -> None:
-    """Scaffold a minimal HTML webapp."""
-    directory.mkdir(parents=True, exist_ok=True)
-    target_folder = directory / "app"
-    target_folder.mkdir(parents=True, exist_ok=True)
-    index = target_folder / "index.html"
-    if index.exists() and not force:
-        click.echo("✗ app/index.html already exists. Use --force to overwrite.", err=True)
-        sys.exit(ExitCodes.INVALID_INPUT)
+def _default_angular_project_name(directory: Path) -> str:
+    """Return a safe Angular project name derived from the target directory."""
+    project_name = sanitize_filename(directory.name)
+    return project_name or "systemlink-webapp"
 
-    content = """<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>Example WebApp</title>
-  </head>
-  <body>
-    <h1>Example WebApp</h1>
-    <p>Created with slcli webapp init</p>
-  </body>
-</html>
-"""
-    index.write_text(content, encoding="utf-8")
-    format_success("Created example index.html", {"Path": str(index)})
 
+def _build_angular_bootstrap_command(directory: Path) -> str:
+    """Build the canonical Angular CLI command for this starter directory."""
+    project_name = _default_angular_project_name(directory)
+    return (
+        f"npx -y @angular/cli@20 new {project_name} --directory . "
+        "--routing --style=scss --skip-git --no-standalone --defaults --force"
+    )
+
+
+def _build_webapp_manifest_and_config(
+    package_name: str,
+    version: str,
+    display_name: str,
+    description: str,
+    section: str,
+    maintainer: str,
+    homepage: str,
+    license_name: str,
+    xb_plugin: str,
+    tags: str,
+    min_server_version: str,
+    build_dir: str,
+    build_command: str,
+    icon_file: str,
+) -> tuple[Dict[str, str], Dict[str, str]]:
+    """Build validated submission manifest and nipkg config payloads."""
+    manifest = _validate_plugin_manager_metadata(
+        {
+            "package": package_name,
+            "version": version,
+            "displayName": display_name,
+            "description": description,
+            "section": section,
+            "maintainer": maintainer,
+            "homepage": homepage,
+            "license": license_name,
+            "xbPlugin": xb_plugin,
+            "slPluginManagerTags": tags,
+            "slPluginManagerMinServerVersion": min_server_version,
+            "nipkgFile": _default_nipkg_filename(package_name, version),
+        }
+    )
+
+    pack_config = dict(manifest)
+    pack_config.pop("nipkgFile", None)
+    pack_config["buildDir"] = build_dir
+    pack_config["buildCommand"] = build_command
+    if icon_file:
+        pack_config["iconFile"] = icon_file
+
+    return manifest, pack_config
 
-_ANGULAR_PROMPTS_MD = """\
-# SystemLink WebApp — AI Prompts
 
-This project was scaffolded with `slcli webapp init --template angular`.
-The **systemlink-webapp** skill has been installed into this project so
-your AI assistant already knows how to build Nimble Angular apps for
-SystemLink — including component choices, API patterns, routing, theming,
-and deployment. Just describe what you want.
+def _render_angular_prompts_md(directory: Path) -> str:
+    """Render the prompt file for the Angular starter."""
+    bootstrap_command = _build_angular_bootstrap_command(directory)
+    return f"""# SystemLink WebApp - AI Prompts
 
-## Getting Started
+This project was initialized with `slcli webapp init`.
+The bundled `systemlink-webapp` and `slcli` skills are already installed into
+this project so your AI assistant can scaffold the Angular workspace and apply
+the SystemLink-specific conventions immediately.
 
-Open this project in your editor and describe your app:
+## Starter Prompt
 
-> "I need a web dashboard for monitoring our production test systems.
-> It should show which systems are online, recent test results, and
-> any assets due for calibration."
+Use this prompt first when the directory still only contains starter files:
 
-Your AI assistant will create the Angular project, install the right
-packages, and build the pages for you.
+> "Bootstrap this directory into a maintainable Angular 20 SystemLink webapp.
+> Run `{bootstrap_command}` to generate the Angular workspace in place, then
+> install `@ni/nimble-angular` and `@ni/systemlink-clients-ts`. Create a
+> reusable app shell aligned with other SystemLink apps: `nimble-theme-provider`
+> at the root, a responsive page header, content regions for summary cards and
+> tables, and shared loading, error, and empty states. Keep the app NgModule-
+> based, configure `APP_BASE_HREF`, remove the `<base>` tag, use hash routing,
+> disable `inlineCritical` in production, import Nimble fonts, and sync the app
+> theme with the host SystemLink shell."
 
-## Example Prompts
+## Manual Bootstrap
 
-Describe your goals — the skill handles the technical details.
+If you want to do the initial setup yourself before handing the project to AI:
+
+```bash
+{bootstrap_command}
+npm install @ni/nimble-angular @ni/systemlink-clients-ts
+```
+
+The Angular workspace should be created in this directory, not inside a nested
+subfolder.
+
+## Example Feature Prompts
 
 ### Fleet monitoring
 
-> "Build a dashboard that shows all connected systems with their
-> status, operating system, and last check-in time. Highlight any
-> systems that have been offline for more than 24 hours."
+> "Build a dashboard that shows all connected systems with their status,
+> operating system, and last check-in time. Highlight systems that have been
+> offline for more than 24 hours."
 
 ### Test results review
 
-> "Create a page where I can browse recent test results, filter by
-> status (passed, failed, running) and program name, and see a
-> summary of failure rates."
+> "Create a page where I can browse recent test results, filter by status,
+> program name, and workspace, and see a summary of failure rates."
 
-### Asset & calibration tracking
+### Asset and calibration tracking
 
-> "Show all tracked assets grouped by calibration status. I want to
-> see which assets are due soon, which are overdue, and be able to
-> click on an asset to see its full details."
+> "Show tracked assets grouped by calibration status. I want overdue and due-
+> soon sections, plus an asset details page with key metadata and history."
 
 ### Production KPIs
 
-> "Build a dashboard with key metrics: first-pass yield, test
-> throughput per hour, and a trend chart of failures over the last
-> 30 days."
+> "Build a dashboard with first-pass yield, throughput per hour, and a trend
+> chart of failures over the last 30 days."
 
 ### Build and deploy
 
@@ -333,24 +566,46 @@ Describe your goals — the skill handles the technical details.
 - [slcli webapp commands](https://ni-kismet.github.io/systemlink-cli/commands.html#webapp)
 """
 
-_ANGULAR_README_MD = """\
-# SystemLink WebApp
 
-A Nimble Angular web application for SystemLink, scaffolded with
-`slcli webapp init --template angular`.
+def _render_angular_start_here_md(directory: Path) -> str:
+    """Render the starter guide for the Angular workflow."""
+    bootstrap_command = _build_angular_bootstrap_command(directory)
+    return f"""# SystemLink Angular WebApp Starter
+
+This directory was initialized with `slcli webapp init`.
+
+`slcli` owns the SystemLink-specific starter layer for this workflow:
+
+- bundled AI skills in `.agents/skills/`
+- ready-made prompts in [PROMPTS.md](PROMPTS.md)
+- deployment guidance for `slcli webapp publish`
+- Plugin Manager manifest scaffolding via `slcli webapp manifest init`
+
+Angular CLI remains the source of truth for the Angular workspace itself. That
+keeps the generated project aligned with current Angular defaults while the
+skills and starter files enforce the SystemLink-specific best practices.
 
-## Prerequisites
+## Bootstrap the Angular workspace
 
-- [Node.js](https://nodejs.org/) 18+ and npm
-- [slcli](https://ni-kismet.github.io/systemlink-cli/)
+```bash
+{bootstrap_command}
+npm install @ni/nimble-angular @ni/systemlink-clients-ts
+```
 
-## Getting Started
+If you use an AI assistant, ask it to follow the starter prompt in
+[PROMPTS.md](PROMPTS.md). The Angular app should be created in this directory,
+not inside a nested subfolder.
 
-Open this directory in your editor and ask your AI assistant to create
-the project — see [PROMPTS.md](PROMPTS.md) for ready-made prompts.
+## Baseline conventions
 
-The AI skills for SystemLink webapp development are already installed
-in this project directory.
+- Angular 20 with an NgModule-based app (`--no-standalone`)
+- `@ni/nimble-angular` for UI and design tokens
+- `@ni/systemlink-clients-ts` as the default API integration path
+- `APP_BASE_HREF` provided in DI and no `<base>` tag in `index.html`
+- Hash routing for SystemLink sub-path hosting
+- `inlineCritical: false` in the production build configuration
+- A reusable SystemLink-aligned shell with theme sync, page header, content
+  regions, and shared loading, error, and empty states
 
 ## Deploy to SystemLink
 
@@ -359,22 +614,34 @@ ng build --configuration production
 slcli webapp publish dist/<project-name>/browser/ \\
   --name "My Dashboard" --workspace Default
 ```
+
+## Plugin Manager packaging metadata
+
+```bash
+slcli webapp manifest init . \\
+    --description "A dashboard for monitoring fleet health and calibration status." \\
+    --section Dashboard \\
+    --maintainer "Your Name <you@example.com>" \\
+    --license MIT
+
+slcli webapp pack --config nipkg.config.json
+```
 """
 
 
 def _init_angular_template(directory: Path, force: bool) -> None:
-    """Scaffold a Nimble Angular project with SystemLink TypeScript clients."""
+    """Scaffold the SystemLink Angular starter for a new webapp."""
     directory.mkdir(parents=True, exist_ok=True)
 
     prompts_file = directory / "PROMPTS.md"
-    readme_file = directory / "README.md"
+    start_here_file = directory / "START_HERE.md"
 
     # Check for existing files
     existing = []
     if prompts_file.exists() and not force:
         existing.append("PROMPTS.md")
-    if readme_file.exists() and not force:
-        existing.append("README.md")
+    if start_here_file.exists() and not force:
+        existing.append("START_HERE.md")
     if existing:
         click.echo(
             f"✗ {', '.join(existing)} already exist(s). Use --force to overwrite.",
@@ -382,22 +649,22 @@ def _init_angular_template(directory: Path, force: bool) -> None:
         )
         sys.exit(ExitCodes.INVALID_INPUT)
 
-    prompts_file.write_text(_ANGULAR_PROMPTS_MD, encoding="utf-8")
-    readme_file.write_text(_ANGULAR_README_MD, encoding="utf-8")
+    prompts_file.write_text(_render_angular_prompts_md(directory), encoding="utf-8")
+    start_here_file.write_text(_render_angular_start_here_md(directory), encoding="utf-8")
 
     # Auto-install AI skills into the project directory
     installed = install_skills_to_directory(directory)
     skill_msg = f"{installed} skill(s) installed" if installed else "skills not found"
 
     format_success(
-        "Scaffolded Nimble Angular project",
+        "Scaffolded SystemLink Angular starter",
         {
             "Directory": str(directory),
             "Skills": skill_msg,
             "Next steps": (
                 "1. cd " + str(directory) + "\n"
-                "   2. Open in your editor and ask AI to create the app\n"
-                "   3. See PROMPTS.md for example prompts"
+                "   2. Open START_HERE.md and PROMPTS.md\n"
+                "   3. Ask AI to bootstrap the Angular workspace in this directory"
             ),
         },
     )
@@ -411,42 +678,148 @@ def register_webapp_commands(cli: Any) -> None:
         """Manage web applications (init/pack locally, publish/CRUD remotely)."""
 
     @webapp.command(name="init")
-    @click.option(
-        "--directory",
+    @click.argument(
         "directory",
         type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
-        default=Path.cwd(),
-        show_default="CWD",
-        help="Target directory to create the project in",
     )
+    @click.option("--force", is_flag=True, help="Overwrite existing starter files")
+    def init_webapp(directory: Path, force: bool) -> None:
+        """Scaffold the SystemLink Angular starter for a new webapp."""
+        try:
+            _init_angular_template(directory, force)
+        except SystemExit:
+            raise
+        except Exception as exc:
+            handle_api_error(exc)
+
+    @webapp.group(name="manifest")
+    def webapp_manifest() -> None:
+        """Create Plugin Manager submission manifests and packaging config files."""
+
+    @webapp_manifest.command(name="init")
+    @click.argument(
+        "directory",
+        type=click.Path(file_okay=False, dir_okay=True, path_type=Path),
+    )
+    @click.option("--package", "package_name", default="", help="Package identifier")
+    @click.option("--version", default="0.1.0", show_default=True, help="Semantic version")
+    @click.option("--display-name", "display_name", default="", help="Human-readable name")
+    @click.option("--description", required=True, help="Plugin description")
+    @click.option("--section", required=True, help="Plugin Manager section/category")
+    @click.option("--maintainer", required=True, help="Maintainer in 'Name <email>' format")
+    @click.option("--homepage", default="", help="Project homepage or source repository URL")
+    @click.option("--license", "license_name", required=True, help="License identifier")
     @click.option(
-        "--template",
-        "template",
-        type=click.Choice(["html", "angular"]),
-        default="html",
+        "--plugin-type",
+        "xb_plugin",
+        type=click.Choice(list(_XB_PLUGIN_VALUES)),
+        default="webapp",
         show_default=True,
-        help="Project template: html (simple page) or angular (Nimble Angular app)",
+        help="Plugin Manager top-level plugin type",
     )
-    @click.option("--force", is_flag=True, help="Overwrite existing files")
-    def init_webapp(directory: Path, template: str, force: bool) -> None:
-        """Scaffold a sample webapp project.
-
-        Use --template html (default) for a minimal index.html, or
-        --template angular for a Nimble Angular project with SystemLink
-        TypeScript clients, AI-ready prompts, and deployment configuration.
-        """
+    @click.option("--tags", default="", help="Comma-separated Plugin Manager search tags")
+    @click.option(
+        "--min-server-version",
+        default="",
+        help="Minimum supported SystemLink server version",
+    )
+    @click.option("--build-dir", default="", help="Build output directory for nipkg.config.json")
+    @click.option(
+        "--build-command",
+        default="npm run build",
+        show_default=True,
+        help="Build command written to nipkg.config.json",
+    )
+    @click.option("--icon-file", default="", help="Icon path written to nipkg.config.json")
+    @click.option("--force", is_flag=True, help="Overwrite existing manifest files")
+    def init_manifest(
+        directory: Path,
+        package_name: str,
+        version: str,
+        display_name: str,
+        description: str,
+        section: str,
+        maintainer: str,
+        homepage: str,
+        license_name: str,
+        xb_plugin: str,
+        tags: str,
+        min_server_version: str,
+        build_dir: str,
+        build_command: str,
+        icon_file: str,
+        force: bool,
+    ) -> None:
+        """Write manifest.json and nipkg.config.json using the Plugin Manager contract."""
         try:
-            if template == "angular":
-                _init_angular_template(directory, force)
-            else:
-                _init_html_template(directory, force)
+            directory.mkdir(parents=True, exist_ok=True)
+
+            package_name = package_name or sanitize_filename(directory.name, "webapp")
+            display_name = display_name or _default_display_name(package_name)
+            build_dir = build_dir or _default_angular_build_dir(directory)
+
+            manifest_path = directory / "manifest.json"
+            config_path = directory / "nipkg.config.json"
+            existing = []
+            if manifest_path.exists() and not force:
+                existing.append("manifest.json")
+            if config_path.exists() and not force:
+                existing.append("nipkg.config.json")
+            if existing:
+                click.echo(
+                    f"✗ {', '.join(existing)} already exist(s). Use --force to overwrite.",
+                    err=True,
+                )
+                sys.exit(ExitCodes.INVALID_INPUT)
+
+            manifest, pack_config = _build_webapp_manifest_and_config(
+                package_name=package_name,
+                version=version,
+                display_name=display_name,
+                description=description,
+                section=section,
+                maintainer=maintainer,
+                homepage=homepage,
+                license_name=license_name,
+                xb_plugin=xb_plugin,
+                tags=tags,
+                min_server_version=min_server_version,
+                build_dir=build_dir,
+                build_command=build_command,
+                icon_file=icon_file,
+            )
+
+            save_json_file(manifest, str(manifest_path))
+            save_json_file(pack_config, str(config_path))
+            format_success(
+                "Created Plugin Manager manifest files",
+                {
+                    "Manifest": str(manifest_path),
+                    "Pack config": str(config_path),
+                    "nipkgFile": manifest["nipkgFile"],
+                },
+            )
         except SystemExit:
             raise
         except Exception as exc:
             handle_api_error(exc)
 
     @webapp.command(name="pack")
-    @click.argument("folder", type=click.Path(exists=True, file_okay=False, path_type=Path))
+    @click.argument(
+        "folder",
+        required=False,
+        type=click.Path(exists=True, file_okay=False, path_type=Path),
+    )
+    @click.option(
+        "--config",
+        "config_path",
+        type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
+        default=None,
+        help=(
+            "Path to nipkg.config.json or compatible metadata JSON. "
+            "If it does not include buildDir, also pass FOLDER."
+        ),
+    )
     @click.option(
         "--output",
         "output",
@@ -454,11 +827,46 @@ def register_webapp_commands(cli: Any) -> None:
         default=None,
         help="Output .nipkg file path",
     )
-    def pack_cmd(folder: Path, output: Optional[Path]) -> None:
+    def pack_cmd(
+        folder: Optional[Path], config_path: Optional[Path], output: Optional[Path]
+    ) -> None:
         """Pack a folder into a .nipkg."""
         try:
+            metadata: Optional[Dict[str, str]] = None
+            resolved_folder = folder
+
+            if config_path is not None:
+                raw_data = load_json_file(str(config_path))
+                if not isinstance(raw_data, dict):
+                    click.echo("✗ Config file must contain a JSON object.", err=True)
+                    sys.exit(ExitCodes.INVALID_INPUT)
+                metadata = _validate_plugin_manager_metadata(
+                    raw_data, require_build_dir=resolved_folder is None
+                )
+
+                if resolved_folder is None:
+                    build_dir = metadata.get("buildDir", "")
+                    base_dir = config_path.parent
+                    resolved_folder = Path(build_dir)
+                    if not resolved_folder.is_absolute():
+                        resolved_folder = base_dir / resolved_folder
+                    resolved_folder = resolved_folder.resolve()
+                    if not resolved_folder.exists() or not resolved_folder.is_dir():
+                        click.echo(
+                            f"✗ buildDir does not exist or is not a directory: {resolved_folder}",
+                            err=True,
+                        )
+                        sys.exit(ExitCodes.INVALID_INPUT)
+
+                if output is None and metadata.get("nipkgFile"):
+                    output = config_path.parent / metadata["nipkgFile"]
+
+            if resolved_folder is None:
+                click.echo("✗ Must provide a folder or --config with buildDir.", err=True)
+                sys.exit(ExitCodes.INVALID_INPUT)
+
             out = Path(output) if output else None
-            result = _pack_folder_to_nipkg(folder, out)
+            result = _pack_folder_to_nipkg(resolved_folder, out, metadata)
             format_success("Packed folder", {"Path": str(result)})
         except SystemExit:
             raise