@rex0220/ksql-flownet 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const HELP_TEXT = `Usage: ksql-flownet [options] [command]
+
+kSQL-FlowNet Control Plane CLI
+
+Options:
+  -h, --help       display help for command
+  -V, --version    display version
+
+Commands:
+  validate <network>  validate a network definition and its SQL files
+  plan <network> [--scheduled-for <timestamp>] [--business-key <key>]
+                      display the business key and stable execution plan (read-only)
+  run-network <network> [--business-key <key>] [--scheduled-for <timestamp>]
+                        [--resume] [--resume-run <run_id>] [--rerun-from <node_id>]
+                        [--json]
+                        [--ksql-flow-bin <path>] [--ksql-flow-config <path>]
+                        [--ksql-flow-workdir <path>]
+                      ensure and execute a Network Run sequentially
+  poll-requests [--check]
+                      claim and process app operation requests (one-shot),
+                      or validate configuration and read access without writes
+  resolve-node --run-id <run_id> --node-id <node_id> --to <status>
+               --reason-file <path> --evidence-ref <ref>
+               --stop-confirmed-by <subject> --stop-evidence-ref <ref>
+               [--manual-completion | --compensation] [--approved-by <subject>]
+                      resolve an UNKNOWN or non-idempotent FAILED node
+  record-job-unlock --result-file <path> --run-id <run_id> --node-id <node_id>
+                    --reason-file <path> --evidence-ref <ref>
+                    --stop-confirmed-by <subject>
+                      associate a kSQL-Flow LOCK_RECOVERY_RESULT with audit
+  force-unlock-network <network_id> --profile <profile>
+                    --expected-owner-invocation-id <invocation_id>
+                    --reason-file <path> --evidence-ref <ref>
+                    --stop-confirmed-by <subject> --stop-evidence-ref <ref>
+                    --stop-method <method>
+                      force-release a stale Network lock with an audit record
+  cancel-run --run-id <run_id> [--release] --reason-file <path>
+                      request or release a Run hold at the next node boundary
+  archive-run <network.yaml> --run-id <run_id> --reason-file <path> [--profile <profile>]
+                      archive a terminal failed or cancelled Run
+  status <network_id> --profile <profile>
+         [--run-id <run_id> | --business-key <key>] [--json]
+                      inspect lock and Run recovery state (read-only)
+`;
+function getVersion() {
+    const packageJsonPath = fileURLToPath(new URL("../../package.json", import.meta.url));
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        !("version" in parsed) ||
+        typeof parsed.version !== "string") {
+        throw new Error("package.json does not contain a valid version");
+    }
+    return parsed.version;
+}
+function printHelp() {
+    process.stdout.write(HELP_TEXT);
+}
+async function main(args) {
+    const [command, ...commandArgs] = args;
+    if (command === undefined || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "--version" || command === "-V") {
+        process.stdout.write(`${getVersion()}\n`);
+        return;
+    }
+    if (command === "validate") {
+        if (commandArgs.length !== 1) {
+            process.stderr.write("Error: validate requires exactly one <network> path.\n");
+            process.exitCode = 1;
+            return;
+        }
+        const { runValidateCommand } = await import("./validate-command.js");
+        process.exitCode = runValidateCommand(commandArgs[0]);
+        return;
+    }
+    if (command === "plan") {
+        const { runPlanCommand } = await import("./plan-command.js");
+        process.exitCode = runPlanCommand(commandArgs);
+        return;
+    }
+    if (command === "run-network") {
+        const { runRunNetworkCommand } = await import("./run-network-command.js");
+        process.exitCode = await runRunNetworkCommand(commandArgs);
+        return;
+    }
+    if (command === "poll-requests") {
+        const { runPollRequestsCommand } = await import("./poll-requests-command.js");
+        process.exitCode = await runPollRequestsCommand(commandArgs);
+        return;
+    }
+    if (command === "resolve-node") {
+        const { runResolveNodeCommand } = await import("./resolve-node-command.js");
+        process.exitCode = await runResolveNodeCommand(commandArgs);
+        return;
+    }
+    if (command === "record-job-unlock") {
+        const { runRecordJobUnlockCommand } = await import("./record-job-unlock-command.js");
+        process.exitCode = await runRecordJobUnlockCommand(commandArgs);
+        return;
+    }
+    if (command === "force-unlock-network") {
+        const { runForceUnlockNetworkCommand } = await import("./force-unlock-network-command.js");
+        process.exitCode = await runForceUnlockNetworkCommand(commandArgs);
+        return;
+    }
+    if (command === "status") {
+        const { runStatusCommand } = await import("./status-command.js");
+        process.exitCode = await runStatusCommand(commandArgs);
+        return;
+    }
+    if (command === "cancel-run") {
+        const { runCancelRunCommand } = await import("./cancel-run-command.js");
+        process.exitCode = await runCancelRunCommand(commandArgs);
+        return;
+    }
+    if (command === "archive-run") {
+        const { runArchiveRunCommand } = await import("./archive-run-command.js");
+        process.exitCode = await runArchiveRunCommand(commandArgs);
+        return;
+    }
+    process.stderr.write(`Error: unknown command '${command}'.\n`);
+    process.stderr.write("Run 'ksql-flownet --help' for usage.\n");
+    process.exitCode = 1;
+}
+await main(process.argv.slice(2));
+//# sourceMappingURL=index.js.map

