@oscharko-dev/keiko-cli 0.2.0

package/dist/investigate.js

@@ -0,0 +1,249 @@
+// `keiko investigate` — investigates a bounded bug report and proposes a minimal fix + a
+// regression test (ADR-0009 D14). Dry-run by default; --apply writes the fix and runs verification.
+// The text path prints the proposed diff (when present) plus clearly-labelled verified facts and
+// the UNVERIFIED model hypothesis; --json emits the full BugInvestigationReport. Failing output and
+// stack traces may be read from files (--output-file / --stack-file) to avoid huge argv. Evidence
+// files are read through the workspace boundary, never raw node:fs. The gateway ModelPort is built
+// from config (loadGatewayConfigFromFile); tests inject deps.model directly so no live gateway is needed.
+// Exit 0 on fix-applied/fix-proposed/investigation-only, 1 on
+// rejected/cancelled/failed/runtime, 2 on usage. Mirrors runGenTestsCli's structure.
+import { Gateway, ConfigInvalidError, GatewayError, assertConfiguredModel, selectConfiguredModel, redact, } from "@oscharko-dev/keiko-model-gateway";
+import { GatewayModelPort } from "@oscharko-dev/keiko-harness";
+import { detectWorkspace, readWorkspaceFile, WorkspaceError, } from "@oscharko-dev/keiko-workspace";
+import { investigateBug, renderBugMarkdownReport } from "@oscharko-dev/keiko-workflows";
+import { loadGatewayConfigFromFile } from "./gateway-config.js";
+const USAGE = `Usage:
+  keiko investigate [--description TEXT] [--output TEXT | --output-file PATH]
+                    [--stack TEXT | --stack-file PATH] [--file PATH[,PATH]]
+                    [--apply] [--model MODEL_ID] [--config PATH] [--json] [--dir-root PATH]
+
+Investigates a bounded bug report and proposes a root-cause hypothesis with a
+minimal fix and a regression test, separating verified facts from model
+hypotheses. At least one evidence source is required (--description, --output[-file],
+--stack[-file], or --file). Dry-run by default (writes nothing); pass --apply to
+write the fix and run verification through the safe tool + verification layers.
+`;
+// Returns the value of a `--flag value` pair, undefined if absent, or null if present without a
+// value (a usage error) — identical contract to runGenTestsCli's flagValue.
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return undefined;
+    }
+    const value = args[i + 1];
+    return value === undefined || value.startsWith("--") ? null : value;
+}
+const VALUE_FLAGS = [
+    "--description",
+    "--output",
+    "--output-file",
+    "--stack",
+    "--stack-file",
+    "--file",
+    "--model",
+    "--config",
+    "--dir-root",
+];
+function readValueFlags(args) {
+    const values = {};
+    for (const flag of VALUE_FLAGS) {
+        const value = flagValue(args, flag);
+        if (value === null) {
+            return null;
+        }
+        values[flag] = value;
+    }
+    return values;
+}
+function parseFiles(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const parts = raw
+        .split(",")
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    return parts.length === 0 ? undefined : parts;
+}
+function parseArgs(args) {
+    const values = readValueFlags(args);
+    if (values === null) {
+        return null;
+    }
+    return {
+        description: values["--description"],
+        output: values["--output"],
+        outputFile: values["--output-file"],
+        stack: values["--stack"],
+        stackFile: values["--stack-file"],
+        files: parseFiles(values["--file"]),
+        apply: args.includes("--apply"),
+        model: values["--model"],
+        config: values["--config"],
+        json: args.includes("--json"),
+        dirRoot: values["--dir-root"] ?? ".",
+    };
+}
+// At least one evidence source must be present, else there is nothing to investigate.
+function hasEvidenceFlag(parsed) {
+    return (parsed.description !== undefined ||
+        parsed.output !== undefined ||
+        parsed.outputFile !== undefined ||
+        parsed.stack !== undefined ||
+        parsed.stackFile !== undefined ||
+        parsed.files !== undefined);
+}
+// Resolves the failing output and stack trace, reading from files when the *-file flags are set.
+// The inline flag is used only when its file counterpart is absent. Throws on a read failure (the
+// CLI catch maps it to a runtime error).
+function resolveReport(parsed, readFile) {
+    const failingOutput = parsed.outputFile !== undefined ? readFile(parsed.outputFile) : parsed.output;
+    const stackTrace = parsed.stackFile !== undefined ? readFile(parsed.stackFile) : parsed.stack;
+    return {
+        ...(parsed.description === undefined ? {} : { description: parsed.description }),
+        ...(failingOutput === undefined ? {} : { failingOutput }),
+        ...(stackTrace === undefined ? {} : { stackTrace }),
+        ...(parsed.files === undefined ? {} : { targetFiles: parsed.files }),
+    };
+}
+function workspaceEvidenceReader(workspace) {
+    return (path) => readWorkspaceFile(workspace, path).text;
+}
+function buildModel(parsed, io, env) {
+    try {
+        const path = parsed.config ?? env.KEIKO_CONFIG_FILE;
+        if (path === undefined) {
+            throw new ConfigInvalidError("no config source; pass --config PATH or set KEIKO_CONFIG_FILE");
+        }
+        const config = loadGatewayConfigFromFile(path, env);
+        if (parsed.model !== undefined) {
+            assertConfiguredModel(config, parsed.model);
+        }
+        const modelId = parsed.model ??
+            selectConfiguredModel(config, {
+                kind: "chat",
+                toolCalling: true,
+                structuredOutput: true,
+            });
+        if (modelId === undefined) {
+            io.err("Error: no configured workflow-capable chat model is available.\n");
+            return 1;
+        }
+        return { port: new GatewayModelPort(new Gateway(config)), modelId };
+    }
+    catch (error) {
+        if (error instanceof GatewayError) {
+            io.err(`Error: model gateway configuration problem — ${redact(error.message)}\n` +
+                `Provide a gateway config with --config PATH or KEIKO_CONFIG_FILE.\n`);
+            return 1;
+        }
+        throw error;
+    }
+}
+function resolveConfiguredModelId(parsed, env) {
+    const path = parsed.config ?? env.KEIKO_CONFIG_FILE;
+    if (path === undefined) {
+        return parsed.model ?? "default";
+    }
+    const config = loadGatewayConfigFromFile(path, env);
+    if (parsed.model !== undefined) {
+        assertConfiguredModel(config, parsed.model);
+        return parsed.model;
+    }
+    return selectConfiguredModel(config, {
+        kind: "chat",
+        toolCalling: true,
+        structuredOutput: true,
+    });
+}
+function resolveModel(parsed, io, env, deps) {
+    if (deps.model !== undefined) {
+        try {
+            const modelId = resolveConfiguredModelId(parsed, env);
+            if (modelId === undefined) {
+                io.err("Error: no configured workflow-capable chat model is available.\n");
+                return 1;
+            }
+            return { port: deps.model, modelId };
+        }
+        catch (error) {
+            if (error instanceof GatewayError) {
+                io.err(`Error: model gateway configuration problem — ${redact(error.message)}\n`);
+                return 1;
+            }
+            throw error;
+        }
+    }
+    return buildModel(parsed, io, env);
+}
+function printText(report, io) {
+    io.out(`${renderBugMarkdownReport(report)}\n`);
+    if (report.dryRunPreview !== undefined) {
+        io.out(`\n${report.dryRunPreview}\n`);
+    }
+    if (report.proposedDiff !== undefined) {
+        io.out(`\n--- proposed fix ---\n${report.proposedDiff}\n`);
+    }
+}
+function exitCodeFor(status) {
+    return status === "fix-applied" || status === "fix-proposed" || status === "investigation-only"
+        ? 0
+        : 1;
+}
+function emitReport(report, io, json) {
+    if (json) {
+        io.out(`${JSON.stringify(report, null, 2)}\n`);
+    }
+    else {
+        printText(report, io);
+    }
+    return exitCodeFor(report.status);
+}
+// Maps a boundary error to an exit code, or rethrows when it is not a recognised IO failure.
+function handleCliError(error, io) {
+    if (error instanceof WorkspaceError) {
+        io.err(`Error [${error.code}]: ${error.message}\n`);
+        return 1;
+    }
+    if (error instanceof Error && isFileReadError(error)) {
+        io.err(`Error: could not read an evidence file — ${redact(error.message)}\n`);
+        return 1;
+    }
+    throw error;
+}
+export async function runInvestigateCli(args, io, env = {}, deps = {}) {
+    // Issue #640: handle --help / -h before workflow-arg validation so help discovery exits 0
+    // with usage on stdout, not 2 with a validation error on stderr.
+    if (args.includes("--help") || args.includes("-h")) {
+        io.out(USAGE);
+        return 0;
+    }
+    const parsed = parseArgs(args);
+    if (parsed === null || !hasEvidenceFlag(parsed)) {
+        io.err(USAGE);
+        return 2;
+    }
+    const model = resolveModel(parsed, io, env, deps);
+    if (typeof model === "number") {
+        return model;
+    }
+    try {
+        const workspace = detectWorkspace(parsed.dirRoot);
+        const readFile = deps.readFile ?? workspaceEvidenceReader(workspace);
+        const report = await investigateBug({
+            workspaceRoot: workspace.root,
+            report: resolveReport(parsed, readFile),
+            apply: parsed.apply,
+            modelId: model.modelId,
+        }, { model: model.port });
+        return emitReport(report, io, parsed.json);
+    }
+    catch (error) {
+        return handleCliError(error, io);
+    }
+}
+// A Node fs read error carries a string `code` (e.g. ENOENT); narrow without `any`.
+function isFileReadError(error) {
+    const code = error.code;
+    return typeof code === "string" && code.length > 0;
+}

