wizards 0.1.9

package/apps/runtime/dist/routes/wizard-stream.js

@@ -0,0 +1,30 @@
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { subscribeDraft } from "../services/draft-events.js";
+import { ownedWizard } from "../services/wizards.js";
+/**
+ * Live changes to a wizard the editor has open — from an MCP client, the architect or another
+ * tab. The editor refetches on `change`; `hello` carries the revision to catch up after a gap.
+ */
+export const wizardStream = new Hono().get("/:id/stream", async (c) => {
+    const w = await ownedWizard(c.get("user").id, c.req.param("id"));
+    return streamSSE(c, async (stream) => {
+        let closed = false;
+        const unsubscribe = subscribeDraft(w.id, (change) => {
+            if (!closed) {
+                void stream.writeSSE({ event: "change", data: JSON.stringify(change) });
+            }
+        });
+        stream.onAbort(() => {
+            closed = true;
+            unsubscribe();
+        });
+        await stream.writeSSE({ event: "hello", data: JSON.stringify({ revision: w.revision }) });
+        while (!closed) {
+            await stream.sleep(20_000);
+            if (!closed) {
+                await stream.writeSSE({ event: "ping", data: "" });
+            }
+        }
+    });
+});

package/apps/runtime/dist/running.js

@@ -0,0 +1,39 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const FILE = "running.json";
+export function writeRunning(dataDir, running) {
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(join(dataDir, FILE), `${JSON.stringify(running, null, 2)}\n`, { mode: 0o600 });
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: the process exists and belongs to somebody else.
+        return error.code === "EPERM";
+    }
+}
+/** The runtime that holds this data folder, if its process still exists. */
+export function readRunning(dataDir) {
+    try {
+        const running = JSON.parse(readFileSync(join(dataDir, FILE), "utf8"));
+        return Number.isInteger(running.pid) && alive(running.pid) ? running : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Takes the note away, unless another runtime wrote it meanwhile. */
+export function clearRunning(dataDir, pid = process.pid) {
+    try {
+        const running = JSON.parse(readFileSync(join(dataDir, FILE), "utf8"));
+        if (running.pid === pid) {
+            rmSync(join(dataDir, FILE), { force: true });
+        }
+    }
+    catch {
+        // nothing there
+    }
+}

package/apps/runtime/dist/sandbox/agentos.js

@@ -0,0 +1,191 @@
+import { posix } from "node:path";
+const WORKDIR = "/workspace";
+const EXEC_TIMEOUT_MS = 120_000;
+const INSTALL_TIMEOUT_MS = 300_000;
+/** The only hosts the VM reaches: where npm and Python packages come from. */
+const REGISTRIES = ["registry.npmjs.org", "pypi.org", "files.pythonhosted.org"];
+/** python at the start of a command, after an operator, or behind VAR=value assignments. */
+const PYTHON_IN_SHELL = /(?:^|[;&|(\n`]|\$\()\s*(?:\w+=\S*\s+)*python3?(?:\.\d+)?(?=\s|$)/;
+/**
+ * What an agentOS VM runs: a WASM userland (a POSIX shell and coreutils, no native binaries),
+ * Node in a V8 isolate and Python as Pyodide. Python started from the shell never returns, so
+ * it is offered as its own tool; of the compiled wheels only numpy loads reliably.
+ */
+export const AGENTOS_CAPABILITIES = {
+    commands: [
+        "sh",
+        "ls",
+        "cat",
+        "head",
+        "tail",
+        "sort",
+        "wc",
+        "grep",
+        "sed",
+        "awk",
+        "find",
+        "diff",
+        "tar",
+        "gzip",
+        "base64",
+        "node",
+        "npm",
+    ],
+    python: "tool",
+    pythonPackages: "Python 3.13 standard library; `packages` installs numpy and pure-Python packages from PyPI such as openpyxl or pypdf — no pandas, pillow or matplotlib",
+    network: "none, except the npm and PyPI registries",
+    uses: "calculations or file conversion",
+    workdir: WORKDIR,
+};
+let runtime = null;
+/** One native sidecar process hosts the VM of every run; the first sandbox starts it. */
+function agentOsRuntime() {
+    runtime ??= (async () => {
+        const [core, runtimeCore] = await Promise.all([
+            import("@rivet-dev/agentos-core"),
+            import("@rivet-dev/agentos-runtime-core"),
+        ]).catch((err) => {
+            throw new Error(`SANDBOX=agentos needs @rivet-dev/agentos-core in this build: ${err.message}`);
+        });
+        keepRuntimeCommands(runtimeCore.SidecarProcess);
+        return { AgentOs: core.AgentOs, sidecar: await core.AgentOs.createSidecar() };
+    })().catch((err) => {
+        runtime = null;
+        throw err;
+    });
+    return runtime;
+}
+const patched = new WeakSet();
+/**
+ * agentOS registers `python` as a kernel command when it creates a VM and leaves it out when
+ * it configures that VM; naming the runtime commands there again is what makes Python start.
+ */
+function keepRuntimeCommands(SidecarProcess) {
+    const proto = SidecarProcess.prototype;
+    if (patched.has(proto)) {
+        return;
+    }
+    patched.add(proto);
+    const configureVm = proto.configureVm;
+    proto.configureVm = function (session, vm, options) {
+        const commands = [
+            "node",
+            "npm",
+            "npx",
+            "python",
+            "python3",
+            ...(options?.bootstrapCommands ?? []),
+        ];
+        return configureVm.call(this, session, vm, {
+            ...options,
+            bootstrapCommands: [...new Set(commands)],
+        });
+    };
+}
+/** Stops the sidecar process. The next sandbox starts a new one. */
+export async function stopAgentOs() {
+    const current = runtime;
+    runtime = null;
+    await (await current?.catch(() => null))?.sidecar.dispose();
+}
+function toResult(result, python = false) {
+    const stdout = result.stdout ?? "";
+    let stderr = result.stderr ?? "";
+    if (python) {
+        // A Python traceback arrives with the interpreter's own JavaScript stack behind it.
+        stderr = stderr.replace(/\n\s+at [\s\S]*$/, "\n");
+    }
+    if (result.outcome === "timed_out") {
+        stderr = `${stderr}\ntimed out`.trim();
+    }
+    else if (result.outcome !== "succeeded" && !stdout && !stderr) {
+        stderr = result.error.message;
+    }
+    return { exitCode: result.exitCode ?? (result.outcome === "succeeded" ? 0 : 1), stdout, stderr };
+}
+/** One agentOS VM per run, inside the server process's sidecar: no Docker, no container. */
+export class AgentOsSandbox {
+    capabilities = AGENTOS_CAPABILITIES;
+    machine = null;
+    installed = new Set();
+    vm() {
+        this.machine ??= (async () => {
+            const { AgentOs, sidecar } = await agentOsRuntime();
+            return AgentOs.create({
+                sidecar: { kind: "explicit", handle: sidecar },
+                // Anything not listed is refused, the host's own loopback included.
+                permissions: {
+                    fs: "allow",
+                    childProcess: "allow",
+                    process: "allow",
+                    env: "allow",
+                    network: {
+                        default: "deny",
+                        rules: [
+                            {
+                                mode: "allow",
+                                operations: ["*"],
+                                patterns: REGISTRIES.flatMap((host) => [`dns://${host}`, `tcp://${host}:443`]),
+                            },
+                        ],
+                    },
+                },
+            });
+        })();
+        return this.machine;
+    }
+    async exec(command, options = {}) {
+        if (PYTHON_IN_SHELL.test(command)) {
+            return {
+                exitCode: 127,
+                stdout: "",
+                stderr: "python is not a shell command in this sandbox; run Python with run_python.",
+            };
+        }
+        const vm = await this.vm();
+        return toResult(await vm.process.exec(command, {
+            cwd: options.cwd ?? WORKDIR,
+            env: options.env,
+            timeoutMs: options.timeoutMs ?? EXEC_TIMEOUT_MS,
+            output: { capture: "all" },
+        }));
+    }
+    async runPython(source, options = {}) {
+        const vm = await this.vm();
+        const missing = (options.packages ?? []).filter((name) => !this.installed.has(name));
+        if (missing.length) {
+            const install = toResult(await vm.python.install(missing, {
+                timeoutMs: INSTALL_TIMEOUT_MS,
+                output: { capture: "all" },
+            }));
+            // A wheel that is listed but not shipped "installs" and then fails to load.
+            if (install.exitCode !== 0 || /Failed to load/.test(install.stdout)) {
+                return { ...install, exitCode: install.exitCode || 1 };
+            }
+            for (const name of missing) {
+                this.installed.add(name);
+            }
+        }
+        return toResult(await vm.python.execute(source, {
+            // Python starts in its HOME whatever cwd says, and only /workspace is shared with the shell.
+            env: { ...options.env, HOME: WORKDIR },
+            timeoutMs: options.timeoutMs ?? EXEC_TIMEOUT_MS,
+            output: { capture: "all" },
+        }), true);
+    }
+    async writeFile(path, data) {
+        const vm = await this.vm();
+        const target = posix.resolve(WORKDIR, path);
+        await vm.filesystem.mkdir(posix.dirname(target), { recursive: true });
+        await vm.filesystem.writeFile(target, data);
+    }
+    async readFile(path) {
+        const vm = await this.vm();
+        return vm.filesystem.readFile(posix.resolve(WORKDIR, path));
+    }
+    async destroy() {
+        const machine = this.machine;
+        this.machine = null;
+        await (await machine?.catch(() => null))?.dispose();
+    }
+}