package/dist/cli/plan-command.d.ts

@@ -0,0 +1,2 @@
+export declare function runPlanCommand(args: readonly string[]): number;
+//# sourceMappingURL=plan-command.d.ts.map

package/dist/cli/plan-command.js

@@ -0,0 +1,100 @@
+import { stableTopologicalSort } from "../dag/topological-sort.js";
+import { resolveBusinessKey } from "../domain/business-key.js";
+import { validateNetworkPath, writeValidationErrors, } from "./validate-command.js";
+function parsePlanArguments(args) {
+    let networkPath;
+    let scheduledFor;
+    let businessKey;
+    const errors = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--scheduled-for" || argument === "--business-key") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                errors.push(`${argument} requires a value`);
+                continue;
+            }
+            if (argument === "--scheduled-for") {
+                if (scheduledFor !== undefined)
+                    errors.push(`${argument} was specified more than once`);
+                scheduledFor = value;
+            }
+            else {
+                if (businessKey !== undefined)
+                    errors.push(`${argument} was specified more than once`);
+                businessKey = value;
+            }
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            errors.push(`unknown option '${argument}'`);
+            continue;
+        }
+        if (networkPath === undefined)
+            networkPath = argument;
+        else
+            errors.push(`unexpected argument '${argument}'`);
+    }
+    if (networkPath === undefined)
+        errors.push("plan requires one <network> path");
+    const result = { errors };
+    if (networkPath !== undefined)
+        Object.assign(result, { networkPath });
+    if (scheduledFor !== undefined)
+        Object.assign(result, { scheduledFor });
+    if (businessKey !== undefined)
+        Object.assign(result, { businessKey });
+    return result;
+}
+export function runPlanCommand(args) {
+    const parsed = parsePlanArguments(args);
+    if (parsed.errors.length > 0 || parsed.networkPath === undefined) {
+        process.stderr.write(`Invalid plan arguments:\n${parsed.errors.map((error) => `- ${error}`).join("\n")}\n`);
+        return 1;
+    }
+    const validated = validateNetworkPath(parsed.networkPath);
+    const errors = [...validated.errors];
+    let businessKey;
+    if (validated.definition !== undefined) {
+        const input = {
+            networkId: validated.definition.network_id,
+            policy: validated.definition.business_key_policy,
+            ...(parsed.scheduledFor === undefined
+                ? {}
+                : { scheduledFor: parsed.scheduledFor }),
+            ...(parsed.businessKey === undefined
+                ? {}
+                : { businessKey: parsed.businessKey }),
+        };
+        const resolved = resolveBusinessKey(input);
+        for (const error of resolved.errors) {
+            if (!errors.some((existing) => existing.code === error.code &&
+                existing.path === error.path &&
+                existing.message === error.message)) {
+                errors.push(error);
+            }
+        }
+        businessKey = resolved.businessKey;
+    }
+    if (errors.length > 0) {
+        writeValidationErrors(errors);
+        return 1;
+    }
+    if (validated.definition === undefined || businessKey === undefined) {
+        process.stderr.write("Error: plan could not be produced.\n");
+        return 1;
+    }
+    const nodeById = new Map(validated.definition.nodes.map((node) => [node.id, node]));
+    const order = stableTopologicalSort(validated.definition.nodes).order;
+    const lines = order.map((nodeId, index) => {
+        const node = nodeById.get(nodeId);
+        if (node === undefined)
+            throw new Error(`missing sorted node '${nodeId}'`);
+        const dependencies = node.depends_on.length === 0 ? "-" : node.depends_on.join(", ");
+        return `${index + 1}. ${node.id} | job_id=${node.job_id} | idempotent=${String(node.idempotent)} | depends_on=${dependencies}`;
+    });
+    process.stdout.write(`Business key: ${businessKey}\nExecution plan:\n${lines.join("\n")}\n`);
+    return 0;
+}
+//# sourceMappingURL=plan-command.js.map

