@junoflow/cli 0.3.0 → 0.9.0

package/src/app-dev/stream.js

@@ -0,0 +1,224 @@
+/** How often an open stream sends a `: ping` comment, as the instance does. */
+export const PING_MS = 20_000;
+
+/**
+ * How a control stands with nothing said about it: the instance's answer for
+ * a button and for an idle control (appserve.ControlValue, `null`s sent).
+ */
+const IDLE = Object.freeze({ value: null, active: false, expires_at: null });
+
+/**
+ * createLive is the dev server's `_juno/stream` (plan-local-dev-6 decision
+ * 6), in the instance's wire shape (internal/appserve, `.claude/rules/
+ * apps.md` "Live values"):
+ *
+ * | Event      | Data                             | When                         |
+ * | ---------- | -------------------------------- | ---------------------------- |
+ * | `snapshot` | `{"values": {states, controls}}` | on connect, and on `reset()` |
+ * | `update`   | `{"values": {states, controls}}` | `set()`, one per moved map   |
+ * | `pressed`  | `{"binding", "at"}`              | `press()`                    |
+ * | (comment)  | `: ping`                         | every `pingMs`               |
+ *
+ * Values are keyed by binding, as the instance keys them: every declared
+ * state binding under `states` (the scenario's value, else null) and every
+ * control binding under `controls` (idle). The panel's overrides sit on top.
+ * A read or read_write binding's override is also seeded into the harness,
+ * so a handler reads what the page is shown; a slot or signal binding holds
+ * no value a handler can read, so its override reaches the page only.
+ *
+ * `stale` is never sent: the dev server serves one version, whatever `?v=`
+ * the client names. A handler's claim or set moves no value here, because
+ * the layer stack is the instance's, as it is in the harness.
+ *
+ * dev is the harness (createDevHarness). Telling the panel the values moved
+ * is the caller's (createPanel).
+ */
+export function createLive({ dev, pingMs = PING_MS }) {
+  const streams = new Set();
+  // The panel's overrides, by binding. Cleared by a scenario switch.
+  let overrides = { states: {}, controls: {} };
+
+  const live = {
+    /** The values a snapshot would carry now. */
+    values() {
+      const states = {};
+      for (const name of Object.keys(dev.manifest.states ?? {})) {
+        states[name] = Object.hasOwn(overrides.states, name)
+          ? overrides.states[name]
+          : (dev.scenario?.value?.states?.[name] ?? null);
+      }
+      const controls = {};
+      for (const name of Object.keys(dev.manifest.controls ?? {})) {
+        controls[name] = overrides.controls[name] ?? { ...IDLE };
+      }
+      return { states, controls };
+    },
+
+    /**
+     * Moves values, `{states?, controls?}` by binding, and sends one
+     * `update` per map that moved, the other map `{}` — as the instance
+     * sends a settle generation and a control change separately. A binding
+     * the manifest does not declare, or a control value that is not an
+     * object, throws before anything moves.
+     */
+    set({ states = {}, controls = {} } = {}) {
+      const declared = {
+        states: dev.manifest.states ?? {},
+        controls: dev.manifest.controls ?? {},
+      };
+      for (const [section, map] of Object.entries({ states, controls })) {
+        if (map === null || typeof map !== 'object' || Array.isArray(map)) {
+          throw new Error(`"${section}" maps bindings to values`);
+        }
+        for (const name of Object.keys(map)) {
+          if (!Object.hasOwn(declared[section], name)) {
+            throw new Error(
+              `"${name}" is not declared in manifest.json ${section} (have: ${Object.keys(declared[section]).sort().join(', ') || '(none)'})`
+            );
+          }
+        }
+      }
+      const movedControls = {};
+      for (const [name, v] of Object.entries(controls)) {
+        movedControls[name] = controlValue(name, v);
+      }
+      const seeded = {};
+      for (const [name, v] of Object.entries(states)) {
+        if (holdsValue(declared.states[name])) seeded[name] = v;
+      }
+      dev.h.states(seeded);
+
+      Object.assign(overrides.states, states);
+      Object.assign(overrides.controls, movedControls);
+      if (Object.keys(states).length) {
+        broadcast('update', { values: { states, controls: {} } });
+      }
+      if (Object.keys(movedControls).length) {
+        broadcast('update', {
+          values: { states: {}, controls: movedControls },
+        });
+      }
+    },
+
+    /** Sends `pressed` for a declared control binding, at now. */
+    press(binding) {
+      const controls = dev.manifest.controls ?? {};
+      if (typeof binding !== 'string' || !Object.hasOwn(controls, binding)) {
+        throw new Error(
+          `"${binding}" is not declared in manifest.json controls (have: ${Object.keys(controls).sort().join(', ') || '(none)'})`
+        );
+      }
+      const data = { binding, at: new Date().toISOString() };
+      broadcast('pressed', data);
+      return data;
+    },
+
+    /**
+     * After the harness was rebuilt (a scenario switch, a manifest save):
+     * drops the overrides with `clear`, or keeps those whose binding is still
+     * declared and seeds them into the fresh harness, then sends every open
+     * stream a new snapshot.
+     */
+    reset({ clear }) {
+      if (clear) {
+        overrides = { states: {}, controls: {} };
+      } else {
+        const states = dev.manifest.states ?? {};
+        const controls = dev.manifest.controls ?? {};
+        overrides = {
+          states: pick(overrides.states, states),
+          controls: pick(overrides.controls, controls),
+        };
+        const seeded = {};
+        for (const [name, v] of Object.entries(overrides.states)) {
+          if (holdsValue(states[name])) seeded[name] = v;
+        }
+        dev.h.states(seeded);
+      }
+      broadcast('snapshot', { values: live.values() });
+    },
+
+    /** The `_juno/stream` route. */
+    serve(req, res) {
+      if (req.method !== 'GET') {
+        res.writeHead(405, {
+          Allow: 'GET',
+          'Content-Type': 'text/plain; charset=utf-8',
+        });
+        return res.end('method not allowed');
+      }
+      const stream = openStream(res, pingMs, () => streams.delete(stream));
+      streams.add(stream);
+      stream.send('snapshot', { values: live.values() });
+    },
+
+    /** Ends every open stream. */
+    close() {
+      for (const s of streams) s.end();
+    },
+  };
+
+  function broadcast(event, data) {
+    for (const s of streams) s.send(event, data);
+  }
+
+  return live;
+}
+
+/**
+ * openStream starts a server-sent event response with the instance's
+ * headers, and a `: ping` comment every pingMs so an idle connection is kept.
+ * The timer stops when the response closes, by either side. Returns
+ * `{send(event, data), end()}`.
+ */
+export function openStream(res, pingMs, onClose = () => {}) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'X-Accel-Buffering': 'no',
+  });
+  res.flushHeaders();
+  const ping = setInterval(() => res.write(': ping\n\n'), pingMs);
+  res.on('close', () => {
+    clearInterval(ping);
+    onClose();
+  });
+  return {
+    // One line of JSON, which never contains a raw newline.
+    send(event, data) {
+      res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+    },
+    end() {
+      clearInterval(ping);
+      res.end();
+    },
+  };
+}
+
+/** A read or read_write binding: what h.states seeds and a handler reads. */
+function holdsValue(binding) {
+  return !binding?.slot && !binding?.signal;
+}
+
+/** A control's value as the instance sends it: the three fields, nulls kept. */
+function controlValue(name, v) {
+  if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+    throw new Error(
+      `controls "${name}" — expected {value, active, expires_at}, got ${JSON.stringify(v)}`
+    );
+  }
+  if (v.expires_at != null && typeof v.expires_at !== 'string') {
+    throw new Error(`controls "${name}" — expires_at must be a string or null`);
+  }
+  return {
+    value: v.value ?? null,
+    active: v.active === true,
+    expires_at: v.expires_at ?? null,
+  };
+}
+
+function pick(map, declared) {
+  return Object.fromEntries(
+    Object.entries(map).filter(([name]) => Object.hasOwn(declared, name))
+  );
+}

