mfeflow 0.4.0 → 0.6.0

package/dist/inspect.d.ts

@@ -1,5 +1,6 @@
 import { type Issue, type MfeManifest, type RegistryEntry } from '@mfeflow/contracts';
 import { type MfeflowProject } from '@mfeflow/core';
+import type { Io } from './io.js';
 export declare const ENVS: readonly ['dev', 'staging', 'prod'];
 export type Read<T> = {
     state: 'missing';
@@ -27,6 +28,8 @@ export interface AppView {
     present: boolean;
     pkg: PackageView | undefined;
     mfe: Read<MfeManifest>;
+    /** Path from the root of the app file that was read: `mfeflow.app.json`, or the old `mfe.json`. */
+    appFile: string;
 }
 export interface WorkspacePackage {
     dir: string;
@@ -39,16 +42,25 @@ export interface ProjectView {
     project: MfeflowProject;
     apps: AppView[];
     workspace: WorkspacePackage[];
+    /** A polyrepo shell only: remote name → manifest URL of its dev server, from the shell's dev config. */
+    devRemotes?: Record<string, string>;
     /** env → remote name → entry. Only remotes with a file in that env are listed. */
     registry: Record<string, Record<string, Read<RegistryEntry>>>;
     /** Folders under registry/envs that exist. */
     envDirs: string[];
+    /** Folders of the apps that still use the old `mfe.json` name. */
+    legacyAppFiles: string[];
 }
 export declare function readText(file: string): Promise<string | undefined>;
 /** Workspace folders for the simple globs pnpm projects use: `dir/*`, plain paths, and `!` exclusions. */
 export declare function expandGlobs(root: string, globs: readonly string[]): Promise<string[]>;
-/** Everything the checks read, loaded once. Throws the E102-E104 errors of `loadProject`. */
-export declare function inspectProject(root: string): Promise<ProjectView>;
+/** Prints the old app file name notice to stderr, at most once for each `io`, which is once per command. */
+export declare function noticeLegacyAppFiles(io: Pick<Io, 'stderr'>, legacy: readonly string[]): void;
+/**
+ * Everything the checks read, loaded once. Throws the E102-E104 errors of `loadProject`, and E122
+ * when an app has both app file names. With `io`, apps on the old name get one notice per command.
+ */
+export declare function inspectProject(root: string, io?: Pick<Io, 'stderr'>): Promise<ProjectView>;
 /**
  * The version of `name` an app uses: what is installed under node_modules (walking up from
  * the app to the project root, as Node does, never above it), else the version its package.json

package/dist/output.d.ts

@@ -1,4 +1,4 @@
-import type { Issue } from '@mfeflow/contracts';
+import type { Issue, RegistryIndex } from '@mfeflow/contracts';
 import { type Plan } from '@mfeflow/core';
 import { type ErrorReport } from './exit.js';
 import type { Finding } from './findings.js';
@@ -12,11 +12,13 @@ export interface PlanReport {
         path: string;
         action: 'create' | 'patch' | 'delete';
     }[];
+    /** `thirdParty` (only present when true): a feature from a registry asked for it. */
     dependencies: {
         file: string;
         name: string;
         range: string;
         dev: boolean;
+        thirdParty?: boolean;
     }[];
     scripts: {
         file: string;
@@ -42,19 +44,88 @@ interface WriteReport {
     /** Unified diff of every change. Only present for a dry run. */
     diff?: string;
 }
+/** One repo of a polyrepo `init`. */
+export interface RepoReport {
+    /** The folder inside `root`. */
+    name: string;
+    repo: 'platform' | 'shell' | 'remote';
+    root: string;
+    /** Files written in this repo, relative to it. */
+    written: string[];
+    installed: boolean;
+}
 export interface InitResult extends WriteReport {
     command: 'init';
     scope: string;
     apps: AppReport[];
+    /** Only for `--topology polyrepo`: the repos made, in the order they were written. */
+    repos?: RepoReport[];
+    next: string[];
+}
+export interface AdoptResult extends WriteReport {
+    command: 'adopt';
+    scope: string;
+    apps: AppReport[];
+    /** Parts of the existing config adopt read but did not carry over, each with the reason. */
+    notAdopted: {
+        dir: string;
+        file: string;
+        field: string;
+        reason: string;
+    }[];
+    /** The build config files adopt read and left exactly as they were. */
+    buildConfig: string[];
+    /** Lines to paste into the shared list of a build config. */
+    snippet: string;
     next: string[];
 }
 export interface AddResult extends WriteReport {
     command: 'add';
-    kind: 'remote' | 'shell' | 'feature' | 'env-key';
+    kind: 'remote' | 'shell' | 'feature' | 'env-key' | 'team-repo';
     /** What was added: an app name, or feature names. */
     added: string[];
     /** Features that were already part of the project. */
     skipped: string[];
+    /** `add team-repo` only: the new repo's folder, next to this one. */
+    created?: string;
+}
+export interface UpgradeFileReport {
+    path: string;
+    reason: 'edited' | 'untracked' | 'edited-by-cli' | 'skipped-feature' | 'symlink';
+    /** `accept`: written with the new version. `keep`: left, and remembered. `undecided`: left, and the run fails without a person to ask. */
+    decision: 'accept' | 'keep' | 'undecided';
+    /** Keys in your file that the new version lacks or has with another value; accepting drops them. */
+    lostKeys: string[];
+    /** The part of `lostKeys` that the new version has with another value. */
+    changedValues: string[];
+    /** Unified diff from your file to the new version. */
+    diff: string;
+}
+export interface UpgradeResult extends WriteReport {
+    command: 'upgrade';
+    from: string;
+    /** Where `from` was read: the `cli` field of mfeflow.json, or the shell's `@mfeflow/runtime` range. */
+    fromSource: 'mfeflow.json' | 'package.json';
+    to: string;
+    /** Nothing to write: the project already matches this version. */
+    upToDate: boolean;
+    /** Generated files you had not changed, now at the new version. */
+    replaced: string[];
+    created: string[];
+    /** package.json, pnpm-workspace.yaml and turbo.json, edited in place. */
+    edited: string[];
+    diverged: UpgradeFileReport[];
+    /** Registry features by name: `verified` against the recorded hash, `first-seen` when none was recorded, or `accepted-changed`. */
+    integrity: Record<string, 'verified' | 'first-seen' | 'accepted-changed'>;
+    /** Generated files you deleted. Not brought back. */
+    missing: string[];
+    /** Files the new version no longer generates. Left in place. */
+    removed: string[];
+    migrations: {
+        feature: string;
+        from: string;
+        to: string;
+    }[];
 }
 export interface FeatureInfo {
     /** `mfeflow` for the features that ship with the CLI, otherwise the registry's namespace, like `@test`. */
@@ -69,8 +140,10 @@ export interface FeatureInfo {
 }
 export interface RegistryStatus {
     namespace: string;
-    /** The index.json asked for. */
+    /** The index.json asked for, with token-like query values hidden. */
     index: string;
+    /** False: the user has not trusted this registry yet, so nothing was requested from it. */
+    trusted: boolean;
     /** How many items it lists. */
     items: number;
     /** Why it could not be read; the other registries are listed regardless. */
@@ -85,15 +158,17 @@ export interface FeaturesResult {
 }
 export interface RegistryEntryInfo {
     namespace: string;
-    /** The URL template from mfeflow.json. */
+    /** The URL template from mfeflow.json, with token-like query values hidden. */
     url: string;
     /** Where its index.json is. */
     index: string;
+    /** Whether the user has trusted this namespace at this URL. */
+    trusted: boolean;
 }
 export interface RegistryResult {
     ok: true;
     command: 'registry';
-    action: 'add' | 'remove' | 'list' | 'build';
+    action: 'add' | 'remove' | 'list' | 'build' | 'trust' | 'untrust';
     dryRun: boolean;
     /** The project folder; null for `build`, which needs none. */
     root: string | null;
@@ -120,6 +195,8 @@ export interface ReportResult {
     summary: Summary;
     checks: CheckReport[];
     findings: Finding[];
+    /** `check-compat --against`: where the shell's versions came from. */
+    against?: string;
 }
 export interface ShellBudget {
     name: string;
@@ -138,7 +215,7 @@ export interface RouteBudget {
     expose: string | null;
     /** Entry plus the expose's synchronous JS, gzip KB. */
     kb: number;
-    /** mfe.json budgets.initialJsKb, or null. */
+    /** mfeflow.app.json budgets.initialJsKb, or null. */
     budgetKb: number | null;
     pass: boolean | null;
 }
@@ -184,12 +261,142 @@ export interface DevResult {
     /** Stopped with Ctrl+C or a termination signal. */
     interrupted: boolean;
 }
+export interface PlannedUpload {
+    key: string;
+    bytes: number;
+    contentType: string;
+    cacheControl: string;
+    /** `create-only`: refuses to overwrite. `if-match`: only if the index is the one that was read. */
+    guard: 'create-only' | 'if-match' | 'none';
+}
+/** What `deploy`, `promote` and `rollback` print with `--json`. `ok` is false when a gate failed. */
+export interface DeployResult {
+    ok: boolean;
+    command: 'deploy' | 'promote' | 'rollback';
+    dryRun: boolean;
+    root: string;
+    env: string;
+    /** The env a promote copied from; null otherwise. */
+    fromEnv: string | null;
+    /** The host as a person wrote it, never an endpoint or a credential. */
+    host: string;
+    remote: string;
+    version: string;
+    /** The version the env served before; null when the remote was not deployed there. */
+    servedBefore: string | null;
+    /** The index now points at `version` (false for a dry run, `--no-publish`, a failed gate, or when it already did). */
+    published: boolean;
+    previous: string | null;
+    rolledBackFrom: string | null;
+    /** Everything the run uploads, in order, the index last. */
+    uploads: PlannedUpload[];
+    uploaded: string[];
+    skipped: string[];
+    /** The registry/envs file written to match the host; null when none was. */
+    localEntry: string | null;
+    /** The index the run would write. Only for a dry run. */
+    index?: RegistryIndex;
+    warnings: string[];
+    findings: Finding[];
+    /** Server mode only: set when the deploy started a percentage rollout. `version` is then the candidate. */
+    rollout?: {
+        id: string;
+        stable: string;
+        candidate: string;
+        percent: number;
+        steps: number[];
+    };
+}
+export interface StatusRemote {
+    name: string;
+    version: string;
+    previous: string | null;
+    history: string[];
+    rolledBackFrom: string | null;
+    /** The version in `registry/envs/<env>/<name>.json`; null when there is no such file. */
+    local: string | null;
+    /** Versions on the host newer than `version` that no environment points at; null when the host cannot list. */
+    unreferenced: string[] | null;
+    drift: string[];
+    /** Server mode with a token: the remote was killed and is not in the served index. */
+    killed?: boolean;
+    /** Server mode with a token: a percentage rollout is running. */
+    rollout?: {
+        candidate: string;
+        percent: number;
+    } | null;
+}
+export interface StatusEnv {
+    env: string;
+    /** The host has an index for this env. */
+    published: boolean;
+    /** When that index was written. The index records no per-remote time. */
+    generatedAt: string | null;
+    remotes: StatusRemote[];
+}
+export interface StatusResult {
+    ok: boolean;
+    command: 'status';
+    root: string;
+    host: string;
+    envs: StatusEnv[];
+    findings: Finding[];
+}
+/** `mfeflow rollout step|complete|abort`. Fields are null for a dry run, which sends nothing. */
+export interface RolloutCommandResult {
+    ok: boolean;
+    command: 'rollout';
+    action: 'step' | 'complete' | 'abort' | 'status';
+    dryRun: boolean;
+    root: string;
+    host: string;
+    env: string;
+    remote: string;
+    stable: string | null;
+    candidate: string | null;
+    percent: number | null;
+    /** What the index serves now. */
+    serves: string | null;
+    /** `rollout status` only: the browser reports behind the gate. */
+    report?: {
+        startedAt: string;
+        steps: number[];
+        candidateCounts: {
+            loads: number;
+            errors: number;
+            clients: number;
+        };
+        stableCounts: {
+            loads: number;
+            errors: number;
+            clients: number;
+        };
+        gate: {
+            verdict: 'wait' | 'ok' | 'halt';
+            reason: string | null;
+        };
+        reporterCapFull: boolean;
+    };
+}
+/** `mfeflow kill` and `mfeflow restore`. */
+export interface KillCommandResult {
+    ok: boolean;
+    command: 'kill' | 'restore';
+    dryRun: boolean;
+    root: string;
+    host: string;
+    env: string;
+    remote: string;
+    /** False when the remote was already in that state. Null for a dry run. */
+    changed: boolean | null;
+    killed: boolean | null;
+}
 export interface FailureResult {
     ok: false;
     error: ErrorReport;
     exitCode: number;
 }
-export type CliResult = InitResult | AddResult | FeaturesResult | RegistryResult | ReportResult | BudgetResult | DevResult | FailureResult;
+export type CliResult = InitResult | AdoptResult | AddResult | UpgradeResult | FeaturesResult | RegistryResult | ReportResult | BudgetResult | DevResult | DeployResult | StatusResult | RolloutCommandResult | KillCommandResult | FailureResult;
 /** The plan as plain data for `--json`, without file contents. Features are listed once. */
 export declare function planReport(plan: Plan): PlanReport;
 /** Checks a document the CLI printed with `--json`. Returns the problems; empty means valid. */

package/dist/pipeline.d.ts

@@ -1,7 +1,18 @@
 import { PlanBuilder, type MfeflowProject, type Plan } from '@mfeflow/core';
 /** Reads a project file by its `/`-separated path; undefined when it does not exist. */
 export declare function projectReader(root: string): (file: string) => Promise<string | undefined>;
-/** A plan builder that reads `root`, keeps dependency versions in the catalog and resolves `@mfeflow/*` ranges. */
-export declare function createBuilder(root: string, checkout: string | undefined): PlanBuilder;
+/**
+ * A plan builder that reads `root`, keeps dependency versions in the catalog and resolves `@mfeflow/*` ranges.
+ * `links` maps a package name to the `link:` path it is installed from instead of a registry range.
+ */
+export declare function createBuilder(root: string, checkout: string | undefined, links?: Readonly<Record<string, string>>): PlanBuilder;
 /** `plan` with the `mfeflow.json` change added, for the summary and the diff. */
 export declare function withProjectChange(plan: Plan, project: MfeflowProject): Plan;
+/**
+ * `project` with `cli` set to the running version, but only when the plan already changes
+ * something and only upward: an older CLI never lowers it, and a run with nothing to do
+ * leaves `mfeflow.json` alone.
+ */
+export declare function stampCli(project: MfeflowProject, plan: Plan): MfeflowProject;
+/** `project` with `cli` raised to the running version; never lowered. */
+export declare function raiseCli(project: MfeflowProject): MfeflowProject;

package/dist/polyrepo.d.ts

@@ -0,0 +1,69 @@
+import { type LoadedFeature, type MfeflowProject, type Plan } from '@mfeflow/core';
+import type { Globals } from './args.js';
+import { type RemoteSpec } from './devremotes.js';
+import { type FeatureOptions } from './options.js';
+import type { PlanReport } from './output.js';
+import type { Runtime } from './runtime.js';
+import { type WriteOutcome } from './write.js';
+export declare const PLATFORM_DIR = "platform";
+export declare const SHELL_DIR = "shell";
+export type RepoKind = 'platform' | 'shell' | 'remote';
+export declare function assertFeaturesFit(features: readonly string[]): void;
+export interface RepoRequest {
+    kind: RepoKind;
+    /** The folder inside the org folder. */
+    dir: string;
+    root: string;
+    scope: string;
+    /** The GitHub owner the CI and Renovate files point at; the scope without `@` when empty. */
+    org?: string | undefined;
+    /** The remote this repo holds (kind remote only). */
+    remote?: RemoteSpec;
+    /** The remotes the shell routes to and lists in its dev config (kind shell only). */
+    shellRemotes?: readonly RemoteSpec[];
+    features: readonly string[];
+    featureOptions: FeatureOptions;
+    local: string | undefined;
+    cwd: string;
+}
+/** Where the shell and each remote install `<scope>/*` from until the platform packages are published. */
+export declare function platformLinks(scope: string): Record<string, string>;
+export declare function remotePorts(names: readonly string[]): RemoteSpec[];
+export declare function repoProject(kind: RepoKind, scope: string, remote?: RemoteSpec): MfeflowProject;
+/**
+ * `core` for one repo of a polyrepo: the same files and dependencies, minus what belongs to the
+ * monorepo as a whole. The root package.json is named after the repo, the README and AGENTS.md come
+ * from the polyrepo template, and a platform repo keeps only the workspace files.
+ */
+export declare function polyrepoCore(core: LoadedFeature, request: Pick<RepoRequest, 'kind' | 'scope' | 'remote'>): Promise<LoadedFeature>;
+export interface RepoPlan {
+    request: RepoRequest;
+    project: MfeflowProject;
+    plan: Plan;
+}
+/** What one repo of the polyrepo would get; nothing is written. */
+export declare function planRepo(rt: Runtime, request: RepoRequest): Promise<RepoPlan>;
+/** `report` with every path under `dir/`, so reports of several repos can share one list. */
+export declare function prefixReport(report: PlanReport, dir: string): PlanReport;
+export declare function mergeReports(reports: readonly PlanReport[]): PlanReport;
+export interface RepoWrite {
+    repo: RepoPlan;
+    outcome: WriteOutcome;
+}
+/** The folders of `dir`'s path that do not exist yet, outermost first. */
+export declare function missingParents(dir: string): Promise<string[]>;
+/** The warning for repos `git init` did not make, or nothing when all of them are. */
+export declare function notReposWarning(dirs: readonly string[]): string[];
+export interface RepoWrites {
+    writes: RepoWrite[];
+    /** Folders where `git init` did not run. */
+    notRepos: string[];
+}
+/**
+ * Writes the repos one after another, each in its own transaction with its own `git init`. If one
+ * fails, the repos this run already wrote are removed again, and so are the folders above them that
+ * this run made (while empty), so nothing half-built is left behind.
+ */
+export declare function writeRepos(rt: Runtime, globals: Globals, org: string, repos: readonly RepoPlan[]): Promise<RepoWrites>;
+/** The GitHub owner from `--org`, checked; undefined when not given. */
+export declare function checkOrg(org: string | undefined): string | undefined;

package/dist/publish.d.ts

@@ -0,0 +1,98 @@
+import type { MfeManifest, RegistryEntry, RegistryIndex, RegistryIndexRemote } from '@mfeflow/contracts';
+import { type ErrorCode } from '@mfeflow/core';
+import { type ApplyResult, type DeployPlan, type GateCode, type RegistryHost } from '@mfeflow/registry/static';
+import { type Globals } from './args.js';
+import { type Finding } from './findings.js';
+import { type AppView, type ProjectView } from './inspect.js';
+import type { PlannedUpload } from './output.js';
+import type { Runtime } from './runtime.js';
+export declare const GATE_CODES: Record<GateCode, ErrorCode>;
+export interface Session {
+    rt: Runtime;
+    globals: Globals;
+    view: ProjectView;
+    host: RegistryHost;
+    hostLabel: string;
+    /** Secret values to scrub from anything printed. */
+    secrets: string[];
+    /** `--base-url`, else `registry.baseUrl` from mfeflow.json. */
+    baseUrl: string | undefined;
+    /** Server mode with no host: there is nowhere to upload artifacts to. */
+    hostless: boolean;
+}
+export declare function envOf(args: Record<string, unknown>, key?: string): string;
+export declare function positionals(args: Record<string, unknown>, max: number, usage: string): string[];
+export declare function openSession(rt: Runtime, args: Record<string, unknown>, raw?: Globals, options?: {
+    hostOptional?: boolean;
+}): Promise<Session>;
+/**
+ * A base URL ends up in a public index, so it must be an https URL (http only on localhost) with no
+ * credentials, query or fragment. Returns the normalised form without a trailing slash.
+ */
+export declare function normalizeBaseUrl(value: string, label: string): string;
+/** A failure from the host or the files around it as the catalogue error that names it. Secrets never reach the message. */
+export declare function hostFailure(error: unknown, secrets: readonly string[]): Error;
+/** Runs host work, turning host errors into catalogue errors. */
+export declare function onHost<T>(s: Session, work: () => Promise<T>): Promise<T>;
+export declare function remoteApp(view: ProjectView, name: string | undefined): AppView & {
+    mfe: MfeOk;
+};
+type MfeOk = {
+    state: 'ok';
+    value: MfeManifest;
+};
+/** The versions the shell has, for the packages a remote's compatibility is judged on. */
+export declare function shellVersions(view: ProjectView, mfe: MfeManifest): Promise<Record<string, string>>;
+export declare const shellManifestKey: (env: string) => string;
+/** The shell's deployed `mf-manifest.json`: the file given, else the one on the host under the env. */
+export declare function readShellManifest(s: Session, env: string, file: string | undefined): Promise<{
+    manifest?: unknown;
+    warnings: string[];
+}>;
+/** Environments that have an index on the host. Empty when the host cannot list. */
+export declare function hostEnvs(s: Session): Promise<string[]>;
+export declare function currentIndex(s: Session, env: string): Promise<{
+    index: RegistryIndex | undefined;
+    etag?: string;
+}>;
+/** Where artifacts are served from: the setting, else read back from an entry already in the index. */
+export declare function baseUrlFor(s: Session, index: RegistryIndex | undefined): string;
+export declare function describeUploads(plan: DeployPlan): PlannedUpload[];
+export declare function gateFindings(plan: DeployPlan, app: string): Finding[];
+export interface Planned {
+    plan: DeployPlan;
+    /** The remote's entry in the index before this run. */
+    before: RegistryIndexRemote | undefined;
+    warnings: string[];
+    /** The pointer already is where the command would move it. */
+    noop?: boolean;
+}
+export interface Committed {
+    planned: Planned;
+    applied: ApplyResult | undefined;
+    /** The index was written. */
+    published: boolean;
+}
+export interface CommitOptions {
+    env: string;
+    name: string;
+    dryRun: boolean;
+    /** Upload the artifacts and leave the index where it is. */
+    noPublish?: boolean;
+    /** Reads the host and plans. Runs again after another writer got in first. */
+    plan: () => Promise<Planned>;
+}
+/**
+ * Plans and applies. When another writer moves the index between the read and the write, reads it
+ * again, plans again and tries once more; a second collision stops with E510 naming what changed.
+ */
+export declare function commit(s: Session, options: CommitOptions): Promise<Committed>;
+/** The entry `registry/envs/<env>/<name>.json` records for what the index serves. */
+export declare function localEntryOf(remote: RegistryIndexRemote): RegistryEntry;
+export declare function writeLocalEntry(root: string, env: string, remote: RegistryIndexRemote): Promise<string>;
+export interface Build {
+    manifest: unknown;
+    files: Record<string, Uint8Array>;
+}
+export declare function readBuild(dir: string, shown: string): Promise<Build>;
+export {};

package/dist/runtime.d.ts

@@ -1,8 +1,9 @@
-import type { FetchLike } from '@mfeflow/core';
+import { type FetchLike } from '@mfeflow/core';
 import { type AssetRoots } from './assets.js';
 import { type Io } from './io.js';
 import { type DevHost } from './proc.js';
 import { type Prompter } from './prompter.js';
+import type { RegistryHost } from '@mfeflow/registry/static';
 import { type System } from './system.js';
 /** Everything a command touches outside its own arguments. Tests replace the parts they watch. */
 export interface Runtime {
@@ -11,7 +12,15 @@ export interface Runtime {
     system: System;
     fetch: FetchLike;
     roots: AssetRoots;
+    /** Where per-user settings live, like the registries the user trusts. */
+    configDir: string;
     /** Processes, signals and file watching for `mfeflow dev`. Defaults to the real ones. */
     dev?: DevHost;
+    /** `fetch` for S3 hosts. Tests stand in for the network. */
+    hostFetch?: typeof fetch;
+    /** `fetch` for the registry server in server mode. Tests point it at a server on 127.0.0.1. */
+    serverFetch?: typeof fetch;
+    /** Wraps the registry host `deploy`, `promote`, `rollback` and `status` open. Tests inject a second writer. */
+    wrapHost?: (host: RegistryHost) => RegistryHost;
 }
 export declare function realRuntime(io?: Io): Runtime;

package/dist/server-client.d.ts

@@ -0,0 +1,61 @@
+import { type RegistryIndex } from '@mfeflow/contracts';
+import { MfeflowError, type ErrorCode } from '@mfeflow/core';
+import type { Runtime } from './runtime.js';
+export declare const URL_ENV = "MFEFLOW_REGISTRY_URL";
+export declare const TOKEN_ENV = "MFEFLOW_REGISTRY_TOKEN";
+type Env = Readonly<Record<string, string | undefined>>;
+/** The server address: `--registry-url`, else `MFEFLOW_REGISTRY_URL`. Undefined means static mode. */
+export declare function serverUrlOf(args: Record<string, unknown>, env: Env): string | undefined;
+/**
+ * The address as the client uses it: https, or http on a loopback host, with no login, query or
+ * fragment, and no trailing slash. A token is sent to this address, so anything else is refused.
+ */
+export declare function normalizeServerUrl(raw: string): string;
+/** The catalogue code for a server error: its own code first, then the HTTP status. Always E5xx. */
+export declare function errorCodeFor(status: number, code: string | undefined): ErrorCode;
+export interface ServerFailure {
+    code: string;
+    message: string;
+    failures?: {
+        code: string;
+        message?: string;
+        route?: string;
+    }[];
+}
+export declare class ServerError extends Error {
+    readonly status: number;
+    readonly failure: ServerFailure;
+    constructor(status: number, failure: ServerFailure);
+}
+export interface Reply {
+    status: number;
+    body: unknown;
+}
+export declare class ServerClient {
+    readonly url: string;
+    private readonly token;
+    private readonly doFetch;
+    private readonly secrets;
+    constructor(url: string, token: string | undefined, doFetch: typeof fetch, secrets: readonly string[]);
+    /** How the server is named in output: never a credential. */
+    get label(): string;
+    /** Text the server sent, with the token taken out, for anything that is printed. */
+    scrub(words: string): string;
+    /** A result document with every string scrubbed. The server's words reach the output through it. */
+    scrubAll<T>(value: T): T;
+    get hasToken(): boolean;
+    /** Throws the catalogue error for anything that is not a 2xx reply; `gates_failed` is thrown as a ServerError. */
+    get(route: string, needsToken?: boolean): Promise<unknown>;
+    post(route: string, body: unknown): Promise<unknown>;
+    /** Like `get` but a 404 is `undefined`. */
+    getOptional(route: string): Promise<unknown>;
+    index(env: string): Promise<RegistryIndex | undefined>;
+    private send;
+    /** A server error as the catalogue error that names it, with secrets scrubbed. */
+    wrap(error: ServerError): MfeflowError;
+    /** Runs a call and turns every failure into a catalogue error, except `gates_failed`, which `onGates` handles. */
+    run<T>(work: () => Promise<T>, onGates?: (failure: ServerFailure) => T): Promise<T>;
+}
+/** The client, or undefined when this run is in static mode. */
+export declare function openServer(rt: Runtime, args: Record<string, unknown>): ServerClient | undefined;
+export {};

package/dist/system.d.ts

@@ -16,5 +16,7 @@ export interface System {
     install(root: string, packageManager: string, verbose: boolean): Promise<void>;
     /** `git init` unless `root` is already inside a work tree. Returns whether it ran. */
     gitInit(root: string): Promise<boolean>;
+    /** `git init` for a repo of its own, even when `root` sits inside another work tree. Returns whether it ran. */
+    initRepo(root: string): Promise<boolean>;
 }
 export declare function createSystem(io: Pick<Io, 'stderr'>, runner?: Run): System;