@qawolf/cli 1.29.0 → 1.31.0

package/dist/runner-sdk.js

@@ -9463,15 +9463,14 @@ var makeContractsV1 = (ids) => {
 };
 var publicContractsV1 = makeContractsV1(defaultIdSchemas);
 
-// src/core/pluralize.ts
-function pluralize(count, singular, plural = `${singular}s`) {
-  return `${String(count)} ${count === 1 ? singular : plural}`;
-}
-
 // src/core/formatSeconds.ts
 function formatSeconds(ms) {
   return `${Math.round(ms / 1000)}s`;
 }
+// src/core/pluralize.ts
+function pluralize(count, singular, plural = `${singular}s`) {
+  return `${String(count)} ${count === 1 ? singular : plural}`;
+}
 
 // src/core/messages/authErrors.ts
 var authErrorMessages = {
@@ -9486,7 +9485,14 @@ var authErrorMessages = {
     rejected401: (noun) => `QA Wolf API rejected the${noun ? ` ${noun}` : ""} request (HTTP 401). Check your API key.`,
     rejected402: (noun) => `QA Wolf API refused the${noun ? ` ${noun}` : ""} request (HTTP 402): billing prevented it.`,
     rejected403: (noun) => `QA Wolf API rejected the${noun ? ` ${noun}` : ""} request (HTTP 403). Check that your API key has access to this environment.`,
-    notFound404: (noun) => `QA Wolf API could not find ${noun ? `${noun} for that environment` : "that environment"} (HTTP 404). Check the --env value.`,
+    notFound404Environment: (noun) => `QA Wolf API could not find ${noun ? `${noun} for that environment` : "that environment"} (HTTP 404). Check the --env value.`,
+    notFound404Runner: (runnerId) => runnerId === undefined ? "That runner is not running (HTTP 404)." : `Runner ${runnerId} is not running (HTTP 404).`,
+    runnerIsGone: "It was never launched, or it has since been terminated or idled out.",
+    launchTheRunner: (runnerId) => runnerId === undefined ? "Launch one with qawolf runner launch --id <id>, or name a running one with --runner." : `Launch it with qawolf runner launch --id ${runnerId}, or send this to a different runner with --runner.`,
+    notFound404Run: (runId) => `QA Wolf has no run ${runId ?? "by that id"} on this team (HTTP 404).`,
+    runIdMayBeRunnerLocal: (runId) => `A run id printed by qawolf runner run belongs to that runner rather than to the platform, so this command cannot resolve it. Read that run with qawolf runner events run-status --run ${runId ?? "<id>"}.`,
+    notFound404Record: (noun, id) => `QA Wolf has no ${noun} ${id} (HTTP 404).`,
+    notFound404: (noun) => noun === undefined ? "QA Wolf found nothing matching the request (HTTP 404)." : `QA Wolf found nothing matching the ${noun} request (HTTP 404).`,
     failedWithStatus: (status, noun) => `QA Wolf API${noun ? ` ${noun}` : ""} request failed (HTTP ${status}).`,
     networkUnreachable: (baseUrl, noun) => `Could not reach the QA Wolf API at ${baseUrl}${noun ? ` to fetch ${noun}` : ""}. Check your network connection and QAWOLF_HOST_URL.`,
     timedOut: (timeoutMs, noun) => `The QA Wolf API${noun ? ` ${noun}` : ""} request timed out after ${formatSeconds(timeoutMs)}. The work may still be finishing on the platform.`,
@@ -9665,7 +9671,7 @@ var flowsMessages = {
     extractingBundle: "Extracting bundle",
     downloadingTeamStorageAssets: "Downloading team-storage assets",
     downloadingTeamStorageAssetsProgress: (current, total) => `Downloading team-storage assets (${String(current)}/${String(total)})`,
-    teamStorageRequiresTeamKey: "Team storage requires a team API key; organization keys are not supported here.",
+    teamStorageRequiresTeam: "Team storage needs a team. Pull an environment to name its team, choose a workspace with 'qawolf auth switch', or use a team API key.",
     summary: (result, assetsAbs) => {
       const flows = pluralize(result.flowCount, "flow");
       const envVars = result.envVarCount === 0 ? "" : ` and ${pluralize(result.envVarCount, "environment variable")}`;
@@ -9815,17 +9821,18 @@ var interactMessages = {
 };
 
 // src/core/messages/interactiveRunner/lifecycle.ts
+var pageAt = (url) => `Its runner page is at ${url}`;
 var noRunnerId = "No runner id. Pass --runner, set QAWOLF_RUNNER_ID, or run qawolf runner launch first.";
 var lifecycleMessages = {
-  alreadyRunning: (id) => `Runner ${id} was already running.`,
+  alreadyRunning: (id, url) => `Runner ${id} was already running. ${pageAt(url)}`,
   defaultNotRemembered: (id) => `Runner ${id} could not be written to .qawolf as this directory's default, so later commands will not find it on their own. Pass --runner ${id}, or set QAWOLF_RUNNER_ID=${id}.`,
   defaultNotForgotten: (id) => `Runner ${id} was terminated, but it could not be removed from .qawolf as this directory's default, so later commands will still be sent to it. Pass --runner, or launch a new runner.`,
   envRunnerIdShadowsLaunch: (launchedId, envId) => `QAWOLF_RUNNER_ID=${envId} is still set, so commands that omit --runner will keep targeting it instead of the runner just launched. Pass --runner ${launchedId} to address this one.`,
   keptAlive: (id) => `Runner ${id} is alive, and its inactivity clock has been reset.`,
   launchFailed: (id, error) => `Launching runner ${id} failed. ${error}`,
   launchLost: (id, error) => `Launching runner ${id} failed. ${error}. The request may still have reached QA Wolf and started a runner, so relaunch the same id with qawolf runner launch --id ${id} to attach to it rather than start a second one, or terminate it with qawolf runner terminate --runner ${id}.`,
-  launched: (id) => `Launched runner ${id}.`,
-  launchedForCommand: (id) => `No runner was given, so launched ${id} for this command. Its browser is fresh: nothing has been run on it and nothing is signed in. It bills until it is terminated or idles out, so terminate it with qawolf runner terminate --runner ${id} when you are done.`,
+  launched: (id, url) => `Launched runner ${id}. ${pageAt(url)}`,
+  launchedForCommand: (id, url) => `No runner was given, so launched ${id} for this command. Its browser is fresh: nothing has been run on it and nothing is signed in. It bills until it is terminated or idles out, so terminate it with qawolf runner terminate --runner ${id} when you are done. ${pageAt(url)}`,
   noRunnerIdForImport: `${noRunnerId} An install also needs a live run to go into, which a runner gets from qawolf runner run.`,
   noRunnerIdForHighlight: `${noRunnerId} Highlighting also needs a live page to draw on, which a runner gets from its first run: run a flow on it with qawolf runner run.`,
   noRunnerIdForInspect: `${noRunnerId} Inspecting also needs a page, which a runner gets from its first run: run a flow on it with qawolf runner run.`,
@@ -9836,7 +9843,14 @@ var lifecycleMessages = {
   terminated: (id) => `Terminated runner ${id}.`,
   runStopped: (id) => `Stopped the run on runner ${id}. The runner is still up, on whatever page the run reached.`,
   nothingToStop: (id) => `Runner ${id} had nothing to stop. The run had already finished, or none had been submitted.`,
-  runnerUnreachable: "The runner could not be reached. It may still be starting, or it may have terminated after inactivity. Retry, or launch it again."
+  runnerUnreachable: "The runner could not be reached. It may still be starting, or it may have terminated after inactivity. Retry, or launch it again.",
+  runnerIdCameFrom: (id, source) => ({
+    environment: `The id ${id} came from QAWOLF_RUNNER_ID.`,
+    flag: `The id ${id} came from --runner.`,
+    given: `The id ${id} is the one this call named.`,
+    launched: `Runner ${id} was launched for this command.`,
+    stored: `The id ${id} came from the runner this directory last launched, recorded in .qawolf.`
+  })[source]
 };
 
 // src/core/messages/interactiveRunner/list.ts
@@ -9935,7 +9949,9 @@ ${dir}`,
   ].join(`
 `),
   outerHopCarriedOver: (names) => `Carried over ${pluralize(names.length, "undeclared package")} from the project node_modules: ${listNames(names)}. Declare them in package.json "dependencies".`,
-  moduleNotFoundHint: (pkg, projectDir) => projectDir === undefined ? `Hint: '${pkg}' could not be resolved. Run from within your flows project so its dependencies can be found.` : `Hint: '${pkg}' could not be resolved. Ensure it is declared in ${projectDir}/package.json "dependencies" and run npm install in that project.`
+  moduleNotFoundHint: (pkg, projectDir) => projectDir === undefined ? `Hint: '${pkg}' could not be resolved. Run from within your flows project so its dependencies can be found.` : `Hint: '${pkg}' could not be resolved. Ensure it is declared in ${projectDir}/package.json "dependencies" and run npm install in that project.`,
+  tsconfigUnparsedNotice: (projectDir) => `Not resolving path aliases: ${projectDir}/tsconfig.json is not valid JSON. Comments and trailing commas are not supported, here or on the platform. Remove them so "compilerOptions.paths" can be read.`,
+  pathAliasNotFoundHint: (specifier, projectDir) => projectDir === undefined ? `Hint: '${specifier}' looks like a tsconfig path alias. Run from within your flows project so its tsconfig.json can be found.` : `Hint: '${specifier}' looks like a tsconfig path alias. Ensure "compilerOptions.paths" in ${projectDir}/tsconfig.json maps it to a file that exists.`
 };
 // src/shell/exit.ts
 var exitCodes = {
@@ -9946,7 +9962,8 @@ var exitCodes = {
   network: 4,
   config: 5,
   timeout: 6,
-  payment: 7
+  payment: 7,
+  notFound: 8
 };
 
 // src/core/sleep.ts
@@ -10017,7 +10034,8 @@ async function listRunners(ctx, deps) {
     id: runner.id,
     isDefault: runner.id === defaultRunnerId,
     launchedHere: heldIds.has(runner.id),
-    runnerName: runner.runnerName
+    runnerName: runner.runnerName,
+    url: runner.url
   }));
   return {
     items: items.sort((left, right) => rank(left) - rank(right) || left.id.localeCompare(right.id)),
@@ -10893,41 +10911,70 @@ function isPathAlias(importPath, paths) {
 // src/core/interactiveRunner/resolveImportPath.ts
 import { dirname as dirname2, join, normalize as normalize2 } from "node:path/posix";
 
-// src/core/interactiveRunner/tsconfigPaths.ts
+// src/core/aliasImports/tsconfigPaths.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function isTsconfigPaths(value) {
   return isRecord(value) && Object.values(value).every((targets) => Array.isArray(targets) && targets.every((target) => typeof target === "string"));
 }
-function parseTsconfigPaths(tsconfigContent) {
+function parseTsconfigContent(tsconfigContent) {
   let parsed;
   try {
     parsed = JSON.parse(tsconfigContent);
   } catch {
-    return;
+    return { type: "unparseable" };
   }
   if (!isRecord(parsed))
-    return;
+    return { paths: undefined, type: "parsed" };
   const compilerOptions = parsed["compilerOptions"];
   if (!isRecord(compilerOptions))
-    return;
+    return { paths: undefined, type: "parsed" };
   const paths = compilerOptions["paths"];
-  return isTsconfigPaths(paths) ? paths : undefined;
+  return {
+    paths: isTsconfigPaths(paths) ? paths : undefined,
+    type: "parsed"
+  };
+}
+function parseTsconfigPaths(tsconfigContent) {
+  const parsed = parseTsconfigContent(tsconfigContent);
+  return parsed.type === "parsed" ? parsed.paths : undefined;
+}
+function parseWildcardPattern(pattern) {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard === -1 || wildcard !== pattern.lastIndexOf("*"))
+    return;
+  return {
+    prefix: pattern.slice(0, wildcard),
+    suffix: pattern.slice(wildcard + 1)
+  };
+}
+function matchesWildcard(importPath, { prefix, suffix }) {
+  return importPath.length >= prefix.length + suffix.length && importPath.startsWith(prefix) && importPath.endsWith(suffix);
+}
+function longestPrefixMatch(importPath, paths) {
+  return Object.entries(paths).flatMap(([pattern, targets]) => {
+    const parsed = parseWildcardPattern(pattern);
+    if (parsed === undefined || !matchesWildcard(importPath, parsed)) {
+      return [];
+    }
+    return [{ pattern: parsed, targets }];
+  }).reduce((best, candidate) => best === undefined || candidate.pattern.prefix.length > best.pattern.prefix.length ? candidate : best, undefined);
 }
 function resolvePathAlias(importPath, paths) {
   if (paths === undefined)
     return;
-  for (const [pattern, targets] of Object.entries(paths)) {
-    const prefix = pattern.replace("*", "");
-    if (!importPath.startsWith(prefix))
-      continue;
-    const [target] = targets;
-    if (target !== undefined) {
-      return target.replace("*", importPath.slice(prefix.length));
-    }
-  }
-  return;
+  const [exactTarget] = paths[importPath] ?? [];
+  if (exactTarget !== undefined)
+    return exactTarget;
+  const match = longestPrefixMatch(importPath, paths);
+  if (match === undefined)
+    return;
+  const [target] = match.targets;
+  if (target === undefined)
+    return;
+  const substituted = importPath.slice(match.pattern.prefix.length, importPath.length - match.pattern.suffix.length);
+  return target.replace("*", substituted);
 }
 
 // src/core/interactiveRunner/resolveImportPath.ts
@@ -11057,6 +11104,37 @@ import { join as join3 } from "node:path";
 var qawolfDir = ".qawolf";
 var defaultOutputDir = `${qawolfDir}/output`;
 
+// src/core/parseJson.ts
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+
+// src/shell/jsonFile.ts
+var pendingWrites = 0;
+async function readJsonFile(fs, path, schema) {
+  const contents = await fs.readFile(path).catch(() => {
+    return;
+  });
+  if (contents === undefined)
+    return;
+  const parsed = schema.safeParse(parseJson(contents));
+  return parsed.success ? parsed.data : undefined;
+}
+async function writeJsonFileAtomically(fs, path, value) {
+  const pendingPath = `${path}.${String(process.pid)}.${String(++pendingWrites)}.tmp`;
+  try {
+    await fs.writeFile(pendingPath, `${JSON.stringify(value, undefined, 2)}
+`);
+    await fs.rename(pendingPath, path);
+  } finally {
+    await fs.rm(pendingPath, { force: true }).catch(() => {});
+  }
+}
+
 // src/shell/interactiveRunner/runFilesManifest.ts
 var manifestFileName = "runner-files.json";
 var manifestSchema = object({
@@ -11067,33 +11145,14 @@ var manifestSchema = object({
 function makeRunFilesManifestStore(options) {
   const directory = join3(options.cwd, qawolfDir);
   const path = join3(directory, manifestFileName);
-  let pendingWrites = 0;
   return {
-    async read() {
-      const contents = await options.fs.readFile(path).catch(() => {
-        return;
-      });
-      if (contents === undefined)
-        return;
-      const parsed = manifestSchema.safeParse(parseJson(contents));
-      return parsed.success ? parsed.data : undefined;
-    },
+    read: () => readJsonFile(options.fs, path, manifestSchema),
     async write(manifest) {
-      const pendingPath = `${path}.${String(process.pid)}.${String(++pendingWrites)}.tmp`;
       await options.fs.mkdir(directory, { recursive: true });
-      await options.fs.writeFile(pendingPath, `${JSON.stringify(manifest, undefined, 2)}
-`);
-      await options.fs.rename(pendingPath, path);
+      await writeJsonFileAtomically(options.fs, path, manifest);
     }
   };
 }
-function parseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return;
-  }
-}
 
 // src/shell/interactiveRunner/runnerStore.ts
 import { join as join4 } from "node:path";
@@ -11106,34 +11165,15 @@ var storedRunnerSchema = object({
 var storeSchema = object({
   defaultRunnerId: string2().optional()
 });
-function parseJson2(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return;
-  }
-}
-var pendingWrites = 0;
 function makeRunnerStore(options) {
   const directory = join4(options.cwd, qawolfDir);
   const path = join4(directory, storeFileName);
   const runnersDir = join4(directory, runnersDirName);
-  const nextPendingPath = (target) => `${target}.${process.pid}.${++pendingWrites}.tmp`;
   const runnerPath = (runnerId) => join4(runnersDir, `${encodeURIComponent(runnerId)}.json`);
-  const writeAtomically = async (target, contents) => {
-    const pendingPath = nextPendingPath(target);
-    await options.fs.writeFile(pendingPath, `${JSON.stringify(contents, undefined, 2)}
-`);
-    await options.fs.rename(pendingPath, target);
-  };
+  const writeAtomically = (target, contents) => writeJsonFileAtomically(options.fs, target, contents);
   const readDefaultRunnerId = async () => {
-    const contents = await options.fs.readFile(path).catch(() => {
-      return;
-    });
-    if (contents === undefined)
-      return;
-    const parsed = storeSchema.safeParse(parseJson2(contents));
-    return parsed.success ? parsed.data.defaultRunnerId : undefined;
+    const stored = await readJsonFile(options.fs, path, storeSchema);
+    return stored?.defaultRunnerId;
   };
   const writeDefaultRunnerId = async (runnerId) => {
     await options.fs.mkdir(directory, { recursive: true });
@@ -11155,15 +11195,7 @@ function makeRunnerStore(options) {
     },
     readDefaultRunnerId,
     async readRunners() {
-      const runners = await Promise.all((await readRunnerFileNames()).map(async (name) => {
-        const contents = await options.fs.readFile(join4(runnersDir, name)).catch(() => {
-          return;
-        });
-        if (contents === undefined)
-          return;
-        const parsed = storedRunnerSchema.safeParse(parseJson2(contents));
-        return parsed.success ? parsed.data : undefined;
-      }));
+      const runners = await Promise.all((await readRunnerFileNames()).map((name) => readJsonFile(options.fs, join4(runnersDir, name), storedRunnerSchema)));
       return runners.filter((runner) => !!runner).sort((left, right) => left.id.localeCompare(right.id));
     },
     async rememberLaunch(runner) {
@@ -11181,7 +11213,7 @@ function makeRunnerStore(options) {
         });
         if (contents === undefined)
           return;
-        if (storedRunnerSchema.safeParse(parseJson2(contents)).success)
+        if (storedRunnerSchema.safeParse(parseJson(contents)).success)
           return;
         await options.fs.rm(runnerFile, { force: true });
       }));
@@ -11380,6 +11412,47 @@ function makeDefaultFs() {
   };
 }
 
+// src/core/publicApi/notFoundSubject.ts
+var runnerRoutesThatNameNoRunner = new Set([
+  "runner.launch",
+  "runner.list"
+]);
+var runRoutesThatResolveOneRun = new Set([
+  "run.diagnose",
+  "run.get",
+  "run.reattempt",
+  "run.stop"
+]);
+var recordFieldNouns = [
+  ["sessionId", "session"],
+  ["triggerId", "trigger"],
+  ["issueId", "issue"],
+  ["flowId", "flow"],
+  ["filePath", "file"]
+];
+function field(input, name) {
+  if (typeof input !== "object" || input === null)
+    return;
+  const value = input[name];
+  return typeof value === "string" ? value : undefined;
+}
+function notFoundSubject(contractName, input) {
+  if (contractName.startsWith("runner.") && !runnerRoutesThatNameNoRunner.has(contractName)) {
+    return { kind: "runner", runnerId: field(input, "id") };
+  }
+  if (runRoutesThatResolveOneRun.has(contractName)) {
+    return { kind: "run", runId: field(input, "runId") };
+  }
+  for (const [name, noun] of recordFieldNouns) {
+    const id = field(input, name);
+    if (id !== undefined)
+      return { id, kind: "record", noun };
+  }
+  if (field(input, "environmentId") !== undefined)
+    return { kind: "environment" };
+  return { kind: "other" };
+}
+
 // src/core/publicApi/flagKind.ts
 function flagKind(schema) {
   if (schema.type === "string")
@@ -11550,6 +11623,42 @@ function applyWorkspaceId(inputSchema, input, workspaceId) {
   return { ...input, workspaceId };
 }
 
+// src/shell/platform/describeNotFound.ts
+var m = authMessages.errors.request;
+var saysNothingMore = (reason) => /^(\w+ )*not ?found\.?$/i.test(reason.trim());
+function describeNotFound(subject, noun, reason) {
+  const explained = reason && !saysNothingMore(reason) ? reason : undefined;
+  const say = (own) => {
+    const body = [explained ? undefined : own.guess, own.guidance].filter((line) => line);
+    return {
+      error: explained ? `${explained} (HTTP 404)` : own.statement,
+      exitCode: exitCodes.notFound,
+      ...body.length > 0 ? { errorBody: body.join(`
+`) } : {}
+    };
+  };
+  switch (subject?.kind) {
+    case "runner":
+      return say({
+        guess: m.runnerIsGone,
+        guidance: m.launchTheRunner(subject.runnerId),
+        statement: m.notFound404Runner(subject.runnerId)
+      });
+    case "run":
+      return say({
+        guess: m.runIdMayBeRunnerLocal(subject.runId),
+        statement: m.notFound404Run(subject.runId)
+      });
+    case "record":
+      return say({ statement: m.notFound404Record(subject.noun, subject.id) });
+    case "other":
+      return say({ statement: m.notFound404(noun) });
+    case "environment":
+    case undefined:
+      return say({ statement: m.notFound404Environment(noun) });
+  }
+}
+
 // src/shell/platform/parseErrorBody.ts
 var defaultMaxLength = 1024;
 function asRecord(value) {
@@ -11592,69 +11701,69 @@ function clip(message, maxLength) {
 }
 
 // src/shell/platform/describeErrors.ts
-var m = authMessages.errors;
+var m2 = authMessages.errors;
 var inlineReasonMaxLength = 200;
 function describeIdentityError(err) {
   if (err.kind === "http") {
     if (err.status === 401 || err.status === 403) {
       return {
-        error: m.identity.invalidOrUnauthorized,
+        error: m2.identity.invalidOrUnauthorized,
         ...err.status === 401 ? { exitCode: exitCodes.auth } : {}
       };
     }
     return {
-      error: m.identity.couldNotVerify(parseErrorBody(err.body, inlineReasonMaxLength), err.status)
+      error: m2.identity.couldNotVerify(parseErrorBody(err.body, inlineReasonMaxLength), err.status)
     };
   }
   if (err.kind === "network") {
-    return { error: m.identity.couldNotVerifyNetwork(err.cause.message) };
+    return { error: m2.identity.couldNotVerifyNetwork(err.cause.message) };
   }
   if (err.kind === "timeout") {
-    return { error: m.identity.timedOut(err.timeoutMs) };
+    return { error: m2.identity.timedOut(err.timeoutMs) };
   }
-  return { error: m.identity.unexpectedFormat };
+  return { error: m2.identity.unexpectedFormat };
 }
-function describeRequestError(err, baseUrl, noun) {
+function describeRequestError(err, baseUrl, noun, notFound) {
   if (err.kind === "http") {
     const reason = parseErrorBody(err.body);
     const body = reason ? { errorBody: reason } : {};
     if (err.status === 401)
       return {
-        error: m.request.rejected401(noun),
+        error: m2.request.rejected401(noun),
         exitCode: exitCodes.auth,
         ...body
       };
     if (err.status === 402)
       return {
-        error: m.request.rejected402(noun),
+        error: m2.request.rejected402(noun),
         exitCode: exitCodes.payment,
         ...body
       };
     if (err.status === 403)
-      return { error: m.request.rejected403(noun), ...body };
+      return { error: m2.request.rejected403(noun), ...body };
     if (err.status === 404)
-      return { error: m.request.notFound404(noun), ...body };
-    return { error: m.request.failedWithStatus(err.status, noun), ...body };
+      return describeNotFound(notFound, noun, reason);
+    return { error: m2.request.failedWithStatus(err.status, noun), ...body };
   }
   if (err.kind === "network") {
-    return { error: m.request.networkUnreachable(baseUrl, noun) };
+    return { error: m2.request.networkUnreachable(baseUrl, noun) };
   }
   if (err.kind === "timeout") {
-    return { error: m.request.timedOut(err.timeoutMs, noun) };
+    return { error: m2.request.timedOut(err.timeoutMs, noun) };
   }
-  return { error: m.request.unexpectedResponse(noun) };
+  return { error: m2.request.unexpectedResponse(noun) };
 }
 function describeBundleDownloadError(err) {
   if (err.kind === "http") {
     if (err.status === 401 || err.status === 403)
-      return m.bundle.linkExpired;
-    return m.bundle.failedWithStatus(err.status);
+      return m2.bundle.linkExpired;
+    return m2.bundle.failedWithStatus(err.status);
   }
   if (err.kind === "network")
-    return m.bundle.networkUnreachable;
+    return m2.bundle.networkUnreachable;
   if (err.kind === "timeout")
-    return m.bundle.timedOut(err.timeoutMs);
-  return m.bundle.malformed;
+    return m2.bundle.timedOut(err.timeoutMs);
+  return m2.bundle.malformed;
 }
 function describeTeamStorageDownloadError(path, err) {
   if (err.kind === "http") {
@@ -11681,12 +11790,16 @@ function callPublicApi(trpc, contract, input, options) {
   return trpc.mutation(path, input, contract.output, options);
 }
 function makeCallPublicApiMethod(trpc, deps, readBackoffMs) {
-  return async (contract, input, options) => requestWithRetry({
-    call: () => callPublicApi(trpc, contract, applyWorkspaceId(contract.input, input, deps.workspaceId), options),
-    backoffMs: contract.kind === "read" ? readBackoffMs : [],
-    describe: (err) => describeRequestError(err, deps.baseUrl, contract.name),
-    sleep: deps.sleep
-  });
+  return async (contract, input, options) => {
+    const sent = applyWorkspaceId(contract.input, input, deps.workspaceId);
+    const subject = notFoundSubject(contract.name, sent);
+    return requestWithRetry({
+      call: () => callPublicApi(trpc, contract, sent, options),
+      backoffMs: contract.kind === "read" ? readBackoffMs : [],
+      describe: (err) => describeRequestError(err, deps.baseUrl, contract.name, subject),
+      sleep: deps.sleep
+    });
+  };
 }
 
 // node_modules/superjson/dist/double-indexed-kv.js
@@ -12800,7 +12913,8 @@ var environmentListItemSchema = object({
   slug: string2()
 });
 var environmentWithVariablesResponseSchema = object({
-  environmentVariables: record(string2(), string2())
+  environmentVariables: record(string2(), string2()),
+  teamId: string2()
 });
 var flowListItemSchema = object({
   flowId: string2(),
@@ -13077,7 +13191,10 @@ async function writeTeamStorageAssets(args, deps) {
 
 // src/shell/platform/teamStorageMethods.ts
 function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
-  async function list() {
+  async function list(opts) {
+    if (opts?.teamId !== undefined) {
+      return listTeamStorageFiles(trpc, { teamId: opts.teamId }, deps);
+    }
     if (deps.workspaceId !== undefined) {
       return listTeamStorageFiles(trpc, { teamId: deps.workspaceId }, deps);
     }
@@ -13087,7 +13204,7 @@ function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
     if (!("team" in identity.value)) {
       return {
         ok: false,
-        error: flowsMessages.pull.teamStorageRequiresTeamKey
+        error: flowsMessages.pull.teamStorageRequiresTeam
       };
     }
     return listTeamStorageFiles(trpc, { teamId: identity.value.team.id }, deps);
@@ -13095,7 +13212,7 @@ function createTeamStorageMethods(trpc, deps, fs, getIdentity) {
   return {
     listTeamStorageFiles: list,
     async syncTeamStorageAssets(assetsAbs, opts) {
-      const files = await list();
+      const files = await list({ teamId: opts?.teamId });
       if (!files.ok)
         return files;
       return downloadTeamStorageAssets({ assetsAbs, files: files.value }, { fetch: deps.fetch, fs, onProgress: opts?.onProgress });
@@ -13125,16 +13242,14 @@ function createPlatformClient(apiKey, deps) {
     ...createTeamStorageMethods(trpc, deps, fs, identityMethods.getIdentity),
     getFlowsBundleUrl: getFlowsBundleUrlImpl,
     callPublicApi: makeCallPublicApiMethod(trpc, deps, requestBackoffMs2),
-    async getEnvVars(envId) {
+    async getEnvironmentWithVariables(envId) {
       const result = await requestWithRetry({
         call: () => trpc.query("environment.getEnvironmentWithVariables", { id: envId }, environmentWithVariablesResponseSchema),
         backoffMs: requestBackoffMs2,
         describe: (err) => describeRequestError(err, deps.baseUrl, "env-vars"),
         sleep: deps.sleep
       });
-      if (!result.ok)
-        return result;
-      return { ok: true, value: result.value.environmentVariables };
+      return result;
     },
     async downloadBundle(envId) {
       const urlResult = await getFlowsBundleUrlImpl(envId);
@@ -13173,25 +13288,36 @@ function createSdkContext(options) {
   };
 }
 
+// src/domains/interactiveRunner/runnerRequestFailure.ts
+function runnerRequestFailure(failure, runner) {
+  const fields = failureFields(failure);
+  if (failure.exitCode !== exitCodes.notFound) {
+    return { ...fields, exitCode: failure.exitCode ?? exitCodes.network };
+  }
+  const cameFrom = interactiveRunnerMessages.runnerIdCameFrom(runner.runnerId, runner.source);
+  return {
+    ...fields,
+    errorBody: fields.errorBody ? `${fields.errorBody}
+${cameFrom}` : cameFrom,
+    exitCode: exitCodes.notFound
+  };
+}
+
 // src/domains/interactiveRunner/readJournal.ts
 var unreachableFailure = {
   error: interactiveRunnerMessages.runnerUnreachable,
   exitCode: exitCodes.network
 };
-async function readJournal(ctx, runnerId, request) {
+async function readJournal(ctx, runner, request) {
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.readJournal, {
-    id: runnerId,
+    id: runner.runnerId,
     stream: request.stream,
     ...request.runId === undefined ? {} : { runId: request.runId },
     ...request.sinceSequence === undefined ? {} : { sinceSequence: request.sinceSequence },
     ...request.tail === undefined ? {} : { tail: request.tail }
   }, runnerCallOptions);
   if (!result.ok) {
-    return {
-      ...failureFields(result),
-      exitCode: exitCodes.network,
-      type: "failed"
-    };
+    return { ...runnerRequestFailure(result, runner), type: "failed" };
   }
   if (result.value.outcome === "failure") {
     result.value.failureReason;
@@ -13200,9 +13326,24 @@ async function readJournal(ctx, runnerId, request) {
   return { type: "read", value: result.value };
 }
 
+// src/runnerSdk/givenRunner.ts
+var givenRunner = (runnerId) => ({
+  runnerId,
+  source: "given"
+});
+
+// src/runnerSdk/toSdkFailure.ts
+function toSdkFailure(failure) {
+  return {
+    error: failure.error,
+    ...failure.errorBody ? { errorDetail: failure.errorBody } : {},
+    ok: false
+  };
+}
+
 // src/runnerSdk/toSdkResult.ts
 function toSdkResult(result) {
-  return result.ok ? { ok: true, value: result.value } : { error: result.error, ok: false };
+  return result.ok ? { ok: true, value: result.value } : toSdkFailure(result);
 }
 
 // src/runnerSdk/lifecycleVerbs.ts
@@ -13213,16 +13354,13 @@ function createLifecycleVerbs({ platformClient }) {
     async keepalive({
       runnerId
     }) {
-      const read = await readJournal(ctx, runnerId, {
+      const read = await readJournal(ctx, givenRunner(runnerId), {
         stream: "run-status",
         tail: 1
       });
       if (read.type === "read")
         return { ok: true, value: { id: runnerId } };
-      return {
-        error: read.type === "unreachable" ? "The runner could not be reached." : read.error,
-        ok: false
-      };
+      return read.type === "unreachable" ? { error: "The runner could not be reached.", ok: false } : toSdkFailure(read);
     },
     async launch({
       id,
@@ -13704,10 +13842,7 @@ async function sendRunFlowRequest(ctx, options, delta) {
   }, runnerCallOptions);
   if (!result.ok) {
     return {
-      failure: {
-        ...failureFields(result),
-        exitCode: result.exitCode ?? exitCodes.network
-      },
+      failure: runnerRequestFailure(result, options.resolved),
       type: "failed"
     };
   }
@@ -13796,17 +13931,14 @@ function createRunVerbs({ deps, platformClient }) {
       stream,
       window
     }) {
-      const read = await readJournal(ctx, runnerId, {
+      const read = await readJournal(ctx, givenRunner(runnerId), {
         stream,
         ...runFilter === "all-runs" ? {} : { runId: runFilter.runId },
         ...window === "newest" ? {} : ("tail" in window) ? { tail: window.tail } : { sinceSequence: window.sinceSequence }
       });
       if (read.type === "read")
         return { ok: true, value: read.value };
-      return {
-        error: read.type === "unreachable" ? "The runner could not be reached." : read.error,
-        ok: false
-      };
+      return read.type === "unreachable" ? { error: "The runner could not be reached.", ok: false } : toSdkFailure(read);
     },
     async run({
       entryPointPath,
@@ -13828,11 +13960,11 @@ function createRunVerbs({ deps, platformClient }) {
         environment: prepared.environment,
         environmentId: prepared.environmentId,
         files: prepared.files,
-        resolved: { runnerId, type: "resolved" },
+        resolved: { ...givenRunner(runnerId), type: "resolved" },
         selection: prepared.selection
       }, deps);
       if (!submitted.ok)
-        return { error: submitted.error, ok: false };
+        return toSdkFailure(submitted);
       return {
         ok: true,
         value: {
@@ -13863,4 +13995,4 @@ export {
   createRunnerSdk
 };
 
-//# debugId=A460E98091C1C6D964756E2164756E21
+//# debugId=C50E262AB8A599ED64756E2164756E21