package/apps/runtime/dist/sandbox/docker.js

@@ -0,0 +1,77 @@
+import { DockerSandbox } from "@mastra/docker";
+/** The image's own working directory, the one its unprivileged user may write to. */
+const WORKDIR = "/sandbox";
+/** Bytes per append when a file is written through the shell; stays far below ARG_MAX. */
+const WRITE_CHUNK = 48 * 1024;
+/** What the engenty-sandbox image carries. The container sits on Docker's default bridge. */
+export const DOCKER_CAPABILITIES = {
+    commands: ["bash", "python3", "pip", "uv", "node", "npm", "bun", "jq", "curl", "git", "unzip"],
+    python: "shell",
+    pythonPackages: "install what you need with pip or uv",
+    network: "open internet",
+    uses: "calculations, charts or file conversion",
+    workdir: WORKDIR,
+};
+const quote = (value) => `'${value.replaceAll("'", `'\\''`)}'`;
+/** One container per run through the host's Docker. */
+export class DockerRunSandbox {
+    runId;
+    image;
+    capabilities = DOCKER_CAPABILITIES;
+    container = null;
+    constructor(runId, image) {
+        this.runId = runId;
+        this.image = image;
+    }
+    start() {
+        this.container ??= (async () => {
+            const sandbox = new DockerSandbox({
+                id: `wizards-${this.runId.toLowerCase()}`,
+                image: this.image,
+                memory: 1024 * 1024 * 1024,
+                pidsLimit: 256,
+                capDrop: ["ALL"],
+                securityOpt: ["no-new-privileges"],
+                workingDir: WORKDIR,
+                labels: { "engenty-wizards.run": this.runId },
+            });
+            await sandbox.start();
+            return sandbox;
+        })();
+        return this.container;
+    }
+    async exec(command, options = {}) {
+        const sandbox = await this.start();
+        const result = await sandbox.executeCommand(command, [], {
+            timeout: options.timeoutMs,
+            cwd: options.cwd,
+            env: options.env,
+        });
+        return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+    }
+    async writeFile(path, data) {
+        const target = quote(path);
+        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+        await this.must(`mkdir -p "$(dirname ${target})" && : > ${target}`);
+        for (let at = 0; at < bytes.length; at += WRITE_CHUNK) {
+            const chunk = bytes.subarray(at, at + WRITE_CHUNK).toString("base64");
+            await this.must(`printf %s ${chunk} | base64 -d >> ${target}`);
+        }
+    }
+    async readFile(path) {
+        const result = await this.must(`base64 -w0 ${quote(path)}`);
+        return Buffer.from(result.stdout.trim(), "base64");
+    }
+    async must(command) {
+        const result = await this.exec(command);
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || `exit code ${result.exitCode}`);
+        }
+        return result;
+    }
+    async destroy() {
+        const container = this.container;
+        this.container = null;
+        await (await container?.catch(() => null))?.destroy();
+    }
+}

package/apps/runtime/dist/sandbox/index.js

@@ -0,0 +1,30 @@
+import { env } from "../env.js";
+import { AGENTOS_CAPABILITIES, AgentOsSandbox } from "./agentos.js";
+import { DOCKER_CAPABILITIES, DockerRunSandbox } from "./docker.js";
+/** What this server's sandbox runs, or null when it is switched off. */
+export function sandboxCapabilities() {
+    if (env.sandbox === "off") {
+        return null;
+    }
+    return env.sandbox === "agentos" ? AGENTOS_CAPABILITIES : DOCKER_CAPABILITIES;
+}
+export function createSandbox(runId) {
+    if (env.sandbox === "off") {
+        throw new Error("The sandbox is switched off on this server.");
+    }
+    return env.sandbox === "agentos"
+        ? new AgentOsSandbox()
+        : new DockerRunSandbox(runId, env.sandboxImage);
+}
+export function shellToolDescription(caps) {
+    const python = caps.python === "tool" ? " Python is not a shell command here: use run_python." : "";
+    return `Run a shell command in a private Linux sandbox (${caps.commands.join(", ")}). Working directory ${caps.workdir}. Network: ${caps.network}.${python}`;
+}
+export function pythonToolDescription(caps) {
+    return `Run Python code in the sandbox (${caps.pythonPackages}). Working directory ${caps.workdir}, shared with run_command and export_file.`;
+}
+/** The authoring guide's line about the sandbox tool. */
+export function sandboxGuideLine() {
+    const uses = (sandboxCapabilities() ?? DOCKER_CAPABILITIES).uses;
+    return `- The sandbox runs code (python/node) for ${uses}; export_file hands files to the person.`;
+}

package/apps/runtime/dist/sandbox/types.js

@@ -0,0 +1 @@
+export {};

package/apps/runtime/dist/secrets/crypto.js

@@ -0,0 +1,28 @@
+import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
+import { env } from "../env.js";
+/** AES-256-GCM for what the store keeps secret (account tokens, passwords, browser sessions). */
+const key = Buffer.from(hkdfSync("sha256", env.storeKey || env.authSecret, "engenty-wizards", "store-secrets", 32));
+export function seal(value) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const body = Buffer.concat([cipher.update(JSON.stringify(value), "utf8"), cipher.final()]);
+    return `v1.${iv.toString("base64url")}.${cipher.getAuthTag().toString("base64url")}.${body.toString("base64url")}`;
+}
+export function unseal(sealed) {
+    const [version, iv, tag, body] = sealed.split(".");
+    if (version !== "v1" || !iv || !tag || !body) {
+        return null;
+    }
+    try {
+        const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64url"));
+        decipher.setAuthTag(Buffer.from(tag, "base64url"));
+        const plain = Buffer.concat([
+            decipher.update(Buffer.from(body, "base64url")),
+            decipher.final(),
+        ]);
+        return JSON.parse(plain.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/apps/runtime/dist/secrets/signing.js

@@ -0,0 +1,34 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { env } from "../env.js";
+/** The query the signature covers: everything but exp/sig, sorted, so parameter order never matters. */
+function payload(url, exp) {
+    const params = [...url.searchParams.entries()]
+        .filter(([k]) => k !== "exp" && k !== "sig")
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `${url.pathname}?${new URLSearchParams(params)}|${exp}`;
+}
+function sign(data) {
+    return createHmac("sha256", env.authSecret).update(data).digest("base64url");
+}
+/**
+ * A link that opens one GET path without a session — for clients that have no studio cookie,
+ * such as an MCP client handing a download to the admin.
+ */
+export function signedUrl(path, ttlSeconds = 3600) {
+    const url = new URL(path, env.appUrl);
+    const exp = String(Math.floor(Date.now() / 1000) + ttlSeconds);
+    url.searchParams.set("exp", exp);
+    url.searchParams.set("sig", sign(payload(url, exp)));
+    return url.toString();
+}
+export function verifySignedUrl(href) {
+    const url = new URL(href, env.appUrl);
+    const exp = url.searchParams.get("exp");
+    const sig = url.searchParams.get("sig");
+    if (!exp || !sig || Number(exp) * 1000 < Date.now()) {
+        return false;
+    }
+    const expected = Buffer.from(sign(payload(url, exp)));
+    const given = Buffer.from(sig);
+    return expected.length === given.length && timingSafeEqual(expected, given);
+}

package/apps/runtime/dist/secrets/vault.js

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { env } from "../env.js";
+import { seal, unseal } from "./crypto.js";
+const run = promisify(execFile);
+/**
+ * Secrets of a runtime that runs alone: the keys the person entered and the linked account's
+ * refresh token. In the desktop app (`SECRETS=keychain`) they live in the macOS Keychain, never
+ * in the database; elsewhere in an encrypted file in the data folder.
+ */
+const SERVICE = "engenty-wizards";
+const keychain = process.env.SECRETS === "keychain" && process.platform === "darwin";
+const file = join(env.dataDir, "vault");
+function readFileVault() {
+    if (!existsSync(file)) {
+        return {};
+    }
+    return unseal(readFileSync(file, "utf8").trim()) ?? {};
+}
+function writeFileVault(all) {
+    writeFileSync(file, seal(all), { mode: 0o600 });
+}
+export async function vaultGet(name) {
+    if (!keychain) {
+        return readFileVault()[name] ?? null;
+    }
+    try {
+        const { stdout } = await run("security", [
+            "find-generic-password",
+            "-s",
+            SERVICE,
+            "-a",
+            name,
+            "-w",
+        ]);
+        return stdout.replace(/\n$/, "") || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function vaultSet(name, value) {
+    if (!keychain) {
+        writeFileVault({ ...readFileVault(), [name]: value });
+        return;
+    }
+    await run("security", ["add-generic-password", "-U", "-s", SERVICE, "-a", name, "-w", value]);
+}
+export async function vaultDelete(name) {
+    if (!keychain) {
+        const all = readFileVault();
+        delete all[name];
+        writeFileVault(all);
+        return;
+    }
+    await run("security", ["delete-generic-password", "-s", SERVICE, "-a", name]).catch(() => undefined);
+}

package/apps/runtime/dist/services/architect.js

@@ -0,0 +1,92 @@
+import { eq } from "drizzle-orm";
+import { runArchitect } from "../agents/architect.js";
+import { chatEngine, subscriptionTurn } from "../agents/subscription.js";
+import { listConnectors } from "../connectors/external.js";
+import { db, schema } from "../db/client.js";
+import { managed } from "../manage.js";
+import { hasTextModel } from "../models.js";
+import { draftFiles, readFile } from "./files.js";
+import { ownedProject } from "./projects.js";
+import { addMessage, draftIssues, ownedWizard, wizardMessages } from "./wizards.js";
+/** The formats a model can look at; an SVG it reads as text. */
+const VISIBLE = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+/** A picture larger than this would pass the model's limit once base64-encoded. */
+const VISIBLE_BYTES = 3_700_000;
+/** The pictures a message attaches ("Angehängt: a.png, b.pdf"), read from the workspace. */
+async function attachedImages(userId, wizardId, message) {
+    const names = message.match(/(?:^|\n\n)(?:Angehängt|Attached): ([^\n]+)$/)?.[1]?.split(", ");
+    const images = [];
+    for (const name of names?.slice(0, 8) ?? []) {
+        try {
+            const { file, data } = await readFile(userId, wizardId, name);
+            if (VISIBLE.has(file.mime) && data.byteLength <= VISIBLE_BYTES) {
+                images.push({ path: file.path, mime: file.mime, data });
+            }
+        }
+        catch {
+            // A name that is no workspace file stays text.
+        }
+    }
+    return images;
+}
+/** One studio chat turn: the architect reads the draft, its workspace and the thread, and changes them with tools. */
+export async function architectTurn(userId, wizardId, message, io) {
+    const w = await ownedWizard(userId, wizardId);
+    const history = await wizardMessages(w.id);
+    const project = await ownedProject(userId, w.projectId);
+    const images = await attachedImages(userId, w.id, message);
+    const userMessageId = await addMessage(w.id, { role: "user", content: message });
+    try {
+        // A runtime that runs alone can answer the chat on the admin's own Claude subscription.
+        const engine = managed ? "models" : await chatEngine(await hasTextModel());
+        const result = engine === "claude"
+            ? {
+                ...(await subscriptionTurn({
+                    wizardId: w.id,
+                    message,
+                    signal: io.signal,
+                    onText: io.onText,
+                    onActivity: io.onActivity,
+                    onThought: io.onThought,
+                    onBuilding: io.onBuilding,
+                    images,
+                })),
+                unfinished: false,
+            }
+            : await runArchitect({
+                userId,
+                wizardId: w.id,
+                message,
+                history: history.map((m) => ({ role: m.role, content: m.content })),
+                mcpServers: project.mcpServers.map((s) => ({ id: s.id, name: s.name })),
+                connectors: await listConnectors(project.id),
+                signal: io.signal,
+                onText: io.onText,
+                onActivity: io.onActivity,
+                onThought: io.onThought,
+                onBuilding: io.onBuilding,
+                images,
+            });
+        const reply = result.unfinished
+            ? `${result.reply ? `${result.reply}\n\n` : ""}Ich bin noch nicht ganz fertig geworden. Schreib „weiter“, dann mache ich genau dort weiter.`
+            : result.reply ||
+                (result.changed
+                    ? "Erledigt."
+                    : "Das habe ich nicht verstanden – magst du es anders formulieren?");
+        await addMessage(w.id, { role: "assistant", content: reply, changed: result.changed });
+        const after = await ownedWizard(userId, wizardId);
+        return {
+            reply,
+            changed: result.changed,
+            draft: after.draft,
+            revision: after.revision,
+            files: await draftFiles(after.id),
+            issues: await draftIssues(after),
+        };
+    }
+    catch (err) {
+        // An unanswered turn would repeat in the next turn's history.
+        await db.delete(schema.wizardMessage).where(eq(schema.wizardMessage.id, userMessageId));
+        throw err;
+    }
+}

package/apps/runtime/dist/services/brand.js

@@ -0,0 +1,20 @@
+import { and, asc, eq } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+/** The project's first logo: the one end users, documents and widgets get. */
+export async function mainLogoId(projectId) {
+    const logo = await db.query.projectFile.findFirst({
+        where: and(eq(schema.projectFile.projectId, projectId), eq(schema.projectFile.kind, "logo")),
+        orderBy: [asc(schema.projectFile.position), asc(schema.projectFile.createdAt)],
+    });
+    return logo?.id ?? null;
+}
+/** What end users see of the project: its title, accent and logo — never the project name. */
+export async function brandView(projectId) {
+    const p = await db.query.project.findFirst({ where: eq(schema.project.id, projectId) });
+    const logo = p ? await mainLogoId(p.id) : null;
+    return {
+        name: p?.brand.name ?? "",
+        accent: p?.brand.colors?.[0]?.value ?? null,
+        logoUrl: logo ? `/api/public/logos/${logo}` : null,
+    };
+}

package/apps/runtime/dist/services/cloud.js

@@ -0,0 +1,52 @@
+import { accountToken } from "../auth/account.js";
+import { env } from "../env.js";
+import { getBlob } from "../files/blobs.js";
+import { readSetting, writeSetting } from "../settings.js";
+import { ServiceError } from "./errors.js";
+import { draftFiles } from "./files.js";
+import { ownedWizard, requireClean } from "./wizards.js";
+const key = (wizardId) => `cloud:${wizardId}`;
+/** Where a local wizard was published to the cloud, if it was. */
+export function cloudCopy(wizardId) {
+    return readSetting(key(wizardId));
+}
+/**
+ * Publishes a local wizard to the cloud runtime of the linked account: definition and workspace
+ * go through the cloud's import API, which validates them like any other write. Publishing
+ * again updates the same cloud wizard, so its link stays.
+ */
+export async function publishToCloud(userId, wizardId) {
+    const w = await ownedWizard(userId, wizardId);
+    const { definition } = await requireClean(w);
+    const token = await accountToken();
+    if (!token) {
+        throw new ServiceError("refused", "Bitte zuerst in den Einstellungen ein Konto anmelden.");
+    }
+    const files = await Promise.all((await draftFiles(w.id)).map(async (f) => ({
+        path: f.path,
+        mime: f.mime,
+        data: (await getBlob(f.hash)).toString("base64"),
+    })));
+    const before = await cloudCopy(w.id);
+    const res = await fetch(`${env.local.cloudUrl}/api/v1/wizards/import`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify({ wizardId: before?.wizardId, definition, files, publish: true }),
+        signal: AbortSignal.timeout(120_000),
+    }).catch(() => null);
+    if (!res) {
+        throw new ServiceError("refused", "Die Cloud ist gerade nicht erreichbar.");
+    }
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok || !body.wizardId || !body.shareUrl) {
+        throw new ServiceError(body.issues?.length ? "has_issues" : "refused", body.error ?? "Veröffentlichen in der Cloud hat nicht geklappt.", body.issues?.length ? { issues: body.issues } : {});
+    }
+    const copy = {
+        wizardId: body.wizardId,
+        shareUrl: body.shareUrl,
+        version: body.version ?? 1,
+        publishedAt: new Date().toISOString(),
+    };
+    await writeSetting(key(w.id), copy);
+    return copy;
+}