@ericsanchezok/synergy-util 3.0.23 → 3.1.0

package/dist/runtime-startup.d.ts

@@ -1,8 +1,229 @@
 import { z } from "zod";
+export interface RuntimeStatusRow {
+    label: string;
+    value: string;
+    kind?: "success" | "warning" | "error" | "pending" | "muted";
+}
 export declare const RUNTIME_STARTUP_PREFIX = "SYNERGY_STARTUP_V1 ";
 export declare const RUNTIME_STARTUP_MAX_LINE_LENGTH = 1024;
-export declare const RuntimeStartupProgress: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const RuntimeStartupStage: z.ZodEnum<{
+    configuration: "configuration";
+    "execution-recovery": "execution-recovery";
+    extensions: "extensions";
+    finalizing: "finalizing";
+    initializing: "initializing";
+    installation: "installation";
+    migrations: "migrations";
+    services: "services";
+    storage: "storage";
+    "storage-recovery": "storage-recovery";
+    transport: "transport";
+}>;
+export type RuntimeStartupStage = z.infer<typeof RuntimeStartupStage>;
+export declare const RuntimeStartupEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"opening">;
+    stage: z.ZodEnum<{
+        configuration: "configuration";
+        "execution-recovery": "execution-recovery";
+        extensions: "extensions";
+        finalizing: "finalizing";
+        initializing: "initializing";
+        installation: "installation";
+        migrations: "migrations";
+        services: "services";
+        storage: "storage";
+        "storage-recovery": "storage-recovery";
+        transport: "transport";
+    }>;
+    current: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"ready">;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"failed">;
+}, z.core.$strict>], "state">;
+export type RuntimeStartupEvent = z.infer<typeof RuntimeStartupEvent>;
+export declare const StorageMaintenanceOperation: z.ZodEnum<{
+    checkpoint: "checkpoint";
+    "create-index": "create-index";
+    "drop-index": "drop-index";
+    "integrity-check": "integrity-check";
+    prune: "prune";
+    reclaim: "reclaim";
+    vacuum: "vacuum";
+}>;
+export type StorageMaintenanceOperation = z.infer<typeof StorageMaintenanceOperation>;
+export declare const StorageMaintenanceStage: z.ZodEnum<{
+    "checkpoint-after": "checkpoint-after";
+    "checkpoint-before": "checkpoint-before";
+    rewrite: "rewrite";
+}>;
+export type StorageMaintenanceStage = z.infer<typeof StorageMaintenanceStage>;
+export declare const StorageMaintenanceEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodLiteral<"started">;
+    operation: z.ZodEnum<{
+        checkpoint: "checkpoint";
+        "create-index": "create-index";
+        "drop-index": "drop-index";
+        "integrity-check": "integrity-check";
+        prune: "prune";
+        reclaim: "reclaim";
+        vacuum: "vacuum";
+    }>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodLiteral<"stage">;
+    stage: z.ZodEnum<{
+        "checkpoint-after": "checkpoint-after";
+        "checkpoint-before": "checkpoint-before";
+        rewrite: "rewrite";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+    }>;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strict>], "state">;
+export type StorageMaintenanceEvent = z.infer<typeof StorageMaintenanceEvent>;
+export declare const StorageStartupProgress: z.ZodObject<{
+    stage: z.ZodEnum<{
+        activate: "activate";
+        "archive-import": "archive-import";
+        "archive-verify": "archive-verify";
+        artifacts: "artifacts";
+        backup: "backup";
+        check: "check";
+        complete: "complete";
+        import: "import";
+        inventory: "inventory";
+        notifications: "notifications";
+        owners: "owners";
+        prepare: "prepare";
+        quarantine: "quarantine";
+        resources: "resources";
+        scan: "scan";
+        staging: "staging";
+        validate: "validate";
+        "validate-engine": "validate-engine";
+        verify: "verify";
+    }>;
+    current: z.ZodNumber;
+    total: z.ZodNumber;
+    bytes: z.ZodNumber;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type StorageStartupProgress = z.infer<typeof StorageStartupProgress>;
+export declare const MigrationStartupTask: z.ZodEnum<{
+    blueprints: "blueprints";
+    browser: "browser";
+    connections: "connections";
+    conversations: "conversations";
+    "file-history": "file-history";
+    notes: "notes";
+    "request-prices": "request-prices";
+    "scheduled-work": "scheduled-work";
+    scopes: "scopes";
+    settings: "settings";
+    storage: "storage";
+    "tool-history": "tool-history";
+    usage: "usage";
+    workflows: "workflows";
+    workspaces: "workspaces";
+}>;
+export type MigrationStartupTask = z.infer<typeof MigrationStartupTask>;
+export declare const RuntimeStartupProgress: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"opening">;
+    stage: z.ZodEnum<{
+        configuration: "configuration";
+        "execution-recovery": "execution-recovery";
+        extensions: "extensions";
+        finalizing: "finalizing";
+        initializing: "initializing";
+        installation: "installation";
+        migrations: "migrations";
+        services: "services";
+        storage: "storage";
+        "storage-recovery": "storage-recovery";
+        transport: "transport";
+    }>;
+    current: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"ready">;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"runtime">;
+    state: z.ZodLiteral<"failed">;
+}, z.core.$strict>], "state">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodLiteral<"started">;
+    operation: z.ZodEnum<{
+        checkpoint: "checkpoint";
+        "create-index": "create-index";
+        "drop-index": "drop-index";
+        "integrity-check": "integrity-check";
+        prune: "prune";
+        reclaim: "reclaim";
+        vacuum: "vacuum";
+    }>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodLiteral<"stage">;
+    stage: z.ZodEnum<{
+        "checkpoint-after": "checkpoint-after";
+        "checkpoint-before": "checkpoint-before";
+        rewrite: "rewrite";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"maintenance">;
+    id: z.ZodNumber;
+    state: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+    }>;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strict>], "state">, z.ZodDiscriminatedUnion<[z.ZodObject<{
     phase: z.ZodLiteral<"starting">;
+}, z.core.$strict>, z.ZodObject<{
+    stage: z.ZodEnum<{
+        activate: "activate";
+        "archive-import": "archive-import";
+        "archive-verify": "archive-verify";
+        artifacts: "artifacts";
+        backup: "backup";
+        check: "check";
+        complete: "complete";
+        import: "import";
+        inventory: "inventory";
+        notifications: "notifications";
+        owners: "owners";
+        prepare: "prepare";
+        quarantine: "quarantine";
+        resources: "resources";
+        scan: "scan";
+        staging: "staging";
+        validate: "validate";
+        "validate-engine": "validate-engine";
+        verify: "verify";
+    }>;
+    current: z.ZodNumber;
+    total: z.ZodNumber;
+    bytes: z.ZodNumber;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    phase: z.ZodLiteral<"storage">;
+    step: z.ZodNumber;
 }, z.core.$strict>, z.ZodObject<{
     phase: z.ZodLiteral<"recovery">;
     current: z.ZodNumber;
@@ -11,6 +232,23 @@ export declare const RuntimeStartupProgress: z.ZodDiscriminatedUnion<[z.ZodObjec
     step: z.ZodNumber;
     current: z.ZodNumber;
     total: z.ZodNumber;
-}, z.core.$strict>], "phase">;
+    task: z.ZodOptional<z.ZodEnum<{
+        blueprints: "blueprints";
+        browser: "browser";
+        connections: "connections";
+        conversations: "conversations";
+        "file-history": "file-history";
+        notes: "notes";
+        "request-prices": "request-prices";
+        "scheduled-work": "scheduled-work";
+        scopes: "scopes";
+        settings: "settings";
+        storage: "storage";
+        "tool-history": "tool-history";
+        usage: "usage";
+        workflows: "workflows";
+        workspaces: "workspaces";
+    }>>;
+}, z.core.$strict>], "phase">]>;
 export type RuntimeStartupProgress = z.infer<typeof RuntimeStartupProgress>;
 export declare function runtimeStartupLine(progress: RuntimeStartupProgress): string;

