@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/reconcile/platform.d.ts

@@ -1,104 +0,0 @@
-export declare const TREESEED_RECONCILE_RUN_MODEL: readonly ["refresh", "plan", "validate", "apply", "refresh", "verify", "persist"];
-export declare const TREESEED_RECONCILE_ACTION_KINDS: readonly ["noop", "create", "update", "replace", "delete", "adopt", "rename", "reattach", "retain", "taint", "blocked"];
-export type TreeseedCanonicalReconcilePhase = typeof TREESEED_RECONCILE_RUN_MODEL[number];
-export type TreeseedCanonicalReconcileActionKind = typeof TREESEED_RECONCILE_ACTION_KINDS[number];
-export interface TreeseedCanonicalGraphNode {
-    id: string;
-    provider?: string | null;
-    type?: string | null;
-    owner?: string | null;
-    environment?: string | null;
-    spec?: unknown;
-    state?: unknown;
-    locators?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-}
-export interface TreeseedCanonicalDrift {
-    id: string;
-    resourceId?: string | null;
-    severity?: 'info' | 'warning' | 'blocking';
-    reason: string;
-    expected?: unknown;
-    observed?: unknown;
-    provider?: string | null;
-    type?: string | null;
-}
-export interface TreeseedCanonicalAction {
-    id: string;
-    kind: TreeseedCanonicalReconcileActionKind;
-    resourceId: string;
-    reason: string;
-    provider?: string | null;
-    type?: string | null;
-    before?: unknown;
-    after?: unknown;
-}
-export interface TreeseedCanonicalPostcondition {
-    id: string;
-    resourceId: string;
-    description: string;
-    source?: 'api' | 'cli' | 'sdk' | 'http' | 'local' | 'derived';
-    required?: boolean;
-    ok: boolean;
-    issues: string[];
-    expected?: unknown;
-    observed?: unknown;
-}
-export interface TreeseedCanonicalLiveVerification {
-    ok: boolean;
-    source?: string;
-    checkedAt?: string | null;
-    issues: string[];
-    checks?: unknown[];
-}
-export interface TreeseedCanonicalReconcileReport {
-    desiredGraph: TreeseedCanonicalGraphNode[];
-    observedGraph: TreeseedCanonicalGraphNode[];
-    stateGraph: TreeseedCanonicalGraphNode[];
-    diff: TreeseedCanonicalDrift[];
-    actions: TreeseedCanonicalAction[];
-    postconditions: TreeseedCanonicalPostcondition[];
-    selectedResources: string[];
-    skippedResources: Array<{
-        id: string;
-        reason: string;
-    }>;
-    blockedDrift: TreeseedCanonicalDrift[];
-    providerLimitations: TreeseedCanonicalDrift[];
-    retainedResources: TreeseedCanonicalGraphNode[];
-    destroyedResources: TreeseedCanonicalGraphNode[];
-    liveVerification: TreeseedCanonicalLiveVerification;
-    ok: boolean;
-}
-export interface CreateTreeseedCanonicalReconcileReportInput {
-    desiredGraph?: TreeseedCanonicalGraphNode[];
-    observedGraph?: TreeseedCanonicalGraphNode[];
-    stateGraph?: TreeseedCanonicalGraphNode[];
-    diff?: TreeseedCanonicalDrift[];
-    actions?: TreeseedCanonicalAction[];
-    postconditions?: TreeseedCanonicalPostcondition[];
-    selectedResources?: string[];
-    skippedResources?: Array<{
-        id: string;
-        reason: string;
-    }>;
-    blockedDrift?: TreeseedCanonicalDrift[];
-    providerLimitations?: TreeseedCanonicalDrift[];
-    retainedResources?: TreeseedCanonicalGraphNode[];
-    destroyedResources?: TreeseedCanonicalGraphNode[];
-    liveVerification?: Partial<TreeseedCanonicalLiveVerification>;
-}
-export declare function createTreeseedCanonicalReconcileReport(input?: CreateTreeseedCanonicalReconcileReportInput): TreeseedCanonicalReconcileReport;
-export declare function assertTreeseedCanonicalReconcileSuccess(report: TreeseedCanonicalReconcileReport): void;
-export declare function summarizeTreeseedCanonicalReconcileReport(report: TreeseedCanonicalReconcileReport): {
-    ok: boolean;
-    desired: number;
-    observed: number;
-    actions: number;
-    postconditions: number;
-    blockedDrift: number;
-    providerLimitations: number;
-    retainedResources: number;
-    destroyedResources: number;
-    liveVerificationOk: boolean;
-};

