lazycodex-ai 5.0.0-beta.89 → 5.0.0-beta.90

package/dist/cli/install-native/index.d.ts

@@ -1,4 +1,12 @@
-export { formatNativeInstallCommand, NATIVE_PACKAGE_SPEC, NATIVE_RECOMMENDED_RUNTIME_NOTE, NATIVE_SETUP_COMMAND, resolveNativeInstallPlan, } from "./plan";
+export { formatNativeInstallCommand, formatNativeInstallEntryCommand, NATIVE_PACKAGE_SPEC, NATIVE_RECOMMENDED_RUNTIME_NOTE, NATIVE_SETUP_COMMAND, resolveNativeInstallPlan, } from "./plan";
 export type { NativeInstallPlan, NativePackageManager } from "./plan";
+export { firstOmoBinOnPath, LEGACY_OMO_BIN_PACKAGES, legacyOmoBins, NATIVE_OMO_PACKAGE, nativeOmoBin, resolveOmoBinEnvironment, scanOmoBins, } from "./legacy-omo-bin";
+export type { OmoBinEntry, OmoBinEnvironment, OmoBinKind } from "./legacy-omo-bin";
+export { removeFileCommand, repairLegacyOmoBins } from "./repair-legacy-omo-bin";
+export type { LegacyOmoBinRepair } from "./repair-legacy-omo-bin";
+export { pathOrderFix, verifyOmoCommand } from "./verify-omo-command";
+export type { OmoCommandVerification, OmoVersionProbe } from "./verify-omo-command";
 export { nativeInstallFailureLines, nativeInstallSuccessLine, runNativeInstall, } from "./run-native-install";
+export { NATIVE_SETUP_OFFER_QUESTION, nativeSetupFollowUpLine, nativeSetupStartLine, offerNativeSetup, } from "./offer-native-setup";
+export type { NativeSetupOfferDependencies, NativeSetupOfferResult, NativeSetupRun } from "./offer-native-setup";
 export type { NativeInstallDependencies, NativeInstallFailure, NativeInstallOutcome, NativeInstallSpawn, NativeInstallSpawnResult, } from "./run-native-install";

package/dist/cli/install-native/legacy-omo-bin.d.ts

@@ -0,0 +1,27 @@
+export declare const NATIVE_OMO_PACKAGE = "omo-ai";
+export declare const LEGACY_OMO_BIN_PACKAGES: readonly string[];
+export type OmoBinKind = "native" | "legacy" | "foreign";
+export interface OmoBinEnvironment {
+    readonly pathDirectories: readonly string[];
+    readonly extraDirectories: readonly string[];
+    readonly isWindows: boolean;
+}
+export interface OmoBinEntry {
+    readonly binPath: string;
+    readonly directory: string;
+    readonly onPath: boolean;
+    readonly kind: OmoBinKind;
+    readonly packageName: string | null;
+    readonly packageVersion: string | null;
+    /** Every file that carries this `omo` command, including the Windows `.cmd` / `.ps1` siblings. */
+    readonly shimPaths: readonly string[];
+}
+export declare function resolveOmoBinEnvironment(input: {
+    readonly env: Record<string, string | undefined>;
+    readonly platform: string;
+    readonly homeDir: string;
+}): OmoBinEnvironment;
+export declare function scanOmoBins(environment: OmoBinEnvironment): readonly OmoBinEntry[];
+export declare function legacyOmoBins(entries: readonly OmoBinEntry[]): readonly OmoBinEntry[];
+export declare function nativeOmoBin(entries: readonly OmoBinEntry[]): OmoBinEntry | null;
+export declare function firstOmoBinOnPath(entries: readonly OmoBinEntry[]): OmoBinEntry | null;

package/dist/cli/install-native/offer-native-setup.d.ts

