@lynxship/cli 0.1.20 → 0.1.21

package/dist/runtime/context.js

@@ -0,0 +1,179 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { assert, } from "@lynxship/contracts";
+import { platformValue, } from "../config.js";
+import { loadCredentials } from "../secure-store.js";
+import { createCliUi } from "../ui/index.js";
+import { globalLynxShipDirectory } from "../paths.js";
+import { prompt } from "../prompt.js";
+import { buildLynxBundle } from "../bundle-build.js";
+import { requireAutolinkReady } from "../autolink.js";
+import { exists, findProjectRoot } from "./project.js";
+import { projectDirectoryFlag, readFlag } from "./args.js";
+export function createCliRuntime(rawArgs) {
+    const args = [...rawArgs];
+    const ui = createCliUi(rawArgs);
+    const json = ui.options.json;
+    const root = findProjectRoot(process.cwd(), {
+        explicitDirectory: projectDirectoryFlag(rawArgs),
+        environmentDirectory: process.env.LYNXSHIP_PROJECT_DIR,
+    });
+    const flag = (name, fallback = null) => readFlag(args, name, fallback);
+    function printValue(value, view) {
+        if (json) {
+            console.log(JSON.stringify(typeof value === "string" ? { result: value } : value));
+            return;
+        }
+        if (!ui.interactive || !view) {
+            console.log(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+            return;
+        }
+        ui.summary(view.title, view.rows);
+        ui.done(view.done);
+    }
+    async function assertInteractivePrompt(label, fallback, optionName) {
+        assert(ui.interactive, "CLI_INTERACTIVE_REQUIRED", `Pass ${label.toLowerCase()} with ${optionName} in non-interactive mode.`);
+        return prompt(label, fallback);
+    }
+    async function requireProjectRoot() {
+        assert(await exists(join(root, "lynxship.json")), "CLI_PROJECT_REQUIRED", "Run this command from a LynxShip project directory containing lynxship.json, or run `lynxship init` first.");
+    }
+    async function readConfigurationStatus() {
+        const credentials = await loadCredentials(root);
+        const r2Configured = (((await exists(join(root, ".lynxship", "r2.json"))) ||
+            (await exists(join(globalLynxShipDirectory(), "r2.json")))) &&
+            Boolean(credentials.r2)) ||
+            Boolean(process.env.CLOUDFLARE_ACCOUNT_ID &&
+                process.env.R2_BUCKET &&
+                process.env.R2_ACCESS_KEY_ID &&
+                process.env.R2_SECRET_ACCESS_KEY);
+        const android = credentials.android;
+        const androidConfigured = Boolean(android?.keystorePath && (await exists(android.keystorePath))) ||
+            Boolean(process.env.LYNXSHIP_KEYSTORE_PATH &&
+                (await exists(process.env.LYNXSHIP_KEYSTORE_PATH)) &&
+                process.env.LYNXSHIP_KEY_ALIAS &&
+                process.env.LYNXSHIP_KEYSTORE_PASSWORD &&
+                process.env.LYNXSHIP_KEY_PASSWORD);
+        return { r2: r2Configured, android: androidConfigured };
+    }
+    async function requireOperationalConfiguration(platform, options = {}) {
+        await requireProjectRoot();
+        const status = await readConfigurationStatus();
+        if (options.requireR2 !== false)
+            assert(status.r2, "CLI_R2_REQUIRED", "Cloudflare R2 must be configured first. Run `lynxship storage configure`.");
+        if (platform !== "android" || options.requireSigning === false)
+            return;
+        assert(status.android, "BUILD_SIGNING_REQUIRED", "Android signing must be configured first. Run `lynxship android configure` or provide an existing keystore.");
+    }
+    async function requireR2Configuration() {
+        await requireProjectRoot();
+        const status = await readConfigurationStatus();
+        assert(status.r2, "CLI_R2_REQUIRED", "Cloudflare R2 must be configured first. Run `lynxship storage configure`.");
+    }
+    function configuredProjectId(config) {
+        assert(typeof config.projectId === "string" && config.projectId.length > 0, "CLI_PROJECT_ID_REQUIRED", "lynxship.json must contain a generated projectId. Run `lynxship init` for a new project configuration.");
+        return config.projectId;
+    }
+    function mobilePlatformValue(value) {
+        const platform = platformValue(value);
+        assert(platform === "android" || platform === "ios", "PLATFORM_COMMAND_UNSUPPORTED", "This command supports only android or ios. Web, HarmonyOS and Desktop use their own build adapters.");
+        return platform;
+    }
+    async function renderConfigurationFooter() {
+        if (!ui.interactive || ui.options.quiet)
+            return;
+        if (rawArgs[0] === "inspect")
+            return;
+        if (rawArgs.includes("--remote"))
+            return;
+        const profileIndex = rawArgs.indexOf("--profile");
+        const simulatorProfile = profileIndex >= 0 && rawArgs[profileIndex + 1] === "simulator";
+        if (rawArgs.includes("--simulator") || simulatorProfile)
+            return;
+        const status = await readConfigurationStatus();
+        const ready = status.r2 && status.android;
+        if (ready)
+            return;
+        ui.configurationStatus([
+            {
+                label: "Cloudflare R2",
+                value: status.r2 ? "configured" : "required · storage configure",
+                valueColor: status.r2 ? "green" : "yellow",
+            },
+            {
+                label: "Android signing",
+                value: status.android ? "configured" : "required · android configure",
+                valueColor: status.android ? "green" : "yellow",
+            },
+            {
+                label: "Operational CLI",
+                value: ready ? "ready" : "blocked until setup is complete",
+                valueColor: ready ? "green" : "red",
+            },
+        ]);
+    }
+    async function buildSharedLynxBundle(miso) {
+        const progress = ui.progress("Shared Lynx bundle");
+        try {
+            progress.update(undefined, "Building the shared Lynx bundle once for native targets…");
+            await buildLynxBundle(root, {
+                quiet: json,
+                onOutput: (message) => progress.event(message),
+                miso,
+            });
+            progress.update(100, "Shared native Lynx bundle ready");
+        }
+        finally {
+            progress.stop();
+        }
+    }
+    async function initSelfHost() {
+        const directory = join(root, ".lynxship");
+        await mkdir(directory, { recursive: true });
+        const file = join(directory, ".env");
+        if (await exists(file))
+            return { status: "unchanged", file };
+        const values = {
+            POSTGRES_PASSWORD: randomBytes(24).toString("base64url"),
+            LYNXSHIP_TOKEN: randomBytes(32).toString("base64url"),
+        };
+        await writeFile(file, `${Object.entries(values)
+            .map(([key, value]) => `${key}=${value}`)
+            .join("\n")}\n`, { mode: 0o600 });
+        return { status: "created", file };
+    }
+    const projectCommandContext = { root, ui, flag, prompt };
+    const commandContext = {
+        root,
+        args,
+        ui,
+        json,
+        flag,
+        project: projectCommandContext,
+        printValue,
+        mobilePlatformValue,
+    };
+    return {
+        rawArgs,
+        args,
+        ui,
+        json,
+        root,
+        flag,
+        projectCommandContext,
+        commandContext,
+        printValue,
+        assertInteractivePrompt,
+        requireProjectRoot,
+        readConfigurationStatus,
+        requireOperationalConfiguration,
+        requireR2Configuration,
+        configuredProjectId,
+        mobilePlatformValue,
+        renderConfigurationFooter,
+        buildSharedLynxBundle,
+        initSelfHost,
+        requireAutolinkReady,
+    };
+}

package/dist/runtime/early-commands.d.ts

@@ -0,0 +1,4 @@
+import type { CliRuntime } from "./context.js";
+export declare function runEarlyCommand(context: CliRuntime, command: string): Promise<boolean>;
+export declare function commandHeader(command: string, args: readonly string[]): string;
+//# sourceMappingURL=early-commands.d.ts.map

package/dist/runtime/early-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"early-commands.d.ts","sourceRoot":"","sources":["../../src/runtime/early-commands.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,wBAAsB,eAAe,CACnC,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CA2UlB;AAED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,MAAM,CAIR"}

package/dist/runtime/early-commands.js

@@ -0,0 +1,284 @@
+import { join } from "node:path";
+import { assert } from "@lynxship/contracts";
+import { initializeBuildProject, initializeProject, } from "../commands/project.js";
+import { runDoctor } from "../commands/doctor.js";
+import { runRspeedyCommand, runDevToolDoctor, } from "../commands/development.js";
+import { runAutolinkCodegen } from "../commands/development.js";
+import { runDevice } from "../commands/device.js";
+import { streamNativeLogs } from "../commands/logs.js";
+import { runConfigurationCommands } from "../commands/configuration.js";
+import { inspectAutolink } from "../autolink.js";
+import { inspectOtaHost } from "../ota-doctor.js";
+import { inspectProjectPlugins, applyProjectPlugins } from "../plugins.js";
+import { inspectEcosystem } from "../ecosystem.js";
+import { runI18nCommand } from "../commands/i18n.js";
+import { loadConfig } from "../config.js";
+import { exists } from "./project.js";
+import { commandTitle } from "../commands/metadata.js";
+export async function runEarlyCommand(context, command) {
+    const { args, root, ui, flag, projectCommandContext, printValue } = context;
+    if (command === "init") {
+        ui.info("Scanning project structure…");
+        const file = join(root, "lynxship.json");
+        if (await exists(file)) {
+            ui.warn("lynxship.json already exists; leaving the project unchanged");
+            printValue({ status: "unchanged", file }, {
+                title: "Project",
+                rows: [{ label: "Configuration", value: file, valueColor: "muted" }],
+                done: "Project already initialized.",
+            });
+            return true;
+        }
+        await initializeProject(projectCommandContext);
+        const initializedConfig = await loadConfig(root);
+        ui.success("Created lynxship.json");
+        printValue({ status: "created", file }, {
+            title: "Initialized",
+            rows: [
+                {
+                    label: "Project ID",
+                    value: initializedConfig.projectId ?? "unassigned",
+                    valueColor: "purple",
+                },
+                { label: "Configuration", value: file, valueColor: "muted" },
+            ],
+            done: "Project initialized. Run lynxship build to get started.",
+        });
+        return true;
+    }
+    if (command === "plugin") {
+        const subcommand = args.shift() ?? "list";
+        assert(["list", "doctor", "apply"].includes(subcommand), "CLI_PLUGIN_COMMAND", "Use `lynxship plugin list`, `lynxship plugin doctor` or `lynxship plugin apply`.");
+        await context.requireProjectRoot();
+        const config = await loadConfig(root);
+        const report = await inspectProjectPlugins(root, config);
+        if (subcommand === "apply") {
+            const platform = context.mobilePlatformValue(flag("--platform", "android"));
+            const profile = flag("--profile", "production");
+            const dryRun = args.includes("--dry-run");
+            const result = await applyProjectPlugins(root, config, {
+                platform,
+                profile,
+                mode: dryRun ? "plan" : "apply",
+            });
+            printValue({
+                status: dryRun ? "planned" : "applied",
+                platform,
+                profile,
+                plugins: result.applied,
+                nativeChanges: result.changes.filter((change) => change.changed)
+                    .length,
+                changes: result.changes,
+                templates: result.templates,
+                cloud: result.cloud,
+                build: result.build,
+            }, {
+                title: `LynxShip plugins · ${platform}`,
+                rows: [
+                    {
+                        label: "Applied",
+                        value: result.applied.length ? result.applied.join(", ") : "none",
+                        valueColor: "green",
+                    },
+                    {
+                        label: "Native changes",
+                        value: String(result.changes.filter((change) => change.changed).length),
+                        valueColor: "blue",
+                    },
+                ],
+                done: dryRun
+                    ? "No native files were modified; review the planned changes."
+                    : "Project plugin changes are applied atomically and idempotently.",
+            });
+            return true;
+        }
+        const invalid = report.plugins.filter((plugin) => plugin.status !== "ready");
+        printValue(report, {
+            title: `LynxShip plugins · ${subcommand}`,
+            rows: report.plugins.length > 0
+                ? report.plugins.map((plugin) => ({
+                    label: plugin.name,
+                    value: `${plugin.status} · ${plugin.capabilities.join(", ") || "no capabilities"} · ${plugin.reason}`,
+                    valueColor: plugin.status === "ready"
+                        ? "green"
+                        : plugin.status === "missing"
+                            ? "red"
+                            : "yellow",
+                }))
+                : [
+                    {
+                        label: "Plugins",
+                        value: "none configured",
+                        valueColor: "muted",
+                    },
+                ],
+            done: invalid.length === 0
+                ? "All project plugin manifests are valid."
+                : "Fix the invalid plugin package before building.",
+        });
+        if (subcommand === "doctor" && invalid.length > 0)
+            process.exitCode = 1;
+        return true;
+    }
+    if (command === "ecosystem") {
+        const packages = await inspectEcosystem(root);
+        printValue({ packages }, {
+            title: "LynxShip ecosystem",
+            rows: packages.map((item) => ({
+                label: item.name,
+                value: item.installed
+                    ? `installed ${item.version}`
+                    : "available · not installed",
+                valueColor: item.installed ? "green" : "muted",
+            })),
+            done: "Ecosystem package status inspected without changing the project.",
+        });
+        return true;
+    }
+    if (command === "i18n") {
+        await context.requireProjectRoot();
+        await runI18nCommand({
+            root,
+            args,
+            ui,
+            flag,
+            printValue,
+        });
+        return true;
+    }
+    if (command === "doctor") {
+        await runDoctor({
+            root,
+            args,
+            ui,
+            flag,
+            printValue,
+            readConfigurationStatus: context.readConfigurationStatus,
+        });
+        return true;
+    }
+    if (["dev", "preview", "inspect"].includes(command)) {
+        await runRspeedyCommand(context.commandContext, command);
+        return true;
+    }
+    if (command === "profile") {
+        await runRspeedyCommand(context.commandContext, "build", {
+            ...process.env,
+            RSPACK_PROFILE: process.env.RSPACK_PROFILE ?? "ALL",
+        });
+        return true;
+    }
+    if (["devtool", "trace", "recorder"].includes(command)) {
+        const subcommand = args.shift() ?? "doctor";
+        assert(subcommand === "doctor", "CLI_DEVTOOL_COMMAND", "Use `lynxship devtool doctor`, `lynxship trace doctor` or `lynxship recorder doctor`.");
+        await runDevToolDoctor(context.commandContext, command);
+        return true;
+    }
+    if (command === "autolink") {
+        const subcommand = args.shift() ?? "check";
+        assert(["check", "codegen"].includes(subcommand), "CLI_AUTOLINK_COMMAND", "Use `lynxship autolink check` or `lynxship autolink codegen`");
+        if (subcommand === "codegen") {
+            await runAutolinkCodegen(context.commandContext);
+            return true;
+        }
+        const platform = context.mobilePlatformValue(flag("--platform", "android"));
+        const status = (await inspectAutolink(root))[platform];
+        printValue(status, {
+            title: `Lynx Autolink · ${platform}`,
+            rows: [
+                {
+                    label: "Required",
+                    value: String(status.required),
+                    valueColor: "blue",
+                },
+                {
+                    label: "Ready",
+                    value: String(status.ready),
+                    valueColor: status.ready ? "green" : "red",
+                },
+                {
+                    label: "Status",
+                    value: status.reason,
+                    valueColor: status.ready ? "green" : "yellow",
+                },
+            ],
+            done: status.ready
+                ? "Autolink host integration is ready."
+                : "Autolink host integration needs attention.",
+        });
+        return true;
+    }
+    if (command === "ota") {
+        assert((args.shift() ?? "doctor") === "doctor", "CLI_OTA_COMMAND", "Only `lynxship ota doctor` is available");
+        const platform = context.mobilePlatformValue(flag("--platform", "android"));
+        const status = await inspectOtaHost(root, platform);
+        printValue(status, {
+            title: `OTA host · ${platform}`,
+            rows: [
+                {
+                    label: "Native files",
+                    value: String(status.files.length),
+                    valueColor: "blue",
+                },
+                {
+                    label: "Missing hooks",
+                    value: status.missing.length ? status.missing.join(", ") : "none",
+                    valueColor: status.missing.length ? "red" : "green",
+                },
+            ],
+            done: status.missing.length === 0
+                ? "Native OTA integration looks ready."
+                : "Integrate the LynxShip OTA client before using device OTA.",
+        });
+        return true;
+    }
+    if (command === "run") {
+        await context.requireProjectRoot();
+        await runDevice(context.commandContext);
+        return true;
+    }
+    if (command === "logs") {
+        await context.requireProjectRoot();
+        await streamNativeLogs(context.commandContext);
+        return true;
+    }
+    if (command === "self-host") {
+        assert((args.shift() ?? "init") === "init", "CLI_SELF_HOST_COMMAND", "Only self-host init is available in this package");
+        ui.info("Preparing local self-host credentials…");
+        const result = await context.initSelfHost();
+        ui.success(result.status === "created"
+            ? "Created protected local environment file"
+            : "Existing environment file preserved");
+        printValue(result, {
+            title: "Self-host setup",
+            rows: [
+                {
+                    label: "Status",
+                    value: result.status,
+                    valueColor: result.status === "created" ? "green" : "yellow",
+                },
+                { label: "Environment", value: result.file, valueColor: "muted" },
+            ],
+            done: "Self-host environment is ready.",
+        });
+        return true;
+    }
+    if (["storage", "ios", "android", "store"].includes(command)) {
+        await runConfigurationCommands({
+            root,
+            args,
+            ui,
+            flag,
+            printValue,
+            project: projectCommandContext,
+            assertInteractivePrompt: context.assertInteractivePrompt,
+            initializeBuildProject,
+            mobilePlatformValue: context.mobilePlatformValue,
+        }, command);
+        return true;
+    }
+    return false;
+}
+export function commandHeader(command, args) {
+    return commandTitle(command === "update" && args[0] === "rollback" ? "rollback" : command);
+}

package/dist/runtime/project.d.ts

@@ -0,0 +1,8 @@
+export interface ProjectRootOptions {
+    explicitDirectory?: string;
+    environmentDirectory?: string;
+}
+export declare function findProjectRoot(start: string, options?: ProjectRootOptions): string;
+export declare function exists(file: string): Promise<boolean>;
+export declare function findLockfile(rootDirectory: string): Promise<string | null>;
+//# sourceMappingURL=project.d.ts.map

package/dist/runtime/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/runtime/project.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAWR;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO3D;AAED,wBAAsB,YAAY,CAChC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CASxB"}

package/dist/runtime/project.js

@@ -0,0 +1,38 @@
+import { access } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+export function findProjectRoot(start, options = {}) {
+    const explicit = options.explicitDirectory ?? options.environmentDirectory;
+    if (explicit)
+        return resolve(explicit);
+    let current = resolve(start);
+    while (true) {
+        if (existsSync(join(current, "lynxship.json")))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return resolve(start);
+        current = parent;
+    }
+}
+export async function exists(file) {
+    try {
+        await access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function findLockfile(rootDirectory) {
+    let current = resolve(rootDirectory);
+    while (true) {
+        for (const file of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"])
+            if (await exists(join(current, file)))
+                return join(current, file);
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/runtime/state.d.ts

@@ -0,0 +1,47 @@
+import { type SigningKey } from "@lynxship/signing";
+import type { BuildJob, Platform, SubmissionJob } from "@lynxship/contracts";
+import { JsonRepository } from "@lynxship/db";
+import { BuildOrchestrator } from "@lynxship/build-orchestrator";
+import { SubmissionService } from "@lynxship/submit";
+import type { RemoteCliState } from "../remote.js";
+export interface CliRelease {
+    id: string;
+    manifest: {
+        protocolVersion: number;
+        projectId: string;
+        channel: string;
+        platform: Platform;
+        runtimeVersion: string;
+        sequence: number;
+        keyId: string;
+        assets: Array<{
+            path: string;
+            hash: string;
+            size: number;
+            url?: string;
+        }>;
+    };
+    signature: string;
+    message: string;
+    createdAt: string;
+}
+export interface CliState extends RemoteCliState {
+    builds: BuildJob[];
+    submissions: SubmissionJob[];
+    releases: CliRelease[];
+    signingKey: SigningKey | null;
+    lastRollback?: {
+        releaseId: string;
+        reason: string;
+        at: string;
+    };
+}
+export interface LoadedCliState {
+    state: CliState;
+    repository: JsonRepository<CliState>;
+    builds: BuildOrchestrator;
+    submissions: SubmissionService;
+}
+export declare function loadState(root: string): Promise<LoadedCliState>;
+export declare function saveState(state: CliState, repository: JsonRepository<CliState>, builds: BuildOrchestrator, submissions: SubmissionService): Promise<void>;
+//# sourceMappingURL=state.d.ts.map

package/dist/runtime/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/runtime/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EACL,iBAAiB,EAElB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAA0B,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGnD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE;QACR,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,QAAQ,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC3E,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,QAAS,SAAQ,cAAc;IAC9C,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,WAAW,EAAE,aAAa,EAAE,CAAC;IAC7B,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,YAAY,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,QAAQ,CAAC;IAChB,UAAU,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACrC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,WAAW,EAAE,iBAAiB,CAAC;CAChC;AAID,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAqBrE;AAED,wBAAsB,SAAS,CAC7B,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,cAAc,CAAC,QAAQ,CAAC,EACpC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,iBAAiB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAQf"}

package/dist/runtime/state.js

@@ -0,0 +1,33 @@
+import { createSigningKey } from "@lynxship/signing";
+import { JsonRepository } from "@lynxship/db";
+import { BuildOrchestrator, LocalBuildExecutor, } from "@lynxship/build-orchestrator";
+import { MockSubmissionProvider, SubmissionService } from "@lynxship/submit";
+import { join } from "node:path";
+let stateSaveQueue = Promise.resolve();
+export async function loadState(root) {
+    const repository = new JsonRepository(join(root, ".lynxship", "state.json"), {
+        builds: [],
+        submissions: [],
+        releases: [],
+        signingKey: null,
+    });
+    const state = await repository.read();
+    state.builds ??= [];
+    state.submissions ??= [];
+    state.releases ??= [];
+    state.signingKey ??= createSigningKey();
+    const builds = new BuildOrchestrator(new LocalBuildExecutor());
+    builds.restore(state.builds);
+    const submissions = new SubmissionService(new MockSubmissionProvider());
+    submissions.restore(state.submissions);
+    return { state, repository, builds, submissions };
+}
+export async function saveState(state, repository, builds, submissions) {
+    const next = stateSaveQueue.then(async () => {
+        state.builds = builds.list();
+        state.submissions = submissions.list();
+        await repository.write(state);
+    });
+    stateSaveQueue = next.catch(() => undefined);
+    await next;
+}

package/dist/secure-store/backends.d.ts

@@ -0,0 +1,20 @@
+import type { StoredCredentials } from "./types.js";
+export interface EncryptedCredentials {
+    version: 1;
+    platform: "windows-dpapi" | "macos-keychain" | "linux-secret-service" | "file-mode-600";
+    values: Record<string, string>;
+}
+export declare function credentialFile(root: string, global?: boolean): string;
+export declare function protect(value: string): Promise<string>;
+export declare function unprotect(value: string): Promise<string>;
+export declare function runSecurity(args: string[]): Promise<string>;
+export declare function runSecretTool(args: string[], input?: string): Promise<string>;
+export declare function keychainAccount(root: string, global: boolean): string;
+export declare function secretServiceAccount(root: string, global: boolean): string;
+export declare function credentialValues(credentials: StoredCredentials): Record<string, string>;
+export declare function credentialsFromValues(values: Record<string, string>): StoredCredentials;
+export declare function readKeychain(root: string, global: boolean): Promise<StoredCredentials | undefined>;
+export declare function saveKeychain(root: string, credentials: StoredCredentials, global: boolean): Promise<void>;
+export declare function readSecretService(root: string, global: boolean): Promise<StoredCredentials | undefined>;
+export declare function saveSecretService(root: string, credentials: StoredCredentials, global: boolean): Promise<boolean>;
+//# sourceMappingURL=backends.d.ts.map

package/dist/secure-store/backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backends.d.ts","sourceRoot":"","sources":["../../src/secure-store/backends.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EACJ,eAAe,GACf,gBAAgB,GAChB,sBAAsB,GACtB,eAAe,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAKD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,UAAQ,GAAG,MAAM,CAKnE;AAiCD,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAM5D;AAED,wBAAsB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAiB3D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBzE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAErE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAE1E;AAED,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,iBAAiB,GAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA6BxB;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,iBAAiB,CAoDnB;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAoBxC;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,iBAAiB,EAC9B,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAsBxC;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,iBAAiB,EAC9B,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,OAAO,CAAC,CAyBlB"}