package/dist/cli/poll-requests-command.d.ts

@@ -0,0 +1,3 @@
+import { type RequestPollerDependencies } from "../requests/request-poller.js";
+export declare function runPollRequestsCommand(args: readonly string[], dependencies?: RequestPollerDependencies): Promise<number>;
+//# sourceMappingURL=poll-requests-command.d.ts.map

package/dist/cli/poll-requests-command.js

@@ -0,0 +1,74 @@
+import { hostname } from "node:os";
+import { FlownetChildClient } from "../requests/flownet-child-client.js";
+import { KintoneRequestStore } from "../requests/kintone-request-store.js";
+import { DEFAULT_REQUEST_HEARTBEAT_INTERVAL_MS, DEFAULT_REQUEST_STALE_AFTER_MS, loadPollRequestsConfig, } from "../requests/poll-requests-config.js";
+import { pollRequests, } from "../requests/request-poller.js";
+import { requiredEnvironment } from "./resolve-node-command.js";
+export async function runPollRequestsCommand(args, dependencies) {
+    const checkOnly = args.length === 1 && args[0] === "--check";
+    if (args.length > 0 && !checkOnly) {
+        process.stderr.write("Invalid poll-requests arguments: only --check is accepted.\n");
+        return 1;
+    }
+    try {
+        const resolvedDependencies = dependencies ?? productionDependencies();
+        if (checkOnly) {
+            await resolvedDependencies.store.listRequested();
+            process.stdout.write(`poll-requests check: ok networks=${resolvedDependencies.config.networks.length} request_app=readable\n`);
+            return 0;
+        }
+        const summary = await pollRequests(resolvedDependencies);
+        process.stdout.write(`poll-requests: requested=${summary.requested} claimed=${summary.claimed} completed=${summary.completed} cancelled=${summary.cancelled} invalid=${summary.invalid} stale=${summary.stale} skipped=${summary.skippedMalformed}\n`);
+        return 0;
+    }
+    catch (error) {
+        const code = errorCode(error);
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error [${code}]: ${message}\n`);
+        return 1;
+    }
+}
+function productionDependencies() {
+    const baseUrl = requiredEnvironment("KSQL_FLOWNET_BASE_URL").replace(/\/$/u, "");
+    const appId = positiveIntegerEnvironment("KSQL_FLOWNET_REQUEST_APP_ID");
+    const apiToken = requiredEnvironment("KSQL_FLOWNET_REQUEST_API_TOKEN");
+    const heartbeatIntervalMs = integerEnvironment("KSQL_FLOWNET_REQUEST_HEARTBEAT_INTERVAL_MS", DEFAULT_REQUEST_HEARTBEAT_INTERVAL_MS);
+    const staleAfterMs = integerEnvironment("KSQL_FLOWNET_REQUEST_STALE_AFTER_MS", DEFAULT_REQUEST_STALE_AFTER_MS);
+    const config = loadPollRequestsConfig(requiredEnvironment("KSQL_FLOWNET_REQUEST_ALLOWLIST_PATH"), { heartbeatIntervalMs, staleAfterMs });
+    return {
+        store: new KintoneRequestStore({ baseUrl, appId, apiToken }),
+        child: new FlownetChildClient({
+            profile: requiredEnvironment("KSQL_FLOWNET_PROFILE"),
+        }),
+        config,
+        host: process.env.KSQL_FLOWNET_HOST ?? hostname(),
+        log(code, detail) {
+            process.stderr.write(`Warning [${code}]: ${detail}\n`);
+        },
+    };
+}
+function positiveIntegerEnvironment(name) {
+    const value = Number(requiredEnvironment(name));
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error(`${name} must be a positive integer`);
+    return value;
+}
+function integerEnvironment(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error(`${name} must be a positive integer`);
+    return value;
+}
+function errorCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string") {
+        return error.code;
+    }
+    return "POLL_REQUESTS_FAILED";
+}
+//# sourceMappingURL=poll-requests-command.js.map

package/dist/cli/record-job-unlock-command.d.ts

@@ -0,0 +1,11 @@
+import type { PersistenceRepository } from "../persistence/repository.js";
+export interface RecordJobUnlockCommandDependencies {
+    repository: PersistenceRepository;
+    servicePrincipal: string;
+    requestedBy: string;
+    readFile?: (path: string) => string;
+    now?: () => Date;
+    uuid?: () => string;
+}
+export declare function runRecordJobUnlockCommand(args: readonly string[], dependencies?: RecordJobUnlockCommandDependencies): Promise<number>;
+//# sourceMappingURL=record-job-unlock-command.d.ts.map

package/dist/cli/record-job-unlock-command.js

@@ -0,0 +1,78 @@
+import { readFileSync } from "node:fs";
+import { recordJobUnlock } from "../orchestration/job-lock-audit.js";
+import { repositoryFromEnvironment, requiredEnvironment, } from "./resolve-node-command.js";
+export async function runRecordJobUnlockCommand(args, dependencies) {
+    const parsed = parseArguments(args);
+    if (parsed.errors.length > 0) {
+        process.stderr.write(`Invalid record-job-unlock arguments:\n${parsed.errors.map((error) => `- ${error}`).join("\n")}\n`);
+        return 1;
+    }
+    try {
+        const runtime = dependencies ?? {
+            repository: repositoryFromEnvironment(),
+            servicePrincipal: requiredEnvironment("KSQL_FLOWNET_SERVICE_PRINCIPAL"),
+            requestedBy: requiredEnvironment("KSQL_FLOWNET_REQUESTED_BY"),
+        };
+        const read = runtime.readFile ?? ((path) => readFileSync(path, "utf8"));
+        const rawResult = read(parsed.values.get("--result-file"));
+        const audit = await recordJobUnlock({
+            repository: runtime.repository,
+            runId: parsed.values.get("--run-id"),
+            nodeId: parsed.values.get("--node-id"),
+            result: JSON.parse(rawResult),
+            reason: read(parsed.values.get("--reason-file")),
+            evidenceRef: parsed.values.get("--evidence-ref"),
+            servicePrincipal: runtime.servicePrincipal,
+            requestedBy: runtime.requestedBy,
+            stopConfirmedBy: parsed.values.get("--stop-confirmed-by"),
+            ...(runtime.now === undefined ? {} : { now: runtime.now }),
+            ...(runtime.uuid === undefined ? {} : { uuid: runtime.uuid }),
+        });
+        process.stdout.write(`RECORDED: ${audit.lock_recovery_result.outcome} for ${audit.lock_recovery_result.jobKey} (${audit.event_id}).\n`);
+        return 0;
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code)
+            : "RECORD_JOB_UNLOCK_FAILED";
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error [${code}]: ${message}\n`);
+        return 1;
+    }
+}
+function parseArguments(args) {
+    const values = new Map();
+    const errors = [];
+    const allowed = new Set([
+        "--result-file",
+        "--run-id",
+        "--node-id",
+        "--reason-file",
+        "--evidence-ref",
+        "--stop-confirmed-by",
+    ]);
+    for (let index = 0; index < args.length; index += 1) {
+        const key = args[index];
+        if (!key.startsWith("--")) {
+            errors.push(`unexpected argument '${key}'`);
+            continue;
+        }
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            errors.push(`${key} requires a value`);
+            continue;
+        }
+        if (!allowed.has(key))
+            errors.push(`unknown option '${key}'`);
+        if (values.has(key))
+            errors.push(`${key} was specified more than once`);
+        values.set(key, value);
+        index += 1;
+    }
+    for (const key of allowed) {
+        if (!values.has(key))
+            errors.push(`${key} is required`);
+    }
+    return { values, errors };
+}
+//# sourceMappingURL=record-job-unlock-command.js.map

