@meetquinn/animactl 0.1.1-canary.21.1.cd63d38

package/dist/shared/runtime-upgrade.d.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+export declare const RuntimeReleaseTrack: z.ZodEnum<{
+    stable: "stable";
+    canary: "canary";
+}>;
+export type RuntimeReleaseTrack = z.infer<typeof RuntimeReleaseTrack>;
+export declare const RuntimeUpgradeGateBlocker: z.ZodObject<{
+    agentId: z.ZodString;
+    itemId: z.ZodString;
+    since: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeUpgradeGateBlocker = z.infer<typeof RuntimeUpgradeGateBlocker>;
+export declare const RuntimeUpgradeGate: z.ZodObject<{
+    blockers: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        itemId: z.ZodString;
+        since: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    state: z.ZodEnum<{
+        idle: "idle";
+        busy: "busy";
+    }>;
+}, z.core.$strip>;
+export type RuntimeUpgradeGate = z.infer<typeof RuntimeUpgradeGate>;
+export declare const RuntimeUpgradeCheckError: z.ZodObject<{
+    message: z.ZodString;
+    type: z.ZodEnum<{
+        unknown: "unknown";
+        network: "network";
+        parse: "parse";
+    }>;
+}, z.core.$strip>;
+export type RuntimeUpgradeCheckError = z.infer<typeof RuntimeUpgradeCheckError>;
+export declare const RuntimeUpgradeOperation: z.ZodObject<{
+    completedAt: z.ZodOptional<z.ZodString>;
+    currentVersion: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    logPath: z.ZodOptional<z.ZodString>;
+    previousVersion: z.ZodOptional<z.ZodString>;
+    rollback: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+        not_needed: "not_needed";
+    }>>;
+    restart: z.ZodOptional<z.ZodObject<{
+        fallbackToIdle: z.ZodBoolean;
+        mode: z.ZodEnum<{
+            "drain-active": "drain-active";
+            idle: "idle";
+        }>;
+        requestedCount: z.ZodNumber;
+        resumedCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    scheduledAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        scheduled: "scheduled";
+        succeeded: "succeeded";
+        idle: "idle";
+    }>;
+    targetVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeUpgradeOperation = z.infer<typeof RuntimeUpgradeOperation>;
+export declare const RuntimeUpgradeStatusResponse: z.ZodObject<{
+    checkedAt: z.ZodString;
+    checkError: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        type: z.ZodEnum<{
+            unknown: "unknown";
+            network: "network";
+            parse: "parse";
+        }>;
+    }, z.core.$strip>>;
+    currentVersion: z.ZodString;
+    gate: z.ZodObject<{
+        blockers: z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            itemId: z.ZodString;
+            since: z.ZodString;
+            status: z.ZodEnum<{
+                queued: "queued";
+                running: "running";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        state: z.ZodEnum<{
+            idle: "idle";
+            busy: "busy";
+        }>;
+    }, z.core.$strip>;
+    latestOnTrack: z.ZodOptional<z.ZodString>;
+    operation: z.ZodObject<{
+        completedAt: z.ZodOptional<z.ZodString>;
+        currentVersion: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+        logPath: z.ZodOptional<z.ZodString>;
+        previousVersion: z.ZodOptional<z.ZodString>;
+        rollback: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+            not_needed: "not_needed";
+        }>>;
+        restart: z.ZodOptional<z.ZodObject<{
+            fallbackToIdle: z.ZodBoolean;
+            mode: z.ZodEnum<{
+                "drain-active": "drain-active";
+                idle: "idle";
+            }>;
+            requestedCount: z.ZodNumber;
+            resumedCount: z.ZodNumber;
+        }, z.core.$strip>>;
+        scheduledAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            failed: "failed";
+            scheduled: "scheduled";
+            succeeded: "succeeded";
+            idle: "idle";
+        }>;
+        targetVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    releaseTrack: z.ZodEnum<{
+        stable: "stable";
+        canary: "canary";
+    }>;
+    state: z.ZodEnum<{
+        error: "error";
+        current: "current";
+        available: "available";
+    }>;
+    updateAvailable: z.ZodBoolean;
+}, z.core.$strip>;
+export type RuntimeUpgradeStatusResponse = z.infer<typeof RuntimeUpgradeStatusResponse>;
+export declare const RuntimeUpgradeApplyResponse: z.ZodObject<{
+    animaHome: z.ZodString;
+    currentVersion: z.ZodString;
+    delayMs: z.ZodNumber;
+    latestOnTrack: z.ZodString;
+    logPath: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    releaseTrack: z.ZodEnum<{
+        stable: "stable";
+        canary: "canary";
+    }>;
+    scheduled: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RuntimeUpgradeApplyResponse = z.infer<typeof RuntimeUpgradeApplyResponse>;
+//# sourceMappingURL=runtime-upgrade.d.ts.map

package/dist/shared/runtime-upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-upgrade.d.ts","sourceRoot":"","sources":["../../shared/runtime-upgrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;EAA+B,CAAC;AAChE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;iBAMpC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAG7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,wBAAwB;;;;;;;iBAGnC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUvC,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAExF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBAStC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/shared/runtime-upgrade.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+export const RuntimeReleaseTrack = z.enum(['stable', 'canary']);
+export const RuntimeUpgradeGateBlocker = z.object({
+    agentId: z.string(),
+    itemId: z.string(),
+    since: z.string(),
+    status: z.enum(['queued', 'running']),
+    summary: z.string().optional(),
+});
+export const RuntimeUpgradeGate = z.object({
+    blockers: z.array(RuntimeUpgradeGateBlocker),
+    state: z.enum(['idle', 'busy']),
+});
+export const RuntimeUpgradeCheckError = z.object({
+    message: z.string(),
+    type: z.enum(['network', 'parse', 'unknown']),
+});
+export const RuntimeUpgradeOperation = z.object({
+    completedAt: z.string().optional(),
+    currentVersion: z.string().optional(),
+    error: z.string().optional(),
+    logPath: z.string().optional(),
+    previousVersion: z.string().optional(),
+    rollback: z.enum(['not_needed', 'succeeded', 'failed']).optional(),
+    restart: z.object({
+        fallbackToIdle: z.boolean(),
+        mode: z.enum(['idle', 'drain-active']),
+        requestedCount: z.number(),
+        resumedCount: z.number(),
+    }).optional(),
+    scheduledAt: z.string().optional(),
+    startedAt: z.string().optional(),
+    status: z.enum(['idle', 'scheduled', 'running', 'succeeded', 'failed']),
+    targetVersion: z.string().optional(),
+});
+export const RuntimeUpgradeStatusResponse = z.object({
+    checkedAt: z.string(),
+    checkError: RuntimeUpgradeCheckError.optional(),
+    currentVersion: z.string(),
+    gate: RuntimeUpgradeGate,
+    latestOnTrack: z.string().optional(),
+    operation: RuntimeUpgradeOperation,
+    releaseTrack: RuntimeReleaseTrack,
+    state: z.enum(['current', 'available', 'error']),
+    updateAvailable: z.boolean(),
+});
+export const RuntimeUpgradeApplyResponse = z.object({
+    animaHome: z.string(),
+    currentVersion: z.string(),
+    delayMs: z.number(),
+    latestOnTrack: z.string(),
+    logPath: z.string(),
+    ok: z.literal(true),
+    releaseTrack: RuntimeReleaseTrack,
+    scheduled: z.literal(true),
+});

package/dist/shared/server-info.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+export declare const ServicesRestartBlocker: z.ZodObject<{
+    agentId: z.ZodString;
+    itemId: z.ZodString;
+    since: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    workerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ServicesRestartBlocker = z.infer<typeof ServicesRestartBlocker>;
+export declare const ServicesRestartSucceededResult: z.ZodObject<{
+    completedAt: z.ZodString;
+    fallbackToIdle: z.ZodBoolean;
+    mode: z.ZodEnum<{
+        "drain-active": "drain-active";
+        idle: "idle";
+    }>;
+    requestedCount: z.ZodNumber;
+    resumedCount: z.ZodNumber;
+    status: z.ZodDefault<z.ZodLiteral<"succeeded">>;
+}, z.core.$strip>;
+export type ServicesRestartSucceededResult = z.infer<typeof ServicesRestartSucceededResult>;
+export declare const ServicesRestartBlockedResult: z.ZodObject<{
+    blockers: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        itemId: z.ZodString;
+        since: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        workerId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    completedAt: z.ZodString;
+    message: z.ZodString;
+    reason: z.ZodEnum<{
+        idle_timeout: "idle_timeout";
+        became_busy: "became_busy";
+        drain_timeout: "drain_timeout";
+    }>;
+    status: z.ZodLiteral<"blocked">;
+}, z.core.$strip>;
+export type ServicesRestartBlockedResult = z.infer<typeof ServicesRestartBlockedResult>;
+export declare const ServicesRestartResult: z.ZodUnion<readonly [z.ZodObject<{
+    blockers: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        itemId: z.ZodString;
+        since: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        workerId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    completedAt: z.ZodString;
+    message: z.ZodString;
+    reason: z.ZodEnum<{
+        idle_timeout: "idle_timeout";
+        became_busy: "became_busy";
+        drain_timeout: "drain_timeout";
+    }>;
+    status: z.ZodLiteral<"blocked">;
+}, z.core.$strip>, z.ZodObject<{
+    completedAt: z.ZodString;
+    fallbackToIdle: z.ZodBoolean;
+    mode: z.ZodEnum<{
+        "drain-active": "drain-active";
+        idle: "idle";
+    }>;
+    requestedCount: z.ZodNumber;
+    resumedCount: z.ZodNumber;
+    status: z.ZodDefault<z.ZodLiteral<"succeeded">>;
+}, z.core.$strip>]>;
+export type ServicesRestartResult = z.infer<typeof ServicesRestartResult>;
+export declare const LastServicesRestart: z.ZodUnion<readonly [z.ZodObject<{
+    blockers: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        itemId: z.ZodString;
+        since: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        workerId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    completedAt: z.ZodString;
+    message: z.ZodString;
+    reason: z.ZodEnum<{
+        idle_timeout: "idle_timeout";
+        became_busy: "became_busy";
+        drain_timeout: "drain_timeout";
+    }>;
+    status: z.ZodLiteral<"blocked">;
+    logPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    completedAt: z.ZodString;
+    fallbackToIdle: z.ZodBoolean;
+    mode: z.ZodEnum<{
+        "drain-active": "drain-active";
+        idle: "idle";
+    }>;
+    requestedCount: z.ZodNumber;
+    resumedCount: z.ZodNumber;
+    status: z.ZodDefault<z.ZodLiteral<"succeeded">>;
+    logPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type LastServicesRestart = z.infer<typeof LastServicesRestart>;
+export declare const ServerInfo: z.ZodObject<{
+    animaHome: z.ZodString;
+    commit: z.ZodOptional<z.ZodString>;
+    dashboardPort: z.ZodNumber;
+    env: z.ZodEnum<{
+        custom: "custom";
+        dev: "dev";
+        dogfood: "dogfood";
+    }>;
+    lastRestart: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        blockers: z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            itemId: z.ZodString;
+            since: z.ZodString;
+            status: z.ZodEnum<{
+                queued: "queued";
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+            workerId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        completedAt: z.ZodString;
+        message: z.ZodString;
+        reason: z.ZodEnum<{
+            idle_timeout: "idle_timeout";
+            became_busy: "became_busy";
+            drain_timeout: "drain_timeout";
+        }>;
+        status: z.ZodLiteral<"blocked">;
+        logPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        completedAt: z.ZodString;
+        fallbackToIdle: z.ZodBoolean;
+        mode: z.ZodEnum<{
+            "drain-active": "drain-active";
+            idle: "idle";
+        }>;
+        requestedCount: z.ZodNumber;
+        resumedCount: z.ZodNumber;
+        status: z.ZodDefault<z.ZodLiteral<"succeeded">>;
+        logPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    ok: z.ZodLiteral<true>;
+    startedAt: z.ZodString;
+    uptimeSeconds: z.ZodNumber;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type ServerInfo = z.infer<typeof ServerInfo>;
+export declare const ServicesRestartResponse: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    animaHome: z.ZodString;
+    delayMs: z.ZodNumber;
+    logPath: z.ZodString;
+    scheduled: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type ServicesRestartResponse = z.infer<typeof ServicesRestartResponse>;
+//# sourceMappingURL=server-info.d.ts.map

package/dist/shared/server-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-info.d.ts","sourceRoot":"","sources":["../../shared/server-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAOjC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,8BAA8B;;;;;;;;;;iBAOzC,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE5F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAExF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAG9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/shared/server-info.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export const ServicesRestartBlocker = z.object({
+    agentId: z.string(),
+    itemId: z.string(),
+    since: z.string(),
+    status: z.enum(['queued', 'running', 'completed', 'failed']),
+    summary: z.string().optional(),
+    workerId: z.string().optional(),
+});
+export const ServicesRestartSucceededResult = z.object({
+    completedAt: z.string(),
+    fallbackToIdle: z.boolean(),
+    mode: z.enum(['idle', 'drain-active']),
+    requestedCount: z.number(),
+    resumedCount: z.number(),
+    status: z.literal('succeeded').default('succeeded'),
+});
+export const ServicesRestartBlockedResult = z.object({
+    blockers: z.array(ServicesRestartBlocker),
+    completedAt: z.string(),
+    message: z.string(),
+    reason: z.enum(['became_busy', 'drain_timeout', 'idle_timeout']),
+    status: z.literal('blocked'),
+});
+export const ServicesRestartResult = z.union([
+    ServicesRestartBlockedResult,
+    ServicesRestartSucceededResult,
+]);
+export const LastServicesRestart = z.union([
+    ServicesRestartBlockedResult.extend({ logPath: z.string().optional() }),
+    ServicesRestartSucceededResult.extend({ logPath: z.string().optional() }),
+]);
+export const ServerInfo = z.object({
+    animaHome: z.string(),
+    commit: z.string().optional(),
+    dashboardPort: z.number(),
+    env: z.enum(['dev', 'dogfood', 'custom']),
+    lastRestart: LastServicesRestart.optional(),
+    ok: z.literal(true),
+    startedAt: z.string(),
+    uptimeSeconds: z.number(),
+    version: z.string(),
+});
+export const ServicesRestartResponse = z.object({
+    ok: z.literal(true),
+    animaHome: z.string(),
+    delayMs: z.number(),
+    logPath: z.string(),
+    scheduled: z.literal(true),
+});

package/dist/shared/server-settings.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const SidebarOrder: z.ZodObject<{
+    agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SidebarOrder = z.infer<typeof SidebarOrder>;
+export declare const ReleaseTrack: z.ZodEnum<{
+    stable: "stable";
+    canary: "canary";
+}>;
+export type ReleaseTrack = z.infer<typeof ReleaseTrack>;
+//# sourceMappingURL=server-settings.d.ts.map

package/dist/shared/server-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-settings.d.ts","sourceRoot":"","sources":["../../shared/server-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,YAAY;;;iBAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,YAAY;;;EAA+B,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/shared/server-settings.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const SidebarOrder = z.object({
+    agents: z.array(z.string()).optional(),
+    kbs: z.array(z.string()).optional(),
+});
+export const ReleaseTrack = z.enum(['stable', 'canary']);

package/dist/shared/skills.d.ts

@@ -0,0 +1,19 @@
+export interface SkillSummary {
+    /** Directory name — stable identifier. */
+    dirName: string;
+    /** Human-readable name from SKILL.md frontmatter, falls back to dirName. */
+    name: string;
+    /** Trigger description from SKILL.md frontmatter, if present. */
+    description?: string;
+}
+export interface AgentSkills {
+    /** Skills from the global skills directory (provider-dependent path). */
+    global: SkillSummary[];
+    /** Skills local to this agent's home directory. */
+    local: SkillSummary[];
+    /** Absolute path that was scanned for global skills. */
+    globalPath: string;
+    /** Absolute path that was scanned for local skills. */
+    localPath: string;
+}
+//# sourceMappingURL=skills.d.ts.map

package/dist/shared/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../shared/skills.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,mDAAmD;IACnD,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/shared/skills.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/slack-manifest.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const CURRENT_SLACK_MANIFEST_VERSION = 1;
+export interface AgentSlackManifestUpdateInfo {
+    agentVersion: number;
+    appManifestUrl?: string;
+    currentVersion: number;
+    manifestUpdateYaml: string;
+    needsUpdate: boolean;
+    reinstallUrl?: string;
+}
+export declare const AgentSlackManifestUpgradeRequest: z.ZodObject<{
+    botToken: z.ZodString;
+}, z.core.$strict>;
+export type AgentSlackManifestUpgradeRequest = z.infer<typeof AgentSlackManifestUpgradeRequest>;
+//# sourceMappingURL=slack-manifest.d.ts.map

package/dist/shared/slack-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-manifest.d.ts","sourceRoot":"","sources":["../../shared/slack-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,gCAAgC;;kBAIlC,CAAC;AAEZ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/shared/slack-manifest.js

@@ -0,0 +1,8 @@
+// Slack app manifest migration contract shared by server and web.
+import { z } from 'zod';
+export const CURRENT_SLACK_MANIFEST_VERSION = 1;
+export const AgentSlackManifestUpgradeRequest = z.object({
+    botToken: z.string().trim().min(1).refine((value) => value.startsWith('xoxb-'), {
+        message: 'botToken must start with xoxb-',
+    }),
+}).strict();

package/dist/shared/snapshot.d.ts

@@ -0,0 +1,47 @@
+export interface ProviderSessionRecord {
+    id: string;
+    kind: string;
+    updatedAt: string;
+}
+export interface ArchivedProviderSessionRecord extends ProviderSessionRecord {
+    archivedAt: string;
+    archivedBy: 'operator';
+    kind: string;
+    note?: string;
+}
+export interface AgentStatusSummary {
+    agentId: string;
+    currentItemStartedAt?: string;
+    currentItemId?: string;
+    queueDepth: number;
+    itemCount: number;
+}
+export interface AgentSessionSummary {
+    archived?: ArchivedProviderSessionRecord[];
+    createdAt: string;
+    currentStartedAt?: string;
+    latestProviderStats?: ProviderSessionStatsSummary;
+    lifetimeTokens?: number;
+    current?: ProviderSessionRecord;
+    updatedAt: string;
+}
+export interface ProviderSessionStatsSummary {
+    activityId: string;
+    autoCompactWindow?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+    contextWindow?: number;
+    createdAt: string;
+    currentContextTokens?: number;
+    inputTokens?: number;
+    model?: string;
+    outputTokens?: number;
+    runtimeKind?: string;
+    serviceTier?: string;
+    sessionCompactionCount?: number;
+    sessionTokenUsage?: number;
+    terminalReason?: string;
+    totalTokens?: number;
+    usedTokens?: number;
+}
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/shared/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../shared/snapshot.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,6BAA6B,EAAE,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,2BAA2B,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,2BAA2B;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/shared/snapshot.js

@@ -0,0 +1,2 @@
+// API contract types for the web snapshot and agent activity view. Consumed by server and web.
+export {};

package/dist/shared/url-routes.d.ts

@@ -0,0 +1,70 @@
+export type AgentTab = 'activity' | 'profile' | 'reminders';
+export declare const AGENT_TABS: readonly AgentTab[];
+export declare const DEFAULT_TAB: AgentTab;
+export interface UrlLocation {
+    agentId: string | null;
+    tab: AgentTab | null;
+}
+/**
+ * Parse `/`, `/agents/<id>`, `/agents/<id>/<tab>` into URL state.
+ * - Bare `/` → both null.
+ * - `/agents/<id>` → tab null (AgentBootstrap will replaceState to `activity`).
+ * - Unknown tab → null (validation layer will normalize).
+ * - Anything else (trailing slashes, extra segments) → null/null (treated as `/`).
+ */
+export declare function parseLocation(pathname: string): UrlLocation;
+export declare function buildPath(loc: {
+    agentId: string | null;
+    tab: AgentTab | null;
+}): string;
+export interface KbLocation {
+    id: string | null;
+    filePath: string | null;
+}
+/**
+ * Parse a kb browse path into `{ id, filePath }`, or `null` for any
+ * non-kb path (so the caller falls back to agent routing).
+ */
+export declare function parseKbPath(pathname: string): KbLocation | null;
+export declare function buildKbPath(loc: KbLocation): string;
+/**
+ * Build the backend raw-bytes URL for a tracked file (iframe / img / asset
+ * target). Per-segment encoding keeps `/` literal as path separators, matching
+ * the server's decode of the `<id>/<filePath>` tail.
+ */
+export declare function buildKbRawPath(id: string, filePath: string): string;
+/**
+ * Inputs `reconcileLocation` needs from the current web state. We accept a
+ * minimal shape so the function is trivially testable without constructing the
+ * full route context.
+ */
+export interface ReconcileSnapshot {
+    agents: ReadonlyArray<{
+        id: string;
+        slack?: {
+            connected?: boolean;
+        };
+    }>;
+    agentStatuses: ReadonlyArray<{
+        agentId: string;
+        currentItemId?: string;
+        queueDepth: number;
+    }>;
+    selectedAgentId?: string;
+}
+/**
+ * Decide whether the current URL state needs a replaceState canonicalization.
+ * Returns the desired target, or `null` when no change is needed.
+ *
+ *   - Unknown agentId              → reset to `/` (next pass re-picks).
+ *   - No agentId in URL            → pick most-recently-active / selected / first.
+ *   - Valid agentId, no tab        → fill in DEFAULT_TAB (or 'profile' if not-connected).
+ *   - Otherwise                    → no-op.
+ *
+ * Sidebar/mobile-nav clicks navigate to `/agents/:id` (no tab), so this
+ * function handles the default-tab selection. Explicit tab clicks from the
+ * header nav set a specific tab and are NOT overridden here — a not-connected
+ * agent can visit Activity and see the empty state.
+ */
+export declare function reconcileLocation(snapshot: ReconcileSnapshot, current: UrlLocation): UrlLocation | null;
+//# sourceMappingURL=url-routes.d.ts.map

package/dist/shared/url-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-routes.d.ts","sourceRoot":"","sources":["../../shared/url-routes.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,CAAC;AAE5D,eAAO,MAAM,UAAU,EAAE,SAAS,QAAQ,EAAkD,CAAC;AAC7F,eAAO,MAAM,WAAW,EAAE,QAAqB,CAAC;AAEhD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAgB3D;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAA;CAAE,GAAG,MAAM,CAIvF;AAeD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAUD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAU/D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAMnD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAInE;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAGhC,MAAM,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE;YAAE,SAAS,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;IACvE,aAAa,EAAE,aAAa,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9F,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,WAAW,GACnB,WAAW,GAAG,IAAI,CAqCpB"}