package/dist/launcher-paths.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveWithExistingAncestor(p: string): string;
+export declare function assertRealpathContained(approvedDir: string, target: string): void;
+export declare function isRealpathContained(approvedDir: string, target: string): boolean;
+//# sourceMappingURL=launcher-paths.d.ts.map

package/dist/launcher-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-paths.d.ts","sourceRoot":"","sources":["../src/launcher-paths.ts"],"names":[],"mappings":"AAkCA,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB7D;AAMD,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CASjF;AAKD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAIhF"}

package/dist/launcher-paths.js

@@ -0,0 +1,69 @@
+// Shared realpath-containment helpers for the launcher. Extracted from `launcher.ts`
+// so `launcher-state.ts` can apply the same boundary at state-file parse time without
+// each call site repeating the check (defense-in-depth against state-file tampering;
+// see ADR-0024 §9 / #125 security audit findings F1/F2).
+//
+// The helpers operate on textual paths AND the filesystem. They realpath the deepest
+// existing ancestor of both the approved dir and the target, so:
+//
+//   - `/tmp/foo` ⇄ `/private/tmp/foo` (macOS symlink-redirected tmp) compare EQUAL;
+//   - a symlink at the still-textual tail is NOT silently followed (we stop walking at
+//     the first existing component and append the tail verbatim);
+//   - the walk is bounded by 64 path components to guarantee termination.
+//
+// `assertRealpathContained` is the PRIMARY symlink defense; `assertApprovedDirNotSymlink`
+// / `assertTargetNotSymlink` in `launcher.ts` are leaf-only defense-in-depth (see header
+// comments there).
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { LauncherError } from "./launcher-platforms.js";
+function realpathOrResolve(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    }
+}
+// Walks up `p`'s ancestry until it finds an existing one; returns the realpath of that
+// existing ancestor concatenated with the not-yet-existing tail. This lets us compare
+// paths consistently even when leaves don't exist (mkdir not yet called), without
+// silently following a symlinked ancestor: the realpath is taken of the FIRST existing
+// segment in the chain, so symlinks along the still-textual tail are not resolved.
+export function resolveWithExistingAncestor(p) {
+    const absolute = resolve(p);
+    const tail = [];
+    let current = absolute;
+    for (let i = 0; i < 64; i += 1) {
+        if (existsSync(current)) {
+            return tail.length === 0
+                ? realpathOrResolve(current)
+                : join(realpathOrResolve(current), ...tail.reverse());
+        }
+        tail.push(current.split(sep).pop() ?? "");
+        const parent = dirname(current);
+        if (parent === current)
+            return absolute;
+        current = parent;
+    }
+    return absolute;
+}
+// Asserts that `target` is contained within `approvedDir` AFTER both have been resolved
+// against the real filesystem. We realpath the deepest-existing ancestor of BOTH sides
+// so `/tmp` ⇄ `/private/tmp` (macOS) and other symlinked-ancestor cases compare equal,
+// while symlinks at the still-textual tail are NOT silently followed.
+export function assertRealpathContained(approvedDir, target) {
+    const realApproved = resolveWithExistingAncestor(approvedDir);
+    const realTarget = resolveWithExistingAncestor(target);
+    if (realTarget !== realApproved && !realTarget.startsWith(realApproved + sep)) {
+        throw new LauncherError("PATH_ESCAPE", `keiko launcher: refusing to write outside the approved directory.\n  approved: ${realApproved}\n  target:   ${realTarget}`);
+    }
+}
+// Predicate form of `assertRealpathContained` — does not throw. Used by parse-time
+// filtering where we want to silently drop tampered entries (and emit a stderr warning)
+// rather than abort the entire `loadState` call.
+export function isRealpathContained(approvedDir, target) {
+    const realApproved = resolveWithExistingAncestor(approvedDir);
+    const realTarget = resolveWithExistingAncestor(target);
+    return realTarget === realApproved || realTarget.startsWith(realApproved + sep);
+}

