@smithers-orchestrator/cli 0.16.9 → 0.18.0

package/src/mdx-plugin.js

@@ -0,0 +1,6 @@
+import { plugin } from "bun";
+import mdx from "@mdx-js/esbuild";
+
+export function mdxPlugin() {
+    plugin(mdx());
+}

package/src/output.js

@@ -8,6 +8,9 @@ import { NodeOutputRouteError } from "@smithers-orchestrator/server/gatewayRoute
 import { EXIT_OK } from "./util/exitCodes.js";
 import { formatCliErrorForStderr, getCliErrorMapping } from "./util/errorMessage.js";
 
+const RUN_ID_PATTERN = /^[a-z0-9_-]{1,64}$/;
+const NODE_ID_PATTERN = /^[a-zA-Z0-9:_-]{1,128}$/;
+
 /**
  * @param {any} response
  * @returns {string}
@@ -69,6 +72,52 @@ async function resolveLatestIteration(adapter, runId, nodeId) {
     }
 }
 
+/**
+ * @param {Record<string, unknown> | null} row
+ * @returns {Record<string, unknown> | null}
+ */
+function stripOutputKeyColumns(row) {
+    if (!row || typeof row !== "object") {
+        return null;
+    }
+    const result = { ...row };
+    delete result.run_id;
+    delete result.runId;
+    delete result.node_id;
+    delete result.nodeId;
+    delete result.iteration;
+    return result;
+}
+
+/**
+ * @param {RunOutputCommandInput} input
+ * @param {number} iteration
+ * @returns {Promise<RunOutputCommandResult>}
+ */
+async function runRawJsonOutput(input, iteration) {
+    if (!RUN_ID_PATTERN.test(input.runId)) {
+        throw new NodeOutputRouteError("InvalidRunId", "runId must match /^[a-z0-9_-]{1,64}$/.");
+    }
+    if (!NODE_ID_PATTERN.test(input.nodeId)) {
+        throw new NodeOutputRouteError("InvalidNodeId", "nodeId must match /^[a-zA-Z0-9:_-]{1,128}$/.");
+    }
+    const run = await input.adapter.getRun(input.runId);
+    if (!run) {
+        throw new NodeOutputRouteError("RunNotFound", `Run not found: ${input.runId}`);
+    }
+    const node = await input.adapter.getNode(input.runId, input.nodeId, iteration);
+    if (!node) {
+        throw new NodeOutputRouteError("NodeNotFound", `Node not found: ${input.nodeId}`);
+    }
+    const outputTable = typeof node.outputTable === "string" ? node.outputTable.trim() : "";
+    if (!outputTable) {
+        throw new NodeOutputRouteError("NodeHasNoOutput", `Node ${input.nodeId} has no output table.`);
+    }
+    const row = await input.adapter.getRawNodeOutputForIteration(outputTable, input.runId, input.nodeId, iteration);
+    input.stdout.write(`${JSON.stringify(stripOutputKeyColumns(row))}\n`);
+    return { exitCode: EXIT_OK };
+}
+
 /**
  * @param {RunOutputCommandInput} input
  * @returns {Promise<RunOutputCommandResult>}
@@ -80,6 +129,9 @@ export async function runOutputOnce(input) {
         iteration = latest ?? 0;
     }
     try {
+        if (input.json && !input.pretty) {
+            return await runRawJsonOutput(input, iteration);
+        }
         const response = await getNodeOutputRoute({
             runId: input.runId,
             nodeId: input.nodeId,

package/src/smithersRuntime.js

@@ -3,10 +3,11 @@ import { Cause, Effect, Exit, Layer, ManagedRuntime } from "effect";
 import { SchedulerLive, WorkflowSessionLive } from "@smithers-orchestrator/scheduler";
 import { CorrelationContextLive, MetricsServiceLive, TracingServiceLive, createSmithersRuntimeLayer, getCurrentSmithersTraceAnnotations, getCurrentSmithersTraceSpan, } from "@smithers-orchestrator/observability";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { SmithersLoggerLayer } from "./util/logger.ts";
 const ObservabilityLayer = Layer.mergeAll(CorrelationContextLive, MetricsServiceLive, TracingServiceLive);
 const SmithersCoreLayer = Layer.mergeAll(ObservabilityLayer, SchedulerLive.pipe(Layer.provide(ObservabilityLayer)), WorkflowSessionLive);
 const SmithersWorkflowEngineLayer = Layer.suspend(() => WorkflowEngine.layerMemory);
-const SmithersRuntimeLayer = Layer.mergeAll(SmithersCoreLayer, SmithersWorkflowEngineLayer, createSmithersRuntimeLayer()).pipe(Layer.orDie);
+const SmithersRuntimeLayer = Layer.mergeAll(SmithersLoggerLayer, SmithersCoreLayer, SmithersWorkflowEngineLayer, createSmithersRuntimeLayer()).pipe(Layer.orDie);
 const runtime = ManagedRuntime.make(SmithersRuntimeLayer);
 /**
  * @template A, E, R

package/src/util/logger.ts

@@ -0,0 +1,97 @@
+import { format } from "node:util";
+import { Logger } from "effect";
+
+type JsonModeState = {
+  jsonMode: boolean;
+  consoleRoutingInstalled: boolean;
+  originalConsole?: {
+    debug: typeof console.debug;
+    error: typeof console.error;
+    info: typeof console.info;
+    log: typeof console.log;
+    trace: typeof console.trace;
+    warn: typeof console.warn;
+  };
+};
+
+const STATE_KEY = Symbol.for("smithers.cli.jsonMode");
+
+function getState(): JsonModeState {
+  const globalState = globalThis as typeof globalThis & {
+    [STATE_KEY]?: JsonModeState;
+  };
+  globalState[STATE_KEY] ??= {
+    jsonMode: false,
+    consoleRoutingInstalled: false,
+  };
+  return globalState[STATE_KEY];
+}
+
+export function setJsonMode(enabled: boolean): void {
+  getState().jsonMode = enabled;
+}
+
+export function isJsonMode(): boolean {
+  return getState().jsonMode === true;
+}
+
+function writeConsoleArgsToStderr(args: ReadonlyArray<unknown>): void {
+  process.stderr.write(`${format(...args)}\n`);
+}
+
+export function installJsonModeConsoleRouting(): void {
+  const state = getState();
+  if (state.consoleRoutingInstalled) {
+    return;
+  }
+
+  const originalConsole = {
+    debug: console.debug.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console),
+    log: console.log.bind(console),
+    trace: console.trace.bind(console),
+    warn: console.warn.bind(console),
+  };
+
+  console.debug = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.debug(...args);
+  };
+  console.error = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.error(...args);
+  };
+  console.info = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.info(...args);
+  };
+  console.log = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.log(...args);
+  };
+  console.trace = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.trace(...args);
+  };
+  console.warn = (...args: unknown[]) => {
+    if (isJsonMode()) return writeConsoleArgsToStderr(args);
+    return originalConsole.warn(...args);
+  };
+
+  state.originalConsole = originalConsole;
+  state.consoleRoutingInstalled = true;
+}
+
+export const smithersEffectLogger = Logger.make<unknown, void>((options) => {
+  const line = Logger.stringLogger.log(options);
+  const stream = isJsonMode() ? process.stderr : process.stdout;
+  stream.write(`${line}\n`);
+});
+
+export const SmithersLoggerLayer = Logger.replace(
+  Logger.defaultLogger,
+  smithersEffectLogger,
+);
+
+installJsonModeConsoleRouting();