package/dist/cli/resolve-node-command.d.ts

@@ -0,0 +1,13 @@
+import { KintonePersistenceRepository } from "../persistence/kintone/repository.js";
+import type { PersistenceRepository } from "../persistence/repository.js";
+export interface ResolveNodeCommandDependencies {
+    repository: PersistenceRepository;
+    servicePrincipal: string;
+    requestedBy: string;
+    readFile?: (path: string) => string;
+    now?: () => Date;
+}
+export declare function runResolveNodeCommand(args: readonly string[], dependencies?: ResolveNodeCommandDependencies): Promise<number>;
+export declare function repositoryFromEnvironment(): KintonePersistenceRepository;
+export declare function requiredEnvironment(name: string): string;
+//# sourceMappingURL=resolve-node-command.d.ts.map

package/dist/cli/resolve-node-command.js

@@ -0,0 +1,174 @@
+import { readFileSync } from "node:fs";
+import { resolveNode, } from "../orchestration/resolve-node.js";
+import { KintonePersistenceRepository } from "../persistence/kintone/repository.js";
+export async function runResolveNodeCommand(args, dependencies) {
+    const parsed = parseArguments(args);
+    if (parsed.errors.length > 0) {
+        process.stderr.write(`Invalid resolve-node arguments:\n${parsed.errors.map((error) => `- ${error}`).join("\n")}\n`);
+        return 1;
+    }
+    try {
+        const runtime = dependencies ?? productionDependencies();
+        const reason = (runtime.readFile ?? ((path) => readFileSync(path, "utf8")))(parsed.reasonFile);
+        const result = await resolveNode({
+            repository: runtime.repository,
+            runId: parsed.runId,
+            nodeId: parsed.nodeId,
+            outcome: parsed.outcome,
+            resolutionType: parsed.manualCompletion
+                ? "NODE_MANUAL_COMPLETION_CONFIRMED"
+                : parsed.compensation
+                    ? "NODE_COMPENSATION_COMPLETED"
+                    : "OUTCOME_CONFIRMED",
+            reason,
+            evidenceRef: parsed.evidenceRef,
+            servicePrincipal: runtime.servicePrincipal,
+            requestedBy: runtime.requestedBy,
+            approvedBy: parsed.approvedBy ?? "",
+            stopConfirmedBy: parsed.stopConfirmedBy,
+            stopEvidenceRef: parsed.stopEvidenceRef,
+            ...(runtime.now === undefined ? {} : { now: runtime.now }),
+        });
+        process.stdout.write(`RESOLVED: ${parsed.runId}/${parsed.nodeId} -> ${result.nodeState.value.status} (revision ${result.nodeState.revision}).\n`);
+        return 0;
+    }
+    catch (error) {
+        const code = errorCode(error, "RESOLVE_NODE_FAILED");
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`Error [${code}]: ${message}\n`);
+        return 1;
+    }
+}
+function parseArguments(args) {
+    const result = {
+        manualCompletion: false,
+        compensation: false,
+        errors: [],
+    };
+    const values = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--manual-completion" || argument === "--compensation") {
+            const key = argument.slice(2);
+            if (key === "manual-completion") {
+                if (result.manualCompletion)
+                    result.errors.push(`${argument} was specified more than once`);
+                result.manualCompletion = true;
+            }
+            else {
+                if (result.compensation)
+                    result.errors.push(`${argument} was specified more than once`);
+                result.compensation = true;
+            }
+            continue;
+        }
+        if (!argument.startsWith("--")) {
+            result.errors.push(`unexpected argument '${argument}'`);
+            continue;
+        }
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            result.errors.push(`${argument} requires a value`);
+            continue;
+        }
+        if (values.has(argument))
+            result.errors.push(`${argument} was specified more than once`);
+        values.set(argument, value);
+        index += 1;
+    }
+    const allowed = new Set([
+        "--run-id",
+        "--node-id",
+        "--to",
+        "--reason-file",
+        "--evidence-ref",
+        "--stop-confirmed-by",
+        "--stop-evidence-ref",
+        "--approved-by",
+    ]);
+    for (const key of values.keys()) {
+        if (!allowed.has(key))
+            result.errors.push(`unknown option '${key}'`);
+    }
+    for (const key of [
+        "--run-id",
+        "--node-id",
+        "--to",
+        "--reason-file",
+        "--evidence-ref",
+        "--stop-confirmed-by",
+        "--stop-evidence-ref",
+    ]) {
+        if (!values.has(key))
+            result.errors.push(`${key} is required`);
+    }
+    const outcome = values.get("--to");
+    if (outcome !== undefined &&
+        outcome !== "SUCCESS" &&
+        outcome !== "FAILED" &&
+        outcome !== "CANCELLED") {
+        result.errors.push("--to must be SUCCESS, FAILED, or CANCELLED");
+    }
+    if (result.manualCompletion && result.compensation)
+        result.errors.push("--manual-completion and --compensation are mutually exclusive");
+    return {
+        ...result,
+        ...(values.has("--run-id") ? { runId: values.get("--run-id") } : {}),
+        ...(values.has("--node-id") ? { nodeId: values.get("--node-id") } : {}),
+        ...(outcome === "SUCCESS" || outcome === "FAILED" || outcome === "CANCELLED"
+            ? { outcome }
+            : {}),
+        ...(values.has("--reason-file")
+            ? { reasonFile: values.get("--reason-file") }
+            : {}),
+        ...(values.has("--evidence-ref")
+            ? { evidenceRef: values.get("--evidence-ref") }
+            : {}),
+        ...(values.has("--stop-confirmed-by")
+            ? { stopConfirmedBy: values.get("--stop-confirmed-by") }
+            : {}),
+        ...(values.has("--stop-evidence-ref")
+            ? { stopEvidenceRef: values.get("--stop-evidence-ref") }
+            : {}),
+        ...(values.has("--approved-by")
+            ? { approvedBy: values.get("--approved-by") }
+            : {}),
+    };
+}
+function productionDependencies() {
+    return {
+        repository: repositoryFromEnvironment(),
+        servicePrincipal: requiredEnvironment("KSQL_FLOWNET_SERVICE_PRINCIPAL"),
+        requestedBy: requiredEnvironment("KSQL_FLOWNET_REQUESTED_BY"),
+    };
+}
+export function repositoryFromEnvironment() {
+    return new KintonePersistenceRepository({
+        baseUrl: requiredEnvironment("KSQL_FLOWNET_BASE_URL").replace(/\/$/u, ""),
+        stateAppId: positiveIntegerEnvironment("KSQL_FLOWNET_STATE_APP_ID"),
+        stateApiToken: requiredEnvironment("KSQL_FLOWNET_STATE_API_TOKEN"),
+        auditAppId: positiveIntegerEnvironment("KSQL_FLOWNET_AUDIT_APP_ID"),
+        auditApiToken: requiredEnvironment("KSQL_FLOWNET_AUDIT_API_TOKEN"),
+    });
+}
+export function requiredEnvironment(name) {
+    const value = process.env[name];
+    if (value === undefined || value.trim() === "")
+        throw new Error(`${name} is required`);
+    return value;
+}
+function positiveIntegerEnvironment(name) {
+    const value = Number(requiredEnvironment(name));
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${name} must be a positive integer`);
+    return value;
+}
+function errorCode(error, fallback) {
+    return typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string"
+        ? error.code
+        : fallback;
+}
+//# sourceMappingURL=resolve-node-command.js.map

package/dist/cli/run-network-command.d.ts

@@ -0,0 +1,14 @@
+import { ensureRun, type EnsureRunInput } from "../orchestration/ensure-run.js";
+import { type SequentialSchedulerSummary } from "../orchestration/sequential-scheduler.js";
+export type EnsureRunInvoker = (input: Omit<EnsureRunInput, "repository" | "lockManager" | "executor" | "bundleStore">) => ReturnType<typeof ensureRun>;
+export interface RunNetworkCommandDependencies {
+    readonly invoke: EnsureRunInvoker;
+    readonly schedule: (result: Awaited<ReturnType<EnsureRunInvoker>>) => Promise<SequentialSchedulerSummary>;
+    readonly profile: string;
+    readonly requestedBy: string;
+    readonly host: string;
+}
+export declare function runRunNetworkCommand(args: readonly string[], dependencies?: RunNetworkCommandDependencies): Promise<number>;
+export declare function resolveOwnerInstanceId(host: string, configured?: string | undefined, pid?: number): string;
+export declare function ksqlFlowBinArgsEnvironment(environment?: NodeJS.ProcessEnv): string[];
+//# sourceMappingURL=run-network-command.d.ts.map