oc-codex-multi-auth 6.21.0 → 6.23.0

package/dist/lib/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,kFAAkF;AAClF,eAAO,MAAM,YAAY,wBAAwB,CAAC;AAElD,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D,uDAAuD;AACvD,eAAO,MAAM,WAAW,wBAAe,CAAC;AAExC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,sCAAsC,CAAC;AACtE,eAAO,MAAM,yBAAyB,+BAA+B,CAAC;AACtE,eAAO,MAAM,0BAA0B,8CAA8C,CAAC;AACtF,eAAO,MAAM,iCAAiC,uCAAuC,CAAC;AACtF,eAAO,MAAM,iCAAiC,uCAAuC,CAAC;AAEtF,uCAAuC;AACvC,eAAO,MAAM,cAAc,oCAAoC,CAAC;AAEhE,gEAAgE;AAChE,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAE7C,yEAAyE;AACzE,eAAO,MAAM,WAAW,WAAW,CAAC;AAEpC,wBAAwB;AACxB,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAC;AAEX,8BAA8B;AAC9B,eAAO,MAAM,cAAc;;;;;;;CAOjB,CAAC;AAEX,oCAAoC;AACpC,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX,wBAAwB;AACxB,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,cAAc,EAAG,6BAAsC,CAAC;AAErE,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,EAAG,gCAAyC,CAAC;AAEhF,qBAAqB;AACrB,eAAO,MAAM,cAAc;;;;CAIjB,CAAC;AAEX,qCAAqC;AACrC,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX,gDAAgD;AAChD,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,iCAAiC;AACjC,eAAO,MAAM,WAAW;;;;;;;;CAUd,CAAC;AAEX,kCAAkC;AAClC,eAAO,MAAM,cAAc;IAC1B,8DAA8D;;IAE9D,sEAAsE;;IAEtE,uEAAuE;;CAE9D,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,kFAAkF;AAClF,eAAO,MAAM,YAAY,wBAAwB,CAAC;AAElD,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D,uDAAuD;AACvD,eAAO,MAAM,WAAW,wBAAe,CAAC;AAExC,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,sCAAsC,CAAC;AACtE,eAAO,MAAM,yBAAyB,+BAA+B,CAAC;AACtE,eAAO,MAAM,0BAA0B,8CAA8C,CAAC;AACtF,eAAO,MAAM,iCAAiC,uCAAuC,CAAC;AACtF,eAAO,MAAM,iCAAiC,uCAAuC,CAAC;AAEtF,uCAAuC;AACvC,eAAO,MAAM,cAAc,oCAAoC,CAAC;AAEhE,gEAAgE;AAChE,eAAO,MAAM,aAAa,kBAAkB,CAAC;AAE7C,yEAAyE;AACzE,eAAO,MAAM,WAAW,WAAW,CAAC;AAEpC,wBAAwB;AACxB,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAC;AAEX,8BAA8B;AAC9B,eAAO,MAAM,cAAc;;;;;;;CAOjB,CAAC;AAEX,oCAAoC;AACpC,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX,wBAAwB;AACxB,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,cAAc,EAAG,6BAAsC,CAAC;AAErE,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,EAAG,gCAAyC,CAAC;AAEhF,qBAAqB;AACrB,eAAO,MAAM,cAAc;;;;CAIjB,CAAC;AAEX,qCAAqC;AACrC,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX,gDAAgD;AAChD,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,iCAAiC;AACjC,eAAO,MAAM,WAAW;;;;;;;;CAUd,CAAC;AAEX,kCAAkC;AAClC,eAAO,MAAM,cAAc;IAC1B,8DAA8D;;IAE9D,sEAAsE;;IAEtE,uEAAuE;;CAE9D,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC"}

package/dist/lib/constants.js

@@ -90,4 +90,17 @@ export const ACCOUNT_LIMITS = {
     /** Number of consecutive auth failures before auto-removing account */
     MAX_AUTH_FAILURES_BEFORE_REMOVAL: 3,
 };
