schornai 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# schornai
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The schorn.ai command-line application. The public npm package and executable are
+both named `schornai`; service implementation remains in the separate private
+workspace package `@schornio/aibox-package-service`.
+
+Requires Node.js 24 or newer. This source adds automatic setup and service commands for the next
+CLI release; publishing the new version is a separate release action.
+
+```sh
+npx schornai
+```
+
+Without arguments, the CLI reports an existing installation and its service
+status. Otherwise it asks `Install schorn.ai ...? [y/N]` before downloading or
+changing files. Only `y` (case-insensitive) proceeds; `n`, Enter, end of input or
+Ctrl+C cancels. Retrying an incomplete installation asks again.
+After confirmation it downloads the latest XRAG setup from
+`https://schorn.ai/xrag/schornai/latest`, validates the archive and platform,
+installs it and starts the service. The endpoint is still being prepared;
+an unavailable download exits with an error and can be retried.
+The bootstrap does not send a platform or architecture to that endpoint, so
+it can currently serve only one target. A macOS ARM64 bundle cannot install
+Linux; Linux needs a separately built bundle for the matching architecture.
+
+New machines get `core`, `supabase` and `document-extractor`; Apple Silicon Macs
+also get `ollama` and `transcriber-mlx`. Setup creates private instance credentials
+and a self-signed localhost TLS certificate. OpenSSL is required. Linux ARM64/x64
+also needs a running Docker Engine and Compose 2.24.4+; the Mac bundle supplies
+Docker/Colima. Other platforms are rejected before downloading. Models, mail
+delivery and a public domain/certificate are configured separately.
+
+The default installation directory is `~/.aibox`; `SCHORNAI_HOME` changes it and
+`SCHORNAI_CONFIG` selects an explicit config file for this default command.
+Existing service configurations and credentials are preserved, including a
+configuration created with `service init` before installing. Such machines keep
+their selected services and must already have their required credentials.
+Legacy Admin installations are reported without migration. A failed setup remains
+retryable with the same command; existing installations are never automatically
+updated or restarted. `--help` and `--version` do not install anything.
+
+For explicit service management:
+
+```sh
+npx schornai service init --services core,supabase,document-extractor,ollama,transcriber-mlx
+npx schornai service start
+npx schornai service sync
+npx schornai service status
+npx schornai service logs --follow
+npx schornai service stop
+```
+
+`init` creates a machine configuration without overwriting an existing one.
+Service binaries and Docker images are installed by the XRAG setup bundle.
+Use `--config PATH` to select another machine directory. Run
+`npx schornai service --help` for the full command list.
+
+## Local development
+
+From the repository root:
+
+```sh
+npm run build:cli
+npm start --workspace apps/cli -- service --help
+```
+
+The build compiles `packages/service` and includes that runtime in the CLI's
+`dist/service` directory. The published package needs no private registry or
+repository checkout. The Mac launcher and XRAG installer use the same service
+build independently of the public CLI.
+
+## Packaging and release
+
+```sh
+npm pack --workspace apps/cli
+```
+
+`prepack` builds the runtime. Review the package contents before publishing with
+an authorized npm account. The service workspace itself is private and does
+not claim the `schornai` npm name. Increase `apps/cli/package.json`'s version and
+update the lockfile for subsequent releases.
+
+See the [operator guide](../../docs/de/box-admin/index.md) for service selection,
+credentials and automatic migration of old Admin installations through XRAG.
+
+`service sync` asks the running daemon to reconcile artifacts immediately.
+Sharing must be configured; the command reports that work was queued, while
+`service logs --follow` and the web app's **Service** page show the result.
+Automatic synchronization uses Yjs notifications and reconnects, not polling.

