@reventlessdev/reventless-local 3.0.0-alpha.220 → 3.0.0-alpha.222

package/src/LocalSeedTarget.res.mjs

@@ -0,0 +1,172 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Seed_Prompt$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Prompt.res.mjs";
+import * as Seed_Connect$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Connect.res.mjs";
+import * as LocalPlatformRegistry$ReventlessLocal from "./LocalPlatformRegistry.res.mjs";
+
+let defaultEndpoint = "http://localhost:4000/graphql";
+
+function loginFor(endpoint) {
+  let i = endpoint.indexOf("://");
+  if (i === -1) {
+    return endpoint;
+  }
+  let afterScheme = i + 3 | 0;
+  let slash = endpoint.indexOf("/", afterScheme);
+  return (
+    slash !== -1 ? endpoint.slice(0, slash) : endpoint
+  ) + "/__inmemory/login";
+}
+
+function relativeIfInside(path) {
+  let cwd = process.cwd();
+  if (path.startsWith(cwd + Nodepath.sep)) {
+    return path.slice((cwd + Nodepath.sep).length);
+  } else {
+    return path;
+  }
+}
+
+function storeLabel(store) {
+  let match = store.kind;
+  let match$1 = store.path;
+  if (match === "sqlite" && match$1 !== undefined) {
+    return `sqlite ` + relativeIfInside(match$1);
+  } else {
+    return match;
+  }
+}
+
+function shortAppName(app) {
+  let i = app.indexOf("/");
+  if (i !== -1) {
+    return app.slice(i + 1 | 0);
+  } else {
+    return app;
+  }
+}
+
+function entryLabel(e) {
+  return `:` + e.port.toString() + `  ` + shortAppName(e.app) + `  ` + storeLabel(e.store);
+}
+
+async function select() {
+  let endpoint = Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT");
+  if (endpoint !== undefined) {
+    return {
+      endpoint: endpoint,
+      loginEndpoint: Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_LOGIN_ENDPOINT"), loginFor(endpoint)),
+      origin: "EnvOverride"
+    };
+  }
+  let running = LocalPlatformRegistry$ReventlessLocal.list(undefined, undefined);
+  let preselected = Stdlib_Option.flatMap(Seed_Prompt$ReventlessSeed.envValue("SEED_PLATFORM"), v => running.find(e => e.port.toString() === v));
+  let chosen = preselected !== undefined ? preselected : (
+      running.length !== 0 ? await Seed_Prompt$ReventlessSeed.select("Platform:", running.map(e => [
+          entryLabel(e),
+          e
+        ]), "SEED_PLATFORM") : undefined
+    );
+  if (chosen !== undefined) {
+    return {
+      endpoint: chosen.endpoint,
+      loginEndpoint: chosen.loginEndpoint,
+      origin: {
+        TAG: "Running",
+        _0: chosen
+      }
+    };
+  } else {
+    return {
+      endpoint: defaultEndpoint,
+      loginEndpoint: loginFor(defaultEndpoint),
+      origin: "NoneRunning"
+    };
+  }
+}
+
+function announce(t) {
+  let entry = t.origin;
+  if (typeof entry !== "object") {
+    if (entry === "EnvOverride") {
+      console.log(`→ ` + t.endpoint + `  (REVENTLESS_GRAPHQL_ENDPOINT)`);
+      return;
+    }
+    console.log(`→ ` + t.endpoint + `  (no local platform registered here — trying the default)`);
+    return;
+  } else {
+    let entry$1 = entry._0;
+    console.log(`→ ` + entry$1.endpoint + `  ·  ` + storeLabel(entry$1.store) + `  (` + shortAppName(entry$1.app) + `)`);
+    return;
+  }
+}
+
+function storePath(t) {
+  let match = t.origin;
+  if (typeof match !== "object") {
+    if (match === "EnvOverride") {
+      return {
+        TAG: "Error",
+        _0: `REVENTLESS_GRAPHQL_ENDPOINT names ` + t.endpoint + `, which does not say which store that platform opened. Set REVENTLESS_LOCAL_BACKEND to the store file, or unset REVENTLESS_GRAPHQL_ENDPOINT to pick a running platform.`
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "no local platform is running here. Start one, or set REVENTLESS_LOCAL_BACKEND to reset a store directly."
+      };
+    }
+  }
+  let match$1 = match._0;
+  let match$2 = match$1.store;
+  let kind = match$2.kind;
+  let endpoint = match$1.endpoint;
+  switch (kind) {
+    case "memory" :
+      return {
+        TAG: "Error",
+        _0: `the platform at ` + endpoint + ` keeps its store in memory; restart it to empty it.`
+      };
+    case "postgres" :
+      return {
+        TAG: "Error",
+        _0: `the platform at ` + endpoint + ` is backed by Postgres, which keeps its event logs off this machine. Reset it against the database.`
+      };
+    case "sqlite" :
+      let path = match$2.path;
+      if (path !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: path
+        };
+      }
+      break;
+  }
+  return {
+    TAG: "Error",
+    _0: `the platform at ` + endpoint + ` reports an unknown store kind "` + kind + `".`
+  };
+}
+
+function connect() {
+  return async () => {
+    let target = await select();
+    announce(target);
+    return await Seed_Connect$ReventlessSeed.local(target.endpoint, target.loginEndpoint, undefined)();
+  };
+}
+
+export {
+  defaultEndpoint,
+  loginFor,
+  relativeIfInside,
+  storeLabel,
+  shortAppName,
+  entryLabel,
+  select,
+  announce,
+  storePath,
+  connect,
+}
+/* node:path Not a pure module */

