@pikku/deploy-standalone 0.12.11 → 0.12.13

package/src/tauri/main-rs.ts

@@ -0,0 +1,241 @@
+import { SERVER_READY_MARKER } from '@pikku/deploy'
+
+import { DATA_DIR_ENV, PARENT_PID_ENV } from '../runtime/parent-watch.js'
+
+type WindowOptions = {
+  windowTitle: string
+  width: number
+  height: number
+}
+
+export type MainRsOptions = WindowOptions &
+  (
+    | {
+        /** The `externalBin` base name — how `shell().sidecar(..)` finds the binary. */
+        sidecarName: string
+        remoteUrl?: undefined
+      }
+    | {
+        /** An already-running server the window opens against. */
+        remoteUrl: string
+        sidecarName?: undefined
+      }
+  )
+
+/**
+ * The shell's whole program.
+ *
+ * Everything it does follows from one decision: the server serves the UI and
+ * the API from a single real HTTP origin, and the webview simply points at it.
+ * A `tauri://localhost` webview would break every cookie, CORS check and OAuth
+ * redirect keyed on `window.location.origin`, which is the trap this design
+ * exists to avoid.
+ *
+ * Which origin that is decides the program. A sidecar binds its port at startup,
+ * so the shell has to start it, read the port off its ready line and open the
+ * window itself. A remote url is known before a line of Rust is generated, so
+ * the window is declared in `tauri.conf.json` and nothing here has to run at
+ * all beyond keeping the app to a single instance.
+ */
+export const renderMainRs = (options: MainRsOptions): string =>
+  options.remoteUrl === undefined
+    ? renderSidecarMainRs(options)
+    : renderRemoteMainRs()
+
+const renderRemoteMainRs = (): string =>
+  `// Generated by \`pikku deploy apply --desktop\`. Safe to edit — the generator
+// will not overwrite this file once you have changed it.
+//
+// The window is declared in tauri.conf.json, pointed straight at the remote
+// server: its origin is known up front, so there is no port to discover and no
+// process to supervise. The webview loads that origin rather than
+// \`tauri://localhost\`, which is what keeps cookies first-party and OAuth
+// redirects working.
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use tauri::Manager;
+
+fn main() {
+    tauri::Builder::default()
+        // A second launch should reach the window that is already open rather
+        // than start a second session against the same server.
+        .plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
+            if let Some(window) = app.get_webview_window("main") {
+                let _ = window.unminimize();
+                let _ = window.show();
+                let _ = window.set_focus();
+            }
+        }))
+        .run(tauri::generate_context!())
+        .expect("error while running the pikku desktop shell");
+}
+`
+
+const renderSidecarMainRs = (
+  options: WindowOptions & { sidecarName: string }
+): string => {
+  const { sidecarName, windowTitle, width, height } = options
+  return `// Generated by \`pikku deploy apply --desktop\`. Safe to edit — the generator
+// will not overwrite this file once you have changed it.
+//
+// The webview points at the sidecar's own HTTP origin rather than at
+// \`tauri://localhost\`, so cookies are first-party, there is no CORS, and OAuth
+// redirects land where the server expects. The sidecar is the application; this
+// shell only supervises it.
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use tauri::{Manager, WebviewUrl, WebviewWindowBuilder};
+use tauri_plugin_shell::process::{CommandChild, CommandEvent};
+use tauri_plugin_shell::ShellExt;
+
+/// Printed by the sidecar once it is listening *and* its startup lifecycle has
+/// finished. The runtime's own "listening on ..." line comes earlier and is not
+/// readiness.
+const READY_PREFIX: &str = "${SERVER_READY_MARKER} on http://";
+
+/// How long to wait for the ready line before giving up. A sidecar that starts
+/// and then hangs prints nothing, so no window is ever built — and a Tauri
+/// process with no window cannot be quit from the dock or the taskbar.
+const READY_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Held so the child is not dropped while the app runs, and so a clean exit can
+/// stop it explicitly.
+struct Sidecar(Mutex<Option<CommandChild>>);
+
+fn parse_ready_port(line: &str) -> Option<u16> {
+    let rest = line.split(READY_PREFIX).nth(1)?;
+    let authority = rest.split_whitespace().next()?;
+    authority
+        .trim_end_matches('/')
+        .rsplit(':')
+        .next()?
+        .parse()
+        .ok()
+}
+
+fn main() {
+    tauri::Builder::default()
+        // A second launch must never spawn a second sidecar: that would be two
+        // SQLite writers on one file. Focus what is already running instead.
+        .plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
+            if let Some(window) = app.get_webview_window("main") {
+                let _ = window.unminimize();
+                let _ = window.show();
+                let _ = window.set_focus();
+            }
+        }))
+        .plugin(tauri_plugin_shell::init())
+        .setup(|app| {
+            let data_dir = app.path().app_data_dir()?;
+            std::fs::create_dir_all(&data_dir)?;
+
+            let (mut rx, child) = app
+                .shell()
+                .sidecar("${sidecarName}")?
+                // Port 0 asks the OS for a free port. Choosing one here and
+                // passing it down would race whatever binds it in between, so
+                // the sidecar binds first and reports back on its ready line.
+                .env("PORT", "0")
+                .env("HOST", "127.0.0.1")
+                // The database, uploaded content and runtime state live here
+                // and nowhere else. A double-clicked app has no meaningful
+                // working directory, so the platform's app-data path is the
+                // only sane answer — the server reads this in bootstrap.
+                .env("${DATA_DIR_ENV}", data_dir.to_string_lossy().to_string())
+                // Tauri stops the sidecar on a clean exit, but a hard crash of
+                // this process never runs that path, and an orphan would hold
+                // the database open with its data key still resident.
+                .env("${PARENT_PID_ENV}", std::process::id().to_string())
+                .spawn()?;
+
+            app.manage(Sidecar(Mutex::new(Some(child))));
+
+            let opened = Arc::new(AtomicBool::new(false));
+
+            let timeout_handle = app.handle().clone();
+            let timeout_opened = opened.clone();
+            std::thread::spawn(move || {
+                std::thread::sleep(READY_TIMEOUT);
+                if !timeout_opened.load(Ordering::SeqCst) {
+                    eprintln!(
+                        "the pikku sidecar did not become ready within {:?} — giving up",
+                        READY_TIMEOUT
+                    );
+                    timeout_handle.exit(1);
+                }
+            });
+
+            let handle = app.handle().clone();
+            tauri::async_runtime::spawn(async move {
+                while let Some(event) = rx.recv().await {
+                    let line = match event {
+                        CommandEvent::Stdout(bytes) => String::from_utf8_lossy(&bytes).into_owned(),
+                        CommandEvent::Stderr(bytes) => {
+                            eprint!("{}", String::from_utf8_lossy(&bytes));
+                            continue;
+                        }
+                        CommandEvent::Terminated(payload) => {
+                            eprintln!("pikku sidecar exited: {:?}", payload.code);
+                            if !opened.load(Ordering::SeqCst) {
+                                handle.exit(1);
+                            }
+                            break;
+                        }
+                        _ => continue,
+                    };
+                    print!("{}", line);
+
+                    if opened.load(Ordering::SeqCst) {
+                        continue;
+                    }
+                    if let Some(port) = parse_ready_port(&line) {
+                        let url = format!("http://127.0.0.1:{}", port);
+                        match url.parse() {
+                            Ok(parsed) => {
+                                let built = WebviewWindowBuilder::new(
+                                    &handle,
+                                    "main",
+                                    WebviewUrl::External(parsed),
+                                )
+                                .title("${windowTitle}")
+                                .inner_size(${width}.0, ${height}.0)
+                                .build();
+                                match built {
+                                    Ok(_) => opened.store(true, Ordering::SeqCst),
+                                    Err(err) => {
+                                        eprintln!("could not open the window: {}", err);
+                                        handle.exit(1);
+                                    }
+                                }
+                            }
+                            Err(err) => {
+                                eprintln!("the sidecar reported an unusable url: {}", err);
+                                handle.exit(1);
+                            }
+                        }
+                    }
+                }
+            });
+
+            Ok(())
+        })
+        .on_window_event(|window, event| {
+            if let tauri::WindowEvent::Destroyed = event {
+                if let Some(sidecar) = window.app_handle().try_state::<Sidecar>() {
+                    if let Ok(mut guard) = sidecar.0.lock() {
+                        if let Some(child) = guard.take() {
+                            let _ = child.kill();
+                        }
+                    }
+                }
+            }
+        })
+        .run(tauri::generate_context!())
+        .expect("error while running the pikku desktop shell");
+}
+`
+}

