revyse 0.1.0 → 0.2.0

package/dist/headless.js

@@ -3116,9 +3116,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path29) {
-    if (path29 === void 0) return this._executableDir;
-    this._executableDir = path29;
+  executableDir(path30) {
+    if (path30 === void 0) return this._executableDir;
+    this._executableDir = path30;
     return this;
   }
   /**
@@ -3374,8 +3374,8 @@ function useColor() {
 var program = new Command();
 
 // src/commands/change.ts
-import { readFileSync as readFileSync12 } from "fs";
-import path28 from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import path29 from "path";
 
 // ../agent-core/src/path-policy.ts
 import { realpathSync } from "fs";
@@ -4292,10 +4292,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path29) {
-  if (!path29)
+function getElementAtPath(obj, path30) {
+  if (!path30)
     return obj;
-  return path29.reduce((acc, key) => acc?.[key], obj);
+  return path30.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4635,11 +4635,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path29, issues) {
+function prefixIssues(path30, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path29);
+    iss.path.unshift(path30);
     return iss;
   });
 }
@@ -5101,16 +5101,16 @@ function flattenError(error62, mapper = (issue2) => issue2.message) {
 }
 function formatError(error62, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error63, path29 = []) => {
+  const processError = (error63, path30 = []) => {
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path29, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path30, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path30, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path30, ...issue2.path]);
       } else {
-        const fullpath = [...path29, ...issue2.path];
+        const fullpath = [...path30, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -5149,17 +5149,17 @@ function formatError(error62, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error62, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error63, path29 = []) => {
+  const processError = (error63, path30 = []) => {
     var _a3;
     for (const issue2 of error63.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path29, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path30, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path30, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path29, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path30, ...issue2.path]);
       } else {
-        const fullpath = [...path29, ...issue2.path];
+        const fullpath = [...path30, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5198,8 +5198,8 @@ function treeifyError(error62, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path29 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path29) {
+  const path30 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path30) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -6301,9 +6301,9 @@ var asciiTabOrNewline = /[\t\n\r]/g;
 function stripTabAndNewline(value) {
   return value.replace(asciiTabOrNewline, "");
 }
-function urlHostnameOk(url2, hostname3) {
-  hostname3.lastIndex = 0;
-  return hostname3.test(url2.hostname);
+function urlHostnameOk(url2, hostname4) {
+  hostname4.lastIndex = 0;
+  return hostname4.test(url2.hostname);
 }
 function urlProtocolOk(url2, protocol) {
   protocol.lastIndex = 0;
@@ -22337,13 +22337,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path29 = ref.slice(1).split("/").filter(Boolean);
-  if (path29.length === 0) {
+  const path30 = ref.slice(1).split("/").filter(Boolean);
+  if (path30.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path29[0] === defsKey) {
-    const key = path29[1] === void 0 ? void 0 : decodeJSONPointerSegment(path29[1]);
+  if (path30[0] === defsKey) {
+    const key = path30[1] === void 0 ? void 0 : decodeJSONPointerSegment(path30[1]);
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24641,16 +24641,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path29, added, removed, oldPosInc, options) {
-    const last = path29.lastComponent;
+  addToPath(path30, added, removed, oldPosInc, options) {
+    const last = path30.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path29.oldPos + oldPosInc,
+        oldPos: path30.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path29.oldPos + oldPosInc,
+        oldPos: path30.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -30455,17 +30455,17 @@ var writeToFiles = (chunks, stdioItems, outputFiles) => {
   const writtenPaths = /* @__PURE__ */ new Set();
   for (const stdioItem of fileItems) {
     const { type, append } = stdioItem;
-    const path29 = type === "fileNumber" ? stdioItem.path : getFileTarget(stdioItem);
-    if (writtenPaths.has(path29)) {
+    const path30 = type === "fileNumber" ? stdioItem.path : getFileTarget(stdioItem);
+    if (writtenPaths.has(path30)) {
       continue;
     }
-    writtenPaths.add(path29);
-    if (append || outputFiles.has(path29)) {
-      appendFileSync(path29, contents);
+    writtenPaths.add(path30);
+    if (append || outputFiles.has(path30)) {
+      appendFileSync(path30, contents);
     } else {
-      writeFileSync2(path29, contents);
+      writeFileSync2(path30, contents);
     }
-    outputFiles.add(path29);
+    outputFiles.add(path30);
   }
 };
 
@@ -33611,7 +33611,7 @@ function createAgentApi(opts) {
   const f = opts.fetch ?? fetch;
   const base = opts.apiUrl.replace(/\/+$/, "");
   const auth = { authorization: `Bearer ${opts.token}` };
-  const call = (path29, body, signal) => f(`${base}${path29}`, {
+  const call = (path30, body, signal) => f(`${base}${path30}`, {
     method: "POST",
     headers: { "content-type": "application/json", ...auth },
     body: JSON.stringify(body),
@@ -33627,18 +33627,18 @@ function createAgentApi(opts) {
   }
   return {
     baseUrl: base,
-    async get(path29) {
-      const res = await f(`${base}${path29}`, { headers: auth });
+    async get(path30) {
+      const res = await f(`${base}${path30}`, { headers: auth });
       if (!res.ok) throw await failure2(res);
       return await res.json();
     },
-    async post(path29, body) {
-      const res = await call(path29, body);
+    async post(path30, body) {
+      const res = await call(path30, body);
       if (!res.ok) throw await failure2(res);
       return await res.json();
     },
-    async *stream(path29, body, signal) {
-      const res = await call(path29, body, signal);
+    async *stream(path30, body, signal) {
+      const res = await call(path30, body, signal);
       if (!res.ok) throw await failure2(res);
       if (!res.body) return;
       const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
@@ -33823,27 +33823,27 @@ var StagedFiles = class {
   /** Paths written by the package manager (I7), not by the model: the write rules don't apply. */
   fromPackageManager = /* @__PURE__ */ new Set();
   /** Current content as the agent sees it: staged if written, else the project's. */
-  async read(path29) {
-    const s = this.staged.get(path29);
+  async read(path30) {
+    const s = this.staged.get(path30);
     if (s) return s.content;
-    const content = await this.host.read(path29);
-    if (!this.seen.has(path29)) this.seen.set(path29, content === null ? null : hashContent(content));
+    const content = await this.host.read(path30);
+    if (!this.seen.has(path30)) this.seen.set(path30, content === null ? null : hashContent(content));
     return content;
   }
   /** Like `read`, without recording a snapshot: for searching, which only looks. */
-  async peek(path29) {
-    const s = this.staged.get(path29);
-    return s ? s.content : this.host.read(path29);
+  async peek(path30) {
+    const s = this.staged.get(path30);
+    return s ? s.content : this.host.read(path30);
   }
   /** Writes `content` (or deletes, with null) in the staging layer. */
-  async write(path29, content) {
-    const existing = this.staged.get(path29);
+  async write(path30, content) {
+    const existing = this.staged.get(path30);
     if (existing) {
       existing.content = content;
       return;
     }
-    const before = await this.read(path29);
-    this.staged.set(path29, {
+    const before = await this.read(path30);
+    this.staged.set(path30, {
       content,
       existed: before !== null,
       baseHash: before === null ? null : hashContent(before)
@@ -33854,9 +33854,9 @@ var StagedFiles = class {
    * a supported SDK). The patch engine applies it with the rest, so it lands, is checked and is
    * reverted together; the write rules that keep the model out of these files don't apply.
    */
-  async writeFromPackageManager(path29, content) {
-    await this.write(path29, content);
-    this.fromPackageManager.add(path29);
+  async writeFromPackageManager(path30, content) {
+    await this.write(path30, content);
+    this.fromPackageManager.add(path30);
   }
   /** The paths the package manager wrote. */
   packageManagerPaths() {
@@ -33874,18 +33874,18 @@ var StagedFiles = class {
   /** What the apply phase changed, net: a file created then deleted is no change at all. */
   changes() {
     const out = [];
-    for (const [path29, s] of [...this.staged].sort(([a2], [b]) => a2.localeCompare(b))) {
+    for (const [path30, s] of [...this.staged].sort(([a2], [b]) => a2.localeCompare(b))) {
       if (!s.existed && s.content === null) continue;
-      if (!s.existed) out.push({ path: path29, kind: "create", content: s.content });
-      else if (s.content === null) out.push({ path: path29, kind: "delete", baseHash: s.baseHash });
+      if (!s.existed) out.push({ path: path30, kind: "create", content: s.content });
+      else if (s.content === null) out.push({ path: path30, kind: "delete", baseHash: s.baseHash });
       else if (hashContent(s.content) !== s.baseHash)
-        out.push({ path: path29, kind: "modify", content: s.content, baseHash: s.baseHash });
+        out.push({ path: path30, kind: "modify", content: s.content, baseHash: s.baseHash });
     }
     return out;
   }
   /** Every file the agent read or wrote, with its hash when first seen (null: didn't exist). */
   snapshots() {
-    return [...this.seen].map(([path29, hash2]) => ({ path: path29, hash: hash2 })).sort((a2, b) => a2.path.localeCompare(b.path));
+    return [...this.seen].map(([path30, hash2]) => ({ path: path30, hash: hash2 })).sort((a2, b) => a2.path.localeCompare(b.path));
   }
 };
 
@@ -33922,7 +33922,7 @@ var ok = (callId, output2) => ({
   output: output2,
   isError: false
 });
-var secretFile = (path29) => `Can't change ${path29}: it looks like it contains a secret. Leave it, and name it in notDone so the developer moves the secret to an environment variable.`;
+var secretFile = (path30) => `Can't change ${path30}: it looks like it contains a secret. Leave it, and name it in notDone so the developer moves the secret to an environment variable.`;
 var fail = (callId, output2) => ({
   callId,
   output: output2,
@@ -33965,12 +33965,12 @@ function createToolRuntime(opts) {
       const found = [];
       let withheld = 0;
       let stopped = false;
-      for (const path29 of await visible(input2.path, input2.glob)) {
+      for (const path30 of await visible(input2.path, input2.glob)) {
         if (found.length >= max || Date.now() - started > budget) {
           stopped = true;
           break;
         }
-        const content = await staging.peek(path29);
+        const content = await staging.peek(path30);
         if (content === null) continue;
         if (containsSecret(content)) {
           withheld++;
@@ -33982,7 +33982,7 @@ function createToolRuntime(opts) {
           if (line.length > MAX_SEARCH_LINE || !matches(line)) continue;
           const text = line.trim();
           found.push(
-            `${path29}:${i2 + 1}: ${text.length > MAX_LINE ? `${text.slice(0, MAX_LINE)}\u2026` : text}`
+            `${path30}:${i2 + 1}: ${text.length > MAX_LINE ? `${text.slice(0, MAX_LINE)}\u2026` : text}`
           );
         }
       }
@@ -34183,7 +34183,7 @@ function createChangeRunner(opts) {
     log(`change ${changeId ?? "(new)"} failed: ${err.message}`);
     fail2(session, changeId, {
       code: "internal",
-      message: "Something went wrong in the Revyse agent. Check the `revyse dev` output.",
+      message: "Something went wrong in the Revyse agent. Check your dev server's output.",
       retryable: true
     });
   }
@@ -34201,7 +34201,7 @@ function createChangeRunner(opts) {
   }
   function sessionOf(changeId) {
     const s = sessions.get(changeId);
-    if (!s) throw new Error("This change isn't open in this `revyse dev` session");
+    if (!s) throw new Error("This change isn't open in this session of your dev server");
     return s;
   }
   function readFiles(paths) {
@@ -34302,7 +34302,7 @@ function createChangeRunner(opts) {
       `/api/changes/${session.id}/plan`,
       {
         element: session.element,
-        files: gathered.files.map(({ path: path29, content, hash: hash2 }) => ({ path: path29, content, hash: hash2 })),
+        files: gathered.files.map(({ path: path30, content, hash: hash2 }) => ({ path: path30, content, hash: hash2 })),
         modelTier: session.tier,
         model: session.model,
         ...extra
@@ -34396,11 +34396,11 @@ function createChangeRunner(opts) {
     if (!patch) return;
     const [browser, baseline] = await Promise.all([browserPrep, baselinePrep]);
     session.stage = "applying";
-    const snapshots = files.map(({ path: path29, hash: hash2 }) => ({ path: path29, hash: hash2 }));
+    const snapshots = files.map(({ path: path30, hash: hash2 }) => ({ path: path30, hash: hash2 }));
     const applied = applyPatch({
       projectRoot: opts.projectRoot,
       changeId: session.id,
-      patch: { files: patch.files.map(({ path: path29, edits }) => ({ path: path29, edits })) },
+      patch: { files: patch.files.map(({ path: path30, edits }) => ({ path: path30, edits })) },
       snapshots
     });
     if (applied.status === "conflict") {
@@ -34978,13 +34978,113 @@ ${r.output.slice(-3e3)}`,
   };
 }
 
+// src/api-client.ts
+var DEFAULT_API_URL = "https://revyse.dev";
+function resolveApiUrl(flag, env = process.env) {
+  return (flag || env.REVYSE_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+}
+var ApiError = class extends Error {
+  constructor(status, code2, message) {
+    super(message);
+    this.status = status;
+    this.code = code2;
+    this.name = "ApiError";
+  }
+  status;
+  code;
+};
+function createApiClient({ apiUrl, token, fetch: f = fetch }) {
+  async function request(method, path30, body) {
+    const res = await f(`${apiUrl}${path30}`, {
+      method,
+      headers: {
+        "content-type": "application/json",
+        ...token ? { authorization: `Bearer ${token}` } : {}
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      const code2 = data.error?.code ?? "error";
+      throw new ApiError(res.status, code2, data.error?.message ?? `Request failed (${res.status})`);
+    }
+    return data;
+  }
+  return {
+    get: (path30) => request("GET", path30),
+    post: (path30, body) => request("POST", path30, body ?? {})
+  };
+}
+
+// src/connect.ts
+import { spawn as spawn2 } from "child_process";
+import { hostname as hostname3 } from "os";
+
+// src/credentials.ts
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { homedir } from "os";
+import path25 from "path";
+function credentialsPath(env = process.env) {
+  const base = env.XDG_CONFIG_HOME || path25.join(homedir(), ".config");
+  return path25.join(base, "revyse", "credentials.json");
+}
+function readAll(file2) {
+  if (!existsSync4(file2)) return {};
+  return JSON.parse(readFileSync9(file2, "utf8"));
+}
+function writeAll(file2, data) {
+  mkdirSync3(path25.dirname(file2), { recursive: true, mode: 448 });
+  writeFileSync5(file2, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+  chmodSync(file2, 384);
+}
+function loadCredential(projectRoot, file2 = credentialsPath()) {
+  return readAll(file2)[path25.resolve(projectRoot)] ?? null;
+}
+function saveCredential(projectRoot, cred, file2 = credentialsPath()) {
+  writeAll(file2, { ...readAll(file2), [path25.resolve(projectRoot)]: cred });
+}
+
+// src/device-login.ts
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function deviceLogin({
+  client,
+  clientName,
+  onCode,
+  sleep = defaultSleep
+}) {
+  const start = await client.post("/api/cli/device", { clientName });
+  onCode(start);
+  let interval = start.interval;
+  const deadline = Date.now() + start.expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    try {
+      return await client.post("/api/cli/token", { deviceCode: start.deviceCode });
+    } catch (err) {
+      if (!(err instanceof ApiError)) throw err;
+      if (err.code === "authorization_pending") continue;
+      if (err.code === "slow_down") {
+        interval += 5;
+        continue;
+      }
+      if (err.code === "access_denied") {
+        throw new Error("Login was denied in the browser.", { cause: err });
+      }
+      if (err.code === "expired_token") break;
+      throw err;
+    }
+  }
+  throw new Error("Login code expired. Run `revyse login` again.");
+}
+
 // src/init-flow.ts
-import { existsSync as existsSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
-import path27 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
+import path28 from "path";
 
 // src/detect.ts
-import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
+import path26 from "path";
 var LOCKFILES2 = [
   ["pnpm-lock.yaml", "pnpm"],
   ["yarn.lock", "yarn"],
@@ -34994,11 +35094,11 @@ var LOCKFILES2 = [
 ];
 var SOURCE_DIR_CANDIDATES = ["src", "app", "pages", "components", "lib"];
 function detectProject(root) {
-  const pkgPath = path25.join(root, "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = path26.join(root, "package.json");
+  if (!existsSync5(pkgPath)) {
     throw new Error(`No package.json found in ${root}. Run revyse init from your project root.`);
   }
-  const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
   const warnings = [];
   const framework = detectFramework(deps);
@@ -35007,13 +35107,13 @@ function detectProject(root) {
   } else if (framework !== "nextjs") {
     warnings.push(`${framework} support is experimental; Next.js is the supported target.`);
   }
-  const managers = LOCKFILES2.filter(([file2]) => existsSync4(path25.join(root, file2)));
+  const managers = LOCKFILES2.filter(([file2]) => existsSync5(path26.join(root, file2)));
   const packageManager = managers[0]?.[1] ?? "npm";
   if (managers.length === 0) warnings.push("No lockfile found; defaulting to npm.");
   if (new Set(managers.map(([, m]) => m)).size > 1) {
     warnings.push(`Multiple lockfiles found; using ${packageManager}.`);
   }
-  const sourceDirs = SOURCE_DIR_CANDIDATES.filter((d) => existsSync4(path25.join(root, d)));
+  const sourceDirs = SOURCE_DIR_CANDIDATES.filter((d) => existsSync5(path26.join(root, d)));
   for (const d of aliasedDirs(root)) if (!sourceDirs.includes(d)) sourceDirs.push(d);
   if (sourceDirs.length === 0) {
     warnings.push("No source directories found; edit sourceDirs in revyse.config.json.");
@@ -35086,17 +35186,17 @@ function hasSource(dir, depth = 3) {
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
     if (entry.isFile() && SOURCE_FILE.test(entry.name)) return true;
     if (entry.isDirectory() && depth > 1 && !NOT_SOURCE.has(entry.name)) {
-      if (hasSource(path25.join(dir, entry.name), depth - 1)) return true;
+      if (hasSource(path26.join(dir, entry.name), depth - 1)) return true;
     }
   }
   return false;
 }
 function aliasedDirs(root) {
-  const file2 = ["tsconfig.json", "jsconfig.json"].map((f) => path25.join(root, f)).find((f) => existsSync4(f));
+  const file2 = ["tsconfig.json", "jsconfig.json"].map((f) => path26.join(root, f)).find((f) => existsSync5(f));
   if (!file2) return [];
   let compilerOptions;
   try {
-    compilerOptions = parseJsonc(readFileSync9(file2, "utf8")).compilerOptions;
+    compilerOptions = parseJsonc(readFileSync10(file2, "utf8")).compilerOptions;
   } catch {
     return [];
   }
@@ -35104,15 +35204,15 @@ function aliasedDirs(root) {
   const baseUrl = compilerOptions?.baseUrl ?? ".";
   const dirs = /* @__PURE__ */ new Set();
   for (const target of Object.values(paths).flat()) {
-    const rel = path25.relative(root, path25.join(root, baseUrl, target)).split(path25.sep).join("/");
+    const rel = path26.relative(root, path26.join(root, baseUrl, target)).split(path26.sep).join("/");
     const top = rel.split("/")[0];
     if (rel.startsWith("..") || NOT_SOURCE.has(top)) continue;
     if (top === "*" || top === "") {
       for (const entry of readdirSync4(root, { withFileTypes: true }))
         if (entry.isDirectory() && !NOT_SOURCE.has(entry.name) && !entry.name.startsWith(".")) {
-          if (hasSource(path25.join(root, entry.name))) dirs.add(entry.name);
+          if (hasSource(path26.join(root, entry.name))) dirs.add(entry.name);
         }
-    } else if (existsSync4(path25.join(root, top)) && statSync6(path25.join(root, top)).isDirectory()) {
+    } else if (existsSync5(path26.join(root, top)) && statSync6(path26.join(root, top)).isDirectory()) {
       dirs.add(top);
     }
   }
@@ -35154,8 +35254,8 @@ Full policy: ${DATA_HANDLING_URL}
 `;
 
 // src/next-config.ts
-import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
-import path26 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync11 } from "fs";
+import path27 from "path";
 
 // ../../node_modules/.pnpm/@babel+parser@8.0.7/node_modules/@babel/parser/lib/index.js
 var Position = class {
@@ -50913,7 +51013,7 @@ var NEXT_CONFIG_FILES = [
 ];
 function findNextConfig(root) {
   for (const name of NEXT_CONFIG_FILES) {
-    if (existsSync5(path26.join(root, name))) return name;
+    if (existsSync6(path27.join(root, name))) return name;
   }
   return null;
 }
@@ -50968,20 +51068,72 @@ ${importLine}`);
   return { status: "unsupported", reason: "it has no `export default` or `module.exports`" };
 }
 function readNextConfig(root, file2) {
-  return readFileSync10(path26.join(root, file2), "utf8");
+  return readFileSync11(path27.join(root, file2), "utf8");
 }
 
+// src/version.ts
+import { createRequire } from "module";
+var VERSION = createRequire(import.meta.url)("../package.json").version;
+
 // src/init-flow.ts
 var CONFIG_FILE = "revyse.config.json";
 var GITIGNORE_ENTRY = ".revyse/";
+var PACKAGES = ["revyse", "@revyse/next"];
+var INSTALL = {
+  npm: ["npm", "install", "--save-dev", "--no-audit", "--no-fund"],
+  pnpm: ["pnpm", "add", "--save-dev"],
+  yarn: ["yarn", "add", "--dev"],
+  bun: ["bun", "add", "--dev"]
+};
+var installCommand = (pm, specs) => [
+  ...INSTALL[pm],
+  ...specs
+];
+var runScript = (pm, script) => pm === "npm" ? `npm run ${script}` : `${pm} ${script}`;
 async function runInit(opts, io) {
   const { root } = opts;
-  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const ask = (q) => opts.yes ? Promise.resolve(true) : io.confirm(q);
-  if (existsSync6(path27.join(root, CONFIG_FILE)) && !opts.force) {
-    io.warn(`${CONFIG_FILE} already exists. Use --force to re-run init.`);
-    return { status: "exists" };
+  let configured;
+  let status;
+  if (existsSync7(path28.join(root, CONFIG_FILE)) && !opts.force) {
+    const config3 = projectConfigSchema.parse(
+      JSON.parse(readFileSync12(path28.join(root, CONFIG_FILE), "utf8"))
+    );
+    io.log(`${CONFIG_FILE} is already here; checking the rest of the setup.`);
+    if (!config3.dataDisclosure || config3.dataDisclosure.version < DISCLOSURE_VERSION)
+      io.warn(
+        "How Revyse handles your code has changed: run `npx revyse init --force` to review it."
+      );
+    configured = { config: config3, nextConfigEdited: false };
+    status = "exists";
+  } else {
+    configured = await configure(opts, io, ask);
+    if (!configured) return { status: "declined" };
+    status = "initialized";
+  }
+  const { config: config2 } = configured;
+  const nextjs = config2.framework === "nextjs";
+  let installed = !nextjs;
+  if (nextjs && opts.setup) installed = await installPackages(root, config2, opts.setup, io, ask);
+  let connection = null;
+  if (opts.setup && opts.connect !== false)
+    connection = await connectProject(root, config2, opts.setup, io, ask);
+  if (nextjs) {
+    const steps = [
+      ...installed ? [] : [`install ${PACKAGES.join(" and ")} as dev dependencies`],
+      ...connection ? [] : ["connect it to Revyse with `npx revyse login`"]
+    ];
+    io.log(
+      steps.length === 0 ? `
+Done. Start your app as usual (\`${runScript(config2.packageManager, config2.scripts.dev ?? "dev")}\`) and click the Revyse button.` : `
+Next: ${steps.join(", then ")}. Then start your app as usual.`
+    );
   }
+  return { status, ...configured, connection };
+}
+async function configure(opts, io, ask) {
+  const { root } = opts;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   const { config: config2, warnings } = detectProject(root);
   io.log(`Detected ${config2.framework} (${config2.packageManager})`);
   io.log(`Source directories: ${config2.sourceDirs.join(", ")}`);
@@ -50989,7 +51141,7 @@ async function runInit(opts, io) {
   io.log(DISCLOSURE_TEXT);
   if (!await ask("Do you accept how Revyse handles your code?")) {
     io.log("Nothing was changed. Run `revyse init` again if you change your mind.");
-    return { status: "declined" };
+    return null;
   }
   const accepted = {
     ...config2,
@@ -51022,46 +51174,146 @@ Revyse needs this change to ${file2} (it only has an effect in \`next dev\`):
         );
         if (await ask(`Apply this change to ${file2}?`))
           nextConfigEdit = { file: file2, code: result.code };
-        else
-          io.log(
-            `Skipped. Wrap the export of ${file2} with withRevyse() yourself before \`revyse dev\`.`
-          );
+        else io.log(`Skipped. Wrap the export of ${file2} with withRevyse() yourself.`);
       }
     }
   }
-  writeFileSync5(path27.join(root, CONFIG_FILE), `${JSON.stringify(accepted, null, 2)}
+  writeFileSync6(path28.join(root, CONFIG_FILE), `${JSON.stringify(accepted, null, 2)}
 `);
-  if (nextConfigEdit) writeFileSync5(path27.join(root, nextConfigEdit.file), nextConfigEdit.code);
+  if (nextConfigEdit) writeFileSync6(path28.join(root, nextConfigEdit.file), nextConfigEdit.code);
   if (ensureGitignored(root))
     io.log(`Added ${GITIGNORE_ENTRY} to .gitignore (local change history).`);
   io.log(`
 Wrote ${CONFIG_FILE}.`);
-  if (config2.framework === "nextjs") {
-    io.log(
-      hasDependency(root, "@revyse/next") ? "Next: run `revyse dev`, then start your app's dev server as usual." : `Next: add the dev dependency \`@revyse/next\` with ${config2.packageManager}, then run \`revyse dev\`.`
-    );
+  return { config: accepted, nextConfigEdited: Boolean(nextConfigEdit) };
+}
+async function installPackages(root, config2, setup2, io, ask) {
+  const missing = PACKAGES.filter((name) => !devDependencies(root)[name]);
+  if (missing.length === 0) return true;
+  const specs = missing.map((name) => `${name}@${VERSION}`);
+  const command = installCommand(config2.packageManager, specs).join(" ");
+  if (!await ask(`Install ${missing.join(" and ")} as dev dependencies (${command})?`)) {
+    io.log(`Skipped. Install them yourself: ${command}`);
+    return false;
+  }
+  try {
+    await setup2.install(root, config2.packageManager, specs);
+    io.log(`Installed ${missing.join(" and ")}.`);
+    return true;
+  } catch (err) {
+    io.warn(`Couldn't install them (${err.message}). Run: ${command}`);
+    return false;
   }
-  return { status: "initialized", config: accepted, nextConfigEdited: Boolean(nextConfigEdit) };
+}
+async function connectProject(root, config2, setup2, io, ask) {
+  const existing = await setup2.connection(root).catch(() => null);
+  if (existing) {
+    io.log(`Connected to Revyse: project "${existing.project}" (${existing.email}).`);
+    return existing;
+  }
+  if (!await ask(
+    "Connect this app to Revyse? Your browser opens to sign in and create the project."
+  ))
+    return null;
+  try {
+    const connection = await setup2.connect(root, {
+      name: projectName(root),
+      framework: config2.framework,
+      packageManager: config2.packageManager
+    });
+    io.log(`Connected to Revyse: project "${connection.project}" (${connection.email}).`);
+    return connection;
+  } catch (err) {
+    io.warn(`Couldn't connect to Revyse (${err.message}).`);
+    return null;
+  }
+}
+function projectName(root) {
+  const name = readPackageJson(root)?.name?.replace(/^@[^/]+\//, "").trim();
+  return (name || path28.basename(root)).slice(0, 100);
 }
 function ensureGitignored(root) {
-  const file2 = path27.join(root, ".gitignore");
-  const current = existsSync6(file2) ? readFileSync11(file2, "utf8") : "";
+  const file2 = path28.join(root, ".gitignore");
+  const current = existsSync7(file2) ? readFileSync12(file2, "utf8") : "";
   const lines = current.split(/\r?\n/).map((l) => l.trim());
   if (lines.includes(GITIGNORE_ENTRY) || lines.includes(".revyse")) return false;
   const separator = current === "" ? "" : current.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync5(file2, `${current}${separator}# Revyse local state
+  writeFileSync6(file2, `${current}${separator}# Revyse local state
 ${GITIGNORE_ENTRY}
 `);
   return true;
 }
-function hasDependency(root, name) {
+function readPackageJson(root) {
   try {
-    const pkg = JSON.parse(readFileSync11(path27.join(root, "package.json"), "utf8"));
-    return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
+    return JSON.parse(readFileSync12(path28.join(root, "package.json"), "utf8"));
   } catch {
-    return false;
+    return null;
   }
 }
+var devDependencies = (root) => readPackageJson(root)?.devDependencies ?? {};
+
+// src/connect.ts
+function openBrowser(url2) {
+  if (process.env.BROWSER === "none") return;
+  const [command, args] = process.platform === "darwin" ? ["open", [url2]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url2.replace(/&/g, "^&")]] : ["xdg-open", [url2]];
+  try {
+    const child = spawn2(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function activationUrl(verificationUriComplete, suggestion) {
+  if (!suggestion) return verificationUriComplete;
+  const url2 = new URL(verificationUriComplete);
+  url2.searchParams.set("name", suggestion.name);
+  url2.searchParams.set("framework", suggestion.framework);
+  url2.searchParams.set("pm", suggestion.packageManager);
+  return url2.toString();
+}
+async function connectInBrowser(opts) {
+  const { token, projectId } = await deviceLogin({
+    client: createApiClient({ apiUrl: opts.apiUrl }),
+    clientName: `revyse-cli on ${hostname3()}`,
+    onCode: ({ userCode, verificationUriComplete }) => {
+      const url2 = activationUrl(verificationUriComplete, opts.suggestion);
+      opts.log(`
+Your browser is opening to connect this app to Revyse. If it doesn't, go to:
+`);
+      opts.log(`  ${url2}
+`);
+      opts.log(`and check the code matches: ${userCode}
+`);
+      opts.log("Waiting for you to approve it\u2026");
+      (opts.open ?? openBrowser)(url2);
+    }
+  });
+  saveCredential(opts.root, { apiUrl: opts.apiUrl, token, projectId });
+  const me = await createApiClient({ apiUrl: opts.apiUrl, token }).get("/api/cli/whoami");
+  return { email: me.user.email, project: me.project.name };
+}
+async function currentConnection(root) {
+  const cred = loadCredential(root);
+  if (!cred) return null;
+  try {
+    const me = await createApiClient(cred).get("/api/cli/whoami");
+    return { email: me.user.email, project: me.project.name };
+  } catch (err) {
+    if (err instanceof ApiError && (err.status === 401 || err.status === 404)) return null;
+    throw err;
+  }
+}
+function initSetup(apiUrl, log) {
+  return {
+    install: async (root, pm, specs) => {
+      const [command, ...args] = installCommand(pm, specs);
+      await execa(command, args, { cwd: root, stdio: "inherit" });
+    },
+    connection: currentConnection,
+    connect: (root, suggestion) => connectInBrowser({ root, apiUrl, suggestion, log })
+  };
+}
 
 // src/prompt.ts
 import { createInterface } from "readline";
@@ -51092,18 +51344,29 @@ function createPrompter(input2 = process.stdin, output2 = process.stdout) {
 }
 
 // src/commands/init.ts
-var initCommand = new Command("init").description("Detect your project, review the data disclosure, and set up Revyse").option("--force", "re-run init when revyse.config.json exists").option("-y, --yes", "accept the disclosure and proposed edits without prompting").action(async (options) => {
-  const prompter = createPrompter();
-  try {
-    const outcome = await runInit(
-      { root: process.cwd(), force: options.force, yes: options.yes },
-      { log: (m) => console.log(m), warn: (m) => console.warn(m), confirm: prompter.confirm }
-    );
-    if (outcome.status !== "initialized") process.exitCode = 1;
-  } finally {
-    prompter.close();
+var initCommand = new Command("init").description(
+  "Set Revyse up in this app: the data disclosure, next.config, the packages, and the project on Revyse"
+).option("--force", "re-run the disclosure and next.config steps when revyse.config.json exists").option("-y, --yes", "accept the disclosure and proposed edits without prompting").option("--no-connect", "set up without connecting to Revyse (CI, offline)").option("--api-url <url>", "Revyse API URL (default: $REVYSE_API_URL or https://revyse.dev)").action(
+  async (options) => {
+    const prompter = createPrompter();
+    const log = (m) => console.log(m);
+    try {
+      const outcome = await runInit(
+        {
+          root: process.cwd(),
+          force: options.force,
+          yes: options.yes,
+          connect: options.connect,
+          setup: initSetup(resolveApiUrl(options.apiUrl), log)
+        },
+        { log, warn: (m) => console.warn(m), confirm: prompter.confirm }
+      );
+      if (outcome.status === "declined") process.exitCode = 1;
+    } finally {
+      prompter.close();
+    }
   }
-});
+);
 
 // src/commands/change.ts
 var changeCommand = new Command("change").description("Headless change operations");
@@ -51117,7 +51380,7 @@ var common2 = (cmd) => cmd.requiredOption("--api-url <url>", "Revyse API URL").r
 function setup(opts) {
   const root = process.cwd();
   const config2 = projectConfigSchema.parse(
-    JSON.parse(readFileSync12(path28.join(root, CONFIG_FILE), "utf8"))
+    JSON.parse(readFileSync13(path29.join(root, CONFIG_FILE), "utf8"))
   );
   const token = opts.token ?? process.env.REVYSE_TOKEN;
   if (!token) throw new Error("A project token is required (--token or REVYSE_TOKEN)");