package/bin/schornai.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+const help = `schorn.ai CLI
+
+Usage: schornai
+       schornai service <init|start|stop|restart|status|sync|logs|run> [options]
+       schornai service --help
+
+Without arguments, show the installed machine's status or ask to install schorn.ai.
+
+News: https://schorn.ai/newsletter`;
+
+try {
+  if (!args.length) {
+    const { runDefaultCLI } = await import("../dist/service/bootstrap.mjs");
+    await runDefaultCLI();
+  } else if (args[0] === "service") {
+    const { runServiceCLI } = await import("../dist/service/commands.mjs");
+    await runServiceCLI(args);
+  } else if (args[0] === "--help" || args[0] === "-h") {
+    console.log(help);
+  } else if (args[0] === "--version") {
+    const { readFile } = await import("node:fs/promises");
+    console.log(
+      JSON.parse(
+        await readFile(new URL("../package.json", import.meta.url), "utf8"),
+      ).version,
+    );
+  } else {
+    throw new Error(`Unknown command: ${args[0]}\n${help}`);
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : "Command failed");
+  process.exitCode = 1;
+}

package/dist/service/bootstrap.mjs

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+import { createHmac, createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { stat, mkdir, writeFile, mkdtemp, chmod, rename, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { r as runServiceCLI, e as extractArchive } from './shared/cli-BxEHldVH.mjs';
+import { i as initConfig, w as writeJson, l as loadConfig, r as resolveFrom, o as object, a as literal, d as defaultConfigPath, s as string, c as createLogger, b as run, e as binary, n as number, f as boolean } from './shared/docker-Dj7cdbkw.mjs';
+import { g as generateSecuritySecrets, h as hasLegacyLayout } from './shared/installer-CWopk_6Z.mjs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import 'node:timers/promises';
+import 'node:http';
+import 'events';
+import 'fs';
+import 'node:events';
+import 'node:string_decoder';
+import 'path';
+import 'assert';
+import 'buffer';
+import 'zlib';
+import 'node:assert';
+import 'node:readline';
+
+// FROM https://github.com/supabase/supabase/blob/794529eddf3e9d454fa2bbc169768bfd2a853d67/apps/docs/components/JwtGenerator/JwtGenerator.tsx
+function generateRandomString(length) {
+    const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    /**
+     * The number of possible Uint8 integers is 256. Since the length of `CHARS`
+     * doesn't fit exactly into 256, simply taking the modulus would create an
+     * uneven distribution that favors the earlier characters. To make a truly
+     * uniform distribution, we have to discard everything above the last full
+     * cycle, and pick again.
+     *
+     * The minus 1 is to account for 0-indexing.
+     */
+    const MAX = Math.floor(256 / CHARS.length) * CHARS.length - 1;
+    const randomUInt8Array = new Uint8Array(1);
+    for (let i = 0; i < length; i++) {
+        let randomNumber;
+        do {
+            crypto.getRandomValues(randomUInt8Array);
+            randomNumber = randomUInt8Array[0];
+            /**
+             * Keep picking until we get a number in the valid range.
+             */
+        } while (randomNumber > MAX);
+        result += CHARS[randomNumber % CHARS.length];
+    }
+    return result;
+}
+
+/** Generates the legacy HS256 API keys expected by self-hosted Supabase. */
+function generateSupabaseKey(type, jwtSecret) {
+    if (jwtSecret.length < 32)
+        throw new Error("JWT_SECRET must contain at least 32 characters");
+    if (type !== "ANON_KEY" && type !== "SERVICE_ROLE_KEY")
+        throw new Error("Invalid Supabase key type");
+    const now = new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const fiveYears = new Date(now.getFullYear() + 5, now.getMonth(), now.getDate());
+    const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64url");
+    const payload = Buffer.from(JSON.stringify({
+        role: type === "ANON_KEY" ? "anon" : "service_role",
+        iss: "supabase",
+        iat: Math.floor(today.valueOf() / 1000),
+        exp: Math.floor(fiveYears.valueOf() / 1000),
+    })).toString("base64url");
+    const signed = `${header}.${payload}`;
+    const signature = createHmac("sha256", jwtSecret)
+        .update(signed)
+        .digest("base64url");
+    return `${signed}.${signature}`;
+}
+
+// FROM https://github.com/supabase/supabase/blob/794529eddf3e9d454fa2bbc169768bfd2a853d67/apps/docs/components/JwtGenerator/JwtGenerator.tsx
+function generateDockerEnv({ boxId = crypto.randomUUID(), samlPrivateKey, siteUrl = "http://replace-with-actual-site-url", }) {
+    const BOX_ID = boxId;
+    const POSTGRES_PASSWORD = generateRandomString(64);
+    const JWT_SECRET = generateRandomString(40);
+    const ANON_KEY = generateSupabaseKey("ANON_KEY", JWT_SECRET);
+    const SERVICE_ROLE_KEY = generateSupabaseKey("SERVICE_ROLE_KEY", JWT_SECRET);
+    const SECRET_KEY_BASE = generateRandomString(64);
+    const VAULT_ENC_KEY = generateRandomString(32);
+    const SAML_PRIVATE_KEY = samlPrivateKey;
+    const { REALTIME_SERVER_SECRET, SUPABASE_AUTH_HOOK_SECRET, SERVICE_API_TOKEN, } = generateSecuritySecrets();
+    return `
+BOX_ID=${BOX_ID}
+
+############
+# Secrets
+############
+
+POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+JWT_SECRET=${JWT_SECRET}
+ANON_KEY=${ANON_KEY}
+SERVICE_ROLE_KEY=${SERVICE_ROLE_KEY}
+SECRET_KEY_BASE=${SECRET_KEY_BASE}
+VAULT_ENC_KEY=${VAULT_ENC_KEY}
+SAML_PRIVATE_KEY=${SAML_PRIVATE_KEY}
+REALTIME_SERVER_SECRET=${REALTIME_SERVER_SECRET}
+SUPABASE_AUTH_HOOK_SECRET=${SUPABASE_AUTH_HOOK_SECRET}
+SERVICE_API_TOKEN=${SERVICE_API_TOKEN}
+
+############
+# Database - You can change these to any PostgreSQL database that has logical replication enabled.
+############
+
+POSTGRES_HOST=db
+POSTGRES_DB=postgres
+POSTGRES_PORT=5432
+# default user is postgres
+
+############
+# Supavisor -- Database pooler
+############
+POOLER_PROXY_PORT_TRANSACTION=6543
+POOLER_DEFAULT_POOL_SIZE=20
+POOLER_MAX_CLIENT_CONN=100
+POOLER_TENANT_ID=schornai-box-v1
+
+
+############
+# API Proxy - Configuration for the Kong Reverse proxy.
+############
+
+KONG_HTTP_PORT=80
+KONG_HTTPS_PORT=443
+
+
+############
+# API - Configuration for PostgREST.
+############
+
+PGRST_DB_SCHEMAS=public,storage,graphql_public,pgmq_public
+
+
+############
+# Auth - Configuration for the GoTrue authentication server.
+############
+
+## General
+SITE_URL=${siteUrl}
+ADDITIONAL_REDIRECT_URLS=ai.schorn.box-app-v1://**
+JWT_EXPIRY=3600
+DISABLE_SIGNUP=false
+API_EXTERNAL_URL=${siteUrl}/auth/v1
+
+## Mailer Config
+MAILER_URLPATHS_CONFIRMATION="/auth/v1/verify"
+MAILER_URLPATHS_INVITE="/auth/v1/verify"
+MAILER_URLPATHS_RECOVERY="/auth/v1/verify"
+MAILER_URLPATHS_EMAIL_CHANGE="/auth/v1/verify"
+
+## Email auth
+ENABLE_EMAIL_SIGNUP=true
+ENABLE_EMAIL_AUTOCONFIRM=false
+SMTP_ADMIN_EMAIL=admin@example.com
+SMTP_HOST=supabase-mail
+SMTP_PORT=2500
+SMTP_USER=fake_mail_user
+SMTP_PASS=fake_mail_password
+SMTP_SENDER_NAME=fake_sender
+ENABLE_ANONYMOUS_USERS=false
+
+## Phone auth
+ENABLE_PHONE_SIGNUP=false
+ENABLE_PHONE_AUTOCONFIRM=true
+
+
+############
+# Studio - Configuration for the Dashboard
+############
+
+STUDIO_DEFAULT_ORGANIZATION=Default Organization
+STUDIO_DEFAULT_PROJECT=Default Project
+
+STUDIO_PORT=3000
+# replace if you intend to use Studio outside of localhost
+SUPABASE_PUBLIC_URL=http://localhost:8000
+
+# Enable webp support
+IMGPROXY_ENABLE_WEBP_DETECTION=true
+
+# Add your OpenAI API key to enable SQL Editor Assistant
+OPENAI_API_KEY=
+
+############
+# Functions - Configuration for Functions
+############
+# NOTE: VERIFY_JWT applies to all functions. Per-function VERIFY_JWT is not supported yet.
+FUNCTIONS_VERIFY_JWT=false
+`;
+}
+
+const execute = promisify(execFile);
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return false;
+    }
+}
+function initialServices(platform, arch) {
+    if (!(platform === "darwin" && arch === "arm64") &&
+        !(platform === "linux" && ["arm64", "x64"].includes(arch)))
+        throw new Error(`No schorn.ai setup is supported for ${platform}/${arch}`);
+    return [
+        "core",
+        "supabase",
+        "document-extractor",
+        ...(platform === "darwin" ? ["ollama", "transcriber-mlx"] : []),
+    ];
+}
+/** Only for a new local instance owned by the bootstrap, never remote workers. */
+async function prepareInitialSetup(configPath, signal) {
+    signal?.throwIfAborted();
+    if (!(await fileExists(configPath))) {
+        const config = await initConfig(configPath, initialServices(process.platform, process.arch));
+        await writeJson(configPath, {
+            ...config,
+            sharing: { url: "http://127.0.0.1:3001" },
+        });
+    }
+    const { config, root } = await loadConfig(configPath);
+    const envPath = resolveFrom(root, config.envFile);
+    if (!(await fileExists(envPath))) {
+        const { stdout } = await execute("openssl", ["genpkey", "-algorithm", "rsa", "-outform", "DER"], { encoding: "buffer", signal });
+        await mkdir(dirname(envPath), { recursive: true, mode: 0o700 });
+        await writeFile(envPath, generateDockerEnv({
+            boxId: config.id,
+            samlPrivateKey: stdout.toString("base64"),
+            siteUrl: "https://localhost",
+        }), { flag: "wx", mode: 0o600 });
+    }
+    const cert = join(root, "docker/volumes/api/cert");
+    const key = join(cert, "privkey.pem");
+    const certificate = join(cert, "fullkey.pem");
+    const hasKey = await fileExists(key);
+    const hasCertificate = await fileExists(certificate);
+    if (hasKey !== hasCertificate)
+        throw new Error(`Incomplete TLS certificate pair in ${cert}; restore the matching pair before retrying`);
+    if (hasKey)
+        return;
+    // Generate outside the destination so an OpenSSL failure leaves no partial pair.
+    await mkdir(dirname(cert), { recursive: true, mode: 0o700 });
+    const stagedCert = await mkdtemp(join(dirname(cert), ".cert-"));
+    try {
+        const stagedKey = join(stagedCert, "privkey.pem");
+        await execute("openssl", [
+            "req",
+            "-x509",
+            "-nodes",
+            "-newkey",
+            "rsa:2048",
+            "-keyout",
+            stagedKey,
+            "-out",
+            join(stagedCert, "fullkey.pem"),
+            "-days",
+            "365",
+            "-subj",
+            "/CN=localhost",
+            "-addext",
+            "subjectAltName=DNS:localhost,IP:127.0.0.1",
+        ], { signal });
+        await chmod(stagedKey, 0o600);
+        signal?.throwIfAborted();
+        await rename(stagedCert, cert);
+    }
+    finally {
+        await rm(stagedCert, { recursive: true, force: true });
+    }
+}
+
+const latestSetupUrl = "https://schorn.ai/xrag/schornai/latest";
+const pendingSchema = object({ version: literal(1), fresh: boolean() });
+async function confirmInstallation(root) {
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    readline.once("close", cancel);
+    readline.once("SIGINT", cancel);
+    try {
+        const answer = await readline.question(`Install schorn.ai in ${root} and start its services? [y/N] `, { signal: controller.signal });
+        return answer.trim().toLowerCase() === "y";
+    }
+    catch (error) {
+        if (controller.signal.aborted)
+            return false;
+        throw error;
+    }
+    finally {
+        readline.close();
+    }
+}
+async function downloadSetup(file, abort) {
+    let url = new URL(latestSetupUrl);
+    const signal = AbortSignal.any([abort, AbortSignal.timeout(3_600_000)]);
+    for (let redirects = 0; redirects <= 5; redirects++) {
+        if (url.protocol !== "https:" || url.username || url.password)
+            throw new Error("Setup downloads require HTTPS without URL credentials");
+        const response = await fetch(url.href, { redirect: "manual", signal });
+        if ([301, 302, 303, 307, 308].includes(response.status)) {
+            await response.body?.cancel();
+            const location = response.headers.get("location");
+            if (!location)
+                throw new Error("Setup download redirect has no location");
+            url = new URL(location, url);
+            continue;
+        }
+        if (!response.ok || !response.body) {
+            await response.body?.cancel();
+            throw new Error(`Setup download failed (HTTP ${response.status}) at ${latestSetupUrl}; retry when the setup bundle is available`);
+        }
+        const hash = createHash("sha256");
+        await pipeline(response.body, new Transform({
+            transform(chunk, _encoding, callback) {
+                hash.update(chunk);
+                callback(null, chunk);
+            },
+        }), createWriteStream(file, { flags: "wx", mode: 0o600 }), { signal });
+        return hash.digest("hex");
+    }
+    throw new Error("Too many setup download redirects");
+}
+async function acquireSetupLock(root) {
+    const lock = join(root, ".setup-lock");
+    try {
+        await mkdir(lock, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        let pid;
+        try {
+            pid = object({ pid: number().int().positive() })
+                .parse(JSON.parse(await readFile(join(lock, "owner.json"), "utf8"))).pid;
+        }
+        catch {
+            throw new Error(`Another setup is starting, or ${lock} needs manual recovery`);
+        }
+        try {
+            process.kill(pid, 0);
+            throw new Error("Another schorn.ai setup is already running");
+        }
+        catch (probe) {
+            if (probe.code !== "ESRCH")
+                throw probe;
+        }
+        await rm(lock, { recursive: true });
+        await mkdir(lock, { mode: 0o700 });
+    }
+    await writeJson(join(lock, "owner.json"), { pid: process.pid });
+    return lock;
+}
+async function runDefaultCLI() {
+    const configPath = resolve(process.env.SCHORNAI_CONFIG ?? defaultConfigPath());
+    const root = dirname(configPath);
+    const pendingFile = join(root, ".setup-incomplete.json");
+    const pending = (await fileExists(pendingFile))
+        ? pendingSchema.parse(JSON.parse(await readFile(pendingFile, "utf8")))
+        : undefined;
+    const configured = await fileExists(configPath);
+    const context = configured ? await loadConfig(configPath) : undefined;
+    const runtime = join(root, "apps/service/cli.mjs");
+    if (!pending &&
+        (context?.config.development || (context && (await fileExists(runtime))))) {
+        console.log(`schorn.ai is already installed in ${root}`);
+        await runServiceCLI(["service", "status", "--config", configPath]);
+        return;
+    }
+    if (!pending && (await hasLegacyLayout(root))) {
+        console.log(`schorn.ai is already installed in ${root} (legacy Admin installation). Use the Admin app for its status.`);
+        return;
+    }
+    if (!configured &&
+        !pending &&
+        ((await fileExists(runtime)) ||
+            (await fileExists(join(root, "docker.env"))) ||
+            (await fileExists(join(root, "docker")))))
+        throw new Error(`Existing schorn.ai files in ${root} have no machine configuration. Restore config.json before continuing.`);
+    initialServices(process.platform, process.arch);
+    if (!(await confirmInstallation(root))) {
+        console.log("Installation cancelled.");
+        return;
+    }
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const lock = await acquireSetupLock(root);
+    const controller = new AbortController();
+    const interrupted = () => controller.abort(new Error("Setup interrupted; run npx schornai to retry"));
+    process.on("SIGINT", interrupted);
+    process.on("SIGTERM", interrupted);
+    const { signal } = controller;
+    let temporary;
+    try {
+        temporary = await mkdtemp(join(tmpdir(), "schornai-setup-"));
+        console.log(`Downloading schorn.ai setup from ${latestSetupUrl}`);
+        const archive = join(temporary, "setup.tar");
+        const id = await downloadSetup(archive, signal);
+        const payload = join(temporary, "payload");
+        await mkdir(payload, { mode: 0o700 });
+        const inspected = await extractArchive(archive, payload, id, signal);
+        if (inspected.xrag.xrag_type !== "setup")
+            throw new Error("The latest schorn.ai download is not an XRAG setup bundle");
+        const manifest = object({ version: literal(1), platform: string(), arch: string() })
+            .parse(JSON.parse(await readFile(join(payload, "installation.json"), "utf8")));
+        if (manifest.platform !== process.platform ||
+            manifest.arch !== process.arch ||
+            (inspected.xrag.platform &&
+                inspected.xrag.platform !== manifest.platform) ||
+            (inspected.xrag.arch && inspected.xrag.arch !== manifest.arch))
+            throw new Error(`The setup bundle does not match this machine (${process.platform}/${process.arch})`);
+        const fresh = pending?.fresh ?? !configured;
+        signal.throwIfAborted();
+        await writeJson(pendingFile, { version: 1, fresh });
+        if (fresh)
+            await prepareInitialSetup(configPath, signal);
+        const installation = await loadConfig(configPath);
+        const log = createLogger(root, installation.environment, true);
+        console.log(`Installing schorn.ai in ${root}`);
+        await run({
+            name: "setup",
+            command: "bash",
+            args: [join(payload, "setup.sh")],
+            cwd: payload,
+            env: {
+                ...process.env,
+                SCHORNAI_HOME: root,
+                SCHORNAI_CONFIG: configPath,
+                SCHORNAI_NODE: process.execPath,
+                SCHORNAI_SERVICE_UPDATE: "1",
+            },
+        }, log, signal);
+        if (!(await fileExists(runtime)))
+            throw new Error("Setup did not install the schorn.ai service runtime");
+        await rm(pendingFile);
+        console.log("schorn.ai installed successfully");
+        await run({
+            name: "service",
+            command: binary(root, "node", process.execPath),
+            args: [runtime, "service", "start", "--config", configPath],
+            env: process.env,
+        }, log, signal);
+        await runServiceCLI(["service", "status", "--config", configPath]);
+        if (fresh)
+            console.log("Open https://localhost (local self-signed certificate).");
+    }
+    finally {
+        try {
+            if (temporary)
+                await rm(temporary, { recursive: true, force: true });
+        }
+        finally {
+            try {
+                await rm(lock, { recursive: true, force: true });
+            }
+            finally {
+                process.removeListener("SIGINT", interrupted);
+                process.removeListener("SIGTERM", interrupted);
+            }
+        }
+    }
+}
+
+export { latestSetupUrl, runDefaultCLI };

package/dist/service/cli.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { r as runServiceCLI } from './shared/cli-BxEHldVH.mjs';
+import 'node:util';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:child_process';
+import 'node:timers/promises';
+import './shared/docker-Dj7cdbkw.mjs';
+import 'node:os';
+import 'node:crypto';
+import 'node:http';
+import 'node:readline';
+import 'node:stream/promises';
+import 'node:stream';
+import 'events';
+import 'fs';
+import 'node:events';
+import 'node:string_decoder';
+import 'path';
+import 'assert';
+import 'buffer';
+import 'zlib';
+import 'node:assert';
+
+runServiceCLI().catch((error) => {
+    console.error(error instanceof Error ? error.message : "Service command failed");
+    process.exitCode = 1;
+});

package/dist/service/commands.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import 'node:util';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:child_process';
+import 'node:timers/promises';
+import './shared/docker-Dj7cdbkw.mjs';
+export { r as runServiceCLI } from './shared/cli-BxEHldVH.mjs';
+import 'node:os';
+import 'node:crypto';
+import 'node:http';
+import 'node:readline';
+import 'node:stream/promises';
+import 'node:stream';
+import 'events';
+import 'fs';
+import 'node:events';
+import 'node:string_decoder';
+import 'path';
+import 'assert';
+import 'buffer';
+import 'zlib';
+import 'node:assert';

package/dist/service/installer.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'node:util';
+import 'node:crypto';
+import './shared/docker-Dj7cdbkw.mjs';
+export { h as hasLegacyLayout, i as installUpdate } from './shared/installer-CWopk_6Z.mjs';
+import 'node:timers/promises';
+import 'node:http';
+import 'node:child_process';
+import 'node:readline';
+import 'node:events';