nylorun 0.15.1-beta → 0.17.0-beta

package/dist/cli.js

@@ -12,14 +12,24 @@ ${stackUsage}
   doctor sandbox [--tenant <name>] [--json]
                                       the sandbox backend the Tenant's Host offers
 
+Agent manifests:
+  apply [<dir>...] [--dry-run] [--if-match <n>]
+                                      save the agent manifest each folder's agent.manifest.json
+                                      describes, with the files it names (Runtime API)
+  migrate v8 <agent.json> [--runtime <environment-manifest.json>] [--out <dir>]
+                                      write the three manifest files from an agent manifest v7
+                                      and an environment manifest v1 (reads no Runtime)
+
 Groups, each with its own --help:
-  agents        list | get | save     the Tenant's agents (Runtime API, an application key)
+  agent-manifests  list | get | versions | rm
+                                      the Tenant's agent manifests (Runtime API)
+  agents        list | get | put | fork | stop | reset | rm | snapshot | restore
+                versions | delete-version | events | secrets
+                                      the Tenant's Agents, made from saved manifests; sessions
+                                      run on them (Runtime API)
   sessions      list | create | get | send | approve | respond | cancel | watch | history
                 usage | calls | trace | exec
                                       the Tenant's sessions (Runtime API)
-  environments  list | get | put | fork | stop | reset | delete | snapshot | restore
-                versions | delete-version | events | secrets | manifests
-                                      the Tenant's Environments (Runtime API)
   artifacts     list | get | upload | download | tree | diff | zip | link | rm
                                       the Tenant's file artifacts (Runtime API)
   tenant        reset | keys | signing-keys | models | usage | calls | budgets | tool-policy |
@@ -32,7 +42,8 @@ A command acts on the local Tenant --tenant names, else the linked project's, el
 project) the default Tenant; NYLORUN_HOME sets its Host root (default
 ~/.nylorun/tenants/<name>). Without --tenant, NYLORUN_RUNTIME_URL names a remote installation:
 with NYLORUN_MANAGEMENT_KEY for status, doctor sandbox and tenant; with NYLORUN_SERVER_KEY, or an
-identity provider's token in NYLORUN_TOKEN, for agents, sessions, environments and artifacts.
+identity provider's token in NYLORUN_TOKEN, for apply, agent-manifests, agents, sessions and
+artifacts.
 The Runtime API groups act for a person with --as <subject> [--scope <scope>]...`;
 const localUsage = `nylorun local <command>
 