package/src/tauri/next-steps.test.ts

@@ -0,0 +1,38 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { renderTauriNextSteps } from './next-steps.js'
+
+describe('what to tell someone holding a freshly generated shell', () => {
+  it('names the command that turns the crate into an app', () => {
+    const lines = renderTauriNextSteps({
+      shellDir: '/work/shop/src-tauri',
+      hasRust: true,
+    }).join('\n')
+
+    assert.match(lines, /cd \/work\/shop\/src-tauri/)
+    assert.match(lines, /tauri build/)
+  })
+
+  it('says a toolchain is missing rather than letting cargo say it', () => {
+    // Generation is pure Node, so `--desktop` succeeds on a machine that cannot
+    // build the result. Someone who has never used Tauri would otherwise find
+    // out from a cargo error, at the point they least expect one.
+    const lines = renderTauriNextSteps({
+      shellDir: '/work/shop/src-tauri',
+      hasRust: false,
+    }).join('\n')
+
+    assert.match(lines, /Rust/)
+    assert.match(lines, /tauri\.app/)
+  })
+
+  it('stays quiet about prerequisites that are already met', () => {
+    const lines = renderTauriNextSteps({
+      shellDir: '/work/shop/src-tauri',
+      hasRust: true,
+    }).join('\n')
+
+    assert.doesNotMatch(lines, /tauri\.app/)
+  })
+})