+/**
+ * Cap on quota-exhausted model hops within one request (index.ts).
+ *
+ * The attempted set already stops a request revisiting a model; this bounds
+ * total hops even under a cyclic custom chain. It must be at least the longest
+ * DEFAULT_UNSUPPORTED_CODEX_FALLBACK_CHAIN row (gpt-6-astra's, 6 targets), or a
+ * request whose models are blocked one after another stops before reaching the
+ * tail of its own default chain. A hop only happens onto a model some account
+ * can serve right now, so a larger cap costs nothing when nothing is usable.
+ * Kept here rather than in fetch-helpers because test/index.test.ts replaces
+ * that module with a factory mock, which would read a new export as undefined.
+ */
+export const MAX_QUOTA_FALLBACK_SWITCHES = 6;
 //# sourceMappingURL=constants.js.map

package/dist/lib/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../lib/constants.ts"],"names":[],"mappings":"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"}

package/dist/lib/plan-allotment.d.ts

@@ -0,0 +1,72 @@
+/**
+ * How much Codex capacity one ChatGPT plan carries relative to another.
+ *
+ * A pool of accounts on different plans has no single "percent used": one
+ * Pro seat spent to 50% has given up far more capacity than a Business
+ * Standard seat spent to 50%, so averaging the two percentages unweighted
+ * reports a pool that does not exist. Every plan here therefore carries a
+ * {@link PlanAllotment.weight} - its allotment relative to a 1x seat - and the
+ * pool total is the weighted mean.
+ *
+ * The weights are OpenAI's own published per-seat ratios, taken from the
+ * plan's monthly price against the 1x Plus/Business Standard seat: Pro is
+ * $200 against $20, and is marketed as 20x. They describe the *subscription*,
+ * not a measured token allowance, which is the only ratio OpenAI states and
+ * the same one the seat is sold on.
+ *
+ * `plan_type` is what the `/wham/usage` endpoint and the `chatgpt_plan_type`
+ * access-token claim report. Two of its slugs are not derivable from their
+ * text - `team` is the slug still emitted for what OpenAI now calls Business,
+ * and `self_serve_business_prolite` is the premium Business seat rather than
+ * the personal Pro Lite tier that shares the `prolite` token - so both are
+ * matched explicitly below.
+ *
+ * This module is deliberately a leaf (no imports). The prompt status line
+ * depends on it, and naming a plan is a separate concern that already has an
+ * owner in `lib/auth/plan-tier.ts`; pulling that in here would drag JWT
+ * decoding into the TUI's render path for a number that needs none of it.
+ */
+export type PlanAllotment = {
+    /**
+     * Allotment relative to a 1x seat, or `undefined` when the plan states no
+     * ratio. `undefined` is not 1: a plan we cannot place must not be
+     * silently averaged as though it were the baseline.
+     */
+    weight?: number;
+    /** Marketing badge for the same ratio, e.g. `5x`. */
+    multiplier?: string;
+    /** Per-seat monthly price in USD, as listed by OpenAI. */
+    monthlyUsd?: number;
+};
+/**
+ * Weight used for a plan that states no ratio, so one unplaceable account
+ * cannot remove every other account from the pool total. It is the baseline
+ * seat rather than a guess at something larger: under-weighting an unknown
+ * plan understates one account, while over-weighting it would let a plan we
+ * failed to recognize dominate the number the whole pool is judged by.
+ */
+export declare const DEFAULT_PLAN_WEIGHT = 1;
+/**
+ * Reduce a `plan_type` to the form the matchers below expect.
+ *
+ * The admin roster spells a tier as one token (`chatgptteamplan`) while the
+ * usage endpoint reports the bare word (`team`), and the premium Business
+ * seat arrives underscored (`self_serve_business_prolite`). All three have to
+ * land on the same normalized text or one seat is weighted differently
+ * depending on which surface named it.
+ */
+export declare function normalizePlanSlug(value: string | null | undefined): string | undefined;
+/**
+ * Resolve a `plan_type` to its allotment. An unrecognized plan returns an
+ * empty allotment rather than a guess, so callers can tell "1x" apart from
+ * "we do not know".
+ */
+export declare function describePlanAllotment(planType: string | null | undefined): PlanAllotment;
+/**
+ * The weight to average an account by, falling back to
+ * {@link DEFAULT_PLAN_WEIGHT} for a plan that states no ratio.
+ */
+export declare function getPlanWeight(planType: string | null | undefined): number;
+/** `5x`, or `undefined` when the plan states no ratio. */
+export declare function formatPlanMultiplier(planType: string | null | undefined): string | undefined;
+//# sourceMappingURL=plan-allotment.d.ts.map

