@junoflow/cli 0.3.0 → 0.9.0

package/src/commands/deploy.js

@@ -1,91 +1,135 @@
-import { watch } from 'node:fs';
 import { join } from 'node:path';
 
-import { JunoClient } from '../api.js';
+import { clientName, JunoClient } from '../api.js';
+import { printDiagnosticsJSON, printJSON } from '../diagnostics.js';
 import { DiagnosticsError } from '../errors.js';
-import { readManifestRaw, readProject, writeTypes } from '../project.js';
+import {
+  readManifestRaw,
+  readProject,
+  updateIntegrationPackage,
+  writeTypes,
+} from '../project.js';
 import { resolveTarget } from '../target.js';
 import { stampTypeFiles } from '../stamp.js';
-import { formatDiagnostics } from '../diagnostics.js';
-import { pickTypeFiles } from './types.js';
+import { pickTypeFiles } from './gen-types.js';
+import { deployOnChange } from '../watch.js';
 
-/** How long to wait for edits to settle before redeploying. */
-const WATCH_DEBOUNCE_MS = 200;
+export const DEPLOY_USAGE =
+  'juno integration deploy [--watch] [--force] [--id <id>] [--json]';
 
 /**
- * `juno deploy [--watch]` — upload the working copy, verify, activate.
+ * `juno integration deploy [--watch]` — upload the working copy, verify, activate.
+ *
+ * It sends `juno.base_version`, so an install changed elsewhere since this
+ * copy was pulled is a 409 (exit 4) rather than a silent overwrite; --force
+ * sends none and replaces whatever is active. A successful deploy writes the
+ * new version back as the base. --id naming another install sends no base and
+ * writes none back: the base belongs to the install the manifest names (see
+ * baseFor).
  *
  * The response carries the regenerated types, so a deploy keeps the committed
  * types/ honest without a second round trip that could answer for a different
  * manifest.
+ *
+ * --json prints the route's body (or the 422's diagnostics) on stdout instead
+ * of the summary line, for CI.
  */
 export async function deploy(argv, io) {
-  const target = await resolveTarget({ url: argv.url, cwd: io.cwd });
-  const client = argv.client ?? new JunoClient(target);
+  const target = await resolveTarget({
+    url: argv.url,
+    cwd: io.cwd,
+    env: io.env,
+  });
+  const client =
+    argv.client ?? new JunoClient(target, { client: clientName(io.env) });
 
   if (!argv.watch) {
-    await deployOnce(client, argv, io, target);
+    try {
+      await deployOnce(client, argv, io, target);
+    } catch (err) {
+      if (argv.json && err instanceof DiagnosticsError) {
+        return printDiagnosticsJSON(err, io);
+      }
+      throw err;
+    }
     return 0;
   }
   return watchAndDeploy(client, argv, io, target);
 }
 
 async function deployOnce(client, argv, io, target) {
+  // Re-read on every deploy, base included, so the watch loop is checked
+  // against its own previous deploy rather than refused by it.
   const project = await readProject(io.cwd);
-  const result = await client.ingest(project, { name: argv.name });
+  const result = await client.ingest(project, {
+    id: argv.id,
+    baseVersion: argv.force ? undefined : baseFor(project, argv, io),
+  });
   // Stamped against the manifest this deploy was built from, so the watch loop
-  // leaves a tree that `juno verify-types` accepts.
+  // leaves a tree that `juno integration verify-types` accepts.
   const written = await writeTypes(
     stampTypeFiles(pickTypeFiles(result.types), await readManifestRaw(io.cwd)),
     io.cwd
   );
+  if (
+    !deploysElsewhere(project, argv) &&
+    project.baseVersion !== result.version
+  ) {
+    const wrote = await updateIntegrationPackage(
+      io.cwd,
+      (pkg) => {
+        pkg.juno.base_version = result.version;
+      },
+      io
+    );
+    if (wrote) written.push('package.json');
+  }
+  if (argv.json) {
+    printJSON(result, io);
+    return result;
+  }
   for (const warning of result.warnings ?? []) io.warn(`warning: ${warning}`);
   io.log(
-    `deployed ${result.name} v${result.version} to ${target} (${written.join(', ')})`
+    `deployed ${result.id} v${result.version} to ${target} (${written.sort().join(', ')})`
   );
   return result;
 }
 
 /**
- * Watch mode is the loop the whole design is for: edit the manifest, the types
- * regenerate, and the editor red-squiggles the method you have not written yet.
- * A failed deploy prints and keeps watching — the next save is the retry.
+ * baseFor is the base a check or deploy sends: the copy's
+ * `juno.base_version`, unless --id names an install other than the
+ * manifest's. That install's versions are ones this copy has never seen, so
+ * there is nothing to compare against, and the warning says the check is off
+ * rather than letting it pass silently. A first deploy to a new id has nothing
+ * to be stale against either, so this needs no --force.
  */
