@maudecode/talaria-web 1.11.0 → 1.13.0

package/dist/tools/updates.d.ts

@@ -4,8 +4,6 @@ export declare const REPOSITORY_URL = "https://github.com/MaudeCode/talaria";
 export declare const API_ROOT = "https://api.github.com/repos/MaudeCode/talaria";
 /** Anchored paths work from both the git root and Web's nested working directory. */
 export declare const WEB_UPDATE_PATHS: string[];
-/** Relative to the git root: the release stamp and the blobs it is verified against. */
-export declare const RELEASE_STAMP = "web/_release.json";
 export declare const CACHE_TTL_S = 1800;
 export declare const AUTO_UPDATE_INTERVAL_MS: number;
 export declare const RESTART_MAX_WAIT_S = 300;
@@ -21,17 +19,19 @@ export type GitRun = (args: string[], cwd: string, timeoutMs?: number) => Promis
 export declare const runGit: GitRun;
 /** Runs one `npm` command in `cwd`; same outcome shape as `GitRun`. */
 export type BuildRun = (args: string[], cwd: string, timeoutMs: number) => Promise<GitOutcome>;
-/** The steps a source checkout needs after its files change (README "From a source checkout"), run from `<root>/web`. */
-export declare const WEB_BUILD_STEPS: readonly string[][];
 export declare const WEB_BUILD_TIMEOUT_MS: number;
-/** The artifact the supervisor re-executes; a build that does not leave it behind did not succeed. */
-export declare const WEB_SERVER_ENTRY = "packages/server/dist/bin/talaria-web.js";
-export declare const runNpm: BuildRun;
+/** Source checkouts are contributor-only: they update with git, and the updater never mutates them (TAL-379). */
+export declare const CONTRIBUTOR_CHECKOUT_MESSAGE = "This is a contributor source checkout. Update it with git and rebuild Web (see web/README.md); only npm installs update automatically.";
 export declare const runPackageNpm: BuildRun;
 export declare const isGitLockError: (output: string) => boolean;
 /** Python `_sanitize_git_diagnostic`: strip URL userinfo, GitHub token shapes, and secret query values. */
 export declare function sanitizeGitDiagnostic(output: string, limit?: number): string;