package/dist/runtime-startup.js

@@ -2,18 +2,117 @@ import { z } from "zod";
 export const RUNTIME_STARTUP_PREFIX = "SYNERGY_STARTUP_V1 ";
 export const RUNTIME_STARTUP_MAX_LINE_LENGTH = 1024;
 const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-export const RuntimeStartupProgress = z.discriminatedUnion("phase", [
-    z.object({ phase: z.literal("starting") }).strict(),
-    z.object({ phase: z.literal("recovery"), current: count }).strict(),
+const timeout = z.number().int().positive().max(2_147_483_647);
+export const RuntimeStartupStage = z.enum([
+    "installation",
+    "initializing",
+    "storage",
+    "migrations",
+    "storage-recovery",
+    "configuration",
+    "execution-recovery",
+    "extensions",
+    "transport",
+    "services",
+    "finalizing",
+]);
+export const RuntimeStartupEvent = z.discriminatedUnion("state", [
     z
         .object({
-        phase: z.literal("migration"),
-        step: count.positive(),
-        current: count,
-        total: count,
+        phase: z.literal("runtime"),
+        state: z.literal("opening"),
+        stage: RuntimeStartupStage,
+        current: count.optional(),
     })
-        .strict()
-        .refine((value) => value.current <= value.total),
+        .strict(),
+    z.object({ phase: z.literal("runtime"), state: z.literal("ready") }).strict(),
+    z.object({ phase: z.literal("runtime"), state: z.literal("failed") }).strict(),
+]);
+export const StorageMaintenanceOperation = z.enum([
+    "checkpoint",
+    "vacuum",
+    "reclaim",
+    "prune",
+    "integrity-check",
+    "create-index",
+    "drop-index",
+]);
+export const StorageMaintenanceStage = z.enum(["checkpoint-before", "rewrite", "checkpoint-after"]);
+const maintenance = { phase: z.literal("maintenance"), id: count.positive() };
+export const StorageMaintenanceEvent = z.discriminatedUnion("state", [
+    z
+        .object({ ...maintenance, state: z.literal("started"), operation: StorageMaintenanceOperation, timeoutMs: timeout })
+        .strict(),
+    z.object({ ...maintenance, state: z.literal("stage"), stage: StorageMaintenanceStage }).strict(),
+    z.object({ ...maintenance, state: z.enum(["completed", "failed"]), elapsedMs: count }).strict(),
+]);
+export const StorageStartupProgress = z.object({
+    stage: z.enum([
+        "prepare",
+        "staging",
+        "scan",
+        "backup",
+        "inventory",
+        "owners",
+        "import",
+        "verify",
+        "archive-verify",
+        "archive-import",
+        "validate-engine",
+        "validate",
+        "activate",
+        "check",
+        "artifacts",
+        "resources",
+        "quarantine",
+        "notifications",
+        "complete",
+    ]),
+    current: count,
+    total: count,
+    bytes: count,
+    timeoutMs: z.number().int().positive().max(2_147_483_647).optional(),
+});
+export const MigrationStartupTask = z.enum([
+    "scheduled-work",
+    "blueprints",
+    "browser",
+    "connections",
+    "settings",
+    "notes",
+    "conversations",
+    "request-prices",
+    "file-history",
+    "tool-history",
+    "usage",
+    "workflows",
+    "scopes",
+    "workspaces",
+    "storage",
+]);
+export const RuntimeStartupProgress = z.union([
+    RuntimeStartupEvent,
+    StorageMaintenanceEvent,
+    z.discriminatedUnion("phase", [
+        z.object({ phase: z.literal("starting") }).strict(),
+        StorageStartupProgress.extend({ phase: z.literal("storage"), step: count.positive() })
+            .strict()
+            .refine((value) => value.total === 0 || value.current <= value.total)
+            .refine((value) => value.stage === "validate-engine"
+            ? value.timeoutMs !== undefined && value.current === 0 && value.total === 0 && value.bytes === 0
+            : value.timeoutMs === undefined),
+        z.object({ phase: z.literal("recovery"), current: count }).strict(),
+        z
+            .object({
+            phase: z.literal("migration"),
+            step: count.positive(),
+            current: count,
+            total: count,
+            task: MigrationStartupTask.optional(),
+        })
+            .strict()
+            .refine((value) => value.total === 0 || value.current <= value.total),
+    ]),
 ]);
 export function runtimeStartupLine(progress) {
     return RUNTIME_STARTUP_PREFIX + JSON.stringify(RuntimeStartupProgress.parse(progress)) + "\n";

package/dist/terminal.d.ts

@@ -0,0 +1,217 @@
+import z from "zod";
+export declare namespace UI {
+    const CancelledError: {
+        new (data: void, options?: ErrorOptions): {
+            cause?: unknown;
+            readonly name: "UICancelledError";
+            readonly data: void;
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"UICancelledError">;
+                data: z.ZodVoid;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "UICancelledError";
+                data: void;
+            };
+            message: string;
+            stack?: string;
+        };
+        isError(error: unknown): error is Error;
+        isError(value: unknown): value is Error;
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"UICancelledError">;
+            data: z.ZodVoid;
+        }, z.core.$strip>;
+        isInstance(input: any): input is import("./error.js").NamedErrorInstance<"UICancelledError", z.ZodVoid>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                cause?: unknown;
+                readonly name: Name;
+                readonly data: z.core.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: Name;
+                    data: z.core.input<Data>;
+                };
+                message: string;
+                stack?: string;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            isInstance(input: any): input is import("./error.js").NamedErrorInstance<Name, Data>;
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    cause?: unknown;
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                };
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                isInstance(input: any): input is import("./error.js").NamedErrorInstance<"UnknownError", z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                cause?: unknown;
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+            };
+            isError(error: unknown): error is Error;
+            isError(value: unknown): value is Error;
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is import("./error.js").NamedErrorInstance<"UnknownError", z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    cause?: unknown;
+                    readonly name: Name;
+                    readonly data: z.core.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, z.core.$strip>;
+                    toObject(): {
+                        name: Name;
+                        data: z.core.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                };
+                isError(error: unknown): error is Error;
+                isError(value: unknown): value is Error;
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                isInstance(input: any): input is import("./error.js").NamedErrorInstance<Name, Data>;
+                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+                readonly Unknown: /*elided*/ any;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    const Style: {
+        TEXT_HIGHLIGHT: string;
+        TEXT_HIGHLIGHT_BOLD: string;
+        TEXT_DIM: string;
+        TEXT_DIM_BOLD: string;
+        TEXT_NORMAL: string;
+        TEXT_NORMAL_BOLD: string;
+        TEXT_WARNING: string;
+        TEXT_WARNING_BOLD: string;
+        TEXT_DANGER: string;
+        TEXT_DANGER_BOLD: string;
+        TEXT_SUCCESS: string;
+        TEXT_SUCCESS_BOLD: string;
+        TEXT_INFO: string;
+        TEXT_INFO_BOLD: string;
+    };
+    function println(...message: string[]): void;
+    function print(...message: string[]): void;
+    function empty(): void;
+    function input(prompt: string): Promise<string>;
+    function error(message: string): void;
+    function markdown(text: string): string;
+    function progressBar(opts: {
+        ratio: number;
+        width?: number;
+        filledChar?: string;
+        emptyChar?: string;
+        filledStyle?: string;
+        emptyStyle?: string;
+        brackets?: boolean;
+    }): string;
+    interface CardRow {
+        label: string;
+        value: string;
+        valueStyle?: string;
+    }
+    function card(opts: {
+        title: string;
+        titleStyle?: string;
+        description?: string;
+        rows: CardRow[];
+        footer?: string;
+        minWidth?: number;
+    }): string;
+}