-async function watchAndDeploy(client, argv, io, target) {
-  io.log(`watching ${io.cwd} — deploying to ${target}`);
-  await runWatchIteration(client, argv, io, target);
-
-  let timer = null;
-  const schedule = () => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      void runWatchIteration(client, argv, io, target);
-    }, WATCH_DEBOUNCE_MS);
-  };
+export function baseFor(project, argv, io) {
+  if (deploysElsewhere(project, argv)) {
+    io.warn(
+      `no stale-base check: deploying to ${argv.id}, not ${project.manifest?.id}`
+    );
+    return undefined;
+  }
+  return project.baseVersion;
+}
 
-  const watchers = [
-    watch(join(io.cwd, 'src'), { recursive: true }, schedule),
-    watch(join(io.cwd, 'manifest.json'), schedule),
-  ];
-  // Resolves only on SIGINT: watch mode ends when the author ends it.
-  await new Promise((resolve) => {
-    process.once('SIGINT', () => {
-      for (const w of watchers) w.close();
-      resolve();
-    });
-  });
-  return 0;
+/** Whether --id names an install other than the one the manifest does. */
+function deploysElsewhere(project, argv) {
+  return argv.id !== undefined && argv.id !== project.manifest?.id;
 }
 
-async function runWatchIteration(client, argv, io, target) {
-  try {
-    await deployOnce(client, argv, io, target);
-  } catch (err) {
-    if (err instanceof DiagnosticsError) {
-      io.error(formatDiagnostics(err.diagnostics));
-    } else {
-      io.error(err.message);
-    }
-  }
+/**
+ * Watch mode is the loop the whole design is for: edit the manifest, the types
+ * regenerate, and the editor red-squiggles the method you have not written yet.
+ */
+function watchAndDeploy(client, argv, io, target) {
+  return deployOnChange({
+    io,
+    target,
+    paths: [
+      { path: join(io.cwd, 'src'), recursive: true },
+      { path: join(io.cwd, 'manifest.json') },
+    ],
+    once: () => deployOnce(client, argv, io, target),
+  });
 }

package/src/commands/flow-check.js

@@ -0,0 +1,75 @@
+import { connect } from '../api.js';
+import { DiagnosticsError } from '../errors.js';
+import { readFlowProject } from '../flow-project.js';
+import { runLocalChecks } from './check.js';
+import { printDiagnosticsJSON, printJSON } from '../diagnostics.js';
+import { printWarnings } from './flow-deploy.js';
+
+export const FLOW_CHECK_USAGE = 'juno flow check [--skip-local] [--json]';
+
+/**
+ * `juno flow check` — local tsc and eslint, then a dry-run ingest: the same
+ * verification deploy runs (and the base_version check, so a stale copy is
+ * reported here before deploy hits it), with nothing committed. Safe to point
+ * at a production instance.
+ */
+export async function flowCheck(argv, io) {
+  const project = await readFlowProject(io.cwd);
+  const failed = !argv['skip-local'] && (await runLocalChecks(argv, io));
+  warnOnDependencyDrift(project, io);
+
+  const { target, client } = await connect(argv, io);
+  let result;
+  try {
+    result = await client.ingestFlow(
+      {
+        flowId: project.flowId,
+        manifest: project.manifest,
+        files: project.files,
+        baseVersion: project.baseVersion,
+      },
+      { dryRun: true }
+    );
+  } catch (err) {
+    if (argv.json && err instanceof DiagnosticsError) {
+      return printDiagnosticsJSON(err, io);
+    }
+    throw err;
+  }
+
+  if (argv.json) {
+    printJSON(result, io);
+  } else {
+    printWarnings(result.warnings, io);
+    io.log(`${result.flow_id}: manifest and src/ verified against ${target}`);
+  }
+  return failed ? 1 : 0;
+}
+
+/**
+ * manifest.dependencies is what verify installs; package.json's dependencies
+ * are only there so a local `npm install` gives tsc the same modules. When the
+ * two disagree, local and server-side checks are checking different programs,
+ * so say which packages differ — and that the manifest is the one to edit.
+ */
+export function warnOnDependencyDrift(project, io) {
+  const declared = project.manifest?.dependencies ?? {};
+  const installed = project.packageJSON?.dependencies ?? {};
+  const names = [
+    ...new Set([...Object.keys(declared), ...Object.keys(installed)]),
+  ].sort();
+  const diffs = [];
+  for (const name of names) {
+    const a = declared[name];
+    const b = installed[name];
+    if (a === b) continue;
+    if (b === undefined) diffs.push(`${name} (only in manifest.json)`);
+    else if (a === undefined) diffs.push(`${name} (only in package.json)`);
+    else diffs.push(`${name} (manifest.json ${a}, package.json ${b})`);
+  }
+  if (diffs.length === 0) return;
+  io.warn(
+    `warning: manifest.json and package.json list different dependencies: ${diffs.join(', ')}. ` +
+      "Juno installs manifest.json's; add packages there, then copy them to package.json (or run `npm run pull` after deploying)."
+  );
+}

package/src/commands/flow-deploy.js

@@ -0,0 +1,110 @@
+import { join } from 'node:path';
+
+import { connect } from '../api.js';
+import { DiagnosticsError } from '../errors.js';
+import {
+  formatDiagnostic,
+  printDiagnosticsJSON,
+  printJSON,
+} from '../diagnostics.js';
+import {
+  MANIFEST,
+  manifestText,
+  readFlowProject,
+  SRC_DIR,
+  typeFiles,
+  updatePackageJSON,
+  writeFlowFiles,
+} from '../flow-project.js';
+import { deployOnChange } from '../watch.js';
+
+export const FLOW_DEPLOY_USAGE =
+  'juno flow deploy [--watch] [--force] [--json]';
+
+/**
+ * `juno flow deploy` — upload manifest.json and src/ to
+ * POST /api/flows/ingest, which verifies and commits them through the same
+ * core the in-app assistant's submit_code uses, and activates the version.
+ *
+ * It sends `juno.base_version`, so a flow edited elsewhere since this copy was
+ * pulled is a 409 (exit 4) rather than a silent overwrite; --force sends none
+ * and replaces whatever is active. On success it writes back what the server
+ * now holds: the canonical manifest, both files under types/, and the new
+ * base_version. --watch redeploys on every save to src/ or manifest.json.
+ */
+export async function flowDeploy(argv, io) {
+  const { target, client } = await connect(argv, io);
+  if (!argv.watch) {
+    return deployOnce(client, argv, io, target);
+  }
+
+  // A deploy writes manifest.json back, which the watcher sees. Remembering
+  // what was last deployed makes that echo — and any save that changed
+  // nothing — a no-op instead of another version.
+  let last = null;
+  return deployOnChange({
+    io,
+    target,
+    paths: [
+      { path: join(io.cwd, SRC_DIR), recursive: true },
+      { path: join(io.cwd, MANIFEST) },
+    ],
+    once: async () => {
+      const project = await readFlowProject(io.cwd);
+      const key = JSON.stringify([project.manifestRaw, project.files]);
+      if (key === last) return;
+      const after = await deployProject(client, project, argv, io, target);
+      last = JSON.stringify([after.manifestRaw, project.files]);
+    },
+  });
+}
+
+async function deployOnce(client, argv, io, target) {
+  const project = await readFlowProject(io.cwd);
+  try {
+    await deployProject(client, project, argv, io, target);
+  } catch (err) {
+    if (argv.json && err instanceof DiagnosticsError) {
+      return printDiagnosticsJSON(err, io);
+    }
+    throw err;
+  }
+  return 0;
+}
+
+async function deployProject(client, project, argv, io, target) {
+  const result = await client.ingestFlow({
+    flowId: project.flowId,
+    manifest: project.manifest,
+    files: project.files,
+    baseVersion: argv.force ? undefined : project.baseVersion,
+  });
+
+  const manifestRaw = manifestText(result.manifest);
+  const written = await writeFlowFiles(io.cwd, {
+    [MANIFEST]: manifestRaw,
+    ...typeFiles(result.types),
+  });
+  if (project.baseVersion !== result.version) {
+    await updatePackageJSON(io.cwd, (pkg) => {
+      pkg.juno.base_version = result.version;
+    });
+    written.push('package.json');
+  }
+
+  if (argv.json) {
+    printJSON(result, io);
+  } else {
+    printWarnings(result.warnings, io);
+    const files = written.length ? ` (${written.sort().join(', ')})` : '';
+    io.log(
+      `deployed ${result.flow_id} v${result.version} to ${target}${files}`
+    );
+  }
+  return { manifestRaw };
+}
+
+/** A route's warnings, each as a diagnostic line with a `warning: ` prefix. */
+export function printWarnings(warnings, io) {
+  for (const w of warnings ?? []) io.warn(`warning: ${formatDiagnostic(w)}`);
+}

package/src/commands/flow-fixture.js

@@ -0,0 +1,67 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { connect } from '../api.js';
+import { UsageError, UserError } from '../errors.js';
+import { readFlowPackage } from '../flow-project.js';
+import { baseVersionOf } from '../working-copy.js';
+import { exists } from './init.js';
+
+export const FLOW_FIXTURE_USAGE = 'juno flow fixture --run <seq> [--force]';
+
+export const FIXTURES_DIR = 'test/fixtures';
+
+/**
+ * `juno flow fixture --run <seq>` — write run `seq` of this working copy's
+ * flow as a flowHarness scenario, `test/fixtures/<flow-id>-<seq>.json`, for a
+ * test to replay with `h.scenario(fixture)`.
+ *
+ * The server builds the fixture (GET /api/flows/{id}/runs/{seq}/fixture) and
+ * the CLI writes what it is handed, as `init` does a scaffold. What the run
+ * did not record comes back as notes, one per line on stderr: each is
+ * something the author checks or fills in before the fixture replays.
+ *
+ * The run is a flag, not a positional, because a working-copy command takes
+ * none except `init`. It writes only a local file, so its effect is `read`.
+ */
+export async function flowFixture(argv, io) {
+  const seq = parseSeq(argv.run);
+  const pkg = await readFlowPackage(io.cwd);
+  const flowId = pkg.juno.flow_id;
+
+  const rel = `${FIXTURES_DIR}/${flowId}-${seq}.json`;
+  const path = join(io.cwd, rel);
+  // Refused before anything is fetched: an existing fixture may be one the
+  // author has edited (a credential filled in, a state corrected).
+  if (!argv.force && (await exists(path))) {
+    throw new UserError(`${rel} already exists; pass --force to overwrite it`);
+  }
+
+  const { client } = await connect(argv, io);
+  const { fixture, notes } = await client.runFixture(flowId, seq);
+
+  await mkdir(join(io.cwd, FIXTURES_DIR), { recursive: true });
+  await writeFile(path, `${JSON.stringify(fixture, null, 2)}\n`, 'utf8');
+
+  io.log(`wrote ${rel}`);
+  const base = baseVersionOf(pkg);
+  if (
+    base !== undefined &&
+    Number.isInteger(fixture?.flow_version) &&
+    fixture.flow_version !== base
+  ) {
+    io.warn(
+      `run ${seq} ran v${fixture.flow_version}; this working copy is at v${base} — the fixture may not replay`
+    );
+  }
+  for (const note of notes ?? []) io.warn(`note: ${note}`);
+  return 0;
+}
+
+/** parseSeq is `--run`'s value as a run number, or a usage error. */
+function parseSeq(value) {
+  if (value === undefined || !/^[1-9][0-9]*$/.test(value)) {
+    throw new UsageError(`usage: ${FLOW_FIXTURE_USAGE}`);
+  }
+  return Number(value);
+}

package/src/commands/flow-gen-types.js

@@ -0,0 +1,37 @@
+import { connect } from '../api.js';
+import { UserError } from '../errors.js';
+import {
+  readFlowManifest,
+  readFlowPackage,
+  typeFiles,
+  writeFlowFiles,
+} from '../flow-project.js';
+
+export const FLOW_GEN_TYPES_USAGE = 'juno flow gen-types';
+
+/**
+ * `juno flow gen-types` — regenerate types/flow-env.d.ts and
+ * types/flow-api.d.ts from manifest.json against the instance's live catalog.
+ * manifest.json itself is left alone: this refreshes what the editor
+ * type-checks against, nothing more. Stale types cannot ship regardless,
+ * because ingest regenerates them.
+ */
+export async function flowGenTypes(argv, io) {
+  await readFlowPackage(io.cwd);
+  const { manifest } = await readFlowManifest(io.cwd);
+  const { client } = await connect(argv, io);
+  const generated = await client.typegenFlow(manifest);
+  const files = typeFiles(generated.types);
+  if (!Object.keys(files).length) {
+    throw new UserError(
+      `${client.target} answered no .d.ts files for this manifest`
+    );
+  }
+  const written = await writeFlowFiles(io.cwd, files);
+  io.log(
+    written.length
+      ? `wrote ${written.join(', ')}`
+      : `${Object.keys(files).sort().join(', ')} already up to date`
+  );
+  return 0;
+}

package/src/commands/flow-init.js

@@ -0,0 +1,59 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { connect } from '../api.js';
+import { printAuthoringIndex } from '../authoring-skills.js';
+import { UsageError, UserError } from '../errors.js';
+import { exists, safeRelative } from './init.js';
+
+export const FLOW_INIT_USAGE = 'juno flow init <id> [--here]';
+
+/**
+ * `juno flow init <id>` — a working copy of the flow's active version, or a
+ * stub for an id with none, written into ./<id> (or the current directory
+ * with --here).
+ *
+ * Every file comes from POST /api/flows/scaffold, the single generator of a
+ * flow working copy: the CLI writes what it is handed and holds no copy of
+ * the layout, the script lines or the types. After the next steps it prints
+ * the flow author's skill index, which is where an external agent starts.
+ */
+export async function flowInit(argv, io) {
+  const [id, ...extra] = argv._;
+  if (!id || extra.length > 0) {
+    throw new UsageError(`usage: ${FLOW_INIT_USAGE}`);
+  }
+
+  const dir = resolve(io.cwd, argv.here ? '.' : id);
+  if (!argv.here && (await exists(dir))) {
+    throw new UserError(`${dir} already exists`);
+  }
+
+  const { target, client } = await connect(argv, io);
+  // The id is validated server-side: one answer to "is this a valid flow id".
+  const { files, warnings } = await client.scaffoldFlow(id, { target });
+
+  for (const [rel, content] of Object.entries(files)) {
+    const path = join(dir, safeRelative(rel));
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, 'utf8');
+  }
+  printScaffoldWarnings(warnings, io);
+
+  io.log(`created ${dir}`);
+  io.log('');
+  io.log(argv.here ? 'npm install' : `cd ${id} && npm install`);
+  io.log('npm test');
+  io.log('npm run deploy');
+  await printAuthoringIndex('flow', client, target, io);
+  return 0;
+}
+
+/**
+ * A stored manifest the live catalog now refuses (a state it binds was
+ * deleted, say) still scaffolds, because the working copy is how it gets
+ * fixed; the refusal comes along as warnings, and they go to stderr.
+ */
+export function printScaffoldWarnings(warnings, io) {
+  for (const w of warnings ?? []) io.warn(`warning: ${w}`);
+}