package/dist/lib/plan-allotment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-allotment.d.ts","sourceRoot":"","sources":["../../lib/plan-allotment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAIF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAetF;AA6CD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,aAAa,CAkBf;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAEzE;AAED,0DAA0D;AAC1D,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,MAAM,GAAG,SAAS,CAEpB"}

package/dist/lib/plan-allotment.js

@@ -0,0 +1,142 @@
+/**
+ * How much Codex capacity one ChatGPT plan carries relative to another.
+ *
+ * A pool of accounts on different plans has no single "percent used": one
+ * Pro seat spent to 50% has given up far more capacity than a Business
+ * Standard seat spent to 50%, so averaging the two percentages unweighted
+ * reports a pool that does not exist. Every plan here therefore carries a
+ * {@link PlanAllotment.weight} - its allotment relative to a 1x seat - and the
+ * pool total is the weighted mean.
+ *
+ * The weights are OpenAI's own published per-seat ratios, taken from the
+ * plan's monthly price against the 1x Plus/Business Standard seat: Pro is
+ * $200 against $20, and is marketed as 20x. They describe the *subscription*,
+ * not a measured token allowance, which is the only ratio OpenAI states and
+ * the same one the seat is sold on.
+ *
+ * `plan_type` is what the `/wham/usage` endpoint and the `chatgpt_plan_type`
+ * access-token claim report. Two of its slugs are not derivable from their
+ * text - `team` is the slug still emitted for what OpenAI now calls Business,
+ * and `self_serve_business_prolite` is the premium Business seat rather than
+ * the personal Pro Lite tier that shares the `prolite` token - so both are
+ * matched explicitly below.
+ *
+ * This module is deliberately a leaf (no imports). The prompt status line
+ * depends on it, and naming a plan is a separate concern that already has an
+ * owner in `lib/auth/plan-tier.ts`; pulling that in here would drag JWT
+ * decoding into the TUI's render path for a number that needs none of it.
+ */
+const UNKNOWN_ALLOTMENT = {};
+/**
+ * Weight used for a plan that states no ratio, so one unplaceable account
+ * cannot remove every other account from the pool total. It is the baseline
+ * seat rather than a guess at something larger: under-weighting an unknown
+ * plan understates one account, while over-weighting it would let a plan we
+ * failed to recognize dominate the number the whole pool is judged by.
+ */
+export const DEFAULT_PLAN_WEIGHT = 1;
+/**
+ * Reduce a `plan_type` to the form the matchers below expect.
+ *
+ * The admin roster spells a tier as one token (`chatgptteamplan`) while the
+ * usage endpoint reports the bare word (`team`), and the premium Business
+ * seat arrives underscored (`self_serve_business_prolite`). All three have to
+ * land on the same normalized text or one seat is weighted differently
+ * depending on which surface named it.
+ */
+export function normalizePlanSlug(value) {
+    if (typeof value !== "string")
+        return undefined;
+    // Case is folded before anything else is stripped, so every pattern below
+    // can be written once in lower case. Stripping first would leave the
+    // trailing-`plan` rule matching `teamplan` but not `Team_Plan`, and the
+    // same seat would then weigh differently depending on which surface spelled
+    // it.
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/^chatgpt[\s_-]*/, "")
+        .replace(/[\s_-]+/g, " ")
+        .replace(/\s?plan$/, "")
+        .trim();
+    return normalized || undefined;
+}
+/**
+ * A `business` seat's ratio, which depends on the qualifier beside it.
+ *
+ * `self_serve_business_prolite` normalizes to `self serve business prolite`,
+ * so `business` is matched as a whole word anywhere in the text rather than
+ * as a prefix. A bare `business` names the workspace rather than the seat,
+ * and the two seats inside it are 5x apart, so it states no ratio at all.
+ */
+function describeBusinessSeat(plan) {
+    if (!/(^| )business( |$)/.test(plan))
+        return undefined;
+    if (plan.includes("prolite") ||
+        plan.includes("pro lite") ||
+        plan.includes("premium")) {
+        return { weight: 5, multiplier: "5x", monthlyUsd: 125 };
+    }
+    if (plan.includes("standard")) {
+        return { weight: 1, multiplier: "1x", monthlyUsd: 25 };
+    }
+    return UNKNOWN_ALLOTMENT;
+}
+/**
+ * The $100 Pro that predates the $200 one. Both report a `pro` family slug,
+ * and they are 4x apart, so the legacy spellings are matched before the
+ * current tier claims the bare word.
+ */
+function isLegacyProPlan(plan) {
+    return (plan === "pro 5x" ||
+        plan === "pro 100" ||
+        plan === "pro legacy" ||
+        plan === "legacy pro" ||
+        plan === "legacy pro 5x" ||
+        plan === "pro legacy 5x");
+}
+function isCurrentProPlan(plan) {
+    return plan === "pro" || plan === "pro 20x" || plan === "pro 200";
+}
+/**
+ * Resolve a `plan_type` to its allotment. An unrecognized plan returns an
+ * empty allotment rather than a guess, so callers can tell "1x" apart from
+ * "we do not know".
+ */
+export function describePlanAllotment(planType) {
+    const plan = normalizePlanSlug(planType);
+    if (!plan)
+        return UNKNOWN_ALLOTMENT;
+    if (plan === "plus")
+        return { weight: 1, multiplier: "1x", monthlyUsd: 20 };
+    // `team` is the slug OpenAI still emits for Business; a qualified
+    // `team premium` / `team standard` is handled by the business matcher.
+    if (plan === "team")
+        return { weight: 1, multiplier: "1x", monthlyUsd: 25 };
+    const business = describeBusinessSeat(plan);
+    if (business)
+        return business;
+    if (isLegacyProPlan(plan))
+        return { weight: 5, multiplier: "5x", monthlyUsd: 100 };
+    if (isCurrentProPlan(plan))
+        return { weight: 20, multiplier: "20x", monthlyUsd: 200 };
+    if (plan === "prolite" || plan === "pro lite") {
+        return { weight: 5, multiplier: "5x", monthlyUsd: 100 };
+    }
+    // Go, Free and Enterprise all reach here. The first two carry no Codex
+    // allotment worth weighting, and Enterprise is negotiated per contract, so
+    // none of them states a ratio this code could apply.
+    return UNKNOWN_ALLOTMENT;
+}
+/**
+ * The weight to average an account by, falling back to
+ * {@link DEFAULT_PLAN_WEIGHT} for a plan that states no ratio.
+ */
+export function getPlanWeight(planType) {
+    return describePlanAllotment(planType).weight ?? DEFAULT_PLAN_WEIGHT;
+}
+/** `5x`, or `undefined` when the plan states no ratio. */
+export function formatPlanMultiplier(planType) {
+    return describePlanAllotment(planType).multiplier;
+}
+//# sourceMappingURL=plan-allotment.js.map

