@nurix/nustack 0.10.0-dev.10

package/dist/commands/workspace-sync.js

@@ -0,0 +1,645 @@
+import os from "node:os";
+import { resolveNuStackUrl } from "../lib/nustack_client.js";
+import { openLocalStore } from "../lib/local_store/database.js";
+import { listActiveBindings, getBindingById, } from "../lib/local_store/bindings.js";
+import { readDeviceState } from "../lib/local_store/device_state.js";
+import { listApplicationsForBinding, getApplication, } from "../lib/local_store/handoff_applications.js";
+import { ensureAccessToken, signedOutCopy } from "../lib/auth_grant.js";
+import { createSyncEngine, observeBinding } from "../lib/git-sync/core/engine.js";
+import { createWatchStreamEmitter } from "../lib/git-sync/core/watch_stream.js";
+import { reconcileInboundBinding, retryApplication, approveHandoff, undoHandoff, listUnacknowledgedNotifications, acknowledgeNotification, renderCommitNotification, } from "../lib/git-sync/inbound/index.js";
+import { listBundles, restoreBundle, deleteBundle, sweepExpiredBundles, } from "../lib/git-sync/recovery/index.js";
+import { resolveRepository } from "../lib/git-sync/core/repository.js";
+import { registerOutbound, createUploadClient, deviceTokenProvider, describeHistoryDecision, publishCurrentState, adoptWithoutPublishing, } from "../lib/git-sync/outbound/index.js";
+import { latestAcceptedUpload } from "../lib/local_store/accepted_uploads.js";
+const ONBOARDING_POINTER = "No NuStack Workspace bindings on this machine. Run `nustack workspace attach` inside a Git repository to bind it.";
+function writeLine(line) {
+    process.stdout.write(`${line}\n`);
+}
+export function registerWorkspaceSyncCommands(workspaceCommand, getGlobalOptions) {
+    void getGlobalOptions;
+    const sync = workspaceCommand
+        .command("sync")
+        .description("Synchronize NuStack Documents with your local Git repository");
+    sync
+        .command("status")
+        .description("Show local binding status and a live Git observation (no network)")
+        .option("--json", "emit the binding observations as JSON")
+        .action(async (options) => runStatus(options));
+    sync
+        .command("now")
+        .description("Run one reconciliation pass over each active binding")
+        .option("--binding <id>", "reconcile only this binding")
+        .option("--json", "emit the reconciliation outcomes as JSON")
+        .action(async (options) => runNow(getGlobalOptions(), options));
+    sync
+        .command("watch")
+        .description("Run the reconciliation engine continuously (the desktop supervision loop)")
+        .option("--binding <id>", "supervise only this binding (the desktop runs one child per binding)")
+        .option("--json", "emit the versioned JSONL watch stream on stdout")
+        .action(async (options) => runWatch(getGlobalOptions(), options));
+    sync
+        .command("pending")
+        .description("List inbound Handoff applications awaiting evaluation, decision, or a technical wait")
+        .option("--json", "emit the pending applications as JSON")
+        .action(async (options) => runPending(options));
+    sync
+        .command("approve <handoffId>")
+        .description("Approve an overwrite decision for a cloud Handoff (a content decision — never automated)")
+        .option("--binding <id>", "disambiguate when more than one binding has this Handoff")
+        .option("--yes", "(refused) approval is a content decision and cannot be pre-confirmed")
+        .option("--json", "emit the outcome as JSON")
+        .action(async (handoffId, options) => runApprove(getGlobalOptions(), handoffId, options));
+    sync
+        .command("retry <handoffId>")
+        .description("Re-evaluate a Handoff parked in a technical wait or error")
+        .option("--binding <id>", "disambiguate when more than one binding has this Handoff")
+        .option("--json", "emit the outcome as JSON")
+        .action(async (handoffId, options) => runRetry(getGlobalOptions(), handoffId, options));
+    sync
+        .command("undo <handoffId>")
+        .description("Revert a committed inbound Handoff with a normal User-identified revert commit")
+        .option("--binding <id>", "disambiguate when more than one binding has this Handoff")
+        .option("--json", "emit the outcome as JSON")
+        .action(async (handoffId, options) => runUndo(getGlobalOptions(), handoffId, options));
+    sync
+        .command("reconcile-history")
+        .description("Resolve a rewritten-history block by publishing current state or adopting it — never a default")
+        .option("--binding <id>", "reconcile only this binding")
+        .option("--publish", "publish current committed state as one Handoff, then adopt HEAD as the baseline")
+        .option("--adopt", "adopt HEAD as the baseline without publishing (cloud state unchanged)")
+        .option("--json", "emit the decision record as JSON")
+        .action(async (options) => runReconcileHistory(getGlobalOptions(), options));
+    const recovery = sync
+        .command("recovery")
+        .description("Manage machine-local recovery bundles saved before an approved overwrite");
+    recovery
+        .command("list")
+        .description("List recovery bundles and their expiries")
+        .option("--json", "emit the bundles as JSON")
+        .action(async (options) => runRecoveryList(options));
+    recovery
+        .command("restore <bundleId>")
+        .description("Restore a recovery bundle's pre-approval content outside the repository")
+        .option("--to <dir>", "extract into this directory instead of the default recovery area")
+        .option("--json", "emit the outcome as JSON")
+        .action(async (bundleId, options) => runRecoveryRestore(bundleId, options));
+    recovery
+        .command("delete <bundleId>")
+        .description("Delete a recovery bundle and its encrypted file")
+        .option("--json", "emit the outcome as JSON")
+        .action(async (bundleId, options) => runRecoveryDelete(bundleId, options));
+}
+async function buildInboundRuntime(store, globals) {
+    const baseUrl = resolveNuStackUrl(globals);
+    const auth = await ensureAccessToken(baseUrl).catch(() => null);
+    if (!auth)
+        return null;
+    const deviceState = readDeviceState(store);
+    return {
+        baseUrl,
+        accessToken: auth.accessToken,
+        userId: deviceState?.activeUserId ?? null,
+        deviceRef: deviceState?.deviceRef ?? null,
+    };
+}
+function resolveApplicationBinding(store, handoffId, bindingOption) {
+    if (bindingOption) {
+        const application = getApplication(store, handoffId, bindingOption);
+        if (!application)
+            return { ok: false, message: `No application for Handoff ${handoffId} on binding ${bindingOption}.` };
+        return { ok: true, bindingId: bindingOption };
+    }
+    const matches = listActiveBindings(store)
+        .filter((binding) => getApplication(store, handoffId, binding.id))
+        .map((binding) => binding.id);
+    if (matches.length === 0)
+        return { ok: false, message: `No application for Handoff ${handoffId} on this machine.` };
+    if (matches.length > 1)
+        return { ok: false, message: `Handoff ${handoffId} is bound to more than one binding; pass --binding <id>.` };
+    return { ok: true, bindingId: matches[0] };
+}
+function displayPath(absolute) {
+    const home = os.homedir();
+    return home.length > 1 && absolute.startsWith(home) ? `~${absolute.slice(home.length)}` : "(outside home)";
+}
+function parseDecisionEvidence(json) {
+    if (!json)
+        return [];
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed.divergent) ? parsed.divergent : [];
+    }
+    catch {
+        return [];
+    }
+}
+function toPendingView(application) {
+    return {
+        handoffId: application.handoffId,
+        bindingId: application.bindingId,
+        state: application.state,
+        waitReason: application.technicalWaitReason,
+        divergence: parseDecisionEvidence(application.decisionState),
+        errorCode: application.errorCode,
+    };
+}
+const PENDING_STATES = ["received", "evaluating", "technical_wait", "decision_required", "approved"];
+async function runPending(options) {
+    const store = await openLocalStore();
+    try {
+        const bindings = listActiveBindings(store);
+        if (bindings.length === 0) {
+            if (options.json)
+                writeLine("[]");
+            else
+                writeLine(ONBOARDING_POINTER);
+            return;
+        }
+        for (const binding of bindings) {
+            for (const application of listUnacknowledgedNotifications(store, binding.id)) {
+                const paths = parseDecisionEvidence(application.decisionState).map((entry) => entry.path);
+                if (!options.json)
+                    for (const line of renderCommitNotification(application, paths))
+                        writeLine(line);
+                acknowledgeNotification(store, application.handoffId, binding.id);
+            }
+        }
+        const pending = bindings.flatMap((binding) => listApplicationsForBinding(store, binding.id, PENDING_STATES));
+        if (options.json) {
+            writeLine(JSON.stringify(pending.map(toPendingView), null, 2));
+            return;
+        }
+        if (pending.length === 0) {
+            writeLine("No pending inbound Handoff applications.");
+            return;
+        }
+        for (const application of pending) {
+            const evidence = parseDecisionEvidence(application.decisionState);
+            const detail = application.state === "decision_required"
+                ? ` — ${evidence.map((entry) => `${entry.path} (${entry.divergence})`).join(", ")}`
+                : application.technicalWaitReason
+                    ? ` — ${application.technicalWaitReason}`
+                    : "";
+            writeLine(`${application.handoffId}  ${application.state}${detail}`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+async function runApprove(globals, handoffId, options) {
+    if (options.yes) {
+        writeLine("`--yes` is refused: approving an overwrite is a content decision and cannot be pre-confirmed.");
+        process.exitCode = 1;
+        return;
+    }
+    const store = await openLocalStore();
+    try {
+        const runtime = await buildInboundRuntime(store, globals);
+        if (!runtime) {
+            writeLine(signedOutCopy());
+            process.exitCode = 1;
+            return;
+        }
+        const resolved = resolveApplicationBinding(store, handoffId, options.binding);
+        if (!resolved.ok) {
+            writeLine(resolved.message);
+            process.exitCode = 1;
+            return;
+        }
+        const result = await approveHandoff(store, runtime, resolved.bindingId, handoffId);
+        if (options.json) {
+            writeLine(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            writeLine(`Approved and committed ${result.commitId.slice(0, 12)} — NuStack did not push it.`);
+            if (result.recoveryBundleId)
+                writeLine(`Recovery bundle ${result.recoveryBundleId} holds your pre-approval content.`);
+        }
+        else if (result.code === "local_state_changed" && result.warning) {
+            writeLine("Your local state changed since the warning — re-review before approving:");
+            for (const entry of result.warning.paths)
+                writeLine(`  ${entry.path} (${entry.divergence})`);
+            writeLine(result.warning.recoveryNote);
+        }
+        else {
+            writeLine(`Approve did not proceed: ${result.code}${result.detail ? ` (${result.detail})` : ""}.`);
+        }
+        if (!result.ok && result.code !== "local_state_changed")
+            process.exitCode = 1;
+    }
+    finally {
+        store.close();
+    }
+}
+async function runRetry(globals, handoffId, options) {
+    const store = await openLocalStore();
+    try {
+        const runtime = await buildInboundRuntime(store, globals);
+        if (!runtime) {
+            writeLine(signedOutCopy());
+            process.exitCode = 1;
+            return;
+        }
+        const resolved = resolveApplicationBinding(store, handoffId, options.binding);
+        if (!resolved.ok) {
+            writeLine(resolved.message);
+            process.exitCode = 1;
+            return;
+        }
+        const result = await retryApplication(store, runtime, resolved.bindingId, handoffId);
+        if (options.json)
+            writeLine(JSON.stringify(result, null, 2));
+        else if (result.ok)
+            writeLine(`Re-evaluated ${handoffId} — now ${result.state}.`);
+        else {
+            writeLine(`Retry did not proceed: ${result.code}.`);
+            process.exitCode = 1;
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+async function runUndo(globals, handoffId, options) {
+    const store = await openLocalStore();
+    try {
+        const runtime = await buildInboundRuntime(store, globals);
+        if (!runtime) {
+            writeLine(signedOutCopy());
+            process.exitCode = 1;
+            return;
+        }
+        const resolved = resolveApplicationBinding(store, handoffId, options.binding);
+        if (!resolved.ok) {
+            writeLine(resolved.message);
+            process.exitCode = 1;
+            return;
+        }
+        const result = await undoHandoff(store, runtime, resolved.bindingId, handoffId);
+        if (options.json) {
+            writeLine(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            writeLine(`Reverted with ${result.revertCommitId.slice(0, 12)} — NuStack did not push it.`);
+        }
+        else if (result.code === "revert_conflict") {
+            writeLine("Revert would conflict with later work — the repository is untouched. Affected paths:");
+            for (const path of result.conflictPaths)
+                writeLine(`  ${path}`);
+        }
+        else if (result.code === "missing_identity") {
+            writeLine("Set your Git identity first: git config user.name and user.email.");
+        }
+        else {
+            writeLine(`Undo did not proceed: ${result.code}.`);
+        }
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    finally {
+        store.close();
+    }
+}
+async function runRecoveryList(options) {
+    const store = await openLocalStore();
+    try {
+        await sweepExpiredBundles(store);
+        const bundles = listBundles(store).map((bundle) => ({
+            id: bundle.id,
+            bindingId: bundle.bindingId,
+            handoffId: bundle.handoffId,
+            state: bundle.state,
+            expiresAt: new Date(bundle.expiresAtMs).toISOString(),
+        }));
+        if (options.json) {
+            writeLine(JSON.stringify(bundles, null, 2));
+            return;
+        }
+        if (bundles.length === 0) {
+            writeLine("No recovery bundles.");
+            return;
+        }
+        for (const bundle of bundles)
+            writeLine(`${bundle.id}  ${bundle.state}  handoff=${bundle.handoffId}  expires=${bundle.expiresAt}`);
+    }
+    finally {
+        store.close();
+    }
+}
+async function runRecoveryRestore(bundleId, options) {
+    const store = await openLocalStore();
+    try {
+        const deviceState = readDeviceState(store);
+        const deviceRef = deviceState?.deviceRef;
+        if (!deviceRef) {
+            writeLine("This device has no recovery key reference — sign in first.");
+            process.exitCode = 1;
+            return;
+        }
+        const result = await restoreBundle(store, deviceRef, bundleId, options.to);
+        if (options.json) {
+            writeLine(JSON.stringify(result.ok ? { ok: true, files: result.files, dir: displayPath(result.dir) } : result, null, 2));
+        }
+        else if (result.ok) {
+            writeLine(`Restored ${result.files.length} file(s) to ${displayPath(result.dir)} (outside the repository).`);
+            for (const file of result.files)
+                writeLine(`  ${file}`);
+        }
+        else {
+            writeLine(`Restore did not proceed: ${result.code}.`);
+        }
+        if (!result.ok)
+            process.exitCode = 1;
+    }
+    finally {
+        store.close();
+    }
+}
+async function runRecoveryDelete(bundleId, options) {
+    const store = await openLocalStore();
+    try {
+        const result = await deleteBundle(store, bundleId);
+        if (options.json)
+            writeLine(JSON.stringify(result, null, 2));
+        else if (result.ok)
+            writeLine(`Deleted recovery bundle ${bundleId}.`);
+        else {
+            writeLine(`Delete did not proceed: ${result.code}.`);
+            process.exitCode = 1;
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+function shortId(id) {
+    return id ? id.slice(0, 12) : "—";
+}
+function outboundStatusFor(store, binding) {
+    const row = store.db
+        .prepare("SELECT COUNT(*) AS n, MIN(next_retry_at_ms) AS next FROM pending_uploads WHERE binding_id = :id")
+        .get({ id: binding.id });
+    const accepted = latestAcceptedUpload(store, binding.id);
+    let historyDecisionPending = false;
+    try {
+        historyDecisionPending = describeHistoryDecision(store, binding, resolveRepository(binding.repositoryRoot)).pending;
+    }
+    catch {
+    }
+    return {
+        pendingUploadCount: row.n,
+        nextRetryAt: row.next != null ? new Date(row.next).toISOString() : null,
+        blockedErrorCode: binding.status === "failed" ? binding.lastErrorCode : null,
+        lastAcceptedHandoffId: accepted?.handoffId ?? null,
+        lastAcceptedWorkspaceSequence: accepted?.workspaceSequence ?? null,
+        historyDecisionPending,
+    };
+}
+function historyTargets(store, bindingOption) {
+    if (bindingOption) {
+        const binding = getBindingById(store, bindingOption);
+        if (!binding)
+            return { ok: false, message: `No binding "${bindingOption}" on this machine.` };
+        return { ok: true, targets: [binding] };
+    }
+    return { ok: true, targets: listActiveBindings(store) };
+}
+async function runReconcileHistory(globals, options) {
+    const store = await openLocalStore();
+    try {
+        if (options.publish && options.adopt) {
+            writeLine("Choose exactly one of --publish or --adopt.");
+            process.exitCode = 1;
+            return;
+        }
+        const resolved = historyTargets(store, options.binding);
+        if (!resolved.ok) {
+            writeLine(resolved.message);
+            process.exitCode = 1;
+            return;
+        }
+        if (resolved.targets.length === 0) {
+            if (options.json)
+                writeLine("[]");
+            else
+                writeLine(ONBOARDING_POINTER);
+            return;
+        }
+        const records = [];
+        for (const binding of resolved.targets) {
+            let repo;
+            try {
+                repo = resolveRepository(binding.repositoryRoot);
+            }
+            catch {
+                records.push({ bindingId: binding.id, error: "repository_unresolved" });
+                if (!options.json)
+                    writeLine(`${binding.id}: repository could not be resolved.`);
+                process.exitCode = 1;
+                continue;
+            }
+            const evidence = describeHistoryDecision(store, binding, repo);
+            if (!evidence.pending) {
+                records.push({ bindingId: binding.id, pending: false });
+                if (!options.json)
+                    writeLine(`${binding.id}: no rewritten-history decision pending.`);
+                continue;
+            }
+            if (!options.publish && !options.adopt) {
+                records.push({
+                    bindingId: binding.id,
+                    pending: true,
+                    oldBaselineCommitId: evidence.oldBaselineCommitId,
+                    headCommitId: evidence.headCommitId,
+                    baselineReadable: evidence.baselineReadable,
+                    choiceRequired: true,
+                });
+                if (!options.json) {
+                    writeLine(`${binding.id}: rewritten history — the recorded baseline is no longer on the bound branch.`);
+                    writeLine(`  old baseline: ${shortId(evidence.oldBaselineCommitId)}   HEAD: ${shortId(evidence.headCommitId)}   baseline readable: ${evidence.baselineReadable}`);
+                    writeLine("  Choose: --publish (publish current committed state) or --adopt (adopt HEAD without publishing). NuStack never guesses.");
+                }
+                process.exitCode = 1;
+                continue;
+            }
+            const baseUrl = resolveNuStackUrl(globals);
+            const client = createUploadClient({ baseUrl, getAccessToken: deviceTokenProvider(baseUrl) });
+            if (options.publish) {
+                const result = await publishCurrentState(store, binding, repo, { client });
+                if (result.ok) {
+                    records.push({ bindingId: binding.id, decision: "publish_current_state", decisionId: result.decisionId, newBaselineCommitId: result.newBaselineCommitId, mode: result.mode, handoffId: result.handoffId ?? null, noOp: result.noOp });
+                    if (!options.json)
+                        writeLine(`${binding.id}: published current state (${result.mode}) — HEAD ${shortId(result.newBaselineCommitId)} is the new baseline${result.handoffId ? `, handoff ${result.handoffId}` : result.noOp ? " (server no-op)" : ""}.`);
+                }
+                else {
+                    records.push({ bindingId: binding.id, decision: "publish_current_state", error: result.code });
+                    if (!options.json)
+                        writeLine(`${binding.id}: publish did not proceed: ${result.code}.`);
+                    process.exitCode = 1;
+                }
+            }
+            else {
+                const result = await adoptWithoutPublishing(store, binding, repo, { client });
+                if (result.ok) {
+                    records.push({ bindingId: binding.id, decision: "adopt_without_publishing", decisionId: result.decisionId, newBaselineCommitId: result.newBaselineCommitId });
+                    if (!options.json)
+                        writeLine(`${binding.id}: adopted HEAD ${shortId(result.newBaselineCommitId)} as the baseline — cloud state unchanged.`);
+                }
+                else {
+                    records.push({ bindingId: binding.id, decision: "adopt_without_publishing", error: result.code });
+                    if (!options.json)
+                        writeLine(`${binding.id}: adopt did not proceed: ${result.code}.`);
+                    process.exitCode = 1;
+                }
+            }
+        }
+        if (options.json)
+            writeLine(JSON.stringify(records, null, 2));
+    }
+    finally {
+        store.close();
+    }
+}
+async function runStatus(options) {
+    const store = await openLocalStore();
+    try {
+        const bindings = listActiveBindings(store);
+        if (bindings.length === 0) {
+            if (options.json)
+                writeLine("[]");
+            else
+                writeLine(ONBOARDING_POINTER);
+            return;
+        }
+        const observations = bindings.map((binding) => ({ ...observeBinding(binding), outbound: outboundStatusFor(store, binding) }));
+        if (options.json) {
+            writeLine(JSON.stringify(observations, null, 2));
+            return;
+        }
+        for (const observation of observations) {
+            const head = shortId(observation.headCommitId);
+            const processed = shortId(observation.lastProcessedCommitId);
+            const branchNote = observation.symbolicBranch === observation.boundBranch
+                ? observation.boundBranch
+                : `${observation.boundBranch} (checked out: ${observation.symbolicBranch ?? "detached"})`;
+            const outbound = observation.outbound;
+            const outboundNote = (outbound.pendingUploadCount > 0 ? `  queued=${outbound.pendingUploadCount}` : "") +
+                (outbound.blockedErrorCode ? `  blocked=${outbound.blockedErrorCode}` : "") +
+                (outbound.lastAcceptedWorkspaceSequence != null ? `  accepted@${outbound.lastAcceptedWorkspaceSequence}` : "") +
+                (outbound.historyDecisionPending ? "  history-decision-required" : "");
+            writeLine(`${observation.bindingId}  ${observation.status}  branch=${branchNote}  ` +
+                `head=${head}  processed=${processed}  pending=${observation.pendingCommitCount}` +
+                outboundNote +
+                (observation.resolved ? "" : "  [repository unresolved]"));
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+async function runNow(globals, options) {
+    const store = await openLocalStore();
+    try {
+        const engine = createSyncEngine({ store });
+        const runtime = await buildInboundRuntime(store, globals);
+        if (runtime)
+            registerOutbound(engine, { baseUrl: runtime.baseUrl });
+        let targets;
+        if (options.binding) {
+            const binding = getBindingById(store, options.binding);
+            if (!binding) {
+                writeLine(`No binding "${options.binding}" on this machine.`);
+                process.exitCode = 1;
+                return;
+            }
+            targets = [binding];
+        }
+        else {
+            targets = listActiveBindings(store);
+        }
+        if (targets.length === 0) {
+            if (options.json)
+                writeLine("[]");
+            else
+                writeLine(ONBOARDING_POINTER);
+            return;
+        }
+        const outcomes = [];
+        for (const binding of targets) {
+            outcomes.push(await engine.reconcileBinding(binding.id, "manual"));
+        }
+        if (runtime) {
+            for (const binding of targets) {
+                await reconcileInboundBinding(store, runtime, binding.id).catch(() => { });
+            }
+        }
+        if (options.json) {
+            writeLine(JSON.stringify(outcomes, null, 2));
+            return;
+        }
+        for (const outcome of outcomes) {
+            const detail = outcome.outcome === "commit_range_ready"
+                ? ` — ${outcome.pendingCommitCount} pending commit(s)`
+                : outcome.waitReason
+                    ? ` — ${outcome.waitReason}`
+                    : outcome.errorCode
+                        ? ` — ${outcome.errorCode}`
+                        : "";
+            writeLine(`${outcome.bindingId}: ${outcome.outcome}${detail}`);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+async function runWatch(globals, options) {
+    const store = await openLocalStore();
+    if (options.binding && !getBindingById(store, options.binding)) {
+        if (options.json)
+            process.stdout.write(`${JSON.stringify({ event: "error", code: "binding_not_found", binding: options.binding })}\n`);
+        else
+            process.stderr.write(`No binding "${options.binding}" on this machine.\n`);
+        store.close();
+        process.exitCode = 1;
+        return;
+    }
+    const emitter = options.json ? createWatchStreamEmitter(process.stdout) : null;
+    const onLog = options.json
+        ? undefined
+        : (line) => {
+            process.stderr.write(`${line}\n`);
+        };
+    const engine = createSyncEngine({
+        store,
+        bindingIds: options.binding ? [options.binding] : null,
+        emitter,
+        onLog,
+    });
+    const runtime = await buildInboundRuntime(store, globals);
+    if (runtime)
+        registerOutbound(engine, { baseUrl: runtime.baseUrl });
+    let stopping = false;
+    const onSignal = () => void shutdown();
+    const shutdown = async () => {
+        if (stopping)
+            return;
+        stopping = true;
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        await engine.stop("signal");
+        try {
+            store.close();
+        }
+        catch {
+        }
+        process.exitCode = 0;
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    if (!options.json && listActiveBindings(store).length === 0) {
+        process.stderr.write(`${ONBOARDING_POINTER}\n`);
+    }
+    await engine.start();
+}