+/** One delayed retry absorbs a transient network blip; a lock conflict is not transient. */
+export declare const FETCH_RETRY_MS = 1000;
+/** `transient`: GitHub was unreachable, slow, or overloaded, so a retry can succeed; the rest describe published state. */
 export declare class ReleaseUnavailable extends Error {
+    readonly transient: boolean;
+    constructor(message: string, transient?: boolean);
 }
 export type GetJson = (path: string, opts: {
     asset: boolean;
@@ -51,6 +51,22 @@ export interface PublishedRelease {
 }
 /** Python `published_web_release`: the newest completed `release-set-<sha>` whose Web component matches the channel's tag family. */
 export declare function publishedWebRelease(channel: Channel, getJson: GetJson, now?: () => number): Promise<PublishedRelease>;
+export declare const EXPERIMENTAL_TARBALL_CAP = 200000000;
+/** The `experimental` tag of the public GHCR artifact: identity from its annotations, content by digest. */
+export interface ExperimentalRelease {
+    tag: string;
+    version: string;
+    sourceRevision: string;
+    digest: string;
+    size: number;
+}
+export interface ExperimentalRegistry {
+    release: () => Promise<ExperimentalRelease>;
+    /** The layer bytes, verified against the release digest and size. */
+    download: (release: ExperimentalRelease) => Promise<Buffer>;
+}
+/** Anonymous GHCR client with `githubJson`'s timeouts, caps, and transient classification. */
+export declare function ghcrExperimental(fetchImpl: typeof fetch): ExperimentalRegistry;
 /** The git root when `webRoot` is `<root>/web` of a Talaria checkout with a GitHub `maudecode/talaria` origin; else null. */
 export declare function checkoutRoot(webRoot: string | null, git: GitRun): Promise<string | null>;
 export interface NpmInstallInfo {
@@ -59,8 +75,6 @@ export interface NpmInstallInfo {
 }
 /** A real global npm install of this package; local, npx, linked and container trees fail closed. */
 export declare function npmInstallInfo(webRoot: string | null, npm?: BuildRun, container?: boolean): Promise<NpmInstallInfo | null>;
-/** Python `verify_release_source`: the stamp Web expects for `release`, computed from immutable blobs at its source revision. */
-export declare function verifyReleaseSource(root: string, release: PublishedRelease, git: GitRun): Promise<Dict>;
 export interface ReleaseIdentity {
     /** `RELEASE_INFO`: the stamp when it matches the checkout, else development info. */
     release: () => Dict;
@@ -69,10 +83,18 @@ export interface ReleaseIdentity {
     /** `RUNNING_SOURCE_REVISION`: HEAD when this process started. */
     runningSourceRevision: () => string | null;
 }
-/** Python `check_web_update`. */
-export declare function checkWebUpdate(webRoot: string | null, currentVersion: string, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, npmRun?: BuildRun): Promise<Dict>;
-/** Python `apply_web_update`: fast-forward a recognized clean checkout to main or a published Stable tag. */
-export declare function applyWebUpdate(webRoot: string | null, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, build?: BuildRun, npmRun?: BuildRun, canApply?: () => boolean): Promise<Dict>;
+/** Python `check_web_update`: npm and packaged installs; a source checkout is contributor-only (TAL-379). */
+export declare function checkWebUpdate(webRoot: string | null, currentVersion: string, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, npmRun?: BuildRun, registry?: ExperimentalRegistry): Promise<Dict>;
+/** Packaged-install collaborators: the Experimental registry and Web's state dir for channel-switch backups. */
+export interface PackagedUpdateOptions {
+    registry?: ExperimentalRegistry | undefined;
+    stateDir?: string | undefined;
+}
+export declare const CHANNEL_SWITCH_BACKUPS = 5;
+/** Copy the persisted stores to `<stateDir>/backups/channel-switch-<UTC timestamp>/`, keeping the newest few; throws on failure. */
+export declare function backupPersistedStores(stateDir: string, now?: Date, keep?: number): string;
+/** Python `apply_web_update`: installs npm releases; a source checkout is never mutated (TAL-379). */
+export declare function applyWebUpdate(webRoot: string | null, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, npmRun?: BuildRun, canApply?: () => boolean, packaged?: PackagedUpdateOptions): Promise<Dict>;
 export interface AgentUpdatePolicy {
     supportedRevision: string;
     supportedVersion: string;
@@ -109,19 +131,30 @@ export interface UpdateServiceDeps {
     /** `web/` of this installation (a Talaria checkout has it at `<root>/web`). */
     webRoot: string;
     git?: GitRun;
-    /** Runs the checkout's npm install/build steps after a source update (default: the npm beside this node). */
-    build?: BuildRun;
-    /** Runs global npm discovery/install for packaged Stable updates. */
+    /** Runs global npm discovery/install for packaged updates. */
     npm?: BuildRun;
     getJson: GetJson;
+    /** The public GHCR Experimental artifact that npm installs follow on the Experimental channel. */
+    experimental?: ExperimentalRegistry;
+    /** Web's state dir; channel switches back up its persisted stores here first. */
+    stateDir?: string;
     identity: ReleaseIdentity;
     webuiVersion: string;
+    /** Re-derive the installed Web version after a check (tags can arrive after startup); returns the current label. */
+    refreshWebuiVersion?: () => string;
     agentDir: () => string | null;
     channel: () => Channel;
     agentChannel?: () => Channel;
     includeAgent: () => boolean;
     autoApply?: () => boolean;
     checkEnabled?: () => boolean;
+    autoNotification?: {
+        begin: () => string;
+        transition: (id: string, phase: 'restarting' | 'succeeded' | 'blocked' | 'failed', expectedIdentity?: string | null, verifiedIdentity?: {
+            revision: string | null;
+            version: string | null;
+        }, detail?: unknown) => void;
+    };
     blockers: () => RestartBlockers;
     /** Re-exec the server once active work drains (`restartWhenSafe`). */
     scheduleRestart: () => void;
@@ -138,6 +171,7 @@ export declare class UpdateService {
     private readonly cache;
     private checking;
     private checkingKey;
+    private readonly lastGood;
     private applying;
     private autoTimer;
     private autoStarted;
@@ -155,10 +189,13 @@ export declare class UpdateService {
     cachedStatus(includeAgent?: boolean, channel?: Channel, agentChannel?: Channel): Dict;
     /** 30 min cache keyed on both channels + include_agent; one in-flight check per key. */
     check(force?: boolean, includeAgent?: boolean, channel?: Channel, agentChannel?: Channel): Promise<Dict>;
+    /** A failed fetch (`stale_check`) keeps the channel's last good result until the cache TTL, so a network blip never flips the status; persistent failures surface. */
+    private keepLastGood;
     startAutoApply(intervalMs?: number): void;
     stopAutoApply(): void;
     /** Shared turn admission stays closed from update start through the supervisor restart. */
     blocksNewWork(): boolean;
+    private pendingRestartResponse;
     autoApplyOnce(): Promise<Dict | null>;
     blockedResponse(target: string): Dict | null;
     private locked;