package/src/Platform.res

@@ -1303,6 +1303,19 @@ module MakeWithConfig = (
         PlatformMCP_Server.printDiagnostics()
       }
     }
+    // Announce this platform — endpoint AND the store it opened — so `seed` and
+    // `seed:reset` can address it instead of inferring a store from their own
+    // environment. Here rather than in makePlatform because this is the one
+    // point both API modes pass through once the servers are actually up: in
+    // split mode they start just above, in unified mode makePlatform started
+    // them and this still runs before the process serves its first request.
+    let (kind, path) = BackendState.describeStore()
+    LocalPlatformRegistry.register(
+      ~port=domainPort,
+      ~endpoint=`http://localhost:${domainPort->Int.toString}/graphql`,
+      ~loginEndpoint=`http://localhost:${domainPort->Int.toString}/__inmemory/login`,
+      ~store={kind, path},
+    )
     // Fire onPlatformDeployed after all servers are started so late-deployed
     // plugins (e.g. PlatformInspector) have their handler refs populated.
     ReventlessCore.Plugin_Helpers.firePlatformDeployedHook({
@@ -2238,7 +2251,7 @@ module MakeWithConfig = (
     // extracts identity from the bearer token, same as the Domain server.
     // Without this, Platform_* queries / mutations run as `anonymous` and
     // skip the group authorization that AppSync would enforce via
-    // `@aws_auth(cognito_groups: ["Admin"])` in production. The Domain
+    // `@aws_cognito_user_pools(cognito_groups: ["Admin"])` in production. The Domain
     // server's `asInterface.start` accepts but ignores `~contextFactory`
     // because it always wires its own internal auth context.
     adminGraphQL.start(

package/src/Platform.res.mjs

@@ -69,6 +69,7 @@ import * as LocalUploadResolvers$ReventlessLocal from "./adapter/LocalUploadReso
 import * as ProjectionCheckpoint$ReventlessLocal from "./adapter/ProjectionCheckpoint.res.mjs";
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
 import * as LocalGeocodeResolvers$ReventlessLocal from "./adapter/LocalGeocodeResolvers.res.mjs";
+import * as LocalPlatformRegistry$ReventlessLocal from "./LocalPlatformRegistry.res.mjs";
 import * as UiFragments_Projection$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs";
 import * as EventLogStorage_Sqlite$ReventlessLocal from "./adapter/EventLog/EventLogStorage_Sqlite.res.mjs";
 import * as ExtensionPoint_Builder$ReventlessLocal from "./components/ExtensionPoint_Builder.res.mjs";
@@ -1105,6 +1106,11 @@ function MakeWithConfig(Config) {
         PlatformMCP_Server$ReventlessLocal.printDiagnostics();
       }
     }
+    let match = BackendState$ReventlessLocal.describeStore();
+    LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
+      kind: match[0],
+      path: match[1]
+    });
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),
@@ -2826,6 +2832,11 @@ function Make($star) {
       PlatformGraphQL_Server$ReventlessLocal.printDiagnostics();
       PlatformMCP_Server$ReventlessLocal.printDiagnostics();
     }