package/dist/lib/plan-allotment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-allotment.js","sourceRoot":"","sources":["../../lib/plan-allotment.ts"],"names":[],"mappings":"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"}

package/dist/lib/plugin-origin.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Where this plugin is running from, and where it has run from before.
+ *
+ * OpenCode can load the plugin from the published package or from a checkout
+ * a developer points it at, and the two are indistinguishable at runtime
+ * unless the plugin asks. Knowing which one is live decides whether offering
+ * an update makes sense, and a record of previous origins is what turns "my
+ * edits stopped taking effect" into a diagnosable event.
+ */
+/**
+ * The origin history file name, shared with the installer.
+ *
+ * The installer is plain JS that must run before anything is built, so it
+ * cannot import this module and declares the same name itself. A test pins the
+ * two together, because a silent disagreement would leave each side reporting
+ * confidently about a file the other never writes.
+ */
+export declare const HISTORY_FILE_NAME = "oc-codex-multi-auth-origin.json";
+export interface PluginOrigin {
+    name: string;
+    version: string;
+    root: string;
+    isLocalCheckout: boolean;
+}
+export interface PluginOriginSighting extends PluginOrigin {
+    firstSeen: string;
+    lastSeen: string;
+}
+export interface PluginOriginHistory {
+    version: number;
+    sightings: PluginOriginSighting[];
+}
+/** Built output lives inside the package, so the root is at or above it. */
+export declare function findPackageRoot(startDirectory: string): string | null;
+/**
+ * A root a package manager chose, as opposed to one a human did. The version
+ * suffix is what separates OpenCode's plugin cache from a monorepo that merely
+ * keeps its packages in a `packages/` directory.
+ */
+export declare function isPackageManagerRoot(root: string, platform?: NodeJS.Platform, cacheDirectory?: string): boolean;
+export declare function resolvePluginOrigin(moduleUrl: string): PluginOrigin | null;
+/** The origin of this running build. Fixed for the life of the process. */
+export declare function getPluginOrigin(): PluginOrigin | null;
+export declare function getPluginOriginHistoryPath(home?: string): string;
+export declare function readPluginOriginHistory(historyPath?: string): PluginOriginHistory;
+/**
+ * History is appended to rather than overwritten, so one origin replacing
+ * another leaves both on record. A last-writer-wins marker would instead
+ * confirm whatever state a clobber left behind.
+ */
+export declare function withSighting(history: PluginOriginHistory, origin: PluginOrigin, seenAt: string, platform?: NodeJS.Platform): PluginOriginHistory;
+/**
+ * Records this origin without dropping anybody else's.
+ *
+ * Every OpenCode process records at startup, and a machine running many of
+ * them starts several at once, so read-modify-write on a shared file is a real
+ * race rather than a theoretical one. The reader that matters here asks which
+ * origins have been seen, so a lost sighting is a lost answer: the very
+ * handover this file exists to report - a checkout replaced by the installed
+ * package - is two different origins written at close to the same time.
+ *
+ * The history is therefore re-read INSIDE the lease, so each writer merges
+ * into what is actually on disk. A writer that cannot take the lease records
+ * nothing rather than overwriting blind; it is about to be started again, and
+ * a missing sighting costs a later startup while a clobbered one costs the
+ * only evidence there was. A lease reclaimed mid-write is the same situation
+ * arriving later, and is answered the same way.
+ */
+export declare function recordPluginOrigin(origin: PluginOrigin, historyPath?: string, now?: () => Date): Promise<PluginOriginHistory>;
+/**
+ * The checkout this plugin used to run from and no longer does. Reported only
+ * when the current origin is package-manager output, since a move between two
+ * checkouts is an ordinary thing to do deliberately.
+ */
+export declare function findReplacedLocalCheckout(origin: PluginOrigin, history: PluginOriginHistory, platform?: NodeJS.Platform): PluginOriginSighting | null;
+export declare function describePluginOrigin(origin: PluginOrigin | null): string;
+//# sourceMappingURL=plugin-origin.d.ts.map

