schornai 0.0.1 → 0.3.0

package/dist/service/shared/installer-CWopk_6Z.mjs

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+import { realpath, stat, readdir, readFile, chmod, appendFile, mkdir, cp, access, rm, rename } from 'node:fs/promises';
+import { createReadStream, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { promisify, parseEnv } from 'node:util';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { d as defaultConfigPath, g as configSchema, l as loadConfig, w as writeJson, h as saveInitialConfig, c as createLogger, j as control, b as run, k as ensureDocker, r as resolveFrom, e as binary } from './docker-Dj7cdbkw.mjs';
+import { execFile } from 'node:child_process';
+import { setTimeout } from 'node:timers/promises';
+import 'node:events';
+
+const execute = promisify(execFile);
+/** Some old Admin versions do not terminate their Node transcriber on quit. */
+async function stopLegacyTranscriber(root, log) {
+    if (process.platform !== "darwin")
+        return;
+    let cwd;
+    try {
+        cwd = await realpath(join(root, "apps/transcriber-mac"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    const matches = await execute("/usr/sbin/lsof", [
+        "-a",
+        "-u",
+        String(process.getuid()),
+        "-d",
+        "cwd",
+        "-F",
+        "pn",
+        "--",
+        cwd,
+    ]).catch((error) => {
+        if (error.code === 1)
+            return { stdout: "" };
+        throw error;
+    });
+    for (const match of matches.stdout.matchAll(/^p(\d+)$/gm)) {
+        const pid = Number(match[1]);
+        const { stdout: command } = await execute("/bin/ps", [
+            "-p",
+            String(pid),
+            "-o",
+            "command=",
+        ]).catch(() => ({ stdout: "" }));
+        if (!/^(?:\S*\/)?node\s+appTranscriberMac\.js\s*$/.test(command.trim()))
+            continue;
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                continue;
+            throw error;
+        }
+        log("setup", "Stopping the legacy transcriber");
+        const deadline = Date.now() + 15_000;
+        while (true) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (error) {
+                if (error.code === "ESRCH")
+                    break;
+                throw error;
+            }
+            if (Date.now() > deadline)
+                throw new Error("Legacy transcriber did not stop; update halted before replacing its files");
+            await setTimeout(100);
+        }
+    }
+}
+
+function getFileHash(path) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash("sha256");
+        const stream = createReadStream(path);
+        stream.on("error", (err) => reject(err));
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => resolve(hash.digest("hex")));
+    });
+}
+async function getFileSystemIntegrity(path) {
+    const stats = await stat(path);
+    if (stats.isFile()) {
+        return {
+            hash: await getFileHash(path),
+            name: path.split("/").pop() ?? "@@INVALID_FILE_NAME@@",
+            type: "file",
+        };
+    }
+    else if (stats.isDirectory()) {
+        const contentNames = await readdir(path);
+        const content = [];
+        for (const contentName of contentNames) {
+            const contentPath = `${path}/${contentName}`;
+            const contentDescription = await getFileSystemIntegrity(contentPath);
+            content.push(contentDescription);
+        }
+        return {
+            content,
+            name: path.split("/").pop() ?? "@@INVALID_DIRECTORY_NAME@@",
+            type: "directory",
+        };
+    }
+    throw new Error(`Cannot get integrity of "${path}" because it is of unsupported type`);
+}
+async function getDirectoryIntegrity(path) {
+    const description = await getFileSystemIntegrity(path);
+    if (description.type === "file") {
+        throw new Error(`Cannot get directory integrity for "${path}" because it is a file`);
+    }
+    return description;
+}
+async function getFileIntegrity(path) {
+    const description = await getFileSystemIntegrity(path);
+    if (description.type === "directory") {
+        throw new Error(`Cannot get file integrity for "${path}" because it is a directory`);
+    }
+    return description;
+}
+function checkIntegrity(expected, actual, path = "") {
+    if (expected.type !== actual.type) {
+        throw new Error(`Expected integrity of type "${expected.type}" but got type "${actual.type}" for "${expected.name}"`);
+    }
+    if (expected.name !== actual.name) {
+        throw new Error(`Expected integrity with name "${expected.name}" but got name "${actual.name}"`);
+    }
+    if (expected.type === "file" && actual.type === "file") {
+        if (expected.hash !== actual.hash) {
+            throw new Error(`Expected file integrity with hash "${expected.hash}" but got hash "${actual.hash}" for file "${expected.name}"`);
+        }
+    }
+    else if (expected.type === "directory" && actual.type === "directory") {
+        if (expected.content.length > actual.content.length) {
+            throw new Error(`Expected directory integrity with ${expected.content.length} content items but got ${actual.content.length} content items for directory "${expected.name}"`);
+        }
+        for (const expectedContent of expected.content) {
+            const actualContent = actual.content.find((content) => content.name === expectedContent.name);
+            if (!actualContent) {
+                throw new Error(`Expected directory integrity to contain content with name "${expectedContent.name}" but it was not found in directory "${expected.name}"`);
+            }
+            checkIntegrity(expectedContent, actualContent, `${path}/${expected.name}`);
+        }
+    }
+    else if (expected.type === "docker-image" &&
+        actual.type === "docker-image") {
+        if (expected.digest !== actual.digest) {
+            throw new Error(`Expected docker image integrity with digest "${expected.digest}" but got digest "${actual.digest}" for image "${expected.name}:${expected.tag}"`);
+        }
+    }
+    else if (expected.type === "bin-version" && actual.type === "bin-version") {
+        if (expected.version !== actual.version) {
+            throw new Error(`Expected bin version integrity with version "${expected.version}" but got version "${actual.version}" for bin "${expected.name}"`);
+        }
+        checkIntegrity(expected.fileIntegrity, actual.fileIntegrity, `${path}/${expected.name}`);
+    }
+    else {
+        throw new Error(`Unsupported integrity types for "${expected.name}": expected type "${expected.type}", actual type "${actual.type}"`);
+    }
+    console.log(`Integrity check passed for "${path}/${expected.name}"`);
+}
+
+function generateSecuritySecrets() {
+    return {
+        SERVICE_API_TOKEN: randomBytes(32).toString("hex"),
+        REALTIME_SERVER_SECRET: randomBytes(32).toString("hex"),
+        SUPABASE_AUTH_HOOK_SECRET: `v1,whsec_${randomBytes(32).toString("base64")}`,
+    };
+}
+/** Add missing secrets on upgrades, preserving keys already used by the box. */
+async function ensureSecuritySecrets(envPath) {
+    const env = parseEnv(await readFile(envPath, "utf8"));
+    const generated = generateSecuritySecrets();
+    const additions = [];
+    for (const key of Object.keys(generated)) {
+        const value = env[key];
+        if (!value) {
+            additions.push(`${key}=${generated[key]}`);
+            continue;
+        }
+        const valid = key !== "SUPABASE_AUTH_HOOK_SECRET"
+            ? value.length >= 32 && !/\s/.test(value)
+            : /^v1,whsec_[A-Za-z0-9+/]+={0,2}$/.test(value) &&
+                Buffer.from(value.slice("v1,whsec_".length), "base64").length >= 32;
+        if (!valid) {
+            throw new Error(`Invalid ${key} in box configuration`);
+        }
+    }
+    // Restrict the existing file before appending credentials. Never log its data.
+    await chmod(envPath, 0o600);
+    if (additions.length) {
+        await appendFile(envPath, `\n${additions.join("\n")}\n`, "utf8");
+    }
+}
+
+async function replaceDirectory(source, destination, log) {
+    const temporary = `${destination}.new-${randomUUID()}`;
+    const previous = `${destination}.previous`;
+    await cp(source, temporary, { recursive: true, verbatimSymlinks: true });
+    try {
+        await rm(previous, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (!["EACCES", "EPERM"].includes(error.code ?? ""))
+            throw error;
+        // Old bundles used sudo ditto for the Mac app. Its root-owned backup can
+        // be moved within the user's Applications folder, but not removed by us.
+        const preserved = `${previous}-${randomUUID()}`;
+        await rename(previous, preserved);
+        log("setup", `Preserved protected backup: ${preserved}`);
+    }
+    if (existsSync(destination))
+        await rename(destination, previous);
+    try {
+        await rename(temporary, destination);
+    }
+    catch (error) {
+        if (existsSync(previous))
+            await rename(previous, destination);
+        throw error;
+    }
+}
+async function hasLegacyLayout(root) {
+    try {
+        return /^name:\s*supabase\s*$/m.test(await readFile(join(root, "docker/docker-compose.yml"), "utf8"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return false;
+    }
+}
+async function installUpdate(bundle) {
+    const configPath = resolve(process.env.SCHORNAI_CONFIG ?? defaultConfigPath());
+    const root = dirname(configPath);
+    const legacyCompose = join(root, "docker/docker-compose.yml");
+    const legacyLayout = await hasLegacyLayout(root);
+    const migrationFile = join(root, "service-migration.json");
+    const legacy = legacyLayout || existsSync(migrationFile);
+    const createConfig = !existsSync(configPath);
+    // Old Admin releases know only setup.sh and docker.env. Keep this bootstrap
+    // in every bundle so an old box can skip any number of intermediate releases.
+    const legacyEnvironment = createConfig && legacy
+        ? parseEnv(await readFile(join(root, "docker.env"), "utf8"))
+        : undefined;
+    const initialConfig = legacyEnvironment
+        ? configSchema.parse({
+            version: 1,
+            id: legacyEnvironment.BOX_ID || randomUUID(),
+            services: [
+                "supabase",
+                "core",
+                "ollama",
+                "transcriber-mlx",
+                "document-extractor",
+            ],
+            docker: { manageColima: process.platform === "darwin" },
+            sharing: { url: "http://127.0.0.1:3001" },
+        })
+        : undefined;
+    const context = await loadConfig(configPath, initialConfig);
+    const { config } = context;
+    if (config.development)
+        throw new Error("Setup bundles install production runtimes. Stop development and use a separate installation config to test setup updates.");
+    const manifest = JSON.parse(await readFile(join(bundle, "installation.json"), "utf8"));
+    if (manifest.version !== 1)
+        throw new Error("Unsupported installation bundle");
+    // Verify everything before stopping services or replacing the first installed file.
+    for (const part of ["apps", "bin", "container"])
+        checkIntegrity(manifest.integrity[part], await getDirectoryIntegrity(join(bundle, part)));
+    const native = config.services.some((service) => ["transcriber-mlx", "ollama"].includes(service));
+    const compatible = manifest.platform === process.platform && manifest.arch === process.arch;
+    if (native && !compatible)
+        throw new Error("This bundle's native binaries do not match this machine");
+    const hasDocker = config.services.some((service) => ["supabase", "core", "document-extractor"].includes(service));
+    if (hasDocker && manifest.arch !== process.arch)
+        throw new Error("Docker image architecture does not match this machine");
+    // A retry must still finish migration after the old Compose file was replaced.
+    if (legacy)
+        await writeJson(migrationFile, { version: 1, from: "admin-app" });
+    if (createConfig)
+        await saveInitialConfig(configPath, config);
+    const log = createLogger(root, context.environment);
+    const dockerEnvironment = {
+        ...context.environment,
+        PATH: `${join(root, "bin/docker")}:${join(root, "bin/lima/bin")}:${context.environment.PATH ?? "/usr/bin:/bin:/opt/homebrew/bin"}`,
+    };
+    const cli = join(root, "apps/service/cli.mjs");
+    const managed = process.env.SCHORNAI_SERVICE_UPDATE === "1";
+    let resume = false;
+    if (!managed) {
+        try {
+            await control(root, "status");
+            resume = true;
+            await control(root, "stop");
+        }
+        catch (error) {
+            if (!["ENOENT", "ECONNREFUSED"].includes(error.code ?? ""))
+                throw error;
+        }
+        if (resume) {
+            const deadline = Date.now() + 120_000;
+            while (true) {
+                try {
+                    await control(root, "status");
+                }
+                catch (error) {
+                    if (["ENOENT", "ECONNREFUSED"].includes(error.code ?? ""))
+                        break;
+                    throw error;
+                }
+                if (Date.now() > deadline)
+                    throw new Error("Service did not stop for update");
+                await setTimeout(250);
+            }
+        }
+    }
+    if (legacyLayout) {
+        if (process.platform === "darwin")
+            await run({
+                name: "setup",
+                command: "osascript",
+                args: [
+                    "-e",
+                    'if application "schorn.ai Admin" is running then tell application "schorn.ai Admin" to quit',
+                    "-e",
+                    "repeat 300 times",
+                    "-e",
+                    'if not (application "schorn.ai Admin" is running) then return',
+                    "-e",
+                    "delay 0.2",
+                    "-e",
+                    "end repeat",
+                    "-e",
+                    'error "Legacy Admin app did not quit"',
+                ],
+                env: context.environment,
+            }, log);
+        await stopLegacyTranscriber(root, log);
+        const legacyDocker = join(root, "bin/docker/docker-compose");
+        // The legacy app owns a foreground Colima process and stops it on quit.
+        const legacyColima = await ensureDocker(context, dockerEnvironment, log);
+        try {
+            await run({
+                name: "setup",
+                command: existsSync(legacyDocker) ? legacyDocker : "docker",
+                args: [
+                    ...(existsSync(legacyDocker) ? [] : ["compose"]),
+                    "--project-directory",
+                    join(root, "docker"),
+                    "--env-file",
+                    resolveFrom(root, config.envFile),
+                    "-f",
+                    legacyCompose,
+                    "down",
+                ],
+                env: dockerEnvironment,
+            }, log);
+        }
+        finally {
+            if (legacyColima)
+                await run({ ...legacyColima, args: ["stop"] }, log);
+        }
+    }
+    if (config.services.some((service) => ["supabase", "core"].includes(service)))
+        await ensureSecuritySecrets(resolveFrom(root, config.envFile));
+    await mkdir(join(root, "apps"), { recursive: true });
+    await mkdir(join(root, "bin"), { recursive: true });
+    if (compatible) {
+        const bins = new Set([
+            "node",
+            ...(hasDocker
+                ? ["docker", ...(config.docker.manageColima ? ["colima", "lima"] : [])]
+                : []),
+            ...(config.services.includes("ollama") ? ["ollama"] : []),
+            ...(config.services.includes("transcriber-mlx") ? ["ffmpeg"] : []),
+        ]);
+        for (const name of bins) {
+            // Linux/container-only bundles use the host's Node, Docker and Ollama.
+            // Mac bundles carry these runtimes and replace them together with the app.
+            if (existsSync(join(bundle, "bin", name)))
+                await replaceDirectory(join(bundle, "bin", name), join(root, "bin", name), log);
+        }
+    }
+    if (config.services.includes("transcriber-mlx"))
+        await replaceDirectory(join(bundle, "apps/transcriber-mac"), join(root, "apps/transcriber-mac"), log);
+    if (hasDocker) {
+        const docker = join(root, "docker");
+        await mkdir(docker, { recursive: true });
+        // Only configuration is copied. Existing PGDATA, storage, certificates and keys remain in place.
+        await cp(join(bundle, "container/volumes"), join(docker, "volumes"), {
+            recursive: true,
+            verbatimSymlinks: true,
+        });
+        await cp(join(bundle, "container/docker-compose.yml"), join(docker, "docker-compose.yml"));
+        await cp(join(bundle, "container/supabase"), join(docker, "supabase"), {
+            recursive: true,
+        });
+        await cp(join(bundle, "container/document-extractor"), join(docker, "document-extractor"), {
+            recursive: true,
+        });
+        const dockerBin = join(root, "bin/docker/docker");
+        const colima = await ensureDocker(context, dockerEnvironment, log);
+        try {
+            for (const image of manifest.images) {
+                if (!image.services.some((service) => config.services.includes(service)))
+                    continue;
+                if (!/^[A-Za-z0-9_.-]+\.tar$/.test(image.file))
+                    throw new Error("Invalid image archive name");
+                await run({
+                    name: "setup",
+                    command: existsSync(dockerBin) ? dockerBin : "docker",
+                    args: [
+                        "load",
+                        "--input",
+                        join(bundle, "container/images", image.file),
+                    ],
+                    env: dockerEnvironment,
+                }, log);
+            }
+        }
+        finally {
+            if (colima)
+                await run({ ...colima, args: ["stop"] }, log);
+        }
+    }
+    // The Mac launcher is optional; headless hosts never install or launch a GUI.
+    const appPath = join(homedir(), "Applications/schorn.ai Admin.app");
+    if (compatible &&
+        process.platform === "darwin" &&
+        existsSync(join(bundle, "apps/schorn.ai Admin.app")) &&
+        (legacy || existsSync(appPath))) {
+        await mkdir(dirname(appPath), { recursive: true });
+        await access(join(bundle, "apps/schorn.ai Admin.app"));
+        await replaceDirectory(join(bundle, "apps/schorn.ai Admin.app"), appPath, log);
+    }
+    await replaceDirectory(join(bundle, "apps/service"), join(root, "apps/service"), log);
+    log("setup", "Update finished");
+    // An old Admin download includes xrag.tar in its extracted working folder.
+    // Record it before starting the daemon to avoid immediately installing it again.
+    if (legacy && existsSync(join(bundle, "xrag.tar"))) {
+        const { hash } = await getFileIntegrity(join(bundle, "xrag.tar"));
+        const state = join(root, "service-artifacts.json");
+        let installed = {};
+        try {
+            installed = JSON.parse(await readFile(state, "utf8"));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeJson(state, { ...installed, [hash]: new Date().toISOString() });
+    }
+    if ((resume || legacy) && !managed)
+        await run({
+            name: "setup",
+            command: binary(root, "node", process.execPath),
+            args: [cli, "service", "start", "--config", context.configPath],
+            env: process.env,
+        }, log);
+    if (legacy)
+        await rm(migrationFile);
+}
+
+export { generateSecuritySecrets as g, hasLegacyLayout as h, installUpdate as i };

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "schornai",
-  "version": "0.0.1",
-  "description": "The schorn.ai CLI — coming soon.",
+  "version": "0.3.0",
+  "description": "The schorn.ai CLI, including machine service commands.",
   "type": "module",
   "bin": {
     "schornai": "bin/schornai.js"
   },
   "files": [
-    "bin/"
+    "bin/",
+    "dist/"
   ],
   "scripts": {
-    "start": "node bin/schornai.js"
+    "start": "node bin/schornai.js",
+    "build": "npm run build --workspace @schornio/aibox-package-service && node scripts/build.mjs",
+    "prepack": "npm run build"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "homepage": "https://schorn.ai",
   "license": "UNLICENSED",
+  "devDependencies": {
+    "@schornio/aibox-package-service": "*"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"