package/src/commands/flow-pull.js

@@ -0,0 +1,115 @@
+import { connect } from '../api.js';
+import { UserError } from '../errors.js';
+import {
+  MANIFEST,
+  manifestText,
+  PACKAGE_JSON,
+  readFlowPackage,
+  updatePackageJSON,
+  writeFlowFiles,
+} from '../flow-project.js';
+import { printScaffoldWarnings } from './flow-init.js';
+import {
+  baseArtifactPaths,
+  baseVersionOf,
+  pullArtifacts,
+  requireCleanTree,
+  setDependencies,
+} from '../working-copy.js';
+
+export const FLOW_PULL_USAGE = 'juno flow pull [--force]';
+
+/**
+ * `juno flow pull` — make the working copy's artifact files the flow's active
+ * version: manifest.json and every file under src/ and test/, exactly as the
+ * version stores them (GET /api/flows/{id}/versions/{v}), never as the
+ * scaffold renders them. types/ is generated, so it comes from
+ * POST /api/flows/scaffold, which also names the active version. In
+ * package.json only `dependencies` (the manifest's) and `juno.base_version`
+ * are Juno's; `scripts` and every other key are the author's and stay.
+ *
+ * A local file is deleted only when the base version (`juno.base_version`)
+ * had it and the pulled one does not; a file neither has is one not deployed
+ * yet, and stays. Project files (tsconfig.json, README.md …) are never
+ * written or deleted.
+ *
+ * It refuses a dirty git tree without --force, as integration pull does: an
+ * uncommitted edit is the one thing nothing can get back.
+ */
+export async function flowPull(argv, io) {
+  const pkg = await readFlowPackage(io.cwd);
+  const flowId = pkg.juno.flow_id;
+
+  await requireCleanTree(io.cwd, {
+    force: argv.force,
+    overwrites: `${MANIFEST}, src/, test/ and types/`,
+    io,
+  });
+
+  const { target, client } = await connect(argv, io);
+  const { files, warnings } = await client.scaffoldFlow(flowId, { target });
+  let scaffoldPkg;
+  try {
+    scaffoldPkg = JSON.parse(files[PACKAGE_JSON]);
+  } catch {
+    throw new UserError(
+      `${target} answered a working copy with no readable ${PACKAGE_JSON}`
+    );
+  }
+  const version = scaffoldPkg.juno?.base_version;
+  const noActive = () =>
+    new UserError(
+      `${flowId} has no active version on ${target} — nothing to pull`
+    );
+  // No base_version is the scaffold's stub for a flow with no active
+  // version; writing it over the author's work would lose it for nothing.
+  if (!Number.isInteger(version)) throw noActive();
+
+  // Everything is fetched before anything is written, so a failure leaves
+  // the working copy as it was.
+  const detail = await client.getFlowVersion(flowId, version);
+  if (!detail) throw noActive();
+  const manifest = JSON.parse(detail.manifest_json);
+  const stored = {
+    [MANIFEST]: manifestText(manifest),
+    ...detail.source_files,
+  };
+  const base = await baseArtifactPaths({
+    base: baseVersionOf(pkg),
+    version,
+    stored,
+    read: async (v) => {
+      const b = await client.getFlowVersion(flowId, v);
+      return b ? [MANIFEST, ...Object.keys(b.source_files ?? {})] : null;
+    },
+    id: flowId,
+    target,
+    io,
+  });
+
+  const { written, removed } = await pullArtifacts(io.cwd, {
+    stored,
+    base,
+    kind: 'flow',
+  });
+  written.push(
+    ...(await writeFlowFiles(
+      io.cwd,
+      Object.fromEntries(
+        Object.entries(files).filter(([name]) => name.startsWith('types/'))
+      )
+    ))
+  );
+  await updatePackageJSON(io.cwd, (p) => {
+    setDependencies(p, manifest);
+    p.juno.base_version = version;
+  });
+  written.push(PACKAGE_JSON);
+  printScaffoldWarnings(warnings, io);
+
+  io.log(
+    `pulled ${flowId} v${version} from ${target} (${written.sort().join(', ')})`
+  );
+  if (removed.length) io.log(`removed ${removed.join(', ')}`);
+  return 0;
+}

package/src/commands/{types.js → gen-types.js}

@@ -1,21 +1,28 @@
-import { JunoClient } from '../api.js';
+import { clientName, JunoClient } from '../api.js';
 import { readManifest, readManifestRaw, writeTypes } from '../project.js';
 import { stampTypeFiles } from '../stamp.js';
 import { resolveTarget } from '../target.js';
 
+export const GEN_TYPES_USAGE = 'juno integration gen-types';
+
 /**
- * `juno types` — POST manifest.json, write back types/.
+ * `juno integration gen-types` — POST manifest.json, write back types/.
  *
  * Both halves come from one call so they cannot skew, and they are committed:
  * a fresh clone compiles offline, and a contributor fixing a bug in someone
  * else's integration never needs a Juno instance. Only the person editing the
  * manifest does, which is the right person to require it of.
  */
-export async function types(argv, io) {
-  const target = await resolveTarget({ url: argv.url, cwd: io.cwd });
+export async function genTypes(argv, io) {
+  const target = await resolveTarget({
+    url: argv.url,
+    cwd: io.cwd,
+    env: io.env,
+  });
   const raw = await readManifestRaw(io.cwd);
   const manifest = await readManifest(io.cwd);
-  const client = argv.client ?? new JunoClient(target);
+  const client =
+    argv.client ?? new JunoClient(target, { client: clientName(io.env) });
 
   const generated = await client.typegen(manifest);
   const written = await writeTypes(