package/src/tauri/next-steps.ts

@@ -0,0 +1,30 @@
+export type TauriNextStepsOptions = {
+  /** Absolute path of the generated crate. */
+  shellDir: string
+  /** Whether a Rust toolchain answered when the triple was resolved. */
+  hasRust: boolean
+}
+
+const PREREQUISITES = 'https://tauri.app/start/prerequisites/'
+
+/**
+ * What to say once the crate and its sidecar are on disk.
+ *
+ * Generation is pure Node — it writes files and copies a binary — so `--desktop`
+ * succeeds perfectly well on a machine that cannot build the result. Saying so
+ * here is the difference between a known prerequisite and a cargo error at the
+ * point someone least expects one.
+ */
+export const renderTauriNextSteps = ({
+  shellDir,
+  hasRust,
+}: TauriNextStepsOptions): string[] => {
+  const lines = [`  Next: cd ${shellDir} && npx tauri build`]
+  if (!hasRust) {
+    lines.push(
+      `  That step needs a Rust toolchain, and none answered here — see ${PREREQUISITES}.`,
+      '  The crate and its sidecar are complete, so another machine can build them as they are.'
+    )
+  }
+  return lines
+}

package/src/tauri/target-triple.test.ts

@@ -0,0 +1,84 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  hostTargetTriple,
+  sidecarFileName,
+  parseRustcHost,
+} from './target-triple.js'
+
+describe('the target triple Tauri demands on a sidecar file name', () => {
+  it('prefers what rustc says its host is', () => {
+    const triple = hostTargetTriple({
+      platform: 'linux',
+      arch: 'x64',
+      rustcVersionVerbose:
+        'rustc 1.97.1\nbinary: rustc\nhost: aarch64-apple-darwin\n',
+    })
+    assert.equal(
+      triple,
+      'aarch64-apple-darwin',
+      'rustc is the toolchain that will actually link the shell'
+    )
+  })
+
+  it('falls back to the running platform when rustc is not installed', () => {
+    assert.equal(
+      hostTargetTriple({ platform: 'darwin', arch: 'arm64' }),
+      'aarch64-apple-darwin'
+    )
+    assert.equal(
+      hostTargetTriple({ platform: 'darwin', arch: 'x64' }),
+      'x86_64-apple-darwin'
+    )
+    assert.equal(
+      hostTargetTriple({ platform: 'linux', arch: 'x64' }),
+      'x86_64-unknown-linux-gnu'
+    )
+    assert.equal(
+      hostTargetTriple({ platform: 'linux', arch: 'arm64' }),
+      'aarch64-unknown-linux-gnu'
+    )
+    assert.equal(
+      hostTargetTriple({ platform: 'win32', arch: 'x64' }),
+      'x86_64-pc-windows-msvc'
+    )
+    assert.equal(
+      hostTargetTriple({ platform: 'win32', arch: 'arm64' }),
+      'aarch64-pc-windows-msvc'
+    )
+  })
+
+  it('names the platform it cannot map rather than guessing', () => {
+    assert.throws(
+      () => hostTargetTriple({ platform: 'sunos', arch: 'mips' as never }),
+      /sunos/
+    )
+  })
+
+  it('ignores rustc output that carries no host line', () => {
+    assert.equal(parseRustcHost('rustc 1.97.1 (8bab26f4f)'), undefined)
+    assert.equal(
+      hostTargetTriple({
+        platform: 'darwin',
+        arch: 'arm64',
+        rustcVersionVerbose: 'rustc 1.97.1',
+      }),
+      'aarch64-apple-darwin'
+    )
+  })
+
+  it('suffixes the binary the way externalBin resolves it', () => {
+    assert.equal(
+      sidecarFileName('shop', 'aarch64-apple-darwin'),
+      'shop-aarch64-apple-darwin'
+    )
+  })
+
+  it('keeps the .exe extension after the triple on windows', () => {
+    assert.equal(
+      sidecarFileName('shop', 'x86_64-pc-windows-msvc'),
+      'shop-x86_64-pc-windows-msvc.exe'
+    )
+  })
+})

package/src/tauri/target-triple.ts

@@ -0,0 +1,65 @@
+/**
+ * Rust target triples, and the file name Tauri's `externalBin` resolves a
+ * sidecar by.
+ *
+ * Tauri appends the *compile* target's triple to every `externalBin` path and
+ * looks the result up on disk, so a binary dropped in as plain `binaries/app`
+ * is silently invisible to the bundler. This is the one detail that makes an
+ * otherwise correct shell fail at build time with "binary not found".
+ */
+
+export type HostPlatform = NodeJS.Platform
+export type HostArch = string
+
+const TRIPLES: Record<string, string> = {
+  'darwin:arm64': 'aarch64-apple-darwin',
+  'darwin:x64': 'x86_64-apple-darwin',
+  'linux:arm64': 'aarch64-unknown-linux-gnu',
+  'linux:x64': 'x86_64-unknown-linux-gnu',
+  'win32:arm64': 'aarch64-pc-windows-msvc',
+  'win32:x64': 'x86_64-pc-windows-msvc',
+}
+
+/** Pull the `host:` line out of `rustc -vV` output. */
+export const parseRustcHost = (output: string): string | undefined =>
+  /^host:\s*(\S+)$/m.exec(output)?.[1]
+
+export type HostTargetTripleOptions = {
+  platform?: HostPlatform
+  arch?: HostArch
+  /** Raw `rustc -vV` output, when the toolchain was reachable. */
+  rustcVersionVerbose?: string
+}
+
+/**
+ * The triple the shell will be built for.
+ *
+ * `rustc -vV` wins when it is available: it is the toolchain that will link the
+ * shell, and it knows things the Node platform pair cannot express — a musl
+ * host, or a Node process running under Rosetta on an arm64 Mac.
+ */
+export const hostTargetTriple = (
+  options: HostTargetTripleOptions = {}
+): string => {
+  const fromRustc = options.rustcVersionVerbose
+    ? parseRustcHost(options.rustcVersionVerbose)
+    : undefined
+  if (fromRustc) return fromRustc
+
+  const platform = options.platform ?? process.platform
+  const arch = options.arch ?? process.arch
+  const triple = TRIPLES[`${platform}:${arch}`]
+  if (!triple) {
+    throw new Error(
+      `No known Rust target triple for ${platform}/${arch}. Install a Rust toolchain so \`rustc -vV\` can report its host, or pass the triple explicitly.`
+    )
+  }
+  return triple
+}
+
+/** `binaries/<name>-<triple>[.exe]`, exactly as `externalBin` looks it up. */
+export const sidecarFileName = (
+  baseName: string,
+  targetTriple: string
+): string =>
+  `${baseName}-${targetTriple}${targetTriple.includes('windows') ? '.exe' : ''}`