urirun://project/home

Jedno registry URI dla komend w kodzie, shellu, kontenerach i usługach.

Deklarujesz trasę raz, kompilujesz ją do registry i wywołujesz ten sam URI lokalnie albo przez HTTP, gRPC, kolejkę, serverless, Docker, MCP lub kartę agenta A2A.

Zacznij od v2 Komendy CLI

quickstart Instalacja z GitHuba

curl -fsSL https://ifuri.com/urirun/install.sh | sh
urirun --help
urirun scan ./project \
  --out generated/bindings.v2.json \
  --registry-out generated/registry.json
urirun list generated/registry.json
urirun run 'tool://local/report/render' --registry generated/registry.json

Runtimeurirun

Repozytoriumtellmesh/urirun

Domyślny kontraktv2 JSON Schema

Wykonaniedry-run first

urirun://schema

Jeden kontrakt, wiele runtime’ów.

Pakowanie komend zaczyna się od schematu. Dekorator, helper albo skan artefaktu generuje binding, potem urirun kompiluje go do registry i uruchamia po tym samym adresie URI.

fn Napisz funkcję Typy i wartości domyślne są źródłem prawdy.

{ } Wygeneruj binding Powstaje inputSchema i szablon argv lub shell.

✓ Skompiluj registry Trasy są walidowane i gotowe do odkrywania.

▶ Uruchom URI Dry-run najpierw, execute dopiero z polityką.

decorator + Pydantic

Dekorator robi binding z sygnatury funkcji.

Typy i wartości domyślne trafiają do JSON Schema, a lista argv zostaje deterministycznym szablonem komendy.

deklaracja

from urirun.v2 import decorated_bindings, uri_command

@uri_command("media://local/video/transcode")
def transcode(input: str, output: str, width: int = 1280, height: int = 720):
    return ["ffmpeg", "-i", "{input}", "-vf", "scale={width}:{height}", "{output}"]

binding + registry

from urirun.v2 import compile_registry, decorated_bindings

bindings = decorated_bindings()
registry = compile_registry(bindings)

plain JS helper

Helper JS składa binding bez transpilerów.

Deklaracja pól tworzy inputSchema, a factory komendy zwraca argv z placeholderami.

deklaracja

import { bindingDocument, string, uriCommand } from "./uri-command.mjs";

const greet = uriCommand(
  "js://local/greet/message",
  { name: string({ required: true }) },
  ({ name }) => ["node", "-e", "console.log(process.argv[1])", name],
);

binding + registry

node generate-bindings.mjs > generated/bindings.v2.json
python -m urirun.v2 compile generated/bindings.v2.json \
  --out generated/registry.json

firmware route table

Firmware może mieć prostą tabelę tras URI.

Kod C obsługuje lokalny dispatch, a registry dla reszty systemu można wygenerować jako kontrakt obok firmware.

deklaracja

static const UriRoute routes[] = {
  {"firmware://device-01/led/command/set", led_set},
  {"firmware://device-01/telemetry/query/latest", telemetry_latest},
};

binding + registry

python -m urirun.v2 add-command "firmware://device-01/led/command/set" \
  --argv "./firmware-cli led set {state}" \
  --param state:boolean:required \
  --out generated/bindings.v2.json
python -m urirun.v2 compile generated/bindings.v2.json --out generated/registry.json

scan scripts

Skrypt shell staje się URI przez skan projektu.

Nie trzeba przepisywać istniejących skryptów. urirun skanuje pliki i tworzy bindingi do kontrolowanego wykonania.

deklaracja

#!/usr/bin/env bash
# scripts/render-report.sh
set -euo pipefail
echo "report for ${1:-today}"

binding + registry

python -m urirun.v2 scan ./scripts \
  --out generated/bindings.v2.json \
  --registry-out generated/registry.json

image label + manifest

Obraz Dockera wskazuje manifest URI.

Kontener niesie własne bindings.json, a skan Dockerfile zbiera manifesty do wspólnego registry.

deklaracja

FROM python:3.12-slim
LABEL io.tellmesh.urirun.manifest="/app/bindings.json"
COPY bindings.json /app/bindings.json
COPY worker.py /app/worker.py

binding + registry

python -m urirun.v2 scan ./docker-stack \
  --out generated/bindings.v2.json \
  --registry-out generated/registry.json

decorator-style declaration

Dekorator TS daje typowaną deklarację komendy.

Metoda zwraca argv, a pola dekoratora są schematem wejścia dla runtime.

deklaracja

class MathCommands {
  @uriCommand("ts://local/math/add", {
    a: { type: "integer", required: true },
    b: { type: "integer", default: 0 },
  })
  add({ a, b }) {
    return ["node", "-e", "console.log(Number(process.argv[1]) + Number(process.argv[2]))", a, b];
  }
}

binding + registry

npx tsx decorators.ts > generated/bindings.v2.json
python -m urirun.v2 compile generated/bindings.v2.json \
  --out generated/registry.json

