@maudecode/talaria-web 0.0.0 → 1.12.1

package/dist/tools/updates.d.ts

@@ -7,6 +7,7 @@ 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;
 export declare const DEFAULT_CHANNEL = "stable";
 export type Channel = 'stable' | 'experimental';
@@ -26,10 +27,16 @@ 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;
+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;
@@ -42,14 +49,37 @@ export interface PublishedRelease {
     sourceRevision: string;
     releaseSet: string;
     image: string;
+    npm: string | null;
     manifestReleaseSet: string;
     runtime: Dict;
     release_url: string;
 }
 /** 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 {
+    packageRoot: string;
+    version: string;
+}
+/** 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 {
@@ -61,15 +91,32 @@ export interface ReleaseIdentity {
     runningSourceRevision: () => string | null;
 }
 /** Python `check_web_update`. */
-export declare function checkWebUpdate(webRoot: string | null, currentVersion: string, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity): Promise<Dict>;
+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`: 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): Promise<Dict>;
-/** Python `_check_repo` for the Agent checkout: fetch tags, prefer the release view, else the branch view. */
-export declare function checkAgentUpdate(path: string | null, git: GitRun): Promise<Dict>;
-/** Python `_apply_update_inner` (agent branch): fetch, stash, `pull --ff-only`, pop. */
-export declare function applyAgentUpdate(path: string | null, git: GitRun): Promise<Dict>;
+export declare function applyWebUpdate(webRoot: string | null, channel: Channel, git: GitRun, getJson: GetJson, id: ReleaseIdentity, build?: BuildRun, npmRun?: BuildRun, canApply?: () => boolean, packaged?: PackagedUpdateOptions): Promise<Dict>;
+export interface AgentUpdatePolicy {
+    supportedRevision: string;
+    supportedVersion: string;
+    confirmedRevision?: string;
+}
+export interface AgentUpdateOptions {
+    agentChannel?: Channel | undefined;
+    confirmedRevision?: string | undefined;
+}
+/** Fetch and compare the independently selected Agent channel. */
+export declare function checkAgentUpdate(path: string | null, git: GitRun, channel?: Channel): Promise<Dict>;
+/** Fetch, confirm the immutable Agent target, stash, fast-forward, and pop. */
+export declare function applyAgentUpdate(path: string | null, git: GitRun, channel?: Channel, policy?: AgentUpdatePolicy): Promise<Dict>;
 /** Python `apply_force_update` (agent branch): fetch, refuse a pure-ancestor rewind, `checkout . && clean -fd && reset --hard`. */
-export declare function forceAgentUpdate(path: string | null, git: GitRun, log: (line: string) => void): Promise<Dict>;
+export declare function forceAgentUpdate(path: string | null, git: GitRun, log: (line: string) => void, channel?: Channel, policy?: AgentUpdatePolicy): Promise<Dict>;
 /** Python `_inventory_locks`: report `.git/**\/*.lock` without touching any of them. */
 export declare function inventoryLocks(path: string): {
     well_known_lock_present: boolean;
@@ -81,6 +128,8 @@ export declare function purgePycache(root: string): void;
 export interface RestartBlockers {
     active_streams: number;
     active_runs: number;
+    active_terminals?: number;
+    active_cron_jobs?: number;
     blocking_stream_ids: string[];
     blocking_run_ids: string[];
     restart_blocked: boolean;
@@ -91,12 +140,30 @@ export interface UpdateServiceDeps {
     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 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;
+        }) => void;
+    };
     blockers: () => RestartBlockers;
     /** Re-exec the server once active work drains (`restartWhenSafe`). */
     scheduleRestart: () => void;
@@ -112,28 +179,45 @@ export declare class UpdateService {
     private readonly deps;
     private readonly cache;
     private checking;
+    private checkingKey;
+    private readonly lastGood;
     private applying;
+    private autoTimer;
+    private autoStarted;
+    private lifecycle;
+    private autoRunning;
+    private autoRestartScheduled;
     private readonly summaries;
     private readonly git;
     private readonly now;
     private readonly sleep;
     constructor(deps: UpdateServiceDeps);
+    private agentChannel;
+    private agentPolicy;
     /** Python `cached_update_status`: no network, no git mutations. */
-    cachedStatus(includeAgent?: boolean, channel?: Channel): Dict;
-    /** Python `check_for_updates`: 30 min cache keyed on channel + include_agent; one in-flight check per key. */
-    check(force?: boolean, includeAgent?: boolean, channel?: Channel): Promise<Dict>;
+    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;
     /** Python `apply_update`. */
-    apply(target: string, channel?: Channel | null): Promise<Dict>;
+    apply(target: string, channel?: Channel | null, canApply?: () => boolean, agentOptions?: AgentUpdateOptions): Promise<Dict>;
     private applyInner;
     private finishAgent;
     /** Python `_ensure_gateway_restart_for_agent_update`: retry once after a transient supervisor handoff failure. */
     private restartGateway;
     /** Python `apply_force_update`: Web keeps its clean-only policy; the Agent resets hard. */
-    force(target: string, channel?: Channel | null): Promise<Dict>;
+    force(target: string, channel?: Channel | null, agentOptions?: AgentUpdateOptions): Promise<Dict>;
     /** Python `apply_clear_lock`: never removes a lock; Web retries the clean path, the Agent gets the manual command. */
-    clearLock(target: string): Promise<Dict>;
+    clearLock(target: string, agentOptions?: AgentUpdateOptions): Promise<Dict>;
     /** Python `_commit_subjects_for_update_with_limit`. */
     private commitSubjects;
     /** Python `summarize_update_payload`: What's New sections, LLM when available, cached per exact range. */