package/src/app-dev/watch.js

@@ -0,0 +1,47 @@
+import { join } from 'node:path';
+
+import { watchPaths } from '../watch.js';
+
+/**
+ * watchApp is `juno app dev`'s rebuild on save (plan-local-dev-6 decision 9):
+ * one debounced watch per part of the working copy, so a save reaches the
+ * one handler that knows what to rebuild.
+ *
+ * | Handler    | Watches                                  |
+ * | ---------- | ---------------------------------------- |
+ * | `manifest` | `manifest.json`                          |
+ * | `src`      | `src/`, recursively                      |
+ * | `page`     | `page/` and `public/`, recursively       |
+ * | `fixtures` | `test/fixtures/`, recursively            |
+ *
+ * manifest.json is watched through its directory, filtered by name, because
+ * a watch on the file itself is lost the first time an editor saves by
+ * renaming over it. A directory absent at start is not watched. Returns
+ * `{close()}`.
+ */
+export function watchApp(cwd, on, { debounceMs } = {}) {
+  const groups = {
+    manifest: [
+      {
+        path: cwd,
+        filter: (name) => name === null || name === 'manifest.json',
+      },
+    ],
+    src: [{ path: join(cwd, 'src'), recursive: true }],
+    page: [
+      { path: join(cwd, 'page'), recursive: true },
+      { path: join(cwd, 'public'), recursive: true },
+    ],
+    fixtures: [{ path: join(cwd, 'test', 'fixtures'), recursive: true }],
+  };
+  const watchers = [];
+  for (const [group, paths] of Object.entries(groups)) {
+    if (typeof on[group] !== 'function') continue;
+    watchers.push(watchPaths(paths, on[group], { debounceMs }));
+  }
+  return {
+    close() {
+      for (const w of watchers) w.close();
+    },
+  };
+}

