@ornncompute/cli 0.2.1 → 0.2.3

package/README.md

@@ -44,6 +44,7 @@ ornn whoami [--json]
 ornn status [--json]
 ornn listings list [--gpu-type <type>] [--facility <name>] [--operator <name>] [--json]
 ornn listings show <listing-id> [--open] [--json]
+ornn listings create [--gpu-type <type>] [--node-count <n>] [--yes] [--json]
 ornn buy <listing-id> [--no-open] [--json]
 ornn exchange create <listing-id> --node-count <n> [--min-node-count <n>] --start-date <yyyy-mm-dd> --end-date <yyyy-mm-dd> --price <usd> [--no-open] [--json]
 ornn exchange list [--limit <1-500>] [--cursor <last-id>] [--json]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ornncompute/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Command-line interface for Ornn compute access workflows.",
   "type": "module",
   "bin": {

package/src/catalog-dispatch.mjs

@@ -1,7 +1,55 @@
+import { readFileSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { stdin as defaultStdin, stdout as defaultStdout } from "node:process";
 
-import { cliRequest, operatorRequest } from "./api-client.mjs";
+import { cliRequest, loadRequiredSession, operatorRequest, resolveApiBaseUrl } from "./api-client.mjs";
+
+async function collectSse(url, headers, durationMs, maxEvents, fetchImpl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), durationMs);
+  const events = [];
+  try {
+    const res = await fetchImpl(url, { method: "GET", headers, signal: controller.signal });
+    if (!res.ok || !res.body) {
+      const detail = await res.text().catch(() => "");
+      throw new Error(detail.trim() || `http_${res.status}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (events.length < maxEvents) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        const data = part
+          .split("\n")
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trim())
+          .join("\n");
+        if (!data) continue;
+        try {
+          events.push(JSON.parse(data));
+        } catch {
+          events.push({ raw: data });
+        }
+        if (events.length >= maxEvents) break;
+      }
+    }
+    try {
+      await reader.cancel();
+    } catch {
+      // already closed
+    }
+  } catch (error) {
+    if (!(error instanceof Error) || error.name !== "AbortError") throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  return { events };
+}
 
 async function loadCapabilities() {
   try {
@@ -34,18 +82,56 @@ export async function confirmCatalogMutation({ stdin, stdout, yes, label }) {
 function catalogFetch({ env, fetchImpl }) {
   return async (path, init) => {
     const method = init?.method ?? "GET";
+    const observabilityPrefix = "/v1/observability";
+    const staffObservability =
+      path.startsWith(`${observabilityPrefix}/nodes/`) ||
+      path.startsWith(`${observabilityPrefix}/nodes?`);
     const staffPath =
+      staffObservability ||
       path.startsWith("/internal") ||
       path.startsWith("/provisioning") ||
       path === "/inventory" ||
       path.startsWith("/inventory/");
     const request = staffPath ? operatorRequest : cliRequest;
+    const requestPath = staffObservability ? path.slice(observabilityPrefix.length) : path;
+    if (init?.headers?.Accept === "text/event-stream") {
+      const session = await loadRequiredSession({ env });
+      const base = resolveApiBaseUrl({ env, session });
+      const parsed = new URL(
+        staffObservability ? `/v1/cli/operator${requestPath}` : path,
+        `${base.replace(/\/+$/, "")}/`,
+      );
+      const duration = Number(parsed.searchParams.get("duration") ?? "20") * 1000;
+      const maxEvents = Number(parsed.searchParams.get("max_events") ?? "40");
+      return collectSse(
+        parsed.toString(),
+        {
+          Accept: "text/event-stream",
+          Authorization: `Bearer ${session.accessToken}`,
+          "X-Ornn-Credential-Type": "user",
+        },
+        duration,
+        maxEvents,
+        fetchImpl,
+      );
+    }
+    let body = init?.body;
+    if (
+      body &&
+      typeof body === "object" &&
+      typeof body.identity_file === "string" &&
+      body.identity_file.trim()
+    ) {
+      const privateKey = readFileSync(body.identity_file.trim(), "utf8");
+      body = { ...body, private_key: privateKey };
+      delete body.identity_file;
+    }
     return request({
-      endpoint: path,
+      endpoint: requestPath,
       env,
       fetchImpl,
       method,
-      ...(init?.body !== undefined ? { body: init.body } : {}),
+      ...(body !== undefined ? { body } : {}),
     });
   };
 }
@@ -174,11 +260,113 @@ export async function usersQueryCommand(args, context) {
   return 0;
 }
 
-export async function nodesConsoleCommand(nodeId, context) {
+export async function nodesConsoleCommand(args, context) {
   const { nodesConsoleCapability } = await loadCapabilities();
+  const [nodeId, ...rest] = args;
+  if (!nodeId) {
+    throw new Error("Usage: ornn nodes console <node-id> [--identity-file <path>] [--json]");
+  }
+  const options = context.parseCommandOptions(
+    rest,
+    { boolean: ["json"], value: ["identity-file"] },
+    "Usage: ornn nodes console <node-id> [--identity-file <path>] [--json]",
+  );
   const result = await runCatalogCapability(
     nodesConsoleCapability,
-    { node_id: nodeId },
+    { node_id: nodeId, identity_file: options.identityFile },
+    {
+      ...context,
+      role: options.identityFile ? "user" : context.staff ? "reviewer" : "user",
+    },
+  );
+  context.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+export async function telemetryLatestCommand(args, context) {
+  const { telemetryLatestCapability } = await loadCapabilities();
+  const [nodeId, ...rest] = args;
+  const options = context.parseCommandOptions(
+    rest,
+    { boolean: ["json"], value: ["start", "end", "span", "max-points"] },
+    "Usage: ornn telemetry latest <node-id> [--span 15m] [--start <iso>] [--end <iso>] [--max-points <n>]",
+  );
+  const result = await runCatalogCapability(
+    telemetryLatestCapability,
+    {
+      node_id: nodeId,
+      start: options.start,
+      end: options.end,
+      span: options.span,
+      max_points: options.maxPoints != null ? Number(options.maxPoints) : undefined,
+    },
+    { ...context, role: context.staff ? "reviewer" : "user" },
+  );
+  context.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+export async function logsLatestCommand(args, context) {
+  const { logsLatestCapability } = await loadCapabilities();
+  const [nodeId, ...rest] = args;
+  const options = context.parseCommandOptions(
+    rest,
+    { boolean: ["json"], value: ["stream", "count", "before", "cursor"] },
+    "Usage: ornn logs latest <node-id> [--stream kernel] [--count 200] [--before <iso>] [--cursor <token>]",
+  );
+  const result = await runCatalogCapability(
+    logsLatestCapability,
+    {
+      node_id: nodeId,
+      stream: options.stream,
+      count: options.count != null ? Number(options.count) : undefined,
+      before: options.before,
+      cursor: options.cursor,
+    },
+    { ...context, role: context.staff ? "reviewer" : "user" },
+  );
+  context.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+export async function telemetryTailCommand(args, context) {
+  const { telemetryTailCapability } = await loadCapabilities();
+  const [nodeId, ...rest] = args;
+  const options = context.parseCommandOptions(
+    rest,
+    { boolean: ["json"], value: ["duration", "max-events", "fields"] },
+    "Usage: ornn telemetry tail <node-id> [--duration 20] [--max-events 40]",
+  );
+  const result = await runCatalogCapability(
+    telemetryTailCapability,
+    {
+      node_id: nodeId,
+      duration: options.duration != null ? Number(options.duration) : undefined,
+      max_events: options.maxEvents != null ? Number(options.maxEvents) : undefined,
+      fields: options.fields,
+    },
+    { ...context, role: context.staff ? "reviewer" : "user" },
+  );
+  context.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+export async function logsTailCommand(args, context) {
+  const { logsTailCapability } = await loadCapabilities();
+  const [nodeId, ...rest] = args;
+  const options = context.parseCommandOptions(
+    rest,
+    { boolean: ["json"], value: ["stream", "duration", "max-events"] },
+    "Usage: ornn logs tail <node-id> [--stream kernel] [--duration 20]",
+  );
+  const result = await runCatalogCapability(
+    logsTailCapability,
+    {
+      node_id: nodeId,
+      stream: options.stream,
+      duration: options.duration != null ? Number(options.duration) : undefined,
+      max_events: options.maxEvents != null ? Number(options.maxEvents) : undefined,
+    },
     { ...context, role: context.staff ? "reviewer" : "user" },
   );
   context.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/src/cli.mjs

@@ -1,11 +1,6 @@
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
 import { createReadStream, createWriteStream, existsSync } from "node:fs";
 import {
-  chmod,
-  mkdir,
-  mkdtemp,
-  open,
   readFile,
   rename,
   rm,
@@ -13,9 +8,8 @@ import {
   writeFile,
 } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { isIP } from "node:net";
-import { homedir, hostname, tmpdir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
@@ -44,8 +38,12 @@ import {
 } from "./device-auth.mjs";
 import {
   listingsCreateCommand,
+  logsLatestCommand,
+  logsTailCommand,
   nodesConsoleCommand,
   operatorListCommand,
+  telemetryLatestCommand,
+  telemetryTailCommand,
   usersQueryCommand,
 } from "./catalog-dispatch.mjs";
 import { maybeNotifyUpdate, updateCommand } from "./update.mjs";
@@ -134,7 +132,11 @@ Usage:
   ornn gpus checkout <gpu-id> [--no-open] [--json]
   ornn nodes list [--json]
   ornn nodes show <node-id> [--json]
-  ornn nodes console <node-id> [--json]
+  ornn nodes console <node-id> [--identity-file <path>] [--json]
+  ornn telemetry latest <node-id> [--span 15m] [--start <iso>] [--end <iso>] [--max-points <n>] [--json]
+  ornn telemetry tail <node-id> [--duration <seconds>] [--json]
+  ornn logs latest <node-id> [--stream kernel] [--count <n>] [--before <iso>] [--cursor <token>] [--json]
+  ornn logs tail <node-id> [--stream kernel] [--duration <seconds>] [--json]
   ornn nodes launch <reservation-id> --key <path|id|label> [--mode bare-metal|vm] [--username <name>] [--network public|private] [--storage-load-drive-id <id>] [--storage-save-drive-id <id>] [--wait] [--json]
   ornn nodes switch <reservation-id> --network public|private --key <path|id|label> [--mode bare-metal|vm] [--username <name>] [--wait] [--json]
   ornn nodes wait <node-or-reservation-id> [--timeout <seconds>] [--json]
@@ -465,6 +467,43 @@ async function dispatch(argv = [], io = {}) {
       });
     }
 
+    if (command === "telemetry" && args[0] === "latest") {
+      return await telemetryLatestCommand(args.slice(1), {
+        env,
+        fetchImpl,
+        parseCommandOptions,
+        stdout,
+        staff: Boolean(env.ORNN_OPERATOR_TOKEN || env.ORNN_STAFF),
+      });
+    }
+    if (command === "telemetry" && args[0] === "tail") {
+      return await telemetryTailCommand(args.slice(1), {
+        env,
+        fetchImpl,
+        parseCommandOptions,
+        stdout,
+        staff: Boolean(env.ORNN_OPERATOR_TOKEN || env.ORNN_STAFF),
+      });
+    }
+    if (command === "logs" && args[0] === "latest") {
+      return await logsLatestCommand(args.slice(1), {
+        env,
+        fetchImpl,
+        parseCommandOptions,
+        stdout,
+        staff: Boolean(env.ORNN_OPERATOR_TOKEN || env.ORNN_STAFF),
+      });
+    }
+    if (command === "logs" && args[0] === "tail") {
+      return await logsTailCommand(args.slice(1), {
+        env,
+        fetchImpl,
+        parseCommandOptions,
+        stdout,
+        staff: Boolean(env.ORNN_OPERATOR_TOKEN || env.ORNN_STAFF),
+      });
+    }
+
     if (LISTINGS_COMMANDS.has(command)) {
       return await availability(args, {
         commandName: command,
@@ -503,7 +542,16 @@ async function dispatch(argv = [], io = {}) {
     }
 
     if (command === "nodes") {
-      return await nodes(args, { env, fetchImpl, openBrowserImpl, spawnProcess, stderr, stdout });
+      return await nodes(args, {
+        env,
+        fetchImpl,
+        openBrowserImpl,
+        parseCommandOptions,
+        spawnProcess,
+        stderr,
+        stdout,
+        staff: Boolean(env.ORNN_OPERATOR_TOKEN || env.ORNN_STAFF),
+      });
     }
 
     if (command === "ssh") {
@@ -2715,8 +2763,7 @@ async function nodes(args, context) {
   }
 
   if (subcommand === "console" && id) {
-    parseCommandOptions([nested, ...rest].filter(Boolean), { boolean: ["json"] }, "Usage: ornn nodes console <node-id>");
-    return await nodesConsoleCommand(id, context);
+    return await nodesConsoleCommand([id, nested, ...rest].filter(Boolean), context);
   }
 
   if (subcommand === "show" && id) {
@@ -8637,12 +8684,6 @@ function validateMinNodeCount(minNodeCount, nodeCount) {
   }
 }
 
-function validateMinGpuCount(minGpuCount, gpuCount) {
-  if (minGpuCount > gpuCount) {
-    throw new Error("--min-gpu-count must be less than or equal to --gpu-count.");
-  }
-}
-
 function arrayOption(value) {
   if (value === undefined || value === null || value === "") {
     return [];

package/vendor/capabilities/capabilities/fleet.js

@@ -25,6 +25,8 @@ const nodesInput = z.object({
 const consoleInput = z.object({
     node_id: z.string().min(1),
     nodeId: z.string().optional(),
+    identity_file: z.string().optional(),
+    commands: z.array(z.string()).optional(),
 });
 export const listOperatorsCapability = defineCapability({
     id: "operator.list",
@@ -106,14 +108,19 @@ export const nodesConsoleCapability = defineCapability({
     id: "nodes.console",
     domain: "fleet",
     roles: ["user", "reviewer", "admin"],
-    description: "Open an authenticated WebSocket into the node's real host shell (PTY), not ssh(1) and not the agent packet bus. Returns a short-lived wss URL plus ticket. CLI attaches an interactive TTY. MCP and Slack return a command loop over the same socket.",
+    description: "Run an allowlisted host snapshot (ps -ef, nvidia-smi) on one node. Pass the orchestrator node UUID, never a hostname. Users must target a reserved node and pass identity_file (local PEM, same as ornn ssh --identity-file). Reviewers and admins may target any enrolled node; the orchestrator loads the stored admin SSH key. Slack staff never pass a key.",
     mutation: "read",
-    http: { method: "POST", path: "/v1/nodes/{id}/console" },
+    http: { method: "POST", path: "/internal/nodes/{id}/console" },
     slack: {
         parameters: {
             type: "object",
             properties: {
-                node_id: { type: "string", description: "Node UUID from nodes.list." },
+                node_id: { type: "string", description: "Node UUID from nodes.list, not a hostname." },
+                commands: {
+                    type: "array",
+                    items: { type: "string", enum: ["ps", "ps -ef", "nvidia-smi", "nvidia-smi -L"] },
+                    description: "Optional allowlisted commands. Default is ps and nvidia-smi.",
+                },
             },
             required: ["node_id"],
         },
@@ -122,9 +129,19 @@ export const nodesConsoleCapability = defineCapability({
     execute: async (ctx, input) => {
         const parsed = consoleInput.parse(input);
         const id = (parsed.node_id || parsed.nodeId || "").trim();
-        return ctx.fetch(`/v1/nodes/${encodeURIComponent(id)}/console`, {
+        if (ctx.role === "user") {
+            const identity = parsed.identity_file?.trim();
+            if (!identity) {
+                return { error: "identity_file_required", detail: "Users must pass identity_file." };
+            }
+            return ctx.fetch(`/nodes/${encodeURIComponent(id)}/console`, {
+                method: "POST",
+                body: { identity_file: identity, commands: parsed.commands },
+            });
+        }
+        return ctx.fetch(`/internal/nodes/${encodeURIComponent(id)}/console`, {
             method: "POST",
-            body: { node_id: id },
+            body: { commands: parsed.commands },
         });
     },
 });

package/vendor/capabilities/capabilities/observability.d.ts

@@ -0,0 +1,5 @@
+export declare const telemetryLatestCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const logsLatestCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const telemetryTailCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const logsTailCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const observabilityCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

package/vendor/capabilities/capabilities/observability.js

@@ -0,0 +1,188 @@
+import { z } from "zod";
+import { defineCapability } from "../capability.js";
+function queryPath(path, params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value?.trim())
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value.trim())}`);
+    }
+    return parts.length ? `${path}?${parts.join("&")}` : path;
+}
+function nodePrefix(role, id) {
+    const encoded = encodeURIComponent(id);
+    return role === "user"
+        ? `/v1/observability/machines/${encoded}`
+        : `/v1/observability/nodes/${encoded}`;
+}
+const latestInput = z.object({
+    node_id: z.string().min(1),
+    nodeId: z.string().optional(),
+    start: z.string().optional(),
+    end: z.string().optional(),
+    span: z.string().optional(),
+    max_points: z.number().int().min(1).max(500).optional(),
+});
+const logsLatestInput = z.object({
+    node_id: z.string().min(1),
+    nodeId: z.string().optional(),
+    stream: z.enum(["serial", "kernel"]).default("kernel"),
+    count: z.number().int().min(1).max(1000).optional(),
+    before: z.string().optional(),
+    cursor: z.string().optional(),
+});
+const tailInput = z.object({
+    node_id: z.string().min(1),
+    nodeId: z.string().optional(),
+    duration: z.number().int().min(1).max(120).optional(),
+    max_events: z.number().int().min(1).max(200).optional(),
+    fields: z.string().optional(),
+});
+const logsTailInput = tailInput.extend({
+    stream: z.enum(["serial", "kernel"]).default("kernel"),
+});
+function nodeId(input) {
+    return (input.node_id || input.nodeId || "").trim();
+}
+function expandSpan(span, start, end) {
+    if (start?.trim() && end?.trim()) {
+        return { start: start.trim(), end: end.trim() };
+    }
+    const now = Date.now();
+    const match = /^(\d+)(m|h|d)$/.exec((span ?? "15m").trim());
+    const amount = match ? Number(match[1]) : 15;
+    const unit = match?.[2] ?? "m";
+    const ms = unit === "d" ? amount * 86_400_000 : unit === "h" ? amount * 3_600_000 : amount * 60_000;
+    return { start: new Date(now - ms).toISOString(), end: new Date(now).toISOString() };
+}
+export const telemetryLatestCapability = defineCapability({
+    id: "telemetry.latest",
+    domain: "observability",
+    roles: ["user", "reviewer", "admin"],
+    description: "One-shot telemetry window for one node (start/end or span plus max_points). Users may only query a reserved machine. Reviewers and admins may query any enrolled node. Pass a node UUID. Use this for heartbeat / last-seen / public_ip. Not a live stream.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/observability/nodes/{id}/telemetry/query" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                node_id: { type: "string", description: "Node UUID from nodes.list." },
+                span: { type: "string", description: "Lookback like 15m, 1h, 1d. Default 15m." },
+                start: { type: "string" },
+                end: { type: "string" },
+                max_points: { type: "number", description: "Default 240, max 500." },
+            },
+            required: ["node_id"],
+        },
+    },
+    input: latestInput,
+    execute: async (ctx, input) => {
+        const parsed = latestInput.parse(input);
+        const id = nodeId(parsed);
+        const range = expandSpan(parsed.span, parsed.start, parsed.end);
+        return ctx.fetch(queryPath(`${nodePrefix(ctx.role, id)}/telemetry/query`, {
+            start: range.start,
+            end: range.end,
+            max_points: String(parsed.max_points ?? 240),
+        }), { method: "GET" });
+    },
+});
+export const logsLatestCapability = defineCapability({
+    id: "logs.latest",
+    domain: "observability",
+    roles: ["user", "reviewer", "admin"],
+    description: "One-shot newest kernel or serial log page (before + count + cursor). Users only on a reserved machine. Not a live tail. First call omits cursor; older pages pass next_cursor.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/observability/nodes/{id}/logs/{stream}/query" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                node_id: { type: "string", description: "Node UUID from nodes.list." },
+                stream: { type: "string", enum: ["serial", "kernel"] },
+                count: { type: "number", description: "Page size. Default 200, max 1000." },
+                before: { type: "string", description: "RFC3339 upper bound. Default now." },
+                cursor: { type: "string", description: "next_cursor from the previous page." },
+            },
+            required: ["node_id"],
+        },
+    },
+    input: logsLatestInput,
+    execute: async (ctx, input) => {
+        const parsed = logsLatestInput.parse(input);
+        const id = nodeId(parsed);
+        const end = parsed.before?.trim() || new Date().toISOString();
+        const start = new Date(Date.parse(end) - 7 * 86_400_000).toISOString();
+        return ctx.fetch(queryPath(`${nodePrefix(ctx.role, id)}/logs/${parsed.stream}/query`, {
+            start,
+            end,
+            limit: String(parsed.count ?? 200),
+            order: "desc",
+            cursor: parsed.cursor,
+        }), { method: "GET" });
+    },
+});
+export const telemetryTailCapability = defineCapability({
+    id: "telemetry.tail",
+    domain: "observability",
+    roles: ["user", "reviewer", "admin"],
+    description: "Live telemetry follow on the same Observability subscribe feed the graphs use. Users only on a reserved machine. Slack and MCP attach for duration (default 20s) and return events. Not telemetry.latest.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/observability/nodes/{id}/telemetry/subscribe" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                node_id: { type: "string", description: "Node UUID from nodes.list." },
+                duration: { type: "number", description: "Seconds to attach. Default 20, max 120." },
+                max_events: { type: "number" },
+                fields: { type: "string" },
+            },
+            required: ["node_id"],
+        },
+    },
+    input: tailInput,
+    execute: async (ctx, input) => {
+        const parsed = tailInput.parse(input);
+        const id = nodeId(parsed);
+        return ctx.fetch(queryPath(`${nodePrefix(ctx.role, id)}/telemetry/subscribe`, {
+            fields: parsed.fields,
+            duration: String(parsed.duration ?? 20),
+            max_events: String(parsed.max_events ?? 40),
+        }), { method: "GET", headers: { Accept: "text/event-stream" } });
+    },
+});
+export const logsTailCapability = defineCapability({
+    id: "logs.tail",
+    domain: "observability",
+    roles: ["user", "reviewer", "admin"],
+    description: "Live kernel or serial log follow on the same Observability subscribe feed LogViewer uses. Users only on a reserved machine. Slack and MCP attach for duration (default 20s). Not logs.latest.",
+    mutation: "read",
+    http: { method: "GET", path: "/v1/observability/nodes/{id}/logs/{stream}/subscribe" },
+    slack: {
+        parameters: {
+            type: "object",
+            properties: {
+                node_id: { type: "string", description: "Node UUID from nodes.list." },
+                stream: { type: "string", enum: ["serial", "kernel"] },
+                duration: { type: "number", description: "Seconds to attach. Default 20, max 120." },
+                max_events: { type: "number" },
+            },
+            required: ["node_id"],
+        },
+    },
+    input: logsTailInput,
+    execute: async (ctx, input) => {
+        const parsed = logsTailInput.parse(input);
+        const id = nodeId(parsed);
+        return ctx.fetch(queryPath(`${nodePrefix(ctx.role, id)}/logs/${parsed.stream}/subscribe`, {
+            duration: String(parsed.duration ?? 20),
+            max_events: String(parsed.max_events ?? 40),
+        }), { method: "GET", headers: { Accept: "text/event-stream" } });
+    },
+});
+export const observabilityCapabilities = [
+    telemetryLatestCapability,
+    telemetryTailCapability,
+    logsLatestCapability,
+    logsTailCapability,
+];