package/dist/launcher-platforms.d.ts

@@ -0,0 +1,25 @@
+export declare const MIN_PORT = 1024;
+export declare const MAX_PORT = 65535;
+export type Platform = "linux" | "darwin" | "win32";
+export declare class LauncherError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function validateExecPath(path: string): string;
+export declare function validatePort(port: number): number;
+export interface LauncherContentInput {
+    readonly exe: string;
+    readonly port: number | undefined;
+}
+export interface PlatformLauncher {
+    readonly id: Platform;
+    readonly installDirFor: (homedir: string) => string;
+    readonly safeFileName: () => string;
+    readonly generateContent: (input: LauncherContentInput) => string;
+    readonly fileMode: number;
+}
+export declare const linuxLauncher: PlatformLauncher;
+export declare const macosLauncher: PlatformLauncher;
+export declare const windowsLauncher: PlatformLauncher;
+export declare function launcherFor(platform: NodeJS.Platform): PlatformLauncher;
+//# sourceMappingURL=launcher-platforms.d.ts.map

package/dist/launcher-platforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-platforms.d.ts","sourceRoot":"","sources":["../src/launcher-platforms.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,QAAQ,OAAO,CAAC;AAC7B,eAAO,MAAM,QAAQ,QAAQ,CAAC;AAE9B,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEpD,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBACjB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK1C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBrD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACpD,QAAQ,CAAC,YAAY,EAAE,MAAM,MAAM,CAAC;IACpC,QAAQ,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,MAAM,CAAC;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAYD,eAAO,MAAM,aAAa,EAAE,gBAoB3B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC;AAQF,eAAO,MAAM,eAAe,EAAE,gBAW7B,CAAC;AAQF,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,gBAAgB,CASvE"}