@@ -0,0 +1,31 @@
+import type { NativeInstallOutcome } from "./run-native-install";
+export declare const NATIVE_SETUP_OFFER_QUESTION = "Run omo setup now to carry your OpenCode credentials, MCP servers and skills over?";
+export type NativeSetupRun = (binPath: string, args: readonly string[]) => Promise<number>;
+export interface NativeSetupOfferDependencies {
+    readonly confirm: (question: string) => Promise<boolean>;
+    readonly runSetup?: NativeSetupRun;
+    /** Receives the start line right before the setup process takes over the terminal. */
+    readonly onStart?: (line: string) => void;
+}
+export type NativeSetupOfferResult = {
+    readonly kind: "not-offered";
+} | {
+    readonly kind: "declined";
+} | {
+    readonly kind: "ran";
+    readonly binPath: string;
+    readonly exitCode: number;
+} | {
+    readonly kind: "failed";
+    readonly binPath: string;
+    readonly reason: string;
+};
+/**
+ * Offers to run onboarding with the exact binary the install just verified. An unverified install
+ * is never offered: whatever `omo` PATH resolves there is, by definition, not omo-ai, and the PATH
+ * fix printed by the verify step stays the next thing to do.
+ */
+export declare function offerNativeSetup(outcome: Pick<NativeInstallOutcome, "verified" | "omoBinPath">, dependencies: NativeSetupOfferDependencies): Promise<NativeSetupOfferResult>;
+export declare function nativeSetupStartLine(binPath: string): string;
+/** The line to print after the offer, or null when the offer already finished onboarding. */
+export declare function nativeSetupFollowUpLine(result: NativeSetupOfferResult): string | null;

package/dist/cli/install-native/omo-bin-test-fixtures.d.ts

@@ -0,0 +1,35 @@
+export interface GlobalBinFixture {
+    readonly root: string;
+    readonly binDir: string;
+    readonly binPath: string;
+    readonly packageDir: string;
+}
+export interface GlobalBinFixtureOptions {
+    readonly root: string;
+    readonly packageName: string;
+    readonly version: string;
+    readonly bins?: readonly string[];
+    readonly link?: "symlink" | "script";
+}
+export declare function createBinFixtureRoot(label: string): string;
+/**
+ * Lays out a global install the way npm and bun really do it: the package under
+ * `lib/node_modules/<name>`, and one entry per bin in `bin/`, either a relative symlink
+ * (npm and bun on POSIX) or a launcher script that names the package path (Windows shims and
+ * omo-ai's own bun shim).
+ */
+export declare function writeGlobalPackageBin(options: GlobalBinFixtureOptions): GlobalBinFixture;
+/**
+ * Lays out the `omo` command the Codex Light installer of a pre-rename release wrote into
+ * `~/.local/bin`: a generated shell wrapper, not a package-manager link, that execs the CLI out of
+ * `<CODEX_HOME>/plugins/cache/sisyphuslabs/omo/<version>/`. The marker comment is what the Light
+ * installer itself matches on when it retires the wrapper.
+ */
+export declare function writeCodexLightRuntimeWrapper(options: {
+    readonly root: string;
+    readonly version: string;
+    readonly marker?: string;
+}): {
+    readonly binDir: string;
+    readonly binPath: string;
+};

package/dist/cli/install-native/plan.d.ts

@@ -9,3 +9,11 @@ export interface NativeInstallPlan {
 }
 export declare function resolveNativeInstallPlan(bunAvailable: boolean): NativeInstallPlan;
 export declare function formatNativeInstallCommand(plan: NativeInstallPlan): string;
+/**
+ * The command every user-facing surface advertises. It is the raw package install plus the parts a
+ * raw install cannot do: clearing a stale global `omo` left by a pre-rename release, and checking
+ * that the `omo` PATH resolves afterwards is the one omo-ai owns. The tag follows the channel of the
+ * running plugin: a prerelease build advertises `@beta` (while `latest` is 4.19.4, which rejects
+ * `--platform=native`), a stable build advertises the bare name, which resolves to `latest`.
+ */
+export declare function formatNativeInstallEntryCommand(plan: NativeInstallPlan, pluginVersion?: string): string;

package/dist/cli/install-native/repair-legacy-omo-bin.d.ts

