sim-setup 1.0.2-preview.48.1 → 1.0.3-preview.49.1

package/README.md

@@ -153,6 +153,22 @@ npx sim-setup doctor --json
 Use `config` to answer “what is configured?” and `status` to answer “what is
 running and healthy?”
 
+### Install the desktop app
+
+`desktop` resolves the macOS installer from your own deployment and prints the
+server URL to enter in the app:
+
+```bash
+npx sim-setup desktop
+npx sim-setup desktop --url https://sim.example.com
+npx sim-setup desktop --no-open
+```
+
+The desktop app is not tied to sim.ai — it bakes in only a default server, and
+every Sim deployment already serves `/api/desktop/update/download` and the
+update feed installed apps poll. Install the signed build, then point it at your
+deployment with **Sim → Server…**. Nothing has to be built or signed by you.
+
 ### Add or change capabilities
 
 Configure one capability without walking through the complete wizard:

package/dist/index.js

@@ -36106,6 +36106,178 @@ var init_feature_setup = __esm(() => {
   init_theme();
 });
 
+// src/urls.ts
+var APP_URL = "http://localhost:3000", APP_SIGNUP_URL;
+var init_urls = __esm(() => {
+  APP_SIGNUP_URL = `${APP_URL}/signup`;
+});
+
+// src/desktop.ts
+var exports_desktop = {};
+__export(exports_desktop, {
+  sanitizeForTerminal: () => sanitizeForTerminal,
+  runDesktop: () => runDesktop,
+  resolveDeploymentUrl: () => resolveDeploymentUrl,
+  probeDownload: () => probeDownload,
+  describeProbe: () => describeProbe
+});
+function deploymentKey(value) {
+  try {
+    return new URL(value).origin.toLowerCase();
+  } catch {
+    return value;
+  }
+}
+function sanitizeForTerminal(value) {
+  const printable = value.replace(/\p{C}/gu, "").replace(/\p{Z}/gu, " ").replace(/ {2,}/g, " ").trim();
+  return truncate(printable, MAX_INSTALLER_NAME);
+}
+function resolveDeploymentUrl(sources, override) {
+  const discovered = sources.flatMap((source) => {
+    const value = source.values?.get(APP_URL_KEY)?.trim();
+    return value ? [{ label: source.label ?? "configuration", value }] : [];
+  });
+  const byDeployment = new Map;
+  for (const { value } of discovered) {
+    byDeployment.set(deploymentKey(value), value);
+  }
+  if (!override && byDeployment.size > 1) {
+    throw new SetupError(`Found ${byDeployment.size} configurations naming different ${APP_URL_KEY} values.`, [
+      ...discovered.map(({ label, value }) => `${label}: ${value}`),
+      "Re-run with --url <deployment url> to say which one the desktop app should use."
+    ]);
+  }
+  const raw = override ?? byDeployment.values().next().value;
+  if (!raw) {
+    return APP_URL;
+  }
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    throw new SetupError(`${APP_URL_KEY} is not a valid URL: ${raw}`, [
+      "Set it to the origin browsers use to reach Sim, e.g. https://sim.example.com"
+    ]);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new SetupError(`${APP_URL_KEY} must be an http(s) URL: ${raw}`);
+  }
+  return url.origin;
+}
+async function probeDownload(downloadUrl, fetchImpl = fetch) {
+  let response;
+  try {
+    response = await fetchImpl(downloadUrl, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+  } catch (error) {
+    return { status: "unreachable", error: getErrorMessage(error, "request failed") };
+  }
+  if (REDIRECT_STATUSES.has(response.status)) {
+    const location = response.headers.get("location");
+    if (!location)
+      return { status: "unexpected", code: response.status };
+    let name = location;
+    try {
+      name = decodeURIComponent(new URL(location).pathname.split("/").pop() ?? location);
+    } catch {}
+    return { status: "ok", installerUrl: location, installerName: sanitizeForTerminal(name) };
+  }
+  if (response.status === 404)
+    return { status: "no-release" };
+  if (response.status === 502)
+    return { status: "feed-unavailable" };
+  return { status: "unexpected", code: response.status };
+}
+function describeProbe(probe, appUrl) {
+  switch (probe.status) {
+    case "ok":
+      return { headline: `${glyph.pass} Installer resolved: ${probe.installerName}`, hints: [] };
+    case "no-release":
+      return {
+        headline: `${glyph.fail} This deployment reports no desktop release for its channel.`,
+        hints: [
+          "Stable desktop builds are published on GitHub releases of simstudioai/sim.",
+          "A brand-new fork with no releases of its own will report this."
+        ]
+      };
+    case "feed-unavailable":
+      return {
+        headline: `${glyph.fail} The deployment could not reach the GitHub release feed.`,
+        hints: [
+          "The Sim server needs outbound access to api.github.com and github.com.",
+          "Unauthenticated GitHub API calls are capped at 60/hour per IP — set GITHUB_TOKEN on the Sim server to raise it to 5000/hour."
+        ]
+      };
+    case "unreachable":
+      return {
+        headline: `${glyph.fail} Could not reach ${appUrl} — ${probe.error}`,
+        hints: [
+          `Check that Sim is running and reachable at ${appUrl} (npx sim-setup status).`,
+          "Pass --url if this machine reaches Sim at a different address."
+        ]
+      };
+    case "unexpected":
+      return { headline: `${glyph.fail} The download endpoint answered ${probe.code}.`, hints: [] };
+  }
+}
+async function runDesktop(flags) {
+  const appUrl = resolveDeploymentUrl(flags.url ? [] : discoverConfigurationSources(), flags.url);
+  const downloadUrl = `${appUrl}${DOWNLOAD_PATH}`;
+  log2.step(`Deployment: ${theme.accent(appUrl)}`);
+  const spin = spinner2();
+  spin.start("Resolving the desktop installer…");
+  const [probe, feedOk] = await Promise.all([
+    probeDownload(downloadUrl),
+    httpHealth(`${appUrl}${FEED_PATH}`, PROBE_TIMEOUT_MS)
+  ]);
+  const { headline, hints } = describeProbe(probe, appUrl);
+  spin.stop(headline);
+  if (probe.status !== "ok") {
+    for (const hint of hints) {
+      log2.info(hint);
+    }
+    outro2(theme.error("The desktop installer could not be resolved."));
+    return 1;
+  }
+  if (!feedOk) {
+    log2.warn(`${FEED_PATH} did not resolve — the app will install but will not auto-update from this deployment.`);
+  }
+  note2([
+    `1. Download and install Sim:`,
+    `   ${theme.accent(downloadUrl)}`,
+    "",
+    `2. Open Sim, then choose ${theme.command("Sim → Server…")} in the menu bar.`,
+    "",
+    `3. Enter your server URL and press Connect:`,
+    `   ${theme.accent(appUrl)}`,
+    "",
+    theme.muted("Sim relaunches against your deployment and updates from it from then on."),
+    theme.muted("The desktop app is macOS-only today; the web app works everywhere.")
+  ].join(`
+`), "Connect the desktop app");
+  if (!flags.noOpen) {
+    if (await confirm2({ message: "Download it now?", initialValue: true })) {
+      openBrowser(downloadUrl);
+    }
+  }
+  outro2(theme.accent("Ready."));
+  return 0;
+}
+var DOWNLOAD_PATH = "/api/desktop/update/download", FEED_PATH = "/api/desktop/update/latest-mac.yml", PROBE_TIMEOUT_MS = 15000, REDIRECT_STATUSES, APP_URL_KEY = "NEXT_PUBLIC_APP_URL", MAX_INSTALLER_NAME = 120;
+var init_desktop = __esm(() => {
+  init_string();
+  init_cli_auth();
+  init_configuration_sources();
+  init_errors();
+  init_probes();
+  init_prompter();
+  init_theme();
+  init_urls();
+  REDIRECT_STATUSES = new Set([301, 302, 307, 308]);
+});
+
 // src/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
@@ -36367,12 +36539,6 @@ var init_docker = __esm(() => {
   APP_DIRS = ["/Applications", join(homedir(), "Applications")];
 });
 
-// src/urls.ts
-var APP_URL = "http://localhost:3000", APP_SIGNUP_URL;
-var init_urls = __esm(() => {
-  APP_SIGNUP_URL = `${APP_URL}/signup`;
-});
-
 // src/modes/k8s.ts
 import { spawn, spawnSync as spawnSync6 } from "node:child_process";
 function run(command, args, failMessage, input) {
@@ -38260,24 +38426,31 @@ function oneFlag(args, flag) {
     fail(`${flag} may only be provided once`);
   return count === 1;
 }
-function parseMode(args) {
-  let mode;
+function parseValueOption(args, flag, requirement) {
+  let value;
   const remaining = [];
+  const prefix = `${flag}=`;
   for (let index = 0;index < args.length; index += 1) {
     const arg = args[index];
-    if (arg !== "--mode" && !arg.startsWith("--mode=")) {
+    if (arg !== flag && !arg.startsWith(prefix)) {
       remaining.push(arg);
       continue;
     }
-    if (mode)
-      fail("--mode may only be provided once");
-    const value = arg === "--mode" ? args[++index] : arg.slice("--mode=".length);
-    if (value !== "compose" && value !== "dev" && value !== "k8s") {
-      fail(`invalid --mode "${value ?? ""}" — expected compose, dev, or k8s`);
-    }
-    mode = value;
+    if (value !== undefined)
+      fail(`${flag} may only be provided once`);
+    const candidate = arg === flag ? args[++index] : arg.slice(prefix.length);
+    if (!candidate || candidate.startsWith("-"))
+      fail(requirement);
+    value = candidate;
+  }
+  return { value, remaining };
+}
+function parseMode(args) {
+  const { value, remaining } = parseValueOption(args, "--mode", "--mode requires a value");
+  if (value !== undefined && value !== "compose" && value !== "dev" && value !== "k8s") {
+    fail(`invalid --mode "${value}" — expected compose, dev, or k8s`);
   }
-  return { mode, remaining };
+  return { mode: value, remaining };
 }
 function expectNoArguments(command, args) {
   if (args.length > 0)
@@ -38320,6 +38493,13 @@ function parseCore(args, helpRequested) {
     }
     return { kind: "add", feature, args: featureArgs };
   }
+  if (command === "desktop") {
+    const noOpen = oneFlag(commandArgs, "--no-open");
+    const { value: url, remaining } = parseValueOption(commandArgs.filter((arg) => arg !== "--no-open"), "--url", "--url requires a deployment URL");
+    if (remaining.length > 0)
+      fail(`Unknown desktop option: ${remaining[0]}`);
+    return { kind: "desktop", noOpen, ...url ? { url } : {} };
+  }
   if (command === "doctor") {
     const fix = oneFlag(commandArgs, "--fix");
     const json = oneFlag(commandArgs, "--json");
@@ -38364,6 +38544,7 @@ var USAGE = `Usage:
   sim-setup [--quick] [--dir <path>] [--mode compose|dev|k8s]
   sim-setup config                         show configured capabilities and integrations
   sim-setup add <feature>                  configure ${SETUP_FEATURES2}
+  sim-setup desktop [--url <url>]          install the macOS desktop app against this deployment
   sim-setup doctor [--fix] [--json]        check your setup
   sim-setup start | stop | restart         bring your install up / down / cycle
   sim-setup update                         pull/rebuild and apply Compose images
@@ -38394,6 +38575,11 @@ async function main() {
     await runFeatureSetup2(invocation.feature, invocation.args);
     return;
   }
+  if (invocation.kind === "desktop") {
+    const { runDesktop: runDesktop2 } = await Promise.resolve().then(() => (init_desktop(), exports_desktop));
+    process.exitCode = await runDesktop2({ url: invocation.url, noOpen: invocation.noOpen });
+    return;
+  }
   if (invocation.kind === "doctor") {
     const { runDoctor: runDoctor2 } = await Promise.resolve().then(() => (init_doctor(), exports_doctor));
     process.exitCode = await runDoctor2({ fix: invocation.fix, json: invocation.json });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim-setup",
-  "version": "1.0.2-preview.48.1",
+  "version": "1.0.3-preview.49.1",
   "description": "Set up and manage a self-hosted Sim installation",
   "type": "module",
   "bin": {