syndai 0.1.1 → 0.4.0

package/src/auth.js

@@ -0,0 +1,245 @@
+// Credentials and the browser-approved login (RFC 8628 device flow, like `gh auth login`).
+//
+// Every door uses one credential type, an `sk_` key. `syndai login` mints one only after an
+// owner or admin approves the request in a browser session at app.syndai.ai/cli. The key is
+// stored per workspace in credentials.json (0600). `SYNDAI_API_KEY` wins over it (CI).
+// There is no --api-key flag, so a key never lands in shell history.
+
+import { hostname } from "node:os";
+import { ApiError, CliError, EXIT, explain, PORTAL_URL, steppable } from "./errors.js";
+import { createClient, DEFAULT_API_URL, interrupted } from "./http.js";
+import { findLink, loadCredentials, removeCredential, saveCredential, storePaths } from "./store.js";
+import { ask, createUi, readAll } from "./ui.js";
+
+/** The key this invocation uses: env first, then the cwd link's workspace, then the default. */
+export function resolveCredential(io, paths) {
+  const envKey = io.env.SYNDAI_API_KEY?.trim();
+  if (envKey) return { apiKey: envKey, customerId: null, source: "SYNDAI_API_KEY" };
+  return storedCredential(io, paths);
+}
+
+function storedCredential(io, paths) {
+  const creds = loadCredentials(paths);
+  const link = findLink(paths, io.cwd);
+  const customerId = link && creds.customers[link.customer_id] ? link.customer_id : creds.default;
+  const entry = customerId ? creds.customers[customerId] : null;
+  if (!entry) return null;
+  return { apiKey: entry.api_key, customerId, source: paths.credentials };
+}
+
+/**
+ * Per-invocation state shared by every command. `stepUp: false` (the commands that follow a
+ * change live) never asks for a missing scope mid-stream: they print it and exit 5.
+ */
+export function createContext(io, flags, { stepUp = true } = {}) {
+  const paths = storePaths(io.env);
+  const ui = createUi(io, { json: flags.json === true, noInput: flags["no-input"] === true });
+  const baseUrl = (io.env.SYNDAI_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+  let cached;
+  let me;
+  const credential = () => {
+    cached ??= resolveCredential(io, paths);
+    if (!cached) throw new CliError(EXIT.AUTH, "You are not logged in.", { next: "syndai login" });
+    return cached;
+  };
+  const clientFor = (getKey) => createClient({ baseUrl, getKey, io });
+  const ctx = {
+    io,
+    ui,
+    paths,
+    flags,
+    baseUrl,
+    clientFor,
+    credential,
+    /** Forget the memoised key and `/me` (after a new key is stored). */
+    reset() {
+      cached = undefined;
+      me = undefined;
+    },
+    async me() {
+      me ??= await ctx.client.call("me");
+      return me;
+    },
+    async customerId() {
+      return credential().customerId ?? (await ctx.me()).customer_id;
+    },
+  };
+  ctx.client = createClient({
+    baseUrl,
+    getKey: async () => credential().apiKey,
+    io,
+    onMissingScope: stepUp ? (scope) => stepUpScope(ctx, scope) : undefined,
+  });
+  return ctx;
+}
+
+/**
+ * A 403 named the scope it needs. On a terminal, with the stored login (never
+ * SYNDAI_API_KEY, which belongs to CI), ask once, approve a key with the current scopes plus
+ * that one in the browser, store it, and let the client retry. Declining mints nothing.
+ */
+async function stepUpScope(ctx, scope) {
+  const { io, ui } = ctx;
+  if (!ui.interactive || !steppable(scope) || ctx.credential().source === "SYNDAI_API_KEY") return false;
+  const answer = await ask(io, `This needs the ${scope} scope. Approve it in your browser? [Y/n] `);
+  if (/^n/i.test(answer)) return false;
+  const token = await deviceApproval(ctx, "CLI", await scopesWith(ctx, [scope]));
+  await storeKey(ctx, token);
+  return true;
+}
+
+/** The stored key's scopes plus `extra` (an unknown or dead stored key adds nothing). */
+async function scopesWith(ctx, extra) {
+  const stored = storedCredential(ctx.io, ctx.paths);
+  let current = [];
+  if (stored) {
+    try {
+      current = (await ctx.clientFor(async () => stored.apiKey).call("me")).scopes ?? [];
+    } catch (err) {
+      if (!(err instanceof ApiError && err.status === 401)) throw err;
+    }
+  }
+  return [...new Set([...current, ...extra])];
+}
+
+/**
+ * Save a new key, THEN revoke the key it replaces (best-effort: a failed revoke only warns,
+ * so the new key is never lost). The same key id again is not revoked.
+ */
+async function storeKey(ctx, token) {
+  const { paths, ui } = ctx;
+  const old = loadCredentials(paths).customers[token.customer_id];
+  saveCredential(paths, token);
+  ctx.reset();
+  if (!old || old.api_key === token.api_key || (old.key_id && old.key_id === token.key_id)) return;
+  try {
+    await ctx.clientFor(async () => old.api_key).call("revokeMe");
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 401) return; // already revoked or expired
+    if (err instanceof CliError && err.exitCode === EXIT.INTERRUPTED) throw err;
+    ui.progress(
+      ui.yellow(`Warning: the previous key was not revoked (${explain(err).message}). Revoke it at ${PORTAL_URL}.`),
+    );
+  }
+}
+
+/**
+ * Ask for a key and wait until an owner approves it in the browser. Returns the token
+ * response `{api_key, customer_id, key_id, expires_at}`.
+ */
+export async function deviceApproval(ctx, clientName, scopes) {
+  const { client, ui, io } = ctx;
+  const start = await client.call("deviceStart", {
+    // No `scopes` means the owner preset (owner_door); a list asks for those on top of it.
+    body: { client_name: clientName, host: hostname(), ...(scopes ? { scopes } : {}) },
+    auth: false,
+    retry: true,
+  });
+  const url = start.verification_uri_complete ?? start.verification_uri;
+  ui.progress(`Your one-time code: ${ui.bold(start.user_code)}`);
+  ui.progress(`Approve it in your browser: ${url}`);
+  if (ui.interactive) io.openUrl(url);
+  ui.progress(ui.dim("Waiting for approval (Ctrl-C to stop)..."));
+
+  let intervalMs = (start.interval ?? 5) * 1000;
+  const expiresAt = io.now() + (start.expires_in ?? 600) * 1000;
+  for (;;) {
+    try {
+      await io.sleep(intervalMs, io.signal);
+    } catch (err) {
+      if (io.signal.aborted) throw interrupted();
+      throw err;
+    }
+    const res = await client.call("deviceToken", {
+      body: { device_code: start.device_code },
+      auth: false,
+      retry: true,
+      raw: true,
+    });
+    if (res.status === 200) return res.body;
+    const error = res.body?.error;
+    if (error === "authorization_pending" && io.now() < expiresAt) continue;
+    if (error === "slow_down") {
+      intervalMs += 5000; // RFC 8628 section 3.5
+      continue;
+    }
+    if (error === "access_denied") {
+      throw new CliError(EXIT.AUTH, "The request was denied in the browser.", {
+        next: "syndai login",
+      });
+    }
+    if (error === "expired_token" || error === "authorization_pending") {
+      throw new CliError(EXIT.AUTH, "The code expired before it was approved.", {
+        next: "syndai login",
+      });
+    }
+    throw new ApiError(res.status, res.body, res.headers);
+  }
+}
+
+export async function login(ctx) {
+  const { io, ui, flags } = ctx;
+  const extra = flags.scope ?? [];
+  const portalOnly = extra.find((scope) => !steppable(scope));
+  if (portalOnly) {
+    throw new CliError(EXIT.USAGE, `${portalOnly} is granted in the portal only.`, { next: PORTAL_URL });
+  }
+  if (extra.length && flags["with-token"]) {
+    throw new CliError(EXIT.USAGE, "--scope asks the browser for a key; it does not go with --with-token.");
+  }
+  let token;
+  if (flags["with-token"]) {
+    if (io.stdin.isTTY) ui.progress("Paste a Syndai API key, then press Ctrl-D:");
+    const apiKey = (await readAll(io.stdin)).trim();
+    if (!apiKey) throw new CliError(EXIT.USAGE, "No key on stdin.", { next: "syndai login" });
+    const me = await ctx.clientFor(async () => apiKey).call("me");
+    token = { api_key: apiKey, customer_id: me.customer_id, key_id: me.key_id, expires_at: me.expires_at };
+  } else {
+    token = await deviceApproval(ctx, "CLI", extra.length ? await scopesWith(ctx, extra) : undefined);
+  }
+  await storeKey(ctx, token);
+  if (io.env.SYNDAI_API_KEY) ui.progress(ui.yellow("Note: SYNDAI_API_KEY is set and wins over this login."));
+  const expires = token.expires_at ? ` until ${token.expires_at.slice(0, 10)}` : "";
+  ui.result(
+    { customer_id: token.customer_id, key_id: token.key_id, expires_at: token.expires_at },
+    `Logged in to workspace ${token.customer_id}${expires}.`,
+  );
+  return EXIT.OK;
+}
+
+export async function logout(ctx) {
+  const { io, ui, paths } = ctx;
+  const stored = storedCredential(io, paths);
+  if (!stored) {
+    ui.result({ logged_out: false }, "Not logged in.");
+    return EXIT.OK;
+  }
+  try {
+    await ctx.clientFor(async () => stored.apiKey).call("revokeMe");
+  } catch (err) {
+    // Already revoked or expired: nothing left to revoke, so just forget it.
+    if (!(err instanceof ApiError && err.status === 401)) throw err;
+  }
+  removeCredential(paths, stored.customerId);
+  if (io.env.SYNDAI_API_KEY) ui.progress(ui.yellow("Note: SYNDAI_API_KEY is still set in this shell."));
+  ui.result(
+    { logged_out: true, customer_id: stored.customerId },
+    `Logged out of workspace ${stored.customerId}; its key is revoked.`,
+  );
+  return EXIT.OK;
+}
+
+export async function whoami(ctx) {
+  const me = await ctx.me();
+  const { source } = ctx.credential();
+  ctx.ui.result(
+    { ...me, source },
+    [
+      `Workspace  ${me.customer_id}`,
+      `Key        ${me.key_name ?? me.key_id}${me.expires_at ? ` (expires ${me.expires_at.slice(0, 10)})` : ""}`,
+      `Scopes     ${(me.scopes ?? []).join(", ")}`,
+      `From       ${source}`,
+    ].join("\n"),
+  );
+  return EXIT.OK;
+}

package/src/changes.js

@@ -0,0 +1,350 @@
+// The change lifecycle: change, watch, answer, review, go-live, revert, cancel, status,
+// edit-text. Each command is a thin call to one route plus, where there is an outcome to
+// wait for, `watchChange`.
+
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { ApiError, CliError, EXIT } from "./errors.js";
+import { projectHost, projectLabel, resolveProject } from "./projects.js";
+import { clearPending, findPending, writePending } from "./store.js";
+import { ask, parseDuration, readJsonInput, ulid } from "./ui.js";
+import { answerInteractively, describe, finish, getChange, nextFor, respond, watchChange } from "./watch.js";
+
+const TERMINAL_PHASES = new Set(["completed", "failed", "cancelled"]);
+const IMAGE_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+};
+
+const timeoutOf = (flags) => (flags.timeout ? parseDuration(flags.timeout) : null);
+
+function needRun(runId, command) {
+  if (!runId) throw new CliError(EXIT.USAGE, `Which change? syndai ${command} <run-id>`);
+  return runId;
+}
+
+export async function change(ctx, words) {
+  const { flags, ui, paths, io } = ctx;
+  const text = words.join(" ").trim();
+  if (!text) throw new CliError(EXIT.USAGE, 'Say what to change: syndai change "make the header blue"');
+  const timeoutMs = timeoutOf(flags);
+  const project = await resolveProject(ctx, { app: flags.app });
+  const outcome = flags.review ? "opens a pull request for your review" : "goes live when checks pass";
+  ui.progress(`Changing ${projectHost(project)} · ${outcome}`);
+
+  const imageRefs = [];
+  for (const file of flags.image ?? []) imageRefs.push(await uploadImage(ctx, file));
+
+  // The request id is on disk BEFORE the POST: a retry, or a rerun after a crash, sends the
+  // same external_request_id, and the server answers with the run it already made.
+  const pending = findPending(paths, { app: project.id, text }) ?? {
+    request_id: `cli:${ulid()}`,
+    app: project.id,
+    text,
+    created_at: new Date(io.now()).toISOString(),
+  };
+  writePending(paths, pending);
+  const runId = await createRun(ctx, {
+    body: {
+      prompt: text,
+      coding_repository_id: project.id,
+      external_request_id: pending.request_id,
+      ...(imageRefs.length ? { image_refs: imageRefs } : {}),
+      ...(flags.review ? { policy_config: { autonomy: "auto" } } : {}),
+    },
+  });
+  clearPending(paths, pending.request_id);
+  ui.progress(ui.dim(`Change ${runId}`));
+  if (flags["no-wait"]) {
+    return finish(ctx, await getChange(ctx, runId), { exitCode: EXIT.OK, next: `syndai watch ${runId}` });
+  }
+  return watchChange(ctx, runId, { timeoutMs });
+}
+
+/** The first non-GitHub product URL in the text, normalised to https; null when there is none.
+ * Same rule as Build home (portal-v2 `productUrlFromText`): a GitHub URL means an existing repo. */
+export function productUrlFromText(text) {
+  for (const m of text.matchAll(/\b(?:https?:\/\/|www\.)[^\s<>"')\]]+/gi)) {
+    const raw = m[0].replace(/[.,;:!?]+$/, "");
+    try {
+      const url = new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`);
+      const host = url.hostname.toLowerCase();
+      if (!host.includes(".") || host === "github.com" || host.endsWith(".github.com")) continue;
+      return url.href;
+    } catch {}
+  }
+  return null;
+}
+
+/** Build-home parity: start a New project. A product URL in the text makes it "your own version
+ * of X" (SPEC-build-your-own D5) unless --no-learn; its feature-pick question is asked inline. */
+export async function newProject(ctx, words) {
+  const { flags, ui, paths, io } = ctx;
+  const text = words.join(" ").trim();
+  if (!text) throw new CliError(EXIT.USAGE, 'Say what to build: syndai new "a booking site for my salon"');
+  const timeoutMs = timeoutOf(flags);
+  const reference = flags["no-learn"] ? null : productUrlFromText(text);
+  ui.progress(
+    reference
+      ? `New project · your own version of ${new URL(reference).hostname.replace(/^www\./, "")}`
+      : "New project",
+  );
+  const pending = findPending(paths, { app: "new", text }) ?? {
+    request_id: `cli:${ulid()}`,
+    app: "new",
+    text,
+    created_at: new Date(io.now()).toISOString(),
+  };
+  writePending(paths, pending);
+  const runId = await createRun(ctx, {
+    body: {
+      prompt: text,
+      new_repository: { scaffold: "syndai-web" },
+      external_request_id: pending.request_id,
+      ...(reference ? { metadata: { reference_product: { kind: "url", value: reference } } } : {}),
+    },
+  });
+  clearPending(paths, pending.request_id);
+  ui.progress(ui.dim(`Change ${runId}`));
+  if (flags["no-wait"]) {
+    return finish(ctx, await getChange(ctx, runId), { exitCode: EXIT.OK, next: `syndai watch ${runId}` });
+  }
+  return watchChange(ctx, runId, { timeoutMs });
+}
+
+async function createRun(ctx, { body }) {
+  try {
+    const created = await ctx.client.call("createRun", { body, retry: true });
+    return created.run.id;
+  } catch (err) {
+    if (!(err instanceof ApiError && err.code === "IDEMPOTENCY_REPLAY")) throw err;
+    const location = err.headers?.get("location") ?? "";
+    const fromLocation = /\/runs\/([^/?#]+)/.exec(location)?.[1];
+    const runId = fromLocation ?? err.problem.existing_run_id;
+    if (!runId) throw err;
+    return runId;
+  }
+}
+
+async function uploadImage(ctx, file) {
+  const contentType = IMAGE_TYPES[path.extname(file).toLowerCase()];
+  if (!contentType)
+    throw new CliError(EXIT.USAGE, `--image takes a png, jpeg, gif or webp file, not ${file}.`);
+  let bytes;
+  try {
+    bytes = readFileSync(file);
+  } catch {
+    throw new CliError(EXIT.USAGE, `Cannot read ${file}.`);
+  }
+  const stored = await ctx.client.call("imageIngest", {
+    body: { content_type: contentType, data_base64: bytes.toString("base64") },
+  });
+  return { object_key: stored.object_key, content_type: contentType };
+}
+
+export async function watch(ctx, runId) {
+  return watchChange(ctx, needRun(runId, "watch"), {
+    timeoutMs: timeoutOf(ctx.flags),
+    logs: ctx.flags.logs === true,
+  });
+}
+
+export async function answer(ctx, runId) {
+  const { flags, ui } = ctx;
+  needRun(runId, "answer");
+  const state = await getChange(ctx, runId);
+  const questions = state.state === "needs_input" ? (state.needs_input ?? []) : [];
+  if (questions.length === 0) {
+    ui.result({ ...state, next: nextFor(state) }, `Nothing to answer. ${describe(state)}`);
+    return EXIT.OK;
+  }
+  if (flags.input !== undefined) {
+    const body = await readJsonInput(ctx.io, flags.input);
+    const entries = Array.isArray(body) ? body : body?.entries;
+    const hitlRequestId =
+      body?.hitl_request_id ?? (questions.length === 1 ? questions[0].hitl_request_id : null);
+    if (!hitlRequestId || !Array.isArray(entries)) {
+      throw new CliError(
+        EXIT.USAGE,
+        '--input needs {"entries":[...]}, and hitl_request_id when several questions are open.',
+      );
+    }
+    await respond(ctx, runId, hitlRequestId, entries);
+  } else if (ui.interactive) {
+    await answerInteractively(ctx, runId, questions);
+  } else {
+    return finish(ctx, state);
+  }
+  const next = `syndai watch ${runId}`;
+  ui.result({ run_id: runId, answered: true, next }, "Answered.");
+  if (!ui.json) ui.progress(`Next: ${next}`);
+  return EXIT.OK;
+}
+
+export async function review(ctx, runId) {
+  const { flags, ui, io, client } = ctx;
+  needRun(runId, "review");
+  if (flags.retry && flags.close) throw new CliError(EXIT.USAGE, "Pick one of --retry and --close.");
+  const params = { run_id: runId };
+  const state = await getChange(ctx, runId);
+  if (state.state !== "held") return finish(ctx, state);
+  if (flags.retry) {
+    await client.call("landRetry", { params });
+    ui.progress("Running the checks again.");
+    return watchChange(ctx, runId, { untilNot: "held" });
+  }
+  if (flags.close) {
+    await client.call("landClose", { params });
+    ui.result({ run_id: runId, closed: true }, "Closed. Nothing went live.");
+    return EXIT.OK;
+  }
+  const diff = await client.call("heldDiff", { params });
+  const reviewUrl = state.held?.review_url ?? null;
+  if (ui.json) {
+    ui.result({ ...state, held_diff: diff, next: reviewUrl ?? nextFor(state) }, "");
+    return EXIT.NEEDS_YOU;
+  }
+  await io.page(renderHeldDiff(state, diff));
+  if (!ui.interactive || !reviewUrl) {
+    ui.progress(`Next: ${reviewUrl ?? `syndai review ${runId}`}`);
+    return EXIT.NEEDS_YOU;
+  }
+  const yes = (await ask(io, "Approve in your browser? [Y/n] ")).toLowerCase();
+  if (yes && !yes.startsWith("y")) {
+    ui.progress(`Next: syndai review ${runId}`);
+    return EXIT.NEEDS_YOU;
+  }
+  ui.progress(`Opening ${reviewUrl}`);
+  io.openUrl(reviewUrl);
+  ui.progress(ui.dim("Waiting for your decision (Ctrl-C stops watching, not the review)..."));
+  return watchChange(ctx, runId, { untilNot: "held" });
+}
+
+export function renderHeldDiff(state, diff) {
+  const lines = [describe(state)];
+  if (diff.head_sha) {
+    const by = diff.expires_at ? ` · decide by ${diff.expires_at.slice(0, 10)}` : "";
+    lines.push(`At ${diff.head_sha.slice(0, 12)}${by}`);
+  }
+  lines.push("", "Files:");
+  for (const file of diff.paths ?? []) {
+    const modes =
+      file.old_mode !== file.new_mode && file.new_mode
+        ? ` (${file.old_mode ?? "none"} -> ${file.new_mode})`
+        : "";
+    lines.push(`  ${file.change.padEnd(10)} ${file.path}${modes}`);
+  }
+  for (const file of diff.paths ?? []) {
+    lines.push("", `--- ${file.path}`);
+    lines.push(file.binary ? "(binary file)" : (file.diff ?? "(no text diff)"));
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+export async function goLive(ctx, runId) {
+  needRun(runId, "go-live");
+  await ctx.client.call("goLive", { params: { run_id: runId } });
+  ctx.ui.progress("Going live.");
+  return watchChange(ctx, runId, { timeoutMs: timeoutOf(ctx.flags), untilNot: "ready" });
+}
+
+export async function revert(ctx, runId) {
+  needRun(runId, "revert");
+  let reverted;
+  try {
+    // Idempotent per landing: a retry returns the same revert change.
+    reverted = await ctx.client.call("revert", {
+      params: { run_id: runId },
+      body: { force: ctx.flags.force === true },
+      retry: true,
+    });
+  } catch (err) {
+    if (err instanceof ApiError && String(err.problem.detail ?? "").startsWith("revert_conflict")) {
+      throw new CliError(EXIT.FAILED, "Newer changes landed on top of this one.", {
+        next: `syndai revert ${runId} --force`,
+      });
+    }
+    throw err;
+  }
+  ctx.ui.progress(`Reverting with change ${reverted.run.id}.`);
+  return watchChange(ctx, reverted.run.id, { timeoutMs: timeoutOf(ctx.flags) });
+}
+
+export async function cancel(ctx, runId) {
+  needRun(runId, "cancel");
+  await ctx.client.call("cancel", { params: { run_id: runId }, body: {} });
+  ctx.ui.result({ run_id: runId, cancelled: true }, "Cancelled.");
+  return EXIT.OK;
+}
+
+export async function status(ctx) {
+  const { client, ui, flags } = ctx;
+  const project = await resolveProject(ctx, { app: flags.app, required: false, picker: false });
+  const query = { coding_repository_id: project?.id, limit: 20 };
+  const [needs, recent] = await Promise.all([
+    client.call("listRuns", { query: { ...query, needs: "owner" } }),
+    client.call("listRuns", { query }),
+  ]);
+  // The ChangeState names the exact next command, so read it rather than guess from the run.
+  const needsYou = await Promise.all(
+    needs.runs.slice(0, 10).map(async (run) => ({ run, state: await getChange(ctx, run.id) })),
+  );
+  const needIds = new Set(needs.runs.map((run) => run.id));
+  const active = recent.runs.filter((run) => !TERMINAL_PHASES.has(run.current_phase) && !needIds.has(run.id));
+  const title = (run) => run.title ?? run.prompt?.slice(0, 60) ?? run.id;
+  const lines = [];
+  if (project) lines.push(ui.bold(projectLabel(project)));
+  if (needsYou.length) {
+    lines.push("Needs you:");
+    for (const { run, state } of needsYou)
+      lines.push(`  ${title(run)}  ${describe(state)}  -> ${nextFor(state)}`);
+  }
+  if (active.length) {
+    lines.push("Running:");
+    for (const run of active) lines.push(`  ${title(run)}  ${run.current_phase}  -> syndai watch ${run.id}`);
+  }
+  if (!needsYou.length && !active.length) lines.push("Nothing needs you, and nothing is running.");
+  ui.result(
+    {
+      project: project ? { id: project.id, name: project.name, live_url: project.live_url } : null,
+      needs_you: needsYou.map(({ state }) => ({ ...state, next: nextFor(state) })),
+      running: active.map((run) => ({ run_id: run.id, title: title(run), phase: run.current_phase })),
+    },
+    lines.join("\n"),
+  );
+  return EXIT.OK;
+}
+
+export async function editText(ctx) {
+  const { flags, ui, client } = ctx;
+  const project = await resolveProject(ctx, { app: flags.app });
+  const params = { coding_repository_id: project.id };
+  if (flags.undo) {
+    const undone = await client.call("undoTextEdit", { params: { ...params, sha: flags.undo }, retry: true });
+    ui.result(undone, `Undone on ${projectHost(project)}.`);
+    return EXIT.OK;
+  }
+  if (flags.from === undefined || flags.to === undefined) {
+    throw new CliError(EXIT.USAGE, 'Give the exact text: syndai edit-text --page / --from "Old" --to "New"');
+  }
+  const pagePath = flags.page ?? "/";
+  const edited = await client.call("textEdit", {
+    params,
+    body: {
+      page: pagePath,
+      before: flags.from,
+      after: flags.to,
+      all: flags.all === true,
+      request_id: randomUUID(),
+    },
+    retry: true,
+  });
+  const next = `syndai edit-text --app ${project.id} --undo ${edited.commit_sha}`;
+  ui.result({ ...edited, next }, `Edited ${projectHost(project)}${pagePath}; live in a few seconds.`);
+  if (!ui.json) ui.progress(`Undo: ${next}`);
+  return EXIT.OK;
+}