package/src/app-project.js

@@ -0,0 +1,133 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, posix, relative, sep } from 'node:path';
+
+import { UserError } from './errors.js';
+import { readSourceFiles, readTestFiles } from './project.js';
+import {
+  baseVersionOf,
+  PAGE_TSCONFIG,
+  readBoundPackage,
+  readManifestFile,
+  writePackageJSON,
+} from './working-copy.js';
+
+/**
+ * An app working copy is the archive's own layout — src/ compiled, page/
+ * built at ingest, public/ served as is, test/ stored and never compiled —
+ * plus manifest.json, types/ (generated), page/tsconfig.json and
+ * package.json, whose `juno` block binds the directory to one app. The
+ * layout is the server's (POST /api/apps/scaffold); this module only knows
+ * what a command reads or writes back, and what it shares with a flow working
+ * copy lives in working-copy.js.
+ */
+export const SRC_DIR = 'src';
+export const PAGE_DIR = 'page';
+export const PUBLIC_DIR = 'public';
+export { PAGE_TSCONFIG };
+
+/**
+ * readAppProject reads what ingest takes: the manifest (parsed, so a broken
+ * one fails here with its parse error rather than as a server 422), src/,
+ * test/, page/ and public/ as one archive, the lockfile, and the binding in
+ * package.json.
+ *
+ * Ingest keys a version on the manifest's id, so a manifest whose id is not
+ * `juno.app_id` would make a second app rather than a version of this one.
+ * That is refused here, before anything is sent, as the flow ingest route
+ * refuses a manifest naming another flow.
+ */
+export async function readAppProject(cwd) {
+  const pkg = await readAppPackage(cwd);
+  const { manifest, manifestRaw } = await readManifestFile(cwd);
+  const appId = pkg.juno.app_id;
+  if (manifest?.id !== appId) {
+    throw new UserError(
+      `manifest.json's id is ${JSON.stringify(manifest?.id)}, but this working copy is app "${appId}" ` +
+        '(juno.app_id in package.json) — deploying it would create a second app rather than a version of this one. ' +
+        `Set the id back to "${appId}", or run \`juno app init <new-id>\` for a new app.`
+    );
+  }
+  return {
+    manifest,
+    manifestRaw,
+    files: {
+      ...(await readSourceFiles(cwd)),
+      ...(await readTestFiles(cwd)),
+      ...(await readPageFiles(cwd)),
+      ...(await readPublicFiles(cwd)),
+    },
+    lockfile: await readOptional(join(cwd, 'package-lock.json')),
+    packageJSON: pkg,
+    appId,
+    baseVersion: baseVersionOf(pkg),
+  };
+}
+
+/** readAppPackage is package.json, refusing a directory that is not an app working copy. */
+export function readAppPackage(cwd) {
+  return readBoundPackage(cwd, { kind: 'app', idKey: 'app_id' });
+}
+
+/**
+ * updateAppPackage rewrites an app working copy's package.json through
+ * `mutate`, keeping every key it does not touch (and their order).
+ */
+export async function updateAppPackage(cwd, mutate) {
+  const pkg = await readAppPackage(cwd);
+  mutate(pkg);
+  await writePackageJSON(cwd, pkg);
+}
+
+/**
+ * readPublicFiles walks public/ and returns repo-relative POSIX paths →
+ * content: every file, since all of public/ is served, except dotfiles
+ * (.DS_Store, an editor's swap file), which are the machine's and not the
+ * page's. The server enforces the caps and the reserved names.
+ */
+export function readPublicFiles(cwd) {
+  return readTree(cwd, PUBLIC_DIR);
+}
+
+/**
+ * readPageFiles is readPublicFiles for page/, less page/tsconfig.json. What
+ * may be in page/ (the entry document and .ts files) is the server's to
+ * enforce, so a stray file is sent and refused by name rather than dropped.
+ */
+export async function readPageFiles(cwd) {
+  const files = await readTree(cwd, PAGE_DIR);
+  delete files[PAGE_TSCONFIG];
+  return files;
+}
+
+/** readTree reads every file under dir but dotfiles, by repo-relative POSIX path. */
+async function readTree(cwd, dir) {
+  const files = {};
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return; // no such directory at all; ingest names a missing entry document
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+        continue;
+      }
+      const rel = relative(cwd, full).split(sep).join(posix.sep);
+      files[rel] = await readFile(full, 'utf8');
+    }
+  }
+  await walk(join(cwd, dir));
+  return files;
+}
+
+async function readOptional(path) {
+  try {
+    return await readFile(path, 'utf8');
+  } catch {
+    return null;
+  }
+}