package/dist/launcher-platforms.js

@@ -0,0 +1,131 @@
+// Pure per-OS modules for `keiko launcher install`. Each platform exports `generateContent`
+// (a pure string-producing function over a sanitized executable path + optional port),
+// `installDirFor(homedir)` (the user-local approved directory), and `safeFileName()`
+// (the canonical filename written under that directory).
+//
+// SECURITY — the content generators do NOT quote or escape; they refuse with `LauncherError`
+// any executable path or port that has not been validated by `validateExecPath` /
+// `validatePort`. The validators are deliberately strict allow-lists: a `keiko` executable
+// path that contains a space, a shell metacharacter, or any character outside
+// `[A-Za-z0-9_@\-./\\:]` is rejected. Spaces in the bin location are a documented
+// unsupported edge case for this release (ADR-0024 D8 / spec §"Per-platform content rules").
+//
+// PLATFORMS:
+//   - Linux:   `~/.local/share/applications/keiko.desktop` (XDG Desktop Entry, text).
+//   - macOS:   `~/Applications/Keiko Launcher.command` (bash script, chmod 0o755).
+//   - Windows: `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Keiko.bat` (.bat fallback,
+//              per ADR-0024 D8 trade-off). The .bat opens a brief cmd window before
+//              handing off to keiko; the binary `.lnk` format is out of scope for this
+//              release. The fallback is acceptable per spec §"Windows .lnk (binary format)".
+import { posix as posixPath, win32 as win32Path } from "node:path";
+// Allow-list: alphanumerics + the small set of safe path separators / characters that npm
+// install paths legitimately produce. Anything else — spaces, quotes, `;`, `$`, backtick,
+// `&`, `|`, `(`, `)`, `<`, `>`, `*`, `?`, `~`, `#`, `!`, `,`, `=`, `+`, control chars —
+// is rejected. The intent is defense-in-depth even though XDG `.desktop` and `.bat`
+// have their own quoting rules: no metacharacter ever reaches the file content.
+const EXEC_PATH_RE = /^[A-Za-z0-9_@\-./\\:]+$/;
+export const MIN_PORT = 1024;
+export const MAX_PORT = 65535;
+export class LauncherError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "LauncherError";
+    }
+}
+export function validateExecPath(path) {
+    if (path.length === 0) {
+        throw new LauncherError("EXEC_PATH_EMPTY", "keiko launcher: resolved executable path is empty.");
+    }
+    if (path.length > 4096) {
+        throw new LauncherError("EXEC_PATH_TOO_LONG", "keiko launcher: resolved executable path exceeds 4096 chars.");
+    }
+    if (!EXEC_PATH_RE.test(path)) {
+        throw new LauncherError("EXEC_PATH_UNSAFE", `keiko launcher: resolved executable path contains disallowed characters: ${path}\nOnly [A-Za-z0-9_@\\-./\\\\:] are permitted. Re-install keiko under a path without spaces or shell metacharacters.`);
+    }
+    return path;
+}
+export function validatePort(port) {
+    if (!Number.isInteger(port) || port < MIN_PORT || port > MAX_PORT) {
+        throw new LauncherError("PORT_OUT_OF_RANGE", `keiko launcher: --port must be an integer in [${String(MIN_PORT)}, ${String(MAX_PORT)}]; received ${String(port)}.`);
+    }
+    return port;
+}
+function portFlag(port) {
+    if (port === undefined)
+        return "";
+    validatePort(port);
+    return ` --port ${String(port)}`;
+}
+function requireSafeExe(exe) {
+    return validateExecPath(exe);
+}
+export const linuxLauncher = {
+    id: "linux",
+    installDirFor: (homedir) => posixPath.join(homedir, ".local", "share", "applications"),
+    safeFileName: () => "keiko.desktop",
+    fileMode: 0o644,
+    generateContent: ({ exe, port }) => {
+        const safeExe = requireSafeExe(exe);
+        const flag = portFlag(port);
+        return [
+            "[Desktop Entry]",
+            "Type=Application",
+            "Name=Keiko",
+            "Comment=Keiko local developer-assist workspace",
+            `Exec=${safeExe} start --open${flag}`,
+            "Terminal=false",
+            "Categories=Development;",
+            "StartupNotify=true",
+            "",
+        ].join("\n");
+    },
+};
+export const macosLauncher = {
+    id: "darwin",
+    installDirFor: (homedir) => posixPath.join(homedir, "Applications"),
+    safeFileName: () => "Keiko Launcher.command",
+    fileMode: 0o755,
+    generateContent: ({ exe, port }) => {
+        const safeExe = requireSafeExe(exe);
+        const flag = portFlag(port);
+        return [
+            "#!/usr/bin/env bash",
+            "# Keiko launcher — generated by `keiko launcher install`. Edit at your own risk.",
+            "# Remove with: keiko launcher remove",
+            "set -euo pipefail",
+            `exec ${safeExe} start --open${flag}`,
+            "",
+        ].join("\n");
+    },
+};
+// Windows .bat fallback (per ADR-0024 D8 trade-off, definitively chosen for this release).
+// A `.bat` opens a brief cmd window before launching keiko; the alternative — a binary
+// `.lnk` shortcut — would launch cleanly but requires emitting the MS-SHLLINK binary
+// shell-link format by hand, which is brittle and out of scope. The brief cmd window is
+// documented and acceptable for the pilot. `@start "" <exe> ...` detaches the keiko
+// process from the cmd window so the latter closes immediately after dispatch.
+export const windowsLauncher = {
+    id: "win32",
+    installDirFor: (homedir) => win32Path.join(homedir, "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs"),
+    safeFileName: () => "Keiko.bat",
+    fileMode: 0o644,
+    generateContent: ({ exe, port }) => {
+        const safeExe = requireSafeExe(exe);
+        const flag = portFlag(port);
+        return `@start "" ${safeExe} start --open${flag}\r\n`;
+    },
+};
+const REGISTRY = {
+    linux: linuxLauncher,
+    darwin: macosLauncher,
+    win32: windowsLauncher,
+};
+export function launcherFor(platform) {
+    const entry = REGISTRY[platform];
+    if (entry === undefined) {
+        throw new LauncherError("PLATFORM_UNSUPPORTED", `keiko launcher: platform "${platform}" is not supported. Supported: linux, darwin, win32.`);
+    }
+    return entry;
+}