package/vendor/capabilities/capability.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType } from "zod";
 import type { ClientKind, Role } from "./role.ts";
-export declare const DOMAINS: readonly ["identity", "listings", "fleet", "users", "reservations", "bids", "access", "clusters", "slurm", "kubernetes", "networks", "storage", "vpn", "billing"];
+export declare const DOMAINS: readonly ["identity", "listings", "fleet", "users", "reservations", "bids", "access", "clusters", "slurm", "kubernetes", "networks", "storage", "vpn", "billing", "observability"];
 export type Domain = (typeof DOMAINS)[number];
 export type Mutation = "read" | "preview-confirm" | "local";
 export type HttpSpec = {

package/vendor/capabilities/capability.js

@@ -14,6 +14,7 @@ export const DOMAINS = [
     "storage",
     "vpn",
     "billing",
+    "observability",
 ];
 /** Fill CLI/MCP/Slack names from `id`. Slack parameters stay optional. */
 export function defineCapability(spec) {

package/vendor/capabilities/catalog.js

@@ -2,6 +2,7 @@ import { kubernetesCapabilities, slurmCapabilities } from "./capabilities/cluste
 import { fleetCapabilities } from "./capabilities/fleet.js";
 import { identityCapabilities } from "./capabilities/identity.js";
 import { listingCapabilities } from "./capabilities/listings.js";
+import { observabilityCapabilities } from "./capabilities/observability.js";
 import { userCapabilities } from "./capabilities/users.js";
 /** System of record for CLI, MCP, and Slack verbs. Add capabilities here. */
 export const catalog = [
@@ -9,6 +10,7 @@ export const catalog = [
     ...listingCapabilities,
     ...fleetCapabilities,
     ...userCapabilities,
+    ...observabilityCapabilities,
     ...slurmCapabilities,
     ...kubernetesCapabilities,
 ];

package/vendor/capabilities/index.d.ts

@@ -6,5 +6,6 @@ export { identityCapabilities, statusCapability, whoamiCapability } from "./capa
 export { createListingCapability, listingCreateInput, listCatalogTermsCapability, listingCapabilities, listListingsCapability, proposeListingCapability, } from "./capabilities/listings.ts";
 export { userCapabilities, usersQueryCapability } from "./capabilities/users.ts";
 export { kubernetesCapabilities, slurmCapabilities } from "./capabilities/clusters.ts";
+export { logsLatestCapability, logsTailCapability, observabilityCapabilities, telemetryLatestCapability, telemetryTailCapability, } from "./capabilities/observability.ts";
 export { CLIENTS, parseRole, roleAtLeast, ROLES, type ClientKind, type Role } from "./role.ts";
 export { bindHardwareFields, HARDWARE_CATALOG_PATH, HARDWARE_KINDS, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, looksLikeSpecDump, normalizeCatalogQuery, parseHardwareCatalog, projectCatalogTerms, proposeListingPayload, resolveCatalogTerm, UNRESOLVED_CATALOG_HINT, type CatalogBindResult, type CatalogTerm, type HardwareCatalog, type HardwareKind, type ResolvedCatalogTerm, } from "./spec-catalog.ts";

package/vendor/capabilities/index.js

@@ -6,5 +6,6 @@ export { identityCapabilities, statusCapability, whoamiCapability } from "./capa
 export { createListingCapability, listingCreateInput, listCatalogTermsCapability, listingCapabilities, listListingsCapability, proposeListingCapability, } from "./capabilities/listings.js";
 export { userCapabilities, usersQueryCapability } from "./capabilities/users.js";
 export { kubernetesCapabilities, slurmCapabilities } from "./capabilities/clusters.js";
+export { logsLatestCapability, logsTailCapability, observabilityCapabilities, telemetryLatestCapability, telemetryTailCapability, } from "./capabilities/observability.js";
 export { CLIENTS, parseRole, roleAtLeast, ROLES } from "./role.js";
 export { bindHardwareFields, HARDWARE_CATALOG_PATH, HARDWARE_KINDS, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, looksLikeSpecDump, normalizeCatalogQuery, parseHardwareCatalog, projectCatalogTerms, proposeListingPayload, resolveCatalogTerm, UNRESOLVED_CATALOG_HINT, } from "./spec-catalog.js";