@@ -0,0 +1,26 @@
+import type { OmoBinEntry } from "./legacy-omo-bin";
+export interface LegacyOmoBinRemoval {
+    readonly binPath: string;
+    readonly packageName: string;
+    readonly packageVersion: string | null;
+}
+export interface LegacyOmoBinRepairFailure {
+    readonly binPath: string;
+    readonly reason: string;
+}
+export interface LegacyOmoBinRepair {
+    readonly removed: readonly LegacyOmoBinRemoval[];
+    readonly failures: readonly LegacyOmoBinRepairFailure[];
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+}
+export declare function describePackage(entry: OmoBinEntry): string;
+export declare function removeFileCommand(binPath: string, isWindows: boolean): string;
+/**
+ * Removes only the `omo` command that a pre-rename release left behind. The package that owns it, and
+ * every other command it installs, stay in place: the rename orphaned this one alias, and uninstalling
+ * somebody's whole global package to install ours is not a decision an installer gets to make.
+ */
+export declare function repairLegacyOmoBins(entries: readonly OmoBinEntry[], options: {
+    readonly isWindows: boolean;
+}): LegacyOmoBinRepair;

package/dist/cli/install-native/run-native-install.d.ts

@@ -1,3 +1,5 @@
+import type { OmoBinEnvironment } from "./legacy-omo-bin";
+import type { OmoVersionProbe } from "./verify-omo-command";
 import type { NativeInstallPlan } from "./plan";
 export interface NativeInstallSpawnResult {
     readonly exitCode: number;
@@ -7,17 +9,25 @@ export type NativeInstallSpawn = (command: string, args: readonly string[]) => P
 export interface NativeInstallDependencies {
     readonly isBunAvailable: () => boolean | Promise<boolean>;
     readonly spawn: NativeInstallSpawn;
+    readonly environment: OmoBinEnvironment;
+    readonly probeVersion: OmoVersionProbe;
 }
 export interface NativeInstallFailure {
     readonly reason: string;
     readonly manualCommand: string;
+    readonly hints?: readonly string[];
 }
 export interface NativeInstallOutcome {
     readonly ok: boolean;
+    /** The `omo` that PATH resolves after the install is the one omo-ai owns. */
+    readonly verified: boolean;
+    /** The verified omo-ai binary; set only when `verified`, so onboarding never runs a bare `omo` lookup. */
+    readonly omoBinPath?: string;
     readonly plan: NativeInstallPlan;
     readonly notes: readonly string[];
+    readonly warnings: readonly string[];
     readonly failure?: NativeInstallFailure;
 }
 export declare function runNativeInstall(dependencies?: NativeInstallDependencies): Promise<NativeInstallOutcome>;
-export declare function nativeInstallSuccessLine(): string;
+export declare function nativeInstallSuccessLine(verified: boolean): string;
 export declare function nativeInstallFailureLines(failure: NativeInstallFailure): readonly string[];

package/dist/cli/install-native/verify-omo-command.d.ts

@@ -0,0 +1,22 @@
+import type { OmoBinEnvironment } from "./legacy-omo-bin";
+export interface OmoVersionProbeResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+}
+export type OmoVersionProbe = (command: string, args: readonly string[]) => Promise<OmoVersionProbeResult>;
+export type OmoCommandVerification = {
+    readonly ok: true;
+    /** The omo-ai `omo` that was verified. */
+    readonly binPath: string;
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+} | {
+    readonly ok: false;
+    readonly notes: readonly string[];
+    readonly warnings: readonly string[];
+};
+export declare function pathOrderFix(directory: string, isWindows: boolean): string;
+export declare function verifyOmoCommand(options: {
+    readonly environment: OmoBinEnvironment;
+    readonly probeVersion: OmoVersionProbe;
+}): Promise<OmoCommandVerification>;

package/dist/cli/native-edition-hint.d.ts

@@ -1,6 +1,6 @@
 import type { InstallConfig } from "./types";
-export declare const NATIVE_EDITION_INSTALL_COMMAND = "bun add -g omo-ai@beta";
-export declare const NATIVE_EDITION_GUIDE_URL = "https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/installation.md#omo-native-beta-omo-via-omo-ai";
+export declare const NATIVE_EDITION_INSTALL_COMMAND: string;
+export declare const NATIVE_EDITION_GUIDE_URL = "https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/guide/migrating-from-opencode.md";
 export declare const NATIVE_EDITION_HINT_TITLE = "OmO Native (beta)";
 export type NativeEditionHintPaint = {
     readonly command: (text: string) => string;