package/src/authoring-skills.js

@@ -0,0 +1,43 @@
+import { warnIfStale } from './installed-skill.js';
+
+/**
+ * The kinds of working copy with an authoring skill index, and the heading
+ * each is printed under. The index itself is the server's
+ * (GET /api/skills?authoring=<kind>): the same name and description lines the
+ * in-app app, flow and integration authors are given, so it cannot drift from the
+ * skills.
+ */
+export const AUTHORING_HEADINGS = {
+  app: 'Skills for writing an app',
+  flow: 'Skills for writing a flow',
+  integration: 'Skills for writing an integration',
+};
+
+/** The heading line, saying how a listed skill is loaded. */
+export function authoringHeading(kind) {
+  return `${AUTHORING_HEADINGS[kind]} (load one with \`juno skill <name>\`):`;
+}
+
+/**
+ * printAuthoringIndex prints a kind's authoring skills after `init` has
+ * written the working copy, as `  <name> — <description>`. Fetching it is a
+ * courtesy: the working copy is already on disk, so a failure is a note on
+ * stderr, never a failed init. It also says when an installed agent skill is
+ * stale, since the index carries the version the instance serves.
+ */
+export async function printAuthoringIndex(kind, client, target, io) {
+  let index;
+  try {
+    index = await client.listSkills({ authoring: kind });
+  } catch (err) {
+    io.warn(`(skill index unavailable: ${err.message})`);
+    return;
+  }
+  const skills = index?.skills ?? [];
+  if (skills.length > 0) {
+    io.log('');
+    io.log(authoringHeading(kind));
+    for (const s of skills) io.log(`  ${s.name} — ${s.description}`);
+  }
+  await warnIfStale(index, target, io);
+}

package/src/commands/agent-skill-install.js

