@odeva/cli 0.0.7 → 0.0.8

package/dist/commands/app/dev.js

@@ -9,11 +9,15 @@ import { loadCredentials } from "../../lib/credentials.js";
 import { adminUrl } from "../../lib/paths.js";
 import {
   cleanupSubscriptions,
+  ensureDevAppInstalled,
   preflightChecks,
   registeredWebhookEnv,
   registerWebhookSubscriptions,
   spawnDevServer,
+  syncDevAppUrls,
   watchedDevInputPaths,
+  waitForLocalDevServer,
+  waitForDevServerReachable,
   writeDevEnvFile
 } from "../../lib/dev-runner.js";
 import { CliError } from "../../lib/errors.js";
@@ -53,11 +57,19 @@ class AppDev extends Command {
         return;
       }
       const api = new OdevaApi();
-      const tunnelSpinner = p.spinner();
-      tunnelSpinner.start("Starting Cloudflare tunnel");
-      const tunnel = await startQuickTunnel(port);
-      tunnelSpinner.stop(`Tunnel ready at ${ui.code(tunnel.url)}`);
       let registered = [];
+      let server = spawnDevServer({
+        cwd: loaded.root,
+        config: loaded.config,
+        env: {
+          ...appEnv,
+          PORT: String(port)
+        }
+      });
+      await this.verifyLocalDevServer(port, server, api, registered);
+      this.log(ui.dim("Starting Cloudflare tunnel..."));
+      const tunnel = await startQuickTunnel(port);
+      this.log(ui.ok(`Tunnel ready at ${ui.code(tunnel.url)}`));
       registered = await this.registerDevWebhooks(api, loaded, tunnel.url);
       this.log("");
       this.log(`${ui.bold("Tunnel:")}     ${tunnel.url}`);
@@ -66,19 +78,12 @@ class AppDev extends Command {
         this.log(`  ${ui.dim("\u2192")} ${reg.config.topic.padEnd(28)} ${reg.fullUrl}`);
       }
       this.log("");
-      this.printInstallHint(loaded, tunnel.url);
+      await this.verifyDevServerReachable(tunnel, port, server, api, registered);
+      const syncedUrls = await this.syncDevAppUrls(api, loaded, tunnel.url);
+      this.printDevAppInfo(syncedUrls);
+      await this.ensureDevAppInstalled(api, loaded, tunnel, port, server, registered);
       this.log(ui.dim("Press Ctrl-C to stop. Subscriptions will be cleaned up on exit."));
       this.log("");
-      let server = spawnDevServer({
-        cwd: loaded.root,
-        config: loaded.config,
-        env: {
-          ...appEnv,
-          PORT: String(port),
-          ODEVA_TUNNEL_URL: tunnel.url,
-          ...registeredWebhookEnv(registered)
-        }
-      });
       let shuttingDown = false;
       let restartingServer = false;
       let serverExited = () => {
@@ -120,6 +125,8 @@ class AppDev extends Command {
           });
           server = nextServer;
           watchServerExit(server);
+          await this.verifyDevServerReachable(tunnel, port, server, api, registered);
+          await this.syncDevAppUrls(api, nextLoaded, tunnel.url);
           this.log(ui.ok("Reloaded app dev config."));
         }).catch((err) => {
           restartingServer = false;
@@ -145,33 +152,36 @@ class AppDev extends Command {
       await Promise.allSettled([tunnel.stop(), cleanupSubscriptions(api, registered)]);
     });
   }
-  printInstallHint(loaded, tunnelUrl) {
+  printDevAppInfo(syncedUrls) {
     const creds = loadCredentials();
     const apps = adminUrl(creds?.apiUrl);
     this.log(`${ui.bold("Install:")}    ${apps}/settings/apps  ${ui.dim('(find your draft app under "Your apps")')}`);
     if (creds?.organizationSlug) {
       this.log(`  ${ui.dim("org:")}      ${creds.organizationSlug}`);
     }
-    const installUrl = loaded.config.install_url?.trim();
-    const expected = `${tunnelUrl}/install`;
-    if (!installUrl) {
-      this.log(ui.warn(
-        `install_url in odeva.app.toml is empty \u2014 installs won't redirect back. Set it to ${expected} and re-run \`odeva app config link\` (or use a stable URL once you deploy).`
-      ));
-    } else if (!installUrl.startsWith(tunnelUrl) && !/localhost|127\.0\.0\.1/.test(installUrl)) {
-      this.log(ui.warn(
-        `install_url is ${installUrl} \u2014 installs from your org will redirect there, not to this tunnel. Update odeva.app.toml + \`odeva app config link\` if you want installs to hit the dev tunnel.`
-      ));
-    }
-    const adminEntryUrl = loaded.config.admin?.entry_url.trim();
-    const expectedAdmin = `${tunnelUrl}/admin`;
-    if (adminEntryUrl && !adminEntryUrl.startsWith(tunnelUrl) && !/localhost|127\.0\.0\.1/.test(adminEntryUrl)) {
-      this.log(ui.warn(
-        `admin.entry_url is ${adminEntryUrl} \u2014 the admin sidebar will iframe that URL, not this tunnel. Set it to ${expectedAdmin} and re-run \`odeva app config link\` for local embed testing.`
-      ));
+    this.log(`  ${ui.dim("install:")}  ${syncedUrls.installUrl}`);
+    if (syncedUrls.adminEntryUrl) {
+      this.log(`  ${ui.dim("admin:")}    ${syncedUrls.adminEntryUrl}`);
     }
+    this.log(ui.dim("  dev URLs are synced to this tunnel for the current app record."));
     this.log("");
   }
+  async syncDevAppUrls(api, loaded, tunnelUrl) {
+    const spinner = p.spinner();
+    spinner.start("Syncing dev app URLs");
+    try {
+      const synced = await syncDevAppUrls({
+        api,
+        config: loaded.config,
+        tunnelUrl
+      });
+      spinner.stop(`Synced app URLs for ${ui.code(synced.app.slug)}`);
+      return synced;
+    } catch (err) {
+      spinner.stop(ui.err("Dev app URL sync failed"));
+      throw err instanceof CliError ? err : new CliError(`Dev app URL sync failed: ${err.message}`);
+    }
+  }
   async registerDevWebhooks(api, loaded, tunnelUrl) {
     const subscriptions = loaded.config.webhooks?.subscriptions ?? [];
     if (subscriptions.length === 0) {
@@ -193,6 +203,65 @@ class AppDev extends Command {
       throw err instanceof CliError ? err : new CliError(`Webhook registration failed: ${err.message}`);
     }
   }
+  async ensureDevAppInstalled(api, loaded, tunnel, port, server, registered) {
+    const spinner = p.spinner();
+    spinner.start("Ensuring app is installed in this organization");
+    try {
+      const installed = await ensureDevAppInstalled({
+        api,
+        config: loaded.config,
+        tunnelUrl: tunnel.url,
+        localPort: port
+      });
+      if (installed.alreadyInstalled) {
+        spinner.stop(`App ${ui.code(installed.app.slug)} is already installed`);
+      } else if (installed.callbackUrl) {
+        spinner.stop(`Installed app ${ui.code(installed.app.slug)} via ${ui.code(installed.callbackUrl)}`);
+      } else {
+        spinner.stop(`Installed app ${ui.code(installed.app.slug)}`);
+      }
+    } catch (err) {
+      spinner.stop(ui.err("App installation failed"));
+      await Promise.allSettled([
+        server.stop(),
+        tunnel.stop(),
+        cleanupSubscriptions(api, registered)
+      ]);
+      throw err;
+    }
+  }
+  async verifyLocalDevServer(port, server, api, registered) {
+    this.log(ui.dim("Waiting for local dev server..."));
+    try {
+      const result = await waitForLocalDevServer({ localPort: port });
+      this.log(ui.ok(`Local dev server ready via ${ui.code(result.path)} (HTTP ${result.status})`));
+    } catch (err) {
+      this.log(ui.err("Local dev server failed to start"));
+      await Promise.allSettled([
+        server.stop(),
+        cleanupSubscriptions(api, registered)
+      ]);
+      throw err;
+    }
+  }
+  async verifyDevServerReachable(tunnel, port, server, api, registered) {
+    this.log(ui.dim("Verifying dev server and tunnel... (trycloudflare can take up to 60s to propagate)"));
+    try {
+      const result = await waitForDevServerReachable({
+        localPort: port,
+        tunnelUrl: tunnel.url
+      });
+      this.log(ui.ok(`Tunnel verified via ${ui.code(result.path)} (HTTP ${result.tunnelStatus})`));
+    } catch (err) {
+      this.log(ui.err("Dev server tunnel check failed"));
+      await Promise.allSettled([
+        server.stop(),
+        tunnel.stop(),
+        cleanupSubscriptions(api, registered)
+      ]);
+      throw err;
+    }
+  }
   watchDevInputs(appConfigPath, onChange) {
     const paths = watchedDevInputPaths(appConfigPath);
     let timer;

package/dist/lib/api.js

@@ -139,6 +139,20 @@ class OdevaApi {
     `);
     return data.developerApps.find((a) => a.clientId === clientId) ?? null;
   }
+  async installApp(appId, grantedScopes) {
+    const data = await this.request(
+      `mutation OdevaCliInstallApp($appId: ID!, $grantedScopes: [String!]) {
+        installApp(appId: $appId, grantedScopes: $grantedScopes) {
+          appInstallation { id status grantedScopes }
+          installCode
+          installUrl
+          errors
+        }
+      }`,
+      { appId, grantedScopes }
+    );
+    return data.installApp;
+  }
   async submitDeveloperApp(id) {
     const data = await this.request(
       `mutation OdevaCliSubmitDeveloperApp($id: ID!) {

package/dist/lib/cloudflared.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
 import { CliError } from "./errors.js";
 const TRYCLOUDFLARE_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+const REGISTERED_CONNECTION_RE = /Registered tunnel connection/i;
 function isCloudflaredInstalled() {
   const result = spawnSync("cloudflared", ["--version"], { stdio: "ignore" });
   return result.status === 0;
@@ -15,32 +16,28 @@ function startQuickTunnel(localPort, options = {}) {
   return new Promise((resolve, reject) => {
     const proc = spawn(
       "cloudflared",
-      ["tunnel", "--no-autoupdate", "--url", `http://localhost:${localPort}`],
+      ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${localPort}`],
       { stdio: ["ignore", "pipe", "pipe"] }
     );
     let resolved = false;
+    let url = null;
+    let registered = false;
     const timeoutMs = options.timeoutMs ?? 3e4;
     const timer = setTimeout(() => {
       if (resolved) return;
       cleanup();
       reject(
         new CliError(`cloudflared did not produce a tunnel URL within ${timeoutMs / 1e3}s.`, {
-          hint: "Check your network connection or run `cloudflared tunnel --url http://localhost:" + localPort + "` manually."
+          hint: "Check your network connection or run `cloudflared tunnel --url http://127.0.0.1:" + localPort + "` manually."
         })
       );
     }, timeoutMs);
     const onData = (chunk) => {
       const text = chunk.toString("utf8");
       const match = TRYCLOUDFLARE_RE.exec(text);
-      if (match && !resolved) {
-        resolved = true;
-        clearTimeout(timer);
-        resolve({
-          url: match[0],
-          process: proc,
-          stop: () => stopProcess(proc)
-        });
-      }
+      if (match) url = match[0];
+      if (REGISTERED_CONNECTION_RE.test(text)) registered = true;
+      maybeResolve();
     };
     proc.stdout?.on("data", onData);
     proc.stderr?.on("data", onData);
@@ -60,16 +57,32 @@ function startQuickTunnel(localPort, options = {}) {
       } catch {
       }
     }
+    function maybeResolve() {
+      if (!url || !registered || resolved) return;
+      resolved = true;
+      clearTimeout(timer);
+      resolve({
+        url,
+        process: proc,
+        stop: () => stopProcess(proc)
+      });
+    }
   });
 }
 function stopProcess(proc) {
   return new Promise((resolve) => {
     if (proc.exitCode !== null) return resolve();
-    proc.once("exit", () => resolve());
+    let resolved = false;
+    const finish = () => {
+      if (resolved) return;
+      resolved = true;
+      resolve();
+    };
+    proc.once("exit", finish);
     try {
       proc.kill("SIGTERM");
     } catch {
-      resolve();
+      finish();
       return;
     }
     setTimeout(() => {
@@ -80,14 +93,19 @@ function stopProcess(proc) {
         }
       }
     }, 2e3);
+    setTimeout(finish, 5e3);
   });
 }
 function parseTunnelUrl(text) {
   const match = TRYCLOUDFLARE_RE.exec(text);
   return match ? match[0] : null;
 }
+function tunnelConnectionRegistered(text) {
+  return REGISTERED_CONNECTION_RE.test(text);
+}
 export {
   isCloudflaredInstalled,
   parseTunnelUrl,
-  startQuickTunnel
+  startQuickTunnel,
+  tunnelConnectionRegistered
 };

package/dist/lib/dev-runner.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { APP_ENV_FILE } from "./app-env.js";
+import { CliError } from "./errors.js";
 async function registerWebhookSubscriptions(api, appName, tunnelUrl, subscriptions) {
   const created = [];
   for (const sub of subscriptions) {
@@ -23,6 +24,57 @@ async function cleanupSubscriptions(api, registered) {
     }
   }
 }
+async function syncDevAppUrls(opts) {
+  const app = await findLinkedApp(opts.api, opts.config.client_id);
+  const installUrl = devAppTunnelUrl({
+    tunnelUrl: opts.tunnelUrl,
+    configuredUrl: opts.config.install_url,
+    defaultPath: "/install"
+  });
+  const adminEntryUrl = opts.config.admin ? devAppTunnelUrl({
+    tunnelUrl: opts.tunnelUrl,
+    configuredUrl: opts.config.admin.entry_url,
+    defaultPath: "/admin"
+  }) : null;
+  const { app: updated } = await opts.api.upsertDeveloperApp({
+    id: app.id,
+    name: opts.config.name,
+    slug: opts.config.slug,
+    description: opts.config.description,
+    homepageUrl: opts.config.homepage_url,
+    installUrl,
+    privacyUrl: opts.config.privacy_url,
+    requestedScopes: opts.config.access_scopes?.scopes,
+    ...opts.config.admin && adminEntryUrl ? {
+      adminEmbed: {
+        entryUrl: adminEntryUrl,
+        sidebar: opts.config.admin.sidebar
+      }
+    } : {}
+  });
+  return { app: updated, installUrl, adminEntryUrl };
+}
+async function ensureDevAppInstalled(opts) {
+  const app = await findLinkedApp(opts.api, opts.config.client_id);
+  const result = await opts.api.installApp(app.id, opts.config.access_scopes?.scopes ?? app.requestedScopes);
+  if (isAlreadyInstalled(result)) {
+    return { app, result, callbackUrl: null, alreadyInstalled: true };
+  }
+  if (result.errors.length > 0) {
+    throw new CliError(`Could not install app: ${result.errors.join(", ")}`);
+  }
+  if (!result.installCode) {
+    return { app, result, callbackUrl: null, alreadyInstalled: false };
+  }
+  const callbackUrl = devInstallCallbackUrl({
+    tunnelUrl: opts.tunnelUrl,
+    installUrl: result.installUrl ?? opts.config.install_url,
+    installCode: result.installCode
+  });
+  await waitForDevInstallRoute({ localPort: opts.localPort, callbackUrl });
+  await completeInstallCallback(callbackUrl);
+  return { app, result, callbackUrl, alreadyInstalled: false };
+}
 function spawnDevServer(opts) {
   const command = opts.config.build?.dev ?? "bun run dev";
   const proc = spawn(command, {
@@ -44,6 +96,75 @@ function spawnDevServer(opts) {
     })
   };
 }
+async function waitForDevServerReachable(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const deadline = Date.now() + (opts.timeoutMs ?? 6e4);
+  const requestTimeoutMs = opts.requestTimeoutMs ?? 2500;
+  const mismatchGraceMs = opts.mismatchGraceMs ?? 45e3;
+  const probe = await waitForLocalProbe(opts.localPort, deadline, requestTimeoutMs, fetchImpl);
+  const tunnelUrl = new URL(opts.tunnelUrl);
+  tunnelUrl.pathname = probe.path;
+  tunnelUrl.search = "";
+  let lastError = "not ready";
+  let mismatchSince = null;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetchWithTimeout(fetchImpl, tunnelUrl, requestTimeoutMs);
+      if (response.status === probe.status) {
+        return {
+          path: probe.path,
+          localStatus: probe.status,
+          tunnelStatus: response.status
+        };
+      }
+      lastError = `HTTP ${response.status}`;
+      mismatchSince ??= Date.now();
+      if (Date.now() - mismatchSince >= mismatchGraceMs) break;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+      mismatchSince = null;
+    }
+    await delay(500);
+  }
+  throw new CliError(`Cloudflare tunnel did not reach the local dev server at ${tunnelUrl.toString()}.`, {
+    hint: `Local ${probe.path} returned HTTP ${probe.status}, but the tunnel returned ${lastError}. Restart \`odeva app dev\` if the quick tunnel URL expired.`
+  });
+}
+async function waitForLocalDevServer(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const deadline = Date.now() + (opts.timeoutMs ?? 3e4);
+  const requestTimeoutMs = opts.requestTimeoutMs ?? 1500;
+  return waitForLocalProbe(opts.localPort, deadline, requestTimeoutMs, fetchImpl);
+}
+function devInstallCallbackUrl(opts) {
+  const url = new URL(devAppTunnelUrl({
+    tunnelUrl: opts.tunnelUrl,
+    configuredUrl: opts.installUrl,
+    defaultPath: "/install",
+    configField: "install_url"
+  }));
+  url.searchParams.set("install_code", opts.installCode);
+  return url.toString();
+}
+function devAppTunnelUrl(opts) {
+  const url = new URL(opts.tunnelUrl);
+  if (opts.configuredUrl) {
+    let configured;
+    try {
+      configured = new URL(opts.configuredUrl);
+    } catch {
+      throw new CliError(`Invalid ${opts.configField ?? "URL"}: ${opts.configuredUrl}`, {
+        hint: "Fix odeva.app.toml or run `odeva app config link` with a valid URL."
+      });
+    }
+    url.pathname = configured.pathname;
+    url.search = configured.search;
+  } else {
+    url.pathname = opts.defaultPath;
+    url.search = "";
+  }
+  return url.toString();
+}
 function writeDevEnvFile(cwd, registered) {
   if (registered.length === 0) return null;
   const path = join(cwd, ".env.odeva.local");
@@ -82,14 +203,113 @@ function joinUrl(base, path) {
   const trimmedPath = path.startsWith("/") ? path : `/${path}`;
   return `${trimmedBase}${trimmedPath}`;
 }
+function isAlreadyInstalled(result) {
+  return result.errors.some((error) => /already installed/i.test(error));
+}
+async function findLinkedApp(api, clientId) {
+  if (!clientId) {
+    throw new CliError("App has not been registered yet.", {
+      hint: "Run `odeva app config link` first."
+    });
+  }
+  const app = await api.findAppByClientId(clientId);
+  if (!app) {
+    throw new CliError(`No app with client_id ${clientId} is owned by your active organization.`, {
+      hint: "If you registered against a different org, run `odeva auth select-org`."
+    });
+  }
+  return app;
+}
+async function waitForDevInstallRoute(opts) {
+  const deadline = Date.now() + (opts.timeoutMs ?? 15e3);
+  const callback = new URL(opts.callbackUrl);
+  const localUrl = new URL(`http://127.0.0.1:${opts.localPort}`);
+  localUrl.pathname = callback.pathname;
+  let lastError = "not ready";
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(localUrl);
+      if (response.status < 500) return;
+      lastError = `HTTP ${response.status}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await delay(250);
+  }
+  throw new CliError(`Dev server did not become ready at ${localUrl.toString()}.`, {
+    hint: `Last probe failed with: ${lastError}`
+  });
+}
+async function waitForLocalProbe(localPort, deadline, requestTimeoutMs, fetchImpl) {
+  const candidates = [
+    { path: "/healthz", accepts: (status) => status < 400 },
+    { path: "/", accepts: (status) => status < 500 }
+  ];
+  let lastError = "not ready";
+  while (Date.now() < deadline) {
+    for (const candidate of candidates) {
+      const url = new URL(`http://127.0.0.1:${localPort}`);
+      url.pathname = candidate.path;
+      try {
+        const response = await fetchWithTimeout(fetchImpl, url, requestTimeoutMs);
+        if (candidate.accepts(response.status)) return { path: candidate.path, status: response.status };
+        lastError = `${candidate.path} returned HTTP ${response.status}`;
+      } catch (err) {
+        lastError = err instanceof Error ? err.message : String(err);
+      }
+    }
+    await delay(250);
+  }
+  throw new CliError(`Dev server did not become reachable at http://127.0.0.1:${localPort}.`, {
+    hint: `Last probe failed with: ${lastError}`
+  });
+}
+async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function completeInstallCallback(callbackUrl) {
+  let response;
+  try {
+    response = await fetch(callbackUrl);
+  } catch (err) {
+    throw new CliError(`Could not reach app install callback at ${callbackUrl}.`, {
+      hint: err instanceof Error ? err.message : String(err)
+    });
+  }
+  if (response.ok) return;
+  let body = "";
+  try {
+    body = (await response.text()).trim().slice(0, 300);
+  } catch {
+    body = "";
+  }
+  throw new CliError(`App install callback failed with HTTP ${response.status}.`, {
+    hint: body || callbackUrl
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function stopProcess(proc) {
   return new Promise((resolve) => {
     if (proc.exitCode !== null) return resolve();
-    proc.once("exit", () => resolve());
+    let resolved = false;
+    const finish = () => {
+      if (resolved) return;
+      resolved = true;
+      resolve();
+    };
+    proc.once("exit", finish);
     try {
       killDevProcess(proc, "SIGTERM");
     } catch {
-      resolve();
+      finish();
       return;
     }
     setTimeout(() => {
@@ -100,6 +320,7 @@ function stopProcess(proc) {
         }
       }
     }, 2e3);
+    setTimeout(finish, 5e3);
   });
 }
 function killDevProcess(proc, signal) {
@@ -134,11 +355,17 @@ function readEnvFile(path) {
 }
 export {
   cleanupSubscriptions,
+  devAppTunnelUrl,
+  devInstallCallbackUrl,
+  ensureDevAppInstalled,
   preflightChecks,
   readEnvFile,
   registerWebhookSubscriptions,
   registeredWebhookEnv,
   spawnDevServer,
+  syncDevAppUrls,
+  waitForDevServerReachable,
+  waitForLocalDevServer,
   watchedDevInputPaths,
   webhookSecretEnvKey,
   webhookSecretForEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odeva/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Build apps on the Odeva booking platform — scaffold, develop, deploy.",
   "license": "MIT",
   "type": "module",