PHP 8 attribute + reflection

Atrybut PHP generuje binding przez reflection.

Parametry funkcji stają się inputSchema, a atrybut trzyma URI i argv.

deklaracja

#[UriCommand(
  uri: "php://local/slug/create",
  argv: ["php", "-r", "echo strtolower($argv[1]);", "{text}"],
)]
function slug(string $text, int $limit = 64): void {}

binding + registry

php examples/php/generate-bindings.php > generated/bindings.v2.json
python -m urirun.v2 compile generated/bindings.v2.json \
  --out generated/registry.json

flow://registry/build

Używaj istniejących artefaktów jako paczek URI.

Najprostsza droga to nie nowe SDK. Wskazujesz urirun to, co projekt już ma, generujesz bindingi, walidujesz registry i uruchamiasz po URI.

repo://project/artifacts/query/scan

Skanuj artefakty

Czytaj etykiety Dockerfile, metadane paczek, targety Make, skrypty shell i jawne bindingi.

registry://local/routes/command/compile

Kompiluj registry

Zamień przenośne pliki bindingów w jedno drzewo lookup dla każdego runtime.

policy://local/execution/query/check

Kontroluj wykonanie

Najpierw dry-run, potem jawne allow rules dla argv, shell, Docker lub wywołań sieciowych.

flow://local/task/command/run

Uruchamiaj ten sam URI

Wołaj go z shella, backendu, przeglądarki, usługi Docker, narzędzia MCP albo karty A2A.

transport://any/adapter/query

Ten sam URI, inny runtime.

URI nazywa to, co ma się wykonać. Transport decyduje jak: in-process, argv, shell, Docker, HTTP, gRPC, kolejka, serverless, MCP lub A2A. Kontrakt i bramka policy zostają w jednym miejscu.

in-process v2.run / local-function dispatch

argv Safe argument templates, no shell

shell Policy-gated shell templates

Docker docker-run / docker-exec, image labels

HTTP v2_service: POST /run, GET /routes

gRPC v2_grpc: Run, RunStream, ListRoutes

queue topic -> v2.run consumer (MQTT/NATS/Kafka shape)

serverless pure handler(event) function

MCP / A2A tools/list, tools/call, agent card

docs://local/index/query

Dokumentacja.

Instalacja Installer curl w jednej linii, PATH i pierwsza komenda urirun. Start Instalacja z GitHuba, skanowanie artefaktów, walidacja i pierwsze uruchomienie URI. Nazewnictwo Gdzie używać nazwy urirun i jak nie mieszać jej ze starszymi nazwami projektu. Komendy CLI, wersjonowane entry pointy i generowanie bindingów w jednej linii. Registry Jak przenośne bindingi stają się trasami runtime do wykonania. Transporty Funkcje lokalne, shell, Docker, HTTP, gRPC, przeglądarka, MCP i A2A. Logo Wektory SVG dla ikony, wordmarka, favicony i lockupów. Roadmap Praktyczne kroki, które uproszczą użycie urirun.

examples://repo/current/query

Przykłady pokazujące współpracę warstw.

Przykłady są małe celowo: pokazują, jak jedno registry obsługuje UI w przeglądarce, backend, usługi Docker, generatory i adaptery firmware.

Cztery pulpity noVNC (pc1 controller, pc2 service-node, pc3 client-node, pc4 monitor-node) w jednym dashboardzie, każdy terminal pokazuje zdarzenia JSON z przepływu URI — novnc_lan_flow: cztery komputery Docker komunikują się przez ten sam kontrakt URI (pc://…, log://…), pokazane razem w dashboardzie.

v2/examples/transports

One registry driven over five transports (in-process, queue, serverless, HTTP, gRPC) plus a simple scan & run.

v2/examples/multi_transport

Docker stack mixing HTTP and gRPC workers: auto-generated registry, conflict detection, and a cross-environment flow.

v2/examples/docker_uri_flow

Docker Compose services communicating through generated URI bindings, with a library-native service dispatcher.

v2/examples/novnc_lan_flow

Four noVNC computers in one Docker LAN, shown together in a dashboard and coordinated by a URI flow.

v2/examples/html_uri_app

Browser UI that calls a Python backend through URI actions and exposes logs, MCP tools, and an A2A card.

v2/examples/generators

JS, Node.js, TypeScript, and PHP declarations that generate the same v2 binding contract.

examples/reference_adapters

Minimal adapters for JavaScript, Python, C/firmware, and browser use.

todo://urirun/usability/query

Następne prace nad użytecznością.

urirun init dla startowego registry, policy i przykładowej trasy
urirun doctor dla środowiska, zależności, portów i konfliktów tras
urirun serve dla lokalnej przeglądarki tras, logów, dry-run console i policy-gated execution
standardowe log:// w frontendzie, backendzie, shellu, firmware i przykładach Docker
urirun diff do porównywania registry przed wdrożeniem