@@ -0,0 +1,64 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+import { connect } from '../api.js';
+import { UsageError } from '../errors.js';
+import { SKILL_DIR } from '../installed-skill.js';
+
+export const AGENT_SKILL_INSTALL_USAGE =
+  'juno agent-skill install [--dir <path>] [--allow-change] [--working-copy] [--agents-md] [--json]';
+
+/**
+ * `juno agent-skill install` writes the skill GET /api/agent-skill renders to
+ * `<dir>/SKILL.md` (default `.claude/skills/juno` under the current
+ * directory) and prints a Claude Code permission block on stdout: every read
+ * command, plus every change command with --allow-change, plus the working
+ * copy's npm scripts of the same tiers with --working-copy. No act command is
+ * ever in it — the server leaves them out, and the CLI adds nothing.
+ *
+ * `--agents-md` prints the same text as an AGENTS.md section instead and
+ * writes nothing; `--json` prints the route's body.
+ */
+export async function agentSkillInstall(args, io) {
+  if (args._.length > 0) {
+    throw new UsageError(
+      `juno agent-skill install takes no argument; usage: ${AGENT_SKILL_INSTALL_USAGE}`
+    );
+  }
+  const { client } = await connect(args, io);
+  const skill = await client.getAgentSkill();
+
+  if (args.json) return printJSON(skill, io);
+  if (args['agents-md']) {
+    io.write(skill.agents_md);
+    return 0;
+  }
+
+  const dir = resolve(io.cwd, args.dir ?? SKILL_DIR);
+  const path = join(dir, 'SKILL.md');
+  await mkdir(dir, { recursive: true });
+  await writeFile(path, skill.skill_md, 'utf8');
+
+  const tiers = (t) => [
+    ...(t?.read ?? []),
+    ...(args['allow-change'] ? (t?.change ?? []) : []),
+  ];
+  const allow = tiers(skill.permissions);
+  if (args['working-copy'])
+    allow.push(...tiers(skill.working_copy_permissions));
+
+  io.warn(`wrote ${path} (version ${skill.version})`);
+  io.warn(
+    args['working-copy']
+      ? "Add these rules to this working copy's .claude/settings.json — not to user-wide settings, " +
+          "where they would also allow any other project's npm scripts:"
+      : 'Add these rules to .claude/settings.json (or ~/.claude/settings.json) to run them without a prompt:'
+  );
+  return printJSON({ permissions: { allow } }, io);
+}
+
+/** Compact off a TTY, indented on one, as every JSON the CLI prints. */
+function printJSON(value, io) {
+  io.log(io.isTTY ? JSON.stringify(value, null, 2) : JSON.stringify(value));
+  return 0;
+}

package/src/commands/app-check.js

@@ -0,0 +1,75 @@
+import { connect } from '../api.js';
+import { readAppProject } from '../app-project.js';
+import { printDiagnosticsJSON, printJSON } from '../diagnostics.js';
+import { DiagnosticsError } from '../errors.js';
+import { EXIT_CONFLICT } from '../exit.js';
+import { runLocalChecks } from './check.js';
+import { warnOnDependencyDrift } from './flow-check.js';
+
+export const APP_CHECK_USAGE = 'juno app check [--skip-local] [--json]';
+
+/**
+ * `juno app check` — local tsc and eslint, then an ingest with
+ * `activate: false`: the verification deploy runs, stored as a draft and not
+ * activated, so the page can be opened at its `~draft/` URL before anyone
+ * else sees it. Unlike a flow's check this stores something — an app's draft
+ * is how it is previewed — which is why its effect is `change`. The draft's
+ * handlers run for real: a preview is live.
+ *
+ * It sends `juno.base_version`. The server never refuses a preview, so a stale
+ * copy still stores its draft; the answer's `stale_base` is the sentence a
+ * deploy would be refused with, printed after the preview, and the exit is 4
+ * — the code every kind's check gives a stale copy.
+ *
+ * --json prints the route's body (or the 422's diagnostics) on stdout and
+ * nothing else; the local tools' own output goes to stderr.
+ */
+export async function appCheck(argv, io) {
+  const project = await readAppProject(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.ingestApp(project, {
+      activate: false,
+      baseVersion: project.baseVersion,
+    });
+  } catch (err) {
+    if (argv.json && err instanceof DiagnosticsError) {
+      return printDiagnosticsJSON(err, io);
+    }
+    throw err;
+  }
+
+  if (argv.json) {
+    printJSON(result, io);
+  } else {
+    for (const w of result.warnings ?? []) io.warn(`warning: ${w}`);
+    io.log(
+      `${result.id}: verified and stored as draft v${result.version} on ${target}`
+    );
+    printPreview(result, io);
+    if (result.stale_base) io.error(result.stale_base);
+  }
+  if (result.stale_base) return EXIT_CONFLICT;
+  return failed ? 1 : 0;
+}
+
+/**
+ * The draft's preview URL is the app's URL with `~draft/` on the end. Juno
+ * reports no URL while the apps_url site setting is unset, and the CLI does
+ * not guess one: the apps listener's address is not the hostname a proxy
+ * puts in front of it.
+ */
+function printPreview(result, io) {
+  if (result.url) {
+    io.log(`preview: ${result.url}~draft/`);
+    return;
+  }
+  io.warn(
+    'no preview URL: apps_url is not set on this instance (Settings → Site). ' +
+      `Once it is, the draft is served at <apps_url>/${result.id}/~draft/`
+  );
+}

package/src/commands/app-deploy.js

@@ -0,0 +1,102 @@
+import { join } from 'node:path';
+
+import { connect } from '../api.js';
+import {
+  PAGE_DIR,
+  PUBLIC_DIR,
+  readAppProject,
+  SRC_DIR,
+  updateAppPackage,
+} from '../app-project.js';
+import { printDiagnosticsJSON, printJSON } from '../diagnostics.js';
+import { DiagnosticsError } from '../errors.js';
+import { deployOnChange } from '../watch.js';
+import {
+  MANIFEST,
+  manifestText,
+  typeFiles,
+  writeChangedFiles,
+} from '../working-copy.js';
+
+export const APP_DEPLOY_USAGE = 'juno app deploy [--watch] [--force] [--json]';
+
+/**
+ * `juno app deploy` — upload manifest.json, src/, page/ and public/ to
+ * POST /api/apps/ingest, which verifies them through the same path the
+ * in-app assistant's submit_code uses, stores a version and activates it.
+ *
+ * It sends `juno.base_version`, so an app 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.
+ *
+ * On success it writes back what the server now holds: the canonical
+ * manifest, the three files under types/, and the new juno.base_version.
+ * --watch redeploys on every save to src/, page/, public/ or manifest.json,
+ * re-reading the base each time, so the loop is checked against its own
+ * previous deploy rather than refused by it.
+ */
+export async function appDeploy(argv, io) {
+  const { target, client } = await connect(argv, io);
+  if (!argv.watch) {
+    const project = await readAppProject(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;
+  }
+
+  // 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, PAGE_DIR), recursive: true },
+      { path: join(io.cwd, PUBLIC_DIR), recursive: true },
+      { path: join(io.cwd, MANIFEST) },
+    ],
+    once: async () => {
+      const project = await readAppProject(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 deployProject(client, project, argv, io, target) {
+  const result = await client.ingestApp(project, {
+    baseVersion: argv.force ? undefined : project.baseVersion,
+  });
+
+  const manifestRaw = manifestText(result.manifest);
+  const written = await writeChangedFiles(io.cwd, {
+    [MANIFEST]: manifestRaw,
+    ...typeFiles(result.types),
+  });
+  if (project.baseVersion !== result.version) {
+    await updateAppPackage(io.cwd, (pkg) => {
+      pkg.juno.base_version = result.version;
+    });
+    written.push('package.json');
+  }
+
+  if (argv.json) {
+    printJSON(result, io);
+  } else {
+    for (const w of result.warnings ?? []) io.warn(`warning: ${w}`);
+    const files = written.length ? ` (${written.sort().join(', ')})` : '';
+    io.log(`deployed ${result.id} v${result.version} to ${target}${files}`);
+    if (result.url) io.log(`open: ${result.url}`);
+  }
+  return { manifestRaw };
+}