@@ -54,7 +65,8 @@ const MOVED = {
     ls: "nylorun ls moved: nylorun local ls",
     delete: "nylorun delete moved: nylorun local delete",
     telemetry: "nylorun telemetry moved: nylorun local telemetry",
-    reset: "nylorun reset moved: nylorun local reset deletes a local Tenant's volumes; nylorun tenant reset clears its sessions or Environments through the Management API",
+    reset: "nylorun reset moved: nylorun local reset deletes a local Tenant's volumes; nylorun tenant reset clears its sessions or Agents through the Management API",
+    environments: "nylorun environments is nylorun agents in protocol 16: Environments are Agents, made from saved agent manifests (nylorun apply). Environment manifests are the runtime section of an agent manifest (nylorun migrate v8).",
     key: "nylorun key moved: nylorun tenant keys put|list|rm",
     keys: "nylorun keys is nylorun tenant keys put|list|rm",
     mcp: "nylorun mcp moved: nylorun tenant mcp inspect <url>",
@@ -66,10 +78,10 @@ const MOVED = {
     runtime: "nylorun runtime was removed: the local Runtime runs in Docker Compose. Use nylorun up|down|status and nylorun local logs.",
 };
 const SANDBOX_MOVED = {
-    ls: "nylorun sandbox ls moved: nylorun environments list",
-    list: "nylorun sandbox ls moved: nylorun environments list",
-    rm: "nylorun sandbox rm moved: nylorun environments delete <id>",
-    delete: "nylorun sandbox rm moved: nylorun environments delete <id>",
+    ls: "nylorun sandbox ls moved: nylorun agents list",
+    list: "nylorun sandbox ls moved: nylorun agents list",
+    rm: "nylorun sandbox rm moved: nylorun agents rm <id>",
+    delete: "nylorun sandbox rm moved: nylorun agents rm <id>",
 };
 const LOCAL_UI_REMOVED = "--local-ui was removed: Studio runs in its own container. Run nylorun studio.";
 const usageError = (message) => new CliError(message, 2);
@@ -150,11 +162,18 @@ async function main() {
         process.exitCode = await tenantCommand(defaultStackDeps(env), args);
         return;
     }
-    if (command === "agents" || command === "sessions" || command === "environments" || command === "artifacts") {
+    if (command === "apply" ||
+        command === "migrate" ||
+        command === "agent-manifests" ||
+        command === "agents" ||
+        command === "sessions" ||
+        command === "artifacts") {
         const group = {
+            apply: async () => (await import("./client/apply.js")).applyCommand,
+            migrate: async () => (await import("./client/migrate.js")).migrateCommand,
+            "agent-manifests": async () => (await import("./client/agent-manifests.js")).agentManifestsCommand,
             agents: async () => (await import("./client/agents.js")).agentsCommand,
             sessions: async () => (await import("./client/sessions.js")).sessionsCommand,
-            environments: async () => (await import("./client/environments.js")).environmentsCommand,
             artifacts: async () => (await import("./client/artifacts.js")).artifactsCommand,
         }[command];
         process.exitCode = await (await group())(defaultStackDeps(env), args);

package/dist/client/agent-manifests.d.ts

@@ -0,0 +1,4 @@
+import type { StackDeps } from "../stack/commands.js";
+export declare const agentManifestsUsage: string;
+/** `nylorun agent-manifests <command> ...` */
+export declare function agentManifestsCommand(deps: StackDeps, args: readonly string[]): Promise<number>;

package/dist/client/agent-manifests.js

@@ -0,0 +1,100 @@
+import { parseAgentManifestRef } from "@nylorun/core/contracts";
+import { parseFlags, positional, printJson, printTable, runtimeCall, runtimeClient, runtimeFlagsUsage, usageError, } from "./runtime.js";
+export const agentManifestsUsage = `nylorun agent-manifests <command>
+
+The Tenant's agent manifests, through the Runtime API with an application key (or
+NYLORUN_TOKEN). Save one with nylorun apply <dir>.
+
+  list [--json]                       each manifest's latest version: its runtime kind, harness
+                                      and the Agents made from it
+  get <name>[@<n>]                    a manifest's latest version (or version n), as JSON
+  versions <name>                     its versions, with the Agents made from each
+  rm <name>                           delete every version (refused while an Agent was made
+                                      from one)
+
+${runtimeFlagsUsage}`;
+/** The harness that runs a manifest's loop, as the list prints it. */
+function harnessOf(view) {
+    const { harness } = view.manifest;
+    const id = harness.id ?? "nylorun";
+    return "kind" in harness && harness.kind === "workflow" ? `${id} (flow)` : id;
+}
+async function list(deps, args) {
+    const usage = "nylorun agent-manifests list [--json]";
+    const flags = parseFlags(args, { booleans: ["--json"] }, usage);
+    positional(flags, 0, usage);
+    const { client, connection } = await runtimeClient(deps, flags);
+    const manifests = await runtimeCall(() => client.agentManifests.list());
+    if (flags.booleans.has("--json")) {
+        printJson(deps, manifests);
+        return 0;
+    }
+    if (manifests.length === 0)
+        deps.out(`No agent manifests on ${connection.label}. Save one with nylorun apply <dir>.`);
+    else
+        printTable(deps, [
+            ["NAME", "VERSION", "KIND", "HARNESS", "AGENTS"],
+            ...manifests.map((view) => [
+                view.name,
+                String(view.version),
+                view.manifest.runtime?.kind ?? "none",
+                harnessOf(view),
+                String(view.agents),
+            ]),
+        ]);
+    return 0;
+}
+async function get(deps, args) {
+    const usage = "nylorun agent-manifests get <name>[@<n>]";
+    const flags = parseFlags(args, {}, usage);
+    const [ref] = positional(flags, 1, usage);
+    const parsed = parseAgentManifestRef(ref);
+    if (!parsed)
+        throw usageError(`${ref} is not an agent manifest's name, or name@version such as triage@3.`);
+    const { client } = await runtimeClient(deps, flags);
+    printJson(deps, await runtimeCall(() => client.agentManifests.get(parsed.name, parsed.version)));
+    return 0;
+}
+async function versions(deps, args) {
+    const usage = "nylorun agent-manifests versions <name>";
+    const flags = parseFlags(args, {}, usage);
+    const [name] = positional(flags, 1, usage);
+    const { client } = await runtimeClient(deps, flags);
+    printJson(deps, await runtimeCall(() => client.agentManifests.versions(name)));
+    return 0;
+}
+async function remove(deps, args) {
+    const usage = "nylorun agent-manifests rm <name>";
+    const flags = parseFlags(args, {}, usage);
+    const [name] = positional(flags, 1, usage);
+    const { client, connection } = await runtimeClient(deps, flags);
+    const deleted = await runtimeCall(() => client.agentManifests.delete(name));
+    if (!deleted.deleted) {
+        deps.err(`No agent manifest ${name} on ${connection.label}.`);
+        return 1;
+    }
+    deps.out(`Deleted agent manifest ${name}: every version.`);
+    return 0;
+}
+const COMMANDS = {
+    list,
+    ls: list,
+    get,
+    versions,
+    rm: remove,
+    delete: remove,
+};
+/** `nylorun agent-manifests <command> ...` */
+export async function agentManifestsCommand(deps, args) {
+    const [sub, ...rest] = args;
+    if (sub === "--help" || sub === "-h") {
+        deps.out(agentManifestsUsage);
+        return 0;
+    }
+    if (sub === "save")
+        throw usageError("Save an agent manifest with nylorun apply <dir>: it composes agent.manifest.json and the files it names.");
+    const command = sub !== undefined && Object.hasOwn(COMMANDS, sub) ? COMMANDS[sub] : undefined;
+    if (!command)
+        throw usageError(sub ? `Unknown agent-manifests command ${sub}.\n${agentManifestsUsage}` : agentManifestsUsage);
+    return command(deps, rest);
+}

package/dist/client/agents.d.ts

@@ -1,6 +1,4 @@
 import type { StackDeps } from "../stack/commands.js";
 export declare const agentsUsage: string;
-/** Every `sha256:<hex>` a manifest names under a `files` map, with where it names it. */
-export declare function namedFiles(manifest: unknown): Map<string, string>;
-/** `nylorun agents <list|get|save> ...` */
+/** `nylorun agents <command> ...` */
 export declare function agentsCommand(deps: StackDeps, args: readonly string[]): Promise<number>;