package/dist/reconcile/platform.js

@@ -1,100 +0,0 @@
-const TREESEED_RECONCILE_RUN_MODEL = [
-  "refresh",
-  "plan",
-  "validate",
-  "apply",
-  "refresh",
-  "verify",
-  "persist"
-];
-const TREESEED_RECONCILE_ACTION_KINDS = [
-  "noop",
-  "create",
-  "update",
-  "replace",
-  "delete",
-  "adopt",
-  "rename",
-  "reattach",
-  "retain",
-  "taint",
-  "blocked"
-];
-function hasBlockingAction(actions) {
-  return actions.some((action) => action.kind === "blocked");
-}
-function liveVerificationOk(input, postconditions) {
-  if (input?.ok === false) return false;
-  if ((input?.issues ?? []).length > 0) return false;
-  return postconditions.every((postcondition) => postcondition.required === false || postcondition.ok);
-}
-function createTreeseedCanonicalReconcileReport(input = {}) {
-  const desiredGraph = input.desiredGraph ?? [];
-  const observedGraph = input.observedGraph ?? [];
-  const stateGraph = input.stateGraph ?? [];
-  const diff = input.diff ?? [];
-  const actions = input.actions ?? [];
-  const postconditions = input.postconditions ?? [];
-  const selectedResources = input.selectedResources ?? desiredGraph.map((node) => node.id);
-  const skippedResources = input.skippedResources ?? [];
-  const blockedDrift = input.blockedDrift ?? diff.filter((entry) => entry.severity === "blocking");
-  const providerLimitations = input.providerLimitations ?? [];
-  const retainedResources = input.retainedResources ?? [];
-  const destroyedResources = input.destroyedResources ?? [];
-  const liveVerification = {
-    ok: input.liveVerification?.ok ?? liveVerificationOk(input.liveVerification, postconditions),
-    source: input.liveVerification?.source ?? "sdk",
-    checkedAt: input.liveVerification?.checkedAt ?? null,
-    issues: input.liveVerification?.issues ?? [],
-    checks: input.liveVerification?.checks ?? []
-  };
-  const ok = liveVerification.ok && blockedDrift.length === 0 && providerLimitations.length === 0 && !hasBlockingAction(actions) && postconditions.every((postcondition) => postcondition.required === false || postcondition.ok);
-  return {
-    desiredGraph,
-    observedGraph,
-    stateGraph,
-    diff,
-    actions,
-    postconditions,
-    selectedResources,
-    skippedResources,
-    blockedDrift,
-    providerLimitations,
-    retainedResources,
-    destroyedResources,
-    liveVerification,
-    ok
-  };
-}
-function assertTreeseedCanonicalReconcileSuccess(report) {
-  if (report.ok) return;
-  const reasons = [
-    ...report.blockedDrift.map((entry) => `blocked drift ${entry.id}: ${entry.reason}`),
-    ...report.providerLimitations.map((entry) => `provider limitation ${entry.id}: ${entry.reason}`),
-    ...report.actions.filter((action) => action.kind === "blocked").map((action) => `blocked action ${action.id}: ${action.reason}`),
-    ...report.postconditions.filter((postcondition) => postcondition.required !== false && !postcondition.ok).map((postcondition) => `postcondition ${postcondition.id}: ${postcondition.issues.join("; ") || "failed"}`),
-    ...report.liveVerification.issues.map((issue) => `live verification: ${issue}`)
-  ];
-  throw new Error(`Treeseed reconciliation did not converge: ${reasons.join(" | ") || "unknown drift remained"}`);
-}
-function summarizeTreeseedCanonicalReconcileReport(report) {
-  return {
-    ok: report.ok,
-    desired: report.desiredGraph.length,
-    observed: report.observedGraph.length,
-    actions: report.actions.length,
-    postconditions: report.postconditions.length,
-    blockedDrift: report.blockedDrift.length,
-    providerLimitations: report.providerLimitations.length,
-    retainedResources: report.retainedResources.length,
-    destroyedResources: report.destroyedResources.length,
-    liveVerificationOk: report.liveVerification.ok
-  };
-}
-export {
-  TREESEED_RECONCILE_ACTION_KINDS,
-  TREESEED_RECONCILE_RUN_MODEL,
-  assertTreeseedCanonicalReconcileSuccess,
-  createTreeseedCanonicalReconcileReport,
-  summarizeTreeseedCanonicalReconcileReport
-};

package/dist/reconcile/providers/docker-private.d.ts

@@ -1,54 +0,0 @@
-export type DockerCommandResult = {
-    ok: boolean;
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    args: string[];
-};
-export declare function inspectDockerAvailability(): {
-    available: boolean;
-    buildxAvailable: boolean;
-    version: string | null;
-    buildx: string | null;
-    warnings: string[];
-};
-export declare function inspectDockerImage(tag: string): Record<string, unknown> | null;
-export declare function inspectDockerManifest(ref: string): {
-    ref: string;
-    output: string;
-} | null;
-export declare function buildDockerImage(input: {
-    tenantRoot: string;
-    packageRoot: string;
-    context: string;
-    dockerfile: string;
-    target?: string | null;
-    platforms: string[];
-    tags: string[];
-    labels?: Record<string, string>;
-    buildArgs?: Record<string, string>;
-    push?: boolean;
-    load?: boolean;
-    provenance?: boolean;
-    env?: NodeJS.ProcessEnv;
-}): {
-    contextPath: string;
-    dockerfilePath: string;
-    tags: string[];
-    platforms: string[];
-    ok: boolean;
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    args: string[];
-};
-export declare function runDockerCompose(input: {
-    composeFile?: string;
-    composeFiles?: string[];
-    projectName: string;
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    profiles?: string[];
-    buildPolicy?: 'never' | 'missing' | 'always';
-    action: 'config' | 'ps' | 'up' | 'down' | 'restart' | 'logs';
-}): DockerCommandResult;

package/dist/reconcile/providers/docker-private.js

@@ -1,101 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-function runDocker(args, options = {}) {
-  const result = spawnSync("docker", args, {
-    cwd: options.cwd,
-    env: { ...process.env, ...options.env ?? {} },
-    encoding: "utf8"
-  });
-  return {
-    ok: (result.status ?? 1) === 0,
-    status: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    args
-  };
-}
-function inspectDockerAvailability() {
-  const version = runDocker(["version", "--format", "{{.Server.Version}}"]);
-  const buildx = runDocker(["buildx", "version"]);
-  return {
-    available: version.ok,
-    buildxAvailable: buildx.ok,
-    version: version.stdout.trim() || null,
-    buildx: buildx.stdout.trim() || null,
-    warnings: [
-      ...version.ok ? [] : ["Docker is not available in this shell"],
-      ...buildx.ok ? [] : ["Docker Buildx is not available in this shell"]
-    ]
-  };
-}
-function inspectDockerImage(tag) {
-  const result = runDocker(["image", "inspect", tag]);
-  if (!result.ok) return null;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    return parsed[0] ?? null;
-  } catch {
-    return { raw: result.stdout };
-  }
-}
-function inspectDockerManifest(ref) {
-  const result = runDocker(["buildx", "imagetools", "inspect", ref]);
-  return result.ok ? { ref, output: result.stdout } : null;
-}
-function buildDockerImage(input) {
-  const packageRoot = resolve(input.packageRoot);
-  const contextPath = resolve(packageRoot, input.context || ".");
-  const dockerfilePath = resolve(packageRoot, input.dockerfile || "Dockerfile");
-  if (!existsSync(dockerfilePath)) {
-    throw new Error(`Dockerfile does not exist: ${dockerfilePath}`);
-  }
-  const args = [
-    "buildx",
-    "build",
-    "--file",
-    dockerfilePath,
-    "--platform",
-    input.platforms.join(","),
-    ...input.target ? ["--target", input.target] : [],
-    ...input.tags.flatMap((tag) => ["--tag", tag]),
-    ...Object.entries(input.labels ?? {}).flatMap(([key, value]) => ["--label", `${key}=${value}`]),
-    ...Object.entries(input.buildArgs ?? {}).flatMap(([key, value]) => ["--build-arg", `${key}=${value}`]),
-    ...input.push ? ["--push"] : [],
-    ...input.load ? ["--load"] : [],
-    ...input.provenance === false ? ["--provenance=false"] : [],
-    contextPath
-  ];
-  const result = runDocker(args, { cwd: packageRoot, env: input.env });
-  if (!result.ok) {
-    throw new Error(result.stderr.trim() || result.stdout.trim() || `docker ${args.join(" ")} failed`);
-  }
-  return {
-    ...result,
-    contextPath,
-    dockerfilePath,
-    tags: input.tags,
-    platforms: input.platforms
-  };
-}
-function runDockerCompose(input) {
-  const composeFiles = input.composeFiles?.length ? input.composeFiles : input.composeFile ? [input.composeFile] : [];
-  const profileArgs = (input.profiles ?? []).flatMap((profile) => ["--profile", profile]);
-  const buildArgs = input.buildPolicy === "always" ? ["--build"] : input.buildPolicy === "never" ? ["--no-build"] : [];
-  const base = [
-    "compose",
-    ...profileArgs,
-    ...composeFiles.flatMap((composeFile) => ["-f", composeFile]),
-    "-p",
-    input.projectName
-  ];
-  const args = input.action === "config" ? [...base, "config", "--hash"] : input.action === "ps" ? [...base, "ps", "--format", "json"] : input.action === "up" ? [...base, "up", "-d", ...buildArgs] : input.action === "down" ? [...base, "down"] : input.action === "restart" ? [...base, "up", "-d", ...buildArgs, "--force-recreate"] : [...base, "logs", "--tail", "200"];
-  return runDocker(args, { cwd: input.cwd, env: input.env });
-}
-export {
-  buildDockerImage,
-  inspectDockerAvailability,
-  inspectDockerImage,
-  inspectDockerManifest,
-  runDockerCompose
-};

package/dist/reconcile/providers/github-private.d.ts

@@ -1,69 +0,0 @@
-export declare function createReconcileGitHubClient(env: NodeJS.ProcessEnv | Record<string, string | undefined>): import("@octokit/core").Octokit & {
-    paginate: import("@octokit/plugin-paginate-rest").PaginateInterface;
-} & import("@octokit/plugin-paginate-graphql").paginateGraphQLInterface & import("@octokit/plugin-rest-endpoint-methods").Api & {
-    retry: {
-        retryRequest: (error: import("octokit").RequestError, retries: number, retryAfter: number) => import("octokit").RequestError;
-    };
-};
-export declare function observeGitHubEnvironment(repository: string, environment: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<{
-    exists: boolean;
-    repository: string;
-    environment: string;
-    secretNames: string[];
-    variableNames: string[];
-    variableValues: {
-        [k: string]: string;
-    };
-    authAvailable?: undefined;
-    error?: undefined;
-} | {
-    exists: boolean;
-    authAvailable: boolean;
-    repository: string;
-    environment: string;
-    secretNames: never[];
-    variableNames: never[];
-    variableValues: {};
-    error: string;
-}>;
-export declare function ensureReconcileGitHubEnvironment(repository: string, environment: string, branchName: string | null, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<{
-    repository: string;
-    environment: string;
-}>;
-export declare function upsertReconcileGitHubSecret(repository: string, environment: string, name: string, value: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<void>;
-export declare function upsertReconcileGitHubVariable(repository: string, environment: string, name: string, value: string, env: NodeJS.ProcessEnv | Record<string, string | undefined>): Promise<void>;
-export declare function observeGitHubWorkflowRun(input: {
-    repository: string;
-    workflow: string;
-    branch?: string | null;
-    env: NodeJS.ProcessEnv | Record<string, string | undefined>;
-}): Promise<import("../../workflow-support.js").GitHubWorkflowRunSummary | {
-    authAvailable: boolean;
-    error: string;
-} | null>;
-export declare function dispatchReconcileGitHubWorkflow(input: {
-    repository: string;
-    workflow: string;
-    branch: string;
-    inputs?: Record<string, string>;
-    wait?: boolean;
-    timeoutMs?: number;
-    env: NodeJS.ProcessEnv | Record<string, string | undefined>;
-}): Promise<{
-    dispatch: import("../../workflow-support.js").GitHubWorkflowDispatchResult;
-    latest: import("../../workflow-support.js").GitHubWorkflowRunSummary | null;
-    completed: {
-        status: string;
-        repository: string;
-        workflow: string;
-        runId: number;
-        headSha: string | null;
-        branch: string | null;
-        createdAt: string | null;
-        updatedAt: string | null;
-        conclusion: string | null;
-        url: string | null;
-        jobs: import("../../operations/services/github-api.js").GitHubWorkflowJobSummary[];
-        failedJobs: import("../../operations/services/github-api.js").GitHubWorkflowJobSummary[];
-    } | null;
-}>;

package/dist/reconcile/providers/github-private.js

@@ -1,145 +0,0 @@
-import {
-  createGitHubApiClient,
-  dispatchGitHubWorkflowRun,
-  ensureGitHubActionsEnvironment,
-  formatGitHubWorkflowFailure,
-  getLatestGitHubWorkflowRun,
-  listGitHubEnvironmentSecretNames,
-  listGitHubEnvironmentVariableNames,
-  listGitHubEnvironmentVariables,
-  upsertGitHubEnvironmentSecret,
-  upsertGitHubEnvironmentVariable,
-  waitForGitHubWorkflowRunCompletion
-} from "../../operations/services/github-api.js";
-function createReconcileGitHubClient(env) {
-  return createGitHubApiClient({ env });
-}
-function isGitHubAuthError(message) {
-  return /authentication failed|bad credentials|requires authentication|401|403|forbidden/iu.test(message);
-}
-async function observeGitHubEnvironment(repository, environment, env) {
-  const client = createReconcileGitHubClient(env);
-  try {
-    const [secretNames, variableNames, variableValues] = await Promise.all([
-      listGitHubEnvironmentSecretNames(repository, environment, { client }),
-      listGitHubEnvironmentVariableNames(repository, environment, { client }),
-      listGitHubEnvironmentVariables(repository, environment, { client })
-    ]);
-    return {
-      exists: true,
-      repository,
-      environment,
-      secretNames: [...secretNames].sort(),
-      variableNames: [...variableNames].sort(),
-      variableValues: Object.fromEntries([...variableValues.entries()].sort(([left], [right]) => left.localeCompare(right)))
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (/not found|404/iu.test(message)) {
-      return {
-        exists: false,
-        authAvailable: true,
-        repository,
-        environment,
-        secretNames: [],
-        variableNames: [],
-        variableValues: {},
-        error: message
-      };
-    }
-    if (isGitHubAuthError(message)) {
-      return {
-        exists: false,
-        authAvailable: false,
-        repository,
-        environment,
-        secretNames: [],
-        variableNames: [],
-        variableValues: {},
-        error: message
-      };
-    }
-    throw error;
-  }
-}
-async function ensureReconcileGitHubEnvironment(repository, environment, branchName, env) {
-  const client = createReconcileGitHubClient(env);
-  return ensureGitHubActionsEnvironment(repository, environment, { client, branchName: branchName ?? void 0 });
-}
-async function upsertReconcileGitHubSecret(repository, environment, name, value, env) {
-  const client = createReconcileGitHubClient(env);
-  return upsertGitHubEnvironmentSecret(repository, environment, name, value, { client });
-}
-async function upsertReconcileGitHubVariable(repository, environment, name, value, env) {
-  const client = createReconcileGitHubClient(env);
-  return upsertGitHubEnvironmentVariable(repository, environment, name, value, { client });
-}
-async function observeGitHubWorkflowRun(input) {
-  const client = createReconcileGitHubClient(input.env);
-  try {
-    return await getLatestGitHubWorkflowRun(input.repository, {
-      client,
-      workflow: input.workflow,
-      branch: input.branch
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (isGitHubAuthError(message) || /not found|404/iu.test(message)) {
-      return {
-        authAvailable: false,
-        error: message
-      };
-    }
-    throw error;
-  }
-}
-async function dispatchReconcileGitHubWorkflow(input) {
-  const client = createReconcileGitHubClient(input.env);
-  const dispatch = await dispatchGitHubWorkflowRun(input.repository, {
-    client,
-    workflow: input.workflow,
-    branch: input.branch,
-    inputs: input.inputs
-  });
-  const latest = await getLatestGitHubWorkflowRun(input.repository, {
-    client,
-    workflow: input.workflow,
-    branch: input.branch
-  });
-  const completed = input.wait ? await waitForGitHubWorkflowRunCompletion(input.repository, {
-    client,
-    workflow: input.workflow,
-    branch: input.branch,
-    timeoutSeconds: input.timeoutMs ? Math.ceil(input.timeoutMs / 1e3) : void 0
-  }) : null;
-  if (completed && completed.conclusion !== "success") {
-    const failedJob = completed.failedJobs?.[0] ?? completed.jobs?.find((job) => job.conclusion && job.conclusion !== "success" && job.conclusion !== "skipped") ?? null;
-    const failedStep = failedJob?.steps?.find((step) => step.conclusion && step.conclusion !== "success" && step.conclusion !== "skipped") ?? null;
-    const failure = formatGitHubWorkflowFailure({
-      repository: input.repository,
-      workflow: input.workflow,
-      runId: completed.runId,
-      runUrl: completed.url,
-      conclusion: completed.conclusion,
-      failedJobName: failedJob?.name,
-      lastActiveStep: failedStep?.name,
-      message: `GitHub workflow ${input.workflow} in ${input.repository} completed with conclusion ${completed.conclusion ?? "unknown"}.`,
-      resumeSafe: false
-    });
-    throw new Error([
-      failure.summary,
-      failure.runUrl ? `Run: ${failure.runUrl}` : null,
-      failure.inspectCommand ? `Inspect: ${failure.inspectCommand}` : null
-    ].filter(Boolean).join("\n"));
-  }
-  return { dispatch, latest, completed };
-}
-export {
-  createReconcileGitHubClient,
-  dispatchReconcileGitHubWorkflow,
-  ensureReconcileGitHubEnvironment,
-  observeGitHubEnvironment,
-  observeGitHubWorkflowRun,
-  upsertReconcileGitHubSecret,
-  upsertReconcileGitHubVariable
-};

package/dist/reconcile/providers/local-private.d.ts

@@ -1,28 +0,0 @@
-import { type TreeseedManagedDevAction } from '../../local-dev/managed-dev.js';
-export declare function runManagedDevAction(input: {
-    tenantRoot: string;
-    action: TreeseedManagedDevAction;
-    surfaces: string[];
-    options?: Record<string, unknown>;
-    env?: NodeJS.ProcessEnv;
-}): Promise<{
-    ok: boolean;
-    status: number;
-    stdout: string;
-    stderr: string;
-    output: string;
-    parsed: import("../../local-dev/managed-dev.js").TreeseedManagedDevResult;
-    args: TreeseedManagedDevAction[];
-    surfaces: string[];
-}>;
-export declare function checkHttpHealth(url: string, timeoutMs?: number): Promise<{
-    ok: boolean;
-    status: number;
-    url: string;
-    error?: undefined;
-} | {
-    ok: boolean;
-    status: null;
-    url: string;
-    error: string;
-}>;

package/dist/reconcile/providers/local-private.js

@@ -1,75 +0,0 @@
-import { runTreeseedManagedDev } from "../../local-dev/managed-dev.js";
-function runManagedDevAction(input) {
-  return runTreeseedManagedDev({
-    action: input.action,
-    cwd: input.tenantRoot,
-    surfaces: input.surfaces.join(","),
-    webRuntime: input.options?.webRuntime,
-    webHost: typeof input.options?.host === "string" ? input.options.host : void 0,
-    webPort: typeof input.options?.port === "number" ? input.options.port : void 0,
-    apiHost: typeof input.options?.apiHost === "string" ? input.options.apiHost : void 0,
-    apiPort: typeof input.options?.apiPort === "number" ? input.options.apiPort : void 0,
-    force: input.options?.force === true,
-    forceConflicts: input.options?.forceConflicts === true,
-    all: input.options?.all === true,
-    follow: input.options?.follow === true,
-    env: input.env
-  }).then((result) => {
-    const safeResult = sanitizeManagedDevResult(result);
-    return {
-      ok: safeResult.ok,
-      status: safeResult.ok ? 0 : 1,
-      stdout: `${JSON.stringify(safeResult)}
-`,
-      stderr: "",
-      output: JSON.stringify(safeResult),
-      parsed: safeResult,
-      args: [input.action],
-      surfaces: input.surfaces
-    };
-  });
-}
-function sanitizeManagedDevResult(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeManagedDevResult(entry));
-  }
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  const result = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (key === "env") {
-      continue;
-    }
-    if (key === "redactedEnv" || key === "envKeys") {
-      continue;
-    }
-    result[key] = sanitizeManagedDevResult(entry);
-  }
-  return result;
-}
-async function checkHttpHealth(url, timeoutMs = 2e3) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(url, { signal: controller.signal });
-    return {
-      ok: response.ok,
-      status: response.status,
-      url
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      status: null,
-      url,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-export {
-  checkHttpHealth,
-  runManagedDevAction
-};