npm - @tangle-network/starter-foundry - Versions diffs - 0.5.4 → 0.7.2 - Mend

@tangle-network/starter-foundry 0.5.4 → 0.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1052) hide show

package/registry/families/tauri-tray/files/preview-server.mjs ADDED Viewed

@@ -0,0 +1,63 @@
+import fs from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const port = Number.parseInt(process.env.PORT || "{{port}}", 10);
+// tauri-tray is a windowless daemon at runtime. The preview server
+// just renders a human-readable summary of what the tray menu will
+// look like — there's no renderer to serve.
+const menuPreview = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>{{projectName}} — Tray Preview</title>
+    <style>
+      body { margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; background: #0f172a; color: #f8fafc; padding: 32px; }
+      h1 { font-size: 20px; margin: 0 0 4px; }
+      p { margin: 0 0 24px; opacity: 0.7; }
+      .tray { max-width: 240px; background: #1e293b; border: 1px solid rgba(248,250,252,0.08); border-radius: 10px; overflow: hidden; }
+      .tray-item { padding: 8px 12px; font-size: 13px; border-bottom: 1px solid rgba(248,250,252,0.06); }
+      .tray-item:last-child { border-bottom: 0; }
+      .tray-sep { height: 1px; background: rgba(248,250,252,0.08); }
+      footer { margin-top: 24px; font-size: 12px; opacity: 0.5; }
+    </style>
+  </head>
+  <body>
+    <h1>{{headline}}</h1>
+    <p>{{subheadline}}</p>
+    <div class="tray">
+      <div class="tray-item">● Status: Idle</div>
+      <div class="tray-sep"></div>
+      <div class="tray-item">Sync now</div>
+      <div class="tray-item">Open logs…</div>
+      <div class="tray-item">Preferences…</div>
+      <div class="tray-sep"></div>
+      <div class="tray-item">Quit</div>
+    </div>
+    <footer>Wire the menu in src-tauri/src/lib.rs — this preview is static HTML only.</footer>
+  </body>
+</html>`;
+const server = http.createServer(async (request, response) => {
+  if (request.url === "/" || request.url === "/index.html") {
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    response.end(menuPreview);
+    return;
+  }
+  try {
+    const filePath = path.join(__dirname, request.url.slice(1));
+    const content = await fs.readFile(filePath);
+    response.writeHead(200, { "content-type": "application/octet-stream" });
+    response.end(content);
+  } catch {
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("not found");
+  }
+});
+server.listen(port, "0.0.0.0", () => {
+  console.log(`preview listening on ${port}`);
+});

package/registry/families/tauri-tray/files/validate-types.mjs ADDED Viewed

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+JSON.parse(await fs.readFile("tsconfig.json", "utf8"));
+const tauriConf = JSON.parse(await fs.readFile("src-tauri/tauri.conf.json", "utf8"));
+const windows = tauriConf.app?.windows ?? [];
+// Tray daemons have NO visible primary window. Either zero windows, or
+// one hidden window used for lazy settings UI.
+const anyVisible = windows.some((w) => w.visible !== false);
+if (anyVisible) {
+  throw new Error("tauri-tray must not declare visible:true windows — tray daemons are windowless by default");
+}
+const cargoToml = await fs.readFile("src-tauri/Cargo.toml", "utf8");
+if (!cargoToml.includes("[package]")) {
+  throw new Error("missing tauri Cargo package block");
+}
+if (!cargoToml.includes("tauri-plugin-notification")) {
+  throw new Error("tauri-tray expects tauri-plugin-notification — tray daemons speak to users through OS notifications");
+}
+const libRs = await fs.readFile("src-tauri/src/lib.rs", "utf8");
+if (!libRs.includes("TrayIconBuilder") || !libRs.includes("Menu")) {
+  throw new Error("src-tauri/src/lib.rs must build a TrayIcon with a Menu");
+}
+console.log("tauri tray ok");

package/registry/families/tauri-tray/manifest.json ADDED Viewed

@@ -0,0 +1,174 @@
+{
+  "id": "tauri-tray",
+  "description": "Tauri system-tray daemon app — tray icon + context menu + native notifications, no primary window.",
+  "tags": [
+    "desktop",
+    "tauri",
+    "tray",
+    "daemon",
+    "typescript"
+  ],
+  "taxonomy": {
+    "language": "typescript",
+    "runtime": "tauri",
+    "surface": "frontend"
+  },
+  "slots": {
+    "auth": {
+      "options": [
+        "auth:none",
+        "auth:better-auth",
+        "auth:clerk",
+        "auth:supabase-auth"
+      ],
+      "default": "auth:none"
+    },
+    "payments": {
+      "options": [
+        "payments:none",
+        "payments:stripe",
+        "payments:coinbase-commerce"
+      ],
+      "default": "payments:none"
+    },
+    "sdk": {
+      "options": [
+        "sdk:none",
+        "sdk:coinbase-cdp",
+        "sdk:solana-web3",
+        "sdk:evm-wallet"
+      ],
+      "default": "sdk:none"
+    }
+  },
+  "defaults": {
+    "projectType": "desktop",
+    "port": 4197,
+    "headline": "Starter Foundry Tray Daemon",
+    "subheadline": "A background tray-icon app driven by a context menu and native notifications."
+  },
+  "files": [
+    {
+      "source": "files/package.json",
+      "target": "package.json"
+    },
+    {
+      "source": "files/preview-server.mjs",
+      "target": "preview-server.mjs"
+    },
+    {
+      "source": "files/validate-types.mjs",
+      "target": "validate-types.mjs"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src-tauri/Cargo.toml"
+    },
+    {
+      "type": "file-exists",
+      "path": "src-tauri/src/lib.rs"
+    },
+    {
+      "type": "command-success",
+      "command": [
+        "node",
+        "validate-types.mjs"
+      ],
+      "expect": "tauri tray ok"
+    },
+    {
+      "type": "http-start",
+      "command": [
+        "node",
+        "preview-server.mjs"
+      ],
+      "path": "/",
+      "expect": "{{headline}}"
+    }
+  ],
+  "contextHints": {
+    "commands": [
+      "pnpm install",
+      "node preview-server.mjs",
+      "cargo tauri dev"
+    ],
+    "entrypoints": [
+      "src-tauri/src/lib.rs",
+      "src-tauri/tauri.conf.json"
+    ],
+    "preview": {
+      "path": "/"
+    },
+    "extensionPoints": [
+      "auth-config.json",
+      "payments-config.json",
+      "sdk-config.json"
+    ]
+  },
+  "keywords": [
+    "system tray app",
+    "tray icon only",
+    "background daemon ui",
+    "notification app",
+    "tray menu app",
+    "tauri tray",
+    "status bar app",
+    "taskbar tray"
+  ],
+  "tieredKeywords": {
+    "tier1": [
+      "system tray app",
+      "tray icon only",
+      "tauri tray",
+      "tray menu",
+      "background daemon"
+    ],
+    "tier2": [
+      "notification app",
+      "status bar daemon",
+      "taskbar tray",
+      "background worker ui",
+      "silent desktop app"
+    ],
+    "tier3": [
+      "always running app",
+      "sync client",
+      "desktop notifier"
+    ],
+    "archetypes": [
+      "tray-only utility",
+      "background sync daemon",
+      "notifier app"
+    ]
+  },
+  "buildHints": {
+    "whenToUse": "Pick tauri-tray when the app has NO primary window — it lives as a tray icon with a right-click context menu and fires OS notifications. Classic examples: Dropbox sync, 1Password background, a Slack notifier, a build-status watcher. If the user needs a popover panel on click, use tauri-menubar. If they need a real window, use tauri-desktop.",
+    "architectureNotes": [
+      "No webview is shown on startup — the app is effectively headless Rust with a tray surface.",
+      "All user interaction is via the tray menu (tauri::menu::Menu) and tauri_plugin_notification for native toast messages.",
+      "A hidden utility webview CAN be created lazily if the agent later needs HTML rendering for a settings pane, but the default shape is pure tray.",
+      "macOS: activation policy set to Accessory so no dock icon appears.",
+      "Windows: startup registers the app in the registry Run key via tauri-plugin-autostart so the tray survives reboots."
+    ],
+    "components": [
+      "Tray menu items (Status, Sync now, Open logs, Preferences, Quit).",
+      "Notification dispatch on sync events (success/failure/reminders).",
+      "Optional file-system log writer — tray daemons often need introspection without a UI."
+    ],
+    "gotchas": [
+      "macOS: without ActivationPolicy::Accessory you end up with a ghost dock icon AND a tray icon. Always set it in the .setup() handler.",
+      "macOS notarization: background daemons still need the hardened runtime + notarization — users see a scary Gatekeeper warning otherwise.",
+      "Windows: tray-only apps without a window confuse some antivirus heuristics. Sign the binary with a code-signing cert and submit to Microsoft SmartScreen via Partner Center to avoid SmartScreen warnings.",
+      "Notifications on macOS require `NSUserNotificationsUsageDescription` in Info.plist (via tauri.conf.json bundle.macOS) AND the user must grant permission on first send — handle the denial case.",
+      "Linux (GNOME 45+): tray icons require the AppIndicator extension. Document this in README — Tauri uses libappindicator under the hood and silently fails on stock GNOME.",
+      "If you later add a hidden webview, do NOT ship it as `visible: true` in tauri.conf.json — set `visible: false` and show programmatically, otherwise the window flashes on app start."
+    ],
+    "integrations": [
+      "tauri-plugin-notification — OS-native toast/alert banners",
+      "tauri-plugin-autostart — launch at login so the tray survives reboots",
+      "tauri-plugin-log — file-based logging since there is no on-screen UI"
+    ]
+  }
+}

package/registry/families/tgi-server/files/.env.example ADDED Viewed

@@ -0,0 +1,22 @@
+# HuggingFace Hub model id. Gated repos (Llama/Mistral/Gemma) require a token
+# AND acceptance of the model license on huggingface.co.
+MODEL_ID={{modelId}}
+# Required for gated models. Create at https://huggingface.co/settings/tokens
+# (read scope is sufficient). Never commit the real token.
+HUGGING_FACE_HUB_TOKEN=
+# Request budget. MAX_INPUT_LENGTH must be STRICTLY LESS than MAX_TOTAL_TOKENS;
+# the difference is the generation budget per request.
+MAX_INPUT_LENGTH={{maxInputLength}}
+MAX_TOTAL_TOKENS={{maxTotalTokens}}
+# Optional quantization: awq | gptq | eetq | bitsandbytes-nf4 | bitsandbytes-fp4
+# Leave empty for bf16/fp16 depending on model dtype.
+QUANTIZE=
+# Tensor-parallel shard count. Set to your GPU count for large models.
+NUM_SHARD=1
+# Local TGI URL the Python client hits.
+TGI_URL=http://localhost:{{port}}

package/registry/families/tgi-server/files/README-tgi.md ADDED Viewed

@@ -0,0 +1,59 @@
+# TGI — operator guide
+HuggingFace Text Generation Inference in a docker-compose wrapper. The
+container pulls weights from the Hub on first boot into the `./data` volume,
+runs HF's production Rust+Python server, and exposes `/generate`,
+`/generate_stream`, `/health`, and the OpenAI-compatible `/v1/chat/completions`.
+## First-run
+```bash
+cp .env.example .env
+# Edit .env: set HUGGING_FACE_HUB_TOKEN for gated models.
+docker compose up -d
+docker compose logs -f tgi  # watch weight download + warmup
+```
+First request after the container is healthy:
+```bash
+curl http://localhost:{{port}}/generate \
+  -H 'Content-Type: application/json' \
+  -d '{"inputs": "explain flash attention", "parameters": {"max_new_tokens": 128}}'
+```
+Or the Python client:
+```bash
+pip install -r requirements.txt
+python -m src.client
+```
+## Swapping models
+Edit `MODEL_ID` in `.env`. Any HF text-generation repo works — TGI loads it
+on next `docker compose up`. For large models:
+- Set `NUM_SHARD` to your GPU count (tensor parallelism).
+- Set `QUANTIZE=awq` (needs AWQ weights) or `QUANTIZE=bitsandbytes-nf4`
+  (works on raw weights, slower).
+- Raise `shm_size` in `docker-compose.yml` past 1gb if NCCL complains.
+## Production notes
+- **Pin the image tag** — `ghcr.io/huggingface/text-generation-inference:2.3.1`
+  instead of `:latest`. TGI bumps transformers across minors and custom
+  architectures silently break.
+- **Gated models** need the token AND license acceptance on huggingface.co.
+- **Tokens budget**: `MAX_INPUT_LENGTH < MAX_TOTAL_TOKENS` is a hard rule;
+  the delta is the generation budget.
+- **GPU**: requires nvidia-container-toolkit. Without a GPU the server
+  silently runs on CPU and OOMs on any non-tiny model.
+- **Metrics**: Prometheus scrape at `/metrics` — tokens/sec, queue depth,
+  per-request latency, batch-fill ratio.
+## Picking between TGI, vLLM, Ollama
+- **TGI**: Hub-native, docker-first, HF ecosystem, strongest quant support.
+- **vLLM**: PagedAttention, best throughput at high concurrency, Python-first.
+- **Ollama**: local GGUF, lowest operator overhead, Mac/CPU-friendly.

package/registry/families/tgi-server/files/client.py ADDED Viewed

@@ -0,0 +1,78 @@
+"""Tiny TGI client. Hits /generate and /generate_stream on a running TGI server.
+Run `docker compose up -d` first, then `python -m src.client`.
+"""
+from __future__ import annotations
+import json
+import os
+import sys
+from typing import Iterator
+import httpx
+TGI_URL = os.environ.get("TGI_URL", "http://localhost:{{port}}")
+DEFAULT_PROMPT = "Explain Flash Attention in one paragraph."
+def generate(prompt: str, max_new_tokens: int = 128, temperature: float = 0.7) -> str:
+    """Call TGI's native /generate endpoint. Returns the generated text only."""
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": max_new_tokens,
+            "temperature": temperature,
+            "do_sample": temperature > 0,
+            "return_full_text": False,
+        },
+    }
+    with httpx.Client(timeout=httpx.Timeout(120.0, connect=10.0)) as client:
+        response = client.post(f"{TGI_URL}/generate", json=payload)
+        response.raise_for_status()
+        body = response.json()
+    # TGI returns {"generated_text": "..."} for non-stream, or a list when
+    # best_of > 1. Normalize both shapes.
+    if isinstance(body, list):
+        return body[0]["generated_text"]
+    return body["generated_text"]
+def generate_stream(prompt: str, max_new_tokens: int = 128, temperature: float = 0.7) -> Iterator[str]:
+    """Stream tokens from /generate_stream. Yields one token string per chunk."""
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": max_new_tokens,
+            "temperature": temperature,
+            "do_sample": temperature > 0,
+        },
+    }
+    with httpx.Client(timeout=httpx.Timeout(120.0, connect=10.0)) as client:
+        with client.stream("POST", f"{TGI_URL}/generate_stream", json=payload) as response:
+            response.raise_for_status()
+            for line in response.iter_lines():
+                if not line or not line.startswith("data:"):
+                    continue
+                data = json.loads(line[len("data:") :].strip())
+                token = data.get("token", {}).get("text")
+                if token:
+                    yield token
+def main() -> int:
+    prompt = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else DEFAULT_PROMPT
+    print(f"> {prompt}\n")
+    try:
+        output = generate(prompt)
+    except httpx.HTTPError as exc:
+        print(f"TGI request failed: {exc}", file=sys.stderr)
+        print(f"Is the server running at {TGI_URL}? `docker compose up -d`", file=sys.stderr)
+        return 1
+    print(output)
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())

package/registry/families/tgi-server/files/docker-compose.yml ADDED Viewed

@@ -0,0 +1,46 @@
+# HuggingFace Text Generation Inference.
+# Pin the image tag in production — `latest` can break custom architectures
+# when HF bumps the embedded transformers version.
+services:
+  tgi:
+    image: ghcr.io/huggingface/text-generation-inference:latest
+    container_name: {{serviceName}}
+    restart: unless-stopped
+    ports:
+      - "{{port}}:80"
+    # NCCL / all-reduce needs more than the default 64MB /dev/shm.
+    shm_size: 1gb
+    environment:
+      MODEL_ID: ${MODEL_ID:-{{modelId}}}
+      HUGGING_FACE_HUB_TOKEN: ${HUGGING_FACE_HUB_TOKEN:-}
+      MAX_INPUT_LENGTH: ${MAX_INPUT_LENGTH:-{{maxInputLength}}}
+      MAX_TOTAL_TOKENS: ${MAX_TOTAL_TOKENS:-{{maxTotalTokens}}}
+      # QUANTIZE: awq | gptq | eetq | bitsandbytes-nf4 | bitsandbytes-fp4
+      QUANTIZE: ${QUANTIZE:-}
+      # NUM_SHARD > 1 splits across multiple GPUs (tensor parallelism).
+      NUM_SHARD: ${NUM_SHARD:-1}
+    command:
+      - --model-id
+      - ${MODEL_ID:-{{modelId}}}
+      - --max-input-length
+      - "${MAX_INPUT_LENGTH:-{{maxInputLength}}}"
+      - --max-total-tokens
+      - "${MAX_TOTAL_TOKENS:-{{maxTotalTokens}}}"
+      - --port
+      - "80"
+    volumes:
+      # Model weights cache. First boot downloads 15-60GB here.
+      - ./data:/data
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:80/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 120s

package/registry/families/tgi-server/files/requirements.txt ADDED Viewed

@@ -0,0 +1,3 @@
+huggingface_hub>=0.24.0
+httpx>=0.27.0
+pydantic>=2.9.0

package/registry/families/tgi-server/files/validate-tgi.mjs ADDED Viewed

@@ -0,0 +1,44 @@
+import fs from "node:fs/promises";
+const [compose, requirements, client, envExample] = await Promise.all([
+  fs.readFile("docker-compose.yml", "utf8"),
+  fs.readFile("requirements.txt", "utf8"),
+  fs.readFile("src/client.py", "utf8"),
+  fs.readFile(".env.example", "utf8"),
+]);
+if (!compose.includes("ghcr.io/huggingface/text-generation-inference")) {
+  throw new Error("docker-compose.yml missing TGI image reference");
+}
+if (!compose.includes("driver: nvidia") || !compose.includes("capabilities: [gpu]")) {
+  throw new Error("docker-compose.yml missing nvidia GPU device reservation");
+}
+if (!compose.includes("shm_size")) {
+  throw new Error("docker-compose.yml missing shm_size (NCCL crashes on default 64MB)");
+}
+if (!compose.includes("/data")) {
+  throw new Error("docker-compose.yml missing model volume mount at /data");
+}
+if (!requirements.includes("huggingface_hub")) {
+  throw new Error("requirements.txt missing huggingface_hub");
+}
+if (!requirements.includes("httpx")) {
+  throw new Error("requirements.txt missing httpx");
+}
+if (!client.includes("/generate")) {
+  throw new Error("src/client.py must hit TGI's /generate endpoint");
+}
+if (!client.includes("httpx")) {
+  throw new Error("src/client.py must import httpx");
+}
+if (!envExample.includes("MODEL_ID")) {
+  throw new Error(".env.example missing MODEL_ID");
+}
+if (!envExample.includes("HUGGING_FACE_HUB_TOKEN")) {
+  throw new Error(".env.example missing HUGGING_FACE_HUB_TOKEN");
+}
+console.log("tgi starter ok");