+    let match = BackendState$ReventlessLocal.describeStore();
+    LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
+      kind: match[0],
+      path: match[1]
+    });
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),

package/src/adapter/Auth/Auth_GraphqlContext.res

@@ -6,9 +6,15 @@
 //   - Missing header                       → `defaultUser`
 //   - Invalid bearer is rejected at HTTP level before this runs (see
 //     `DomainGraphQL_Server._dispatch`); on the admin server there is no
-//     dispatch layer, so an invalid bearer falls through to `defaultUser`
-//     too. AppSync enforces the same `@aws_auth(cognito_groups: ["Admin"])`
-//     directive at the schema layer in production.
+//     dispatch layer, so an invalid bearer reaches this as an `AuthError`.
+//     AppSync enforces the same `@aws_cognito_user_pools(cognito_groups:
+//     ["Admin"])` directive at the schema layer in production.
+//
+// The outcome is carried onto the context beside the identity, not folded into
+// it. Whether credentials verified and whether the verified caller holds a group
+// are different questions with different answers for the client — one is worth
+// retrying with new credentials, the other never is — and a group check that
+// sees only the identity cannot tell which one it is refusing.
 
 module YG = GraphqlYoga
 
@@ -32,13 +38,34 @@ let identityFromAuthResult = (result: Reventless.Identity.authResult): Reventles
   | AuthError(_) => Reventless.Identity.anonymous
   }
 
+/**
+ Whether the request presented credentials the adapter accepted.
+
+ `identityFromAuthResult` cannot answer this: it maps both `Anonymous` and
+ `AuthError` onto the same anonymous identity, so by the time a resolver holds
+ an identity, "nobody presented credentials", "the credentials did not verify"
+ and "credentials verified for someone without the group" are one shape. That
+ collapse is what made a group check unable to say which of them it was
+ refusing.
+
+ A request carrying no `Authorization` header at all counts as authenticated
+ here, because `LocalAuth.authenticate` answers it with `defaultUser` by
+ design — in-memory mode decides such a caller is somebody, and this reports
+ the decision rather than second-guessing it.
+ */
+let isAuthenticated = (result: Reventless.Identity.authResult): bool =>
+  switch result {
+  | Authenticated(_) => true
+  | Anonymous | AuthError(_) => false
+  }
+
 let buildAuthContext = async (initial: YG.initialContext): JSON.t => {
   let ctx: yogaInitialCtx = Obj.magic(initial)
   let headers = extractHeaders(ctx.request.headers)
   let requestContext: ReventlessCore.Auth_Adapter.requestContext = {headers: headers}
   let result = await LocalAuth.authenticate(requestContext)
   let identity = identityFromAuthResult(result)
-  Obj.magic({"identity": identity})
+  Obj.magic({"identity": identity, "authenticated": isAuthenticated(result)})
 }
 
 // Read the identity attached by `buildAuthContext` from the resolver context.
@@ -54,27 +81,71 @@ let extractIdentity = (ctx: JSON.t): Reventless.Identity.t =>
   | _ => Reventless.Identity.anonymous
   }
 
+// Read the authentication outcome `buildAuthContext` recorded. Falls back to
+// `false` for the same reasons `extractIdentity` falls back to anonymous, and
+// with the same conservatism: a context this cannot read is one that proves
+// nothing about the caller, and "unauthenticated" is the answer that asks them
+// to present credentials rather than telling them theirs were rejected.
+let extractAuthenticated = (ctx: JSON.t): bool =>
+  try {
+    switch (ctx->Obj.magic)["authenticated"]->Nullable.toOption {
+    | Some(authenticated) => (authenticated: bool)
+    | None => false
+    }
+  } catch {
+  | _ => false
+  }
+
 // An unauthorized caller reads the reason: `GraphQL_CallerError` explains why a