package/dist/launcher-state.d.ts

@@ -0,0 +1,25 @@
+import { type Platform } from "./launcher-platforms.js";
+export declare const LAUNCHER_STATE_VERSION: 1;
+export interface LauncherStateEntry {
+    readonly path: string;
+    readonly platform: Platform;
+    readonly contentSha256: string;
+    readonly createdAt: string;
+}
+export interface LauncherState {
+    readonly version: 1;
+    readonly entries: readonly LauncherStateEntry[];
+}
+export declare function hashContent(content: string): string;
+export interface ParseOptions {
+    readonly homedir?: string | undefined;
+    readonly onWarn?: ((message: string) => void) | undefined;
+}
+export declare function parseState(raw: unknown, options?: ParseOptions): LauncherState;
+export declare function loadState(stateDir: string, options?: ParseOptions): LauncherState;
+export declare const MAX_STATE_FILE_BYTES: number;
+export declare function saveState(stateDir: string, state: LauncherState): void;
+export declare function upsertEntry(state: LauncherState, entry: LauncherStateEntry): LauncherState;
+export declare function removeEntry(state: LauncherState, path: string): LauncherState;
+export declare function findEntry(state: LauncherState, path: string): LauncherStateEntry | undefined;
+//# sourceMappingURL=launcher-state.d.ts.map

package/dist/launcher-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher-state.d.ts","sourceRoot":"","sources":["../src/launcher-state.ts"],"names":[],"mappings":"AAmCA,OAAO,EAA8B,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGpF,eAAO,MAAM,sBAAsB,EAAG,CAAU,CAAC;AAIjD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACjD;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AA6BD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC3D;AA4BD,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,YAAiB,GAAG,aAAa,CAUlF;AAsDD,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,aAAa,CAcrF;AAKD,eAAO,MAAM,oBAAoB,QAAU,CAAC;AAmC5C,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CA0BtE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAG1F;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAK7E;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAE5F"}