package/dist/lib/plugin-origin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-origin.d.ts","sourceRoot":"","sources":["../../lib/plugin-origin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,oCAAoC,CAAC;AA0BnE,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,oBAAoB,EAAE,CAAC;CAClC;AA0BD,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASrE;AAkCD;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,cAAc,GAAE,MAAgC,GAC9C,OAAO,CAYT;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAiB1E;AAID,2EAA2E;AAC3E,wBAAgB,eAAe,IAAI,YAAY,GAAG,IAAI,CAGrD;AAED,wBAAgB,0BAA0B,CAAC,IAAI,GAAE,MAAkB,GAAG,MAAM,CAE3E;AAeD,wBAAgB,uBAAuB,CACtC,WAAW,GAAE,MAAqC,GAChD,mBAAmB,CAUrB;AAMD;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC1C,mBAAmB,CAiBrB;AA6BD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,YAAY,EACpB,WAAW,GAAE,MAAqC,EAClD,GAAG,GAAE,MAAM,IAAuB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CA4C9B;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC1C,oBAAoB,GAAG,IAAI,CAc7B;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,MAAM,CAKxE"}

package/dist/lib/plugin-origin.js

@@ -0,0 +1,301 @@
+/**
+ * Where this plugin is running from, and where it has run from before.
+ *
+ * OpenCode can load the plugin from the published package or from a checkout
+ * a developer points it at, and the two are indistinguishable at runtime
+ * unless the plugin asks. Knowing which one is live decides whether offering
+ * an update makes sense, and a record of previous origins is what turns "my
+ * edits stopped taking effect" into a diagnosable event.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { lock } from "proper-lockfile";
+import { createLogger } from "./logger.js";
+import { renameWithWindowsRetry } from "./storage/atomic-write.js";
+const log = createLogger("plugin-origin");
+/**
+ * The origin history file name, shared with the installer.
+ *
+ * The installer is plain JS that must run before anything is built, so it
+ * cannot import this module and declares the same name itself. A test pins the
+ * two together, because a silent disagreement would leave each side reporting
+ * confidently about a file the other never writes.
+ */
+export const HISTORY_FILE_NAME = "oc-codex-multi-auth-origin.json";
+const HISTORY_VERSION = 1;
+const MAX_SIGHTINGS = 10;
+const PACKAGE_ROOT_LOOKUP_DEPTH = 3;
+/** The lease covers one small read and one small write, so it is short. */
+const HISTORY_LOCK_STALE_MS = 10_000;
+const HISTORY_LOCK_UPDATE_MS = 2_000;
+const HISTORY_LOCK_RETRIES = {
+    retries: 10,
+    factor: 1.8,
+    minTimeout: 50,
+    maxTimeout: 500,
+    randomize: true,
+};
+const MANAGED_PACKAGE_NAMES = new Set(["oc-codex-multi-auth", "oc-chatgpt-multi-auth"]);
+function isManagedPackageName(name) {
+    return MANAGED_PACKAGE_NAMES.has(name.toLowerCase());
+}
+function defaultCacheDirectory(home = homedir()) {
+    return join(home, ".cache", "opencode");
+}
+function emptyHistory() {
+    return { version: HISTORY_VERSION, sightings: [] };
+}
+function readPackageManifest(directory) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function manifestName(manifest) {
+    const name = manifest?.name;
+    return typeof name === "string" && name.trim() ? name.trim() : null;
+}
+/** Built output lives inside the package, so the root is at or above it. */
+export function findPackageRoot(startDirectory) {
+    let current = resolve(startDirectory);
+    for (let depth = 0; depth <= PACKAGE_ROOT_LOOKUP_DEPTH; depth += 1) {
+        if (manifestName(readPackageManifest(current)))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+    return null;
+}
+function pathSegments(path) {
+    return path.replaceAll("\\", "/").replace(/\/+$/, "").split("/").filter(Boolean);
+}
+function foldPathCase(value, platform) {
+    return platform === "win32" || platform === "darwin" ? value.toLowerCase() : value;
+}
+function isInsideDirectory(candidate, directory, platform) {
+    const relativePath = relative(foldPathCase(resolve(directory), platform), foldPathCase(resolve(candidate), platform));
+    return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+/**
+ * How two spellings of a root are told apart. Windows reaches one directory
+ * under several of them, and so does a default-case-insensitive APFS volume,
+ * so comparing verbatim there would let `C:\Repo` and `c:\repo` - or `/Repo`
+ * and `/repo` - occupy two slots in a bounded history and evict a genuinely
+ * different origin between them.
+ */
+function rootComparisonKey(root, platform = process.platform) {
+    const normalized = root.replaceAll("\\", "/").replace(/\/+$/, "");
+    return foldPathCase(normalized, platform);
+}
+/**
+ * A root a package manager chose, as opposed to one a human did. The version
+ * suffix is what separates OpenCode's plugin cache from a monorepo that merely
+ * keeps its packages in a `packages/` directory.
+ */
+export function isPackageManagerRoot(root, platform = process.platform, cacheDirectory = defaultCacheDirectory()) {
+    const segments = pathSegments(root).map((segment) => foldPathCase(segment, platform));
+    if (segments.some((segment, index) => segment === "node_modules" ||
+        (segments[index - 1] === "packages" && segment.includes("@")))) {
+        return true;
+    }
+    return isInsideDirectory(root, cacheDirectory, platform);
+}
+export function resolvePluginOrigin(moduleUrl) {
+    let moduleDirectory;
+    try {
+        moduleDirectory = dirname(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return null;
+    }
+    const root = findPackageRoot(moduleDirectory);
+    if (!root)
+        return null;
+    const manifest = readPackageManifest(root);
+    const name = manifestName(manifest);
+    if (!name || !isManagedPackageName(name))
+        return null;
+    const version = typeof manifest?.version === "string" ? manifest.version : "0.0.0";
+    return { name, version, root, isLocalCheckout: !isPackageManagerRoot(root) };
+}
+let cachedOrigin;
+/** The origin of this running build. Fixed for the life of the process. */
+export function getPluginOrigin() {
+    if (cachedOrigin === undefined)
+        cachedOrigin = resolvePluginOrigin(import.meta.url);
+    return cachedOrigin;
+}
+export function getPluginOriginHistoryPath(home = homedir()) {
+    return join(home, ".opencode", HISTORY_FILE_NAME);
+}
+function isSighting(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const candidate = value;
+    return (typeof candidate.name === "string" &&
+        typeof candidate.version === "string" &&
+        typeof candidate.root === "string" &&
+        typeof candidate.isLocalCheckout === "boolean" &&
+        typeof candidate.firstSeen === "string" &&
+        typeof candidate.lastSeen === "string");
+}
+export function readPluginOriginHistory(historyPath = getPluginOriginHistoryPath()) {
+    try {
+        const parsed = JSON.parse(readFileSync(historyPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return emptyHistory();
+        const sightings = parsed.sightings;
+        if (!Array.isArray(sightings))
+            return emptyHistory();
+        return { version: HISTORY_VERSION, sightings: sightings.filter(isSighting) };
+    }
+    catch {
+        return emptyHistory();
+    }
+}
+function byLastSeen(left, right) {
+    return (Date.parse(left.lastSeen) || 0) - (Date.parse(right.lastSeen) || 0);
+}
+/**
+ * History is appended to rather than overwritten, so one origin replacing
+ * another leaves both on record. A last-writer-wins marker would instead
+ * confirm whatever state a clobber left behind.
+ */
+export function withSighting(history, origin, seenAt, platform = process.platform) {
+    // Matched on the comparison key, recorded as the origin spells it: a reader
+    // is shown the path they configured, not a folded version of it.
+    const key = rootComparisonKey(origin.root, platform);
+    const sameRoot = (sighting) => rootComparisonKey(sighting.root, platform) === key;
+    const previous = history.sightings.find(sameRoot);
+    const others = history.sightings.filter((sighting) => !sameRoot(sighting));
+    const current = {
+        ...origin,
+        firstSeen: previous?.firstSeen ?? seenAt,
+        lastSeen: seenAt,
+    };
+    return {
+        version: HISTORY_VERSION,
+        sightings: [...others, current].slice(-MAX_SIGHTINGS),
+    };
+}
+/**
+ * Replaces the history, unless ownership was lost while the new copy was being
+ * written. Only the rename is visible to anybody else, so that is where the
+ * question has to be asked: checking earlier leaves the whole of `writeFile`
+ * as a window in which the lease can be reclaimed and newer history written,
+ * which this rename would then replace with an older snapshot.
+ *
+ * Returns whether the replacement happened.
+ */
+async function writeHistory(historyPath, history, stillOwned) {
+    const temporaryPath = `${historyPath}.${process.pid}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(history, null, 2)}\n`, "utf-8");
+    try {
+        if (!stillOwned())
+            return false;
+        await renameWithWindowsRetry(temporaryPath, historyPath);
+        return true;
+    }
+    finally {
+        if (existsSync(temporaryPath)) {
+            await rm(temporaryPath, { force: true }).catch(() => undefined);
+        }
+    }
+}
+/**
+ * Records this origin without dropping anybody else's.
+ *
+ * Every OpenCode process records at startup, and a machine running many of
+ * them starts several at once, so read-modify-write on a shared file is a real
+ * race rather than a theoretical one. The reader that matters here asks which
+ * origins have been seen, so a lost sighting is a lost answer: the very
+ * handover this file exists to report - a checkout replaced by the installed
+ * package - is two different origins written at close to the same time.
+ *
+ * The history is therefore re-read INSIDE the lease, so each writer merges
+ * into what is actually on disk. A writer that cannot take the lease records
+ * nothing rather than overwriting blind; it is about to be started again, and
+ * a missing sighting costs a later startup while a clobbered one costs the
+ * only evidence there was. A lease reclaimed mid-write is the same situation
+ * arriving later, and is answered the same way.
+ */
+export async function recordPluginOrigin(origin, historyPath = getPluginOriginHistoryPath(), now = () => new Date()) {
+    await mkdir(dirname(historyPath), { recursive: true });
+    let compromised;
+    let release = null;
+    try {
+        release = await lock(historyPath, {
+            realpath: false,
+            lockfilePath: `${historyPath}.lock`,
+            stale: HISTORY_LOCK_STALE_MS,
+            update: HISTORY_LOCK_UPDATE_MS,
+            retries: HISTORY_LOCK_RETRIES,
+            // proper-lockfile's default rethrows from the timer that refreshes the
+            // lease, so it lands outside every promise chain and ends the process
+            // hosting this plugin. A stalled event loop is enough to trigger it.
+            // Nothing here is worth an editor closing, so the loss is recorded and
+            // the write is abandoned instead.
+            onCompromised: (error) => {
+                compromised = error;
+                log.warn("The plugin origin history lease was reclaimed", {
+                    path: `${historyPath}.lock`,
+                    error: error.message,
+                });
+            },
+        });
+    }
+    catch (error) {
+        log.debug("Skipped recording the plugin origin; another process holds the history", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return readPluginOriginHistory(historyPath);
+    }
+    try {
+        const next = withSighting(readPluginOriginHistory(historyPath), origin, now().toISOString());
+        // Whoever reclaimed the lease owns the file now, so writing what we read
+        // before they did would drop their sighting - the clobber the lease
+        // exists to prevent. Asked again at the rename, since the lease can be
+        // lost at any point up to it.
+        if (compromised)
+            return readPluginOriginHistory(historyPath);
+        const written = await writeHistory(historyPath, next, () => !compromised);
+        return written ? next : readPluginOriginHistory(historyPath);
+    }
+    finally {
+        await release().catch(() => undefined);
+    }
+}
+/**
+ * The checkout this plugin used to run from and no longer does. Reported only
+ * when the current origin is package-manager output, since a move between two
+ * checkouts is an ordinary thing to do deliberately.
+ */
+export function findReplacedLocalCheckout(origin, history, platform = process.platform) {
+    if (origin.isLocalCheckout)
+        return null;
+    const currentKey = rootComparisonKey(origin.root, platform);
+    return (history.sightings
+        .filter((sighting) => isManagedPackageName(sighting.name) &&
+        sighting.isLocalCheckout &&
+        rootComparisonKey(sighting.root, platform) !== currentKey)
+        .sort(byLastSeen)
+        .at(-1) ?? null);
+}
+export function describePluginOrigin(origin) {
+    if (!origin)
+        return "unknown";
+    return origin.isLocalCheckout
+        ? `local checkout at ${origin.root} (v${origin.version})`
+        : `installed package v${origin.version}`;
+}
+//# sourceMappingURL=plugin-origin.js.map