-// resolver has to construct the error rather than throw a bare one. Mirrors the
-// directive-level `@aws_auth` rejection that AppSync surfaces in production.
+// resolver has to construct the error rather than throw a bare one. The AWS
+// counterpart is the field-level refusal AppSync returns for a caller who fails
+// an `@aws_cognito_user_pools(cognito_groups: [...])` gate.
 let makeGraphqlError = GraphQL_CallerError.make
 
+/**
+ Nobody the server could identify asked for a gated field.
+
+ Keeps the code it has always carried. A client reading only `UNAUTHORIZED` is
+ one that treats it as "your credentials are not being honoured", and narrowing
+ the code to the case where that is true makes such a client correct rather than
+ breaking it.
+ */
 let unauthorizedError = (~group: string): exn =>
   makeGraphqlError(
     `Unauthorized: requires group "${group}"`,
-    {"extensions": {"code": "UNAUTHORIZED"}},
+    {"extensions": {"code": ReventlessCore.Auth_RefusalVocabulary.localIdentityCode}},
+  )
+
+/**
+ Somebody the server identified asked for a field their groups do not cover.
+
+ Separate from `unauthorizedError` because the two ask for different things and
+ a client cannot tell them apart from the refusal alone. Answering both with one
+ code left every caller to guess, and the guess that fits an expired token —
+ discard the session and ask them to sign in again — ends a working session for
+ a caller who was simply not entitled to the field. Presenting credentials again
+ cannot change this answer, which is what the distinct code says.
+ */
+let forbiddenError = (~group: string): exn =>
+  makeGraphqlError(
+    `Forbidden: requires group "${group}"`,
+    {"extensions": {"code": ReventlessCore.Auth_RefusalVocabulary.localEntitlementCode}},
   )
 
-// Wrap a resolver so it raises a GraphQL "Unauthorized" error when the
-// requesting identity lacks the required group. Mirrors AppSync's
-// `@aws_auth(cognito_groups: [...])` semantics for admin fields on the
-// in-memory adapter. Use for fields whose corresponding read-model entry
+// Wrap a resolver so it refuses a caller whose identity lacks the required
+// group. Mirrors AppSync's `@aws_cognito_user_pools(cognito_groups: [...])`
+// semantics for admin fields on the in-memory adapter. Both paths draw the same
+// two-way distinction — AppSync as HTTP 401 versus a field error, this as two
+// `extensions.code` values — and `ReventlessCore.Auth_RefusalVocabulary` is the
+// mapping between them. Use for fields whose corresponding read-model entry
 // carries `authorization: Some({group, ...})` — pass the group string here.
 let requireGroup = (~group: string, resolver: YG.resolverFn): YG.resolverFn =>
   async (root, args, ctx) => {
     let identity = extractIdentity(ctx)
     if identity.groups->Array.includes(group) {
       await resolver(root, args, ctx)
+    } else if extractAuthenticated(ctx) {
+      throw(forbiddenError(~group))
     } else {
       throw(unauthorizedError(~group))
     }

package/src/adapter/Auth/Auth_GraphqlContext.res.mjs

@@ -3,6 +3,7 @@
 import * as Graphql from "graphql";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 import * as LocalAuth$ReventlessLocal from "./LocalAuth.res.mjs";
+import * as Auth_RefusalVocabulary$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Auth/Auth_RefusalVocabulary.res.mjs";
 
 function extractHeaders(headers) {
   let acc = {};
@@ -20,14 +21,24 @@ function identityFromAuthResult(result) {
   }
 }
 
+function isAuthenticated(result) {
+  if (typeof result !== "object") {
+    return false;
+  } else {
+    return result.TAG === "Authenticated";
+  }
+}
+
 async function buildAuthContext(initial) {
   let headers = extractHeaders(initial.request.headers);
   let requestContext = {
     headers: headers
   };
   let result = await LocalAuth$ReventlessLocal.authenticate(requestContext);
+  let identity = identityFromAuthResult(result);
   return {
-    identity: identityFromAuthResult(result)
+    identity: identity,
+    authenticated: isAuthenticated(result)
   };
 }
 
@@ -44,6 +55,19 @@ function extractIdentity(ctx) {
   }
 }
 
+function extractAuthenticated(ctx) {
+  try {
+    let authenticated = ctx.authenticated;
+    if (authenticated == null) {
+      return false;
+    } else {
+      return authenticated;
+    }
+  } catch (exn) {
+    return false;
+  }
+}
+
 function makeGraphqlError(prim0, prim1) {
   return new Graphql.GraphQLError(prim0, prim1);
 }
@@ -51,7 +75,15 @@ function makeGraphqlError(prim0, prim1) {
 function unauthorizedError(group) {
   return new Graphql.GraphQLError(`Unauthorized: requires group "` + group + `"`, {
     extensions: {
-      code: "UNAUTHORIZED"
+      code: Auth_RefusalVocabulary$ReventlessCore.localIdentityCode
+    }
+  });
+}
+
+function forbiddenError(group) {
+  return new Graphql.GraphQLError(`Forbidden: requires group "` + group + `"`, {
+    extensions: {
+      code: Auth_RefusalVocabulary$ReventlessCore.localEntitlementCode
     }
   });
 }
@@ -62,6 +94,9 @@ function requireGroup(group, resolver) {
     if (identity.groups.includes(group)) {
       return await resolver(root, args, ctx);
     }
+    if (extractAuthenticated(ctx)) {
+      throw forbiddenError(group);
+    }
     throw unauthorizedError(group);
   };
 }
@@ -72,10 +107,13 @@ export {
   YG,
   extractHeaders,
   identityFromAuthResult,
+  isAuthenticated,
   buildAuthContext,
   extractIdentity,
+  extractAuthenticated,
   makeGraphqlError,
   unauthorizedError,
+  forbiddenError,
   requireGroup,
 }
 /* graphql Not a pure module */

package/src/adapter/BackendState.res

@@ -50,3 +50,18 @@ let getObjectStoreRoot = () =>
   | Sqlite({path}) if path != ":memory:" => Some(NodePath.dirname(path))
   | Sqlite(_) | Memory | Postgres(_) => None
   }
+
+// How the active backend names itself to a tool outside this process — the
+// answer `LocalPlatformRegistry` publishes so `seed` and `seed:reset` stop
+// inferring it from their own environment.
+//
+// Absolute, because the platform resolved `./.reventless/local.db` against ITS
+// cwd and a reader may not share it. `:memory:` reports "memory": there is no
+// file to open, which is the only distinction that changes what a tool can do.
+let describeStore = (): (string, option<string>) =>
+  switch current.contents {
+  | Memory => ("memory", None)
+  | Sqlite({path}) if path == ":memory:" => ("memory", None)
+  | Sqlite({path}) => ("sqlite", Some(NodePath.resolve([path])))
+  | Postgres(_) => ("postgres", None)
+  }

package/src/adapter/BackendState.res.mjs

@@ -58,6 +58,34 @@ function getObjectStoreRoot() {
   }
 }
 
+function describeStore() {
+  let match = current.contents;
+  if (typeof match !== "object") {
+    return [
+      "memory",
+      undefined
+    ];
+  }
+  if (match.TAG !== "Sqlite") {
+    return [
+      "postgres",
+      undefined
+    ];
+  }
+  let path = match.path;
+  if (path === ":memory:") {
+    return [
+      "memory",
+      undefined
+    ];
+  } else {
+    return [
+      "sqlite",
+      Nodepath.resolve(path)
+    ];
+  }
+}
+
 export {
   current,
   setMemory,
@@ -66,5 +94,6 @@ export {
   getSqliteDb,
   getPostgresPool,
   getObjectStoreRoot,
+  describeStore,
 }
 /* node:path Not a pure module */

package/src/adapter/PlatformGraphQL_Server.res

@@ -10,10 +10,15 @@
 //
 // Authorization: every query AND mutation resolver registered here is
 // wrapped with `Auth_GraphqlContext.requireGroup(~group="Admin")` so
-// non-Admin identities raise an `UNAUTHORIZED` GraphQLError before the
-// underlying resolver runs. Mirrors AppSync's
-// `@aws_auth(cognito_groups: ["Admin"])` directive that gates Platform_*
-// fields in the AWS adapter.
+// non-Admin identities are refused before the underlying resolver runs.
+// Mirrors AppSync's `@aws_cognito_user_pools(cognito_groups: ["Admin"])`
+// directive that gates Platform_* fields in the AWS adapter.
+//
+// The refusal names which kind it is: `FORBIDDEN` for a caller the server
+// identified who does not hold the group, `UNAUTHORIZED` for one it could not
+// identify at all. Every surface here is admin-gated, so a client discovering
+// through them meets this refusal as a matter of course rather than as a
+// failure, and cannot afford to read it as a session that has ended.
 //
 // Mutations are wrapped (in addition to their per-command
 // `commandAuthorization` rule inside `CommandGeneratorResolvers_GraphQL.register`)

package/src/reset/LocalSeedReset.res

@@ -476,30 +476,52 @@ let scopeOptions = (plugins: array<string>): array<(string, scope)> =>
     [("platform", Platform), ("everything", Everything)],
   )
 
-/** Runs the reset against the store the local platform would open.
-
-    `dbPath` defaults to what `REVENTLESS_LOCAL_BACKEND` selects, so the tool and
-    the platform cannot disagree about which store is "the" store. A Memory or
-    Postgres backend has no local file to reset and says so rather than appearing
-    to work. */
+/** Runs the reset against the store the selected platform actually opened.
+
+    Resolution order, and why it is this way round: the store used to be read off
+    `REVENTLESS_LOCAL_BACKEND` in THIS process, which describes no platform at
+    all. With a second platform up — the VS Code runner beside a hand-started one
+    — that emptied a database nobody was serving while reporting success, and the
+    `seed` that follows then refused because the served store was still full. So
+    the running platform is asked instead, and the variable is kept only for the
+    case discovery cannot serve: a store whose platform is down.
+
+    1. `~dbPath` — a programmatic caller has already decided.
+    2. `REVENTLESS_LOCAL_BACKEND` **set in this shell** — an explicit target.
+    3. the platform selected by {!LocalSeedTarget.select} — the normal path.
+
+    Note for callers wiring this into a package script: do NOT default the
+    variable there (`${REVENTLESS_LOCAL_BACKEND:-sqlite:./…}`). It would make
+    step 2 always fire, and that default is the very guess this replaces. */
 let run = (~dbPath: option<string>=?): unit => {
   let go = async () => {
-    let resolved = switch dbPath {
-    | Some(p) => Some(p)
-    | None =>
+    let fromBackendEnv = () =>
       switch Backend.fromEnv() {
-      | Backend.Sqlite({path}) if path != ":memory:" => Some(path)
+      | Backend.Sqlite({path}) if path != ":memory:" => Ok(path)
       | Backend.Sqlite(_) | Backend.Memory =>
-        Console.log(
-          "Nothing to reset — REVENTLESS_LOCAL_BACKEND selects an in-memory store, which a restart already empties.",
+        Error(
+          "REVENTLESS_LOCAL_BACKEND selects an in-memory store, which a restart already empties.",
         )
-        None
       | Backend.Postgres(_) =>
-        Console.log(
-          "Nothing to reset here — the Postgres backend keeps its event logs off this machine. Reset it against the database.",
+        Error(
+          "the Postgres backend keeps its event logs off this machine. Reset it against the database.",
         )
-        None
       }
+
+    let resolved = switch (dbPath, Seed.Prompt.envValue("REVENTLESS_LOCAL_BACKEND")) {
+    | (Some(p), _) => Ok(p)
+    | (None, Some(_)) => fromBackendEnv()
+    | (None, None) =>
+      let target = await LocalSeedTarget.select()
+      target->LocalSeedTarget.announce
+      target->LocalSeedTarget.storePath
+    }
+
+    let resolved = switch resolved {
+    | Ok(path) => Some(path)
+    | Error(reason) =>
+      Console.log(`Nothing to reset — ${reason}`)
+      None
     }
 
     switch resolved {