@meetquinn/animactl 0.1.2 → 0.1.3

package/dist/server/runtime/runtime-worker.js

@@ -5,16 +5,13 @@ import { isRestartDrainActive } from '../services/restart-drain.js';
 import { AgentRuntimeBridge } from './runtime-bridge.js';
 import { runtimeContextForItemId } from './context.js';
 import { clearActiveRuntimeItem, setActiveRuntimeItem } from './active-item.js';
-import { recordRuntimeAborted, recordRuntimeActivity, recordRuntimeEvent, recordRuntimeFollowupAppended, recordRuntimeFollowupFailed, recordRuntimePending, } from './activity.js';
-import { runtimeErrorPayload } from './activity-text.js';
+import { recordRuntimeAborted, recordRuntimeEvent, } from './activity.js';
+import { startActiveRunControl } from './active-run-control.js';
+import { appendQueuedFollowupsUntilFinished } from './followup-appender.js';
+import { recordFinalRuntimeFailure, runProviderWithCrashRetries } from './provider-runner.js';
 // Executor for one agent: claims queued inbox items, runs the provider runtime,
 // appends follow-up items into the active run, and settles item lifecycle state.
 const IDLE_TIMEOUT_MS_DEFAULT = PROVIDER_IDLE_TIMEOUT_MS_DEFAULT;
-const IDLE_CHECK_INTERVAL_FLOOR_MS = 50;
-const IDLE_CHECK_INTERVAL_CAP_MS = 1_000;
-const FOLLOWUP_POLL_MS = 100;
-const PROVIDER_CRASH_MAX_RETRIES = 3;
-const PROVIDER_CRASH_RETRY_BACKOFF_MS = 500;
 export class AgentRuntimeWorker {
     options;
     logger;
@@ -120,7 +117,23 @@ export class AgentRuntimeWorker {
         let followupError;
         try {
             context = await runtimeContextForItemId(item.id, this.options);
-            followupLoop = this.appendQueuedFollowupsUntilFinished(context, itemAbort.signal, handle).catch((error) => {
+            const activeContext = context;
+            followupLoop = appendQueuedFollowupsUntilFinished({
+                activeContext,
+                agentRuntime: this.options.agentRuntime,
+                itemDone: itemAbort.signal,
+                logger: this.logger,
+                onFollowupAccepted: () => handle.noteActivity(),
+                onFollowupAppended: async (followupContext, _text) => {
+                    handle.appendedFollowups.push(followupContext);
+                    await this.notifyItemFollowupAppended(activeContext, followupContext);
+                },
+                onFollowupSettled: (followupContext) => this.notifySettledItems([followupContext]),
+                queue: this.queue,
+                runtimeBridge: this.runtimeBridge,
+                runtimeConfig: this.options,
+                workerId: this.workerId,
+            }).catch((error) => {
                 followupError = error;
             });
             const agentConfig = await defaultAgentRegistryService.serviceFor(this.options.agentId).getConfig();
@@ -131,17 +144,28 @@ export class AgentRuntimeWorker {
                 workerId: this.workerId,
             });
             await this.notifyItemStarted(context);
-            const result = await this.runProviderWithCrashRetries({
-                context,
-                handle,
+            if (context.item.handling.resumeReason === 'runtime_restart') {
+                await this.recordRestartResumeActivity(context);
+            }
+            const runContext = context;
+            const result = await runProviderWithCrashRetries({
+                agentId: this.options.agentId,
+                agentRuntime: this.options.agentRuntime,
+                buildInput: (retryNotice) => this.runtimeBridge.runInput({
+                    context: runContext,
+                    onActivity: () => handle.noteActivity(),
+                    profile: {
+                        displayName: agentConfig.profile?.displayName ?? this.options.agentId,
+                        ...(agentConfig.profile?.role ? { role: agentConfig.profile.role } : {}),
+                    },
+                    retryNotice,
+                    session: runContext.session,
+                    signal: itemAbort.signal,
+                    suppressFailureRecord: true,
+                }),
                 onFinalFailureRecorded: () => {
                     runtimeFailureRecorded = true;
                 },
-                profile: {
-                    displayName: agentConfig.profile?.displayName ?? this.options.agentId,
-                    ...(agentConfig.profile?.role ? { role: agentConfig.profile.role } : {}),
-                },
-                session: context.session,
                 signal: itemAbort.signal,
             });
             itemAbort.abort('completed');
@@ -171,7 +195,12 @@ export class AgentRuntimeWorker {
                 itemSettled = true;
             }
             else if (context && !runtimeFailureRecorded) {
-                await this.recordFinalRuntimeFailure(error, 0);
+                await recordFinalRuntimeFailure({
+                    agentId: this.options.agentId,
+                    agentRuntime: this.options.agentRuntime,
+                    error,
+                    retryAttempts: 0,
+                });
             }
             if (!itemSettled)
                 await this.queue.fail(item.id);
@@ -201,209 +230,31 @@ export class AgentRuntimeWorker {
         }
     }
     registerActiveItem(itemId, abortController) {
-        const startedAt = Date.now();
-        const tickInterval = Math.max(IDLE_CHECK_INTERVAL_FLOOR_MS, Math.min(IDLE_CHECK_INTERVAL_CAP_MS, Math.floor(this.idleTimeoutMs / 2)));
-        const handle = {
+        const handle = startActiveRunControl({
             abortController,
-            appendedFollowups: [],
-            drainRequestInFlight: false,
-            lastActivityAt: startedAt,
-            startedAt,
-            watchdog: setInterval(() => {
-                if (abortController.signal.aborted)
-                    return;
-                const now = Date.now();
-                if (now - handle.lastActivityAt >= this.idleTimeoutMs) {
-                    abortController.abort('idle_timeout');
-                    return;
-                }
-                void this.checkExternalRequests(itemId, abortController, handle);
-            }, tickInterval),
-        };
+            agentRuntime: this.options.agentRuntime,
+            idleTimeoutMs: this.idleTimeoutMs,
+            itemId,
+            logger: this.logger,
+            queue: this.queue,
+        });
         this.activeItem = handle;
         return handle;
     }
-    noteProviderActivity(handle) {
-        handle.lastActivityAt = Date.now();
-    }
-    async runProviderWithCrashRetries(input) {
-        let retryCount = 0;
-        let previousError;
-        for (;;) {
-            try {
-                return await this.options.agentRuntime.run(await this.runtimeBridge.runInput({
-                    context: input.context,
-                    onActivity: () => this.noteProviderActivity(input.handle),
-                    profile: input.profile,
-                    retryNotice: retryCount > 0
-                        ? providerCrashRetryPrompt({
-                            attempt: retryCount,
-                            maxRetries: PROVIDER_CRASH_MAX_RETRIES,
-                            previousError: errorMessage(previousError),
-                        })
-                        : undefined,
-                    session: input.session,
-                    signal: input.signal,
-                    suppressFailureRecord: true,
-                }));
-            }
-            catch (error) {
-                previousError = error;
-                if (input.signal.aborted)
-                    throw error;
-                if (!isProviderCrashError(error) || retryCount >= PROVIDER_CRASH_MAX_RETRIES) {
-                    await this.recordFinalRuntimeFailure(error, retryCount, { providerFailure: true });
-                    input.onFinalFailureRecorded();
-                    throw error;
-                }
-                retryCount += 1;
-                const retryAfterMs = PROVIDER_CRASH_RETRY_BACKOFF_MS * retryCount;
-                await recordRuntimeEvent({ agentId: this.options.agentId }, this.options.agentRuntime.kind, this.options.agentRuntime.env, {
-                    attempt: retryCount,
-                    error: errorMessage(error),
-                    eventType: 'provider.crash.retry',
-                    maxRetries: PROVIDER_CRASH_MAX_RETRIES,
-                    retryAfterMs,
-                });
-                await this.options.agentRuntime.close?.();
-                await sleep(retryAfterMs, input.signal);
-            }
-        }
-    }
-    async recordFinalRuntimeFailure(error, retryAttempts, options = {}) {
-        const processCrash = isProviderCrashError(error);
-        await recordRuntimeActivity({ agentId: this.options.agentId }, this.options.agentRuntime.kind, 'runtime.failed', {
-            ...runtimeErrorPayload(error),
-            ...(options.providerFailure
-                ? {
-                    failureSource: 'provider',
-                    maxRetries: PROVIDER_CRASH_MAX_RETRIES,
-                    providerReason: processCrash ? 'process_crash' : 'provider_error',
-                    retryAttempts,
-                    retryable: processCrash && retryAttempts < PROVIDER_CRASH_MAX_RETRIES,
-                }
-                : {}),
+    async recordRestartResumeActivity(context) {
+        await recordRuntimeEvent({ agentId: this.options.agentId }, this.options.agentRuntime.kind, this.options.agentRuntime.env, {
+            eventType: 'runtime.restart_resumed',
+            itemId: context.item.id,
+            message: 'Resumed after restart',
         });
     }
-    async checkExternalRequests(itemId, abortController, handle) {
-        try {
-            const item = await this.queue.find(itemId);
-            if (item?.handling.stopRequestedAt && !abortController.signal.aborted) {
-                abortController.abort('user_stop');
-                return;
-            }
-            const drainRequestedAt = item?.handling.drainRequestedAt;
-            if (drainRequestedAt &&
-                !handle.drainRequestInFlight &&
-                handle.drainRequestedAt !== drainRequestedAt &&
-                !abortController.signal.aborted) {
-                handle.drainRequestInFlight = true;
-                handle.drainRequestedAt = drainRequestedAt;
-                void this.drainActiveItem(itemId, item.handling.drainTimeoutMs, abortController, handle);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Runtime worker control check failed for item ${itemId}: ${errorMessage(error)}`);
-        }
-    }
-    async drainActiveItem(itemId, timeoutMs, abortController, handle) {
-        try {
-            if (!this.options.agentRuntime.requestDrain)
-                return;
-            await withTimeout(this.options.agentRuntime.requestDrain({ activeItemId: itemId, signal: abortController.signal }), timeoutMs ?? 15_000, `Timed out waiting for item ${itemId} to reach a restart drain point`);
-            const current = await this.queue.find(itemId);
-            if (current?.handling.drainRequestedAt !== handle.drainRequestedAt)
-                return;
-            if (!abortController.signal.aborted)
-                abortController.abort('restart_drain');
-        }
-        catch (error) {
-            this.logger.error(`Runtime worker drain request failed for item ${itemId}: ${errorMessage(error)}`);
-        }
-        finally {
-            handle.drainRequestInFlight = false;
-        }
-    }
     releaseActiveItem() {
         const handle = this.activeItem;
         if (!handle)
             return;
-        clearInterval(handle.watchdog);
+        handle.release();
         this.activeItem = undefined;
     }
-    async appendQueuedFollowupsUntilFinished(activeContext, itemDone, handle) {
-        const skippedItemIds = new Set();
-        while (!itemDone.aborted) {
-            if (await isRestartDrainActive()) {
-                await sleep(FOLLOWUP_POLL_MS, itemDone);
-                continue;
-            }
-            const item = await this.queue.claimNextFollowup({
-                activeItemId: activeContext.item.id,
-                excludedItemIds: skippedItemIds,
-                workerId: this.workerId,
-            });
-            if (!item) {
-                await sleep(FOLLOWUP_POLL_MS, itemDone);
-                continue;
-            }
-            await this.tryOneFollowupItem(activeContext, item, handle, itemDone, skippedItemIds);
-        }
-    }
-    async tryOneFollowupItem(activeContext, item, handle, itemDone, skippedItemIds) {
-        let appended = false;
-        let context;
-        try {
-            context = await runtimeContextForItemId(item.id, this.options);
-            const followup = await appendRuntimeFollowup({
-                activeContext,
-                agentRuntime: this.options.agentRuntime,
-                context,
-                runtimeBridge: this.runtimeBridge,
-            });
-            if (followup.status === 'appended') {
-                await this.recordFollowupAppendSuccess(activeContext, context, followup.text, handle);
-                appended = true;
-                return;
-            }
-            await this.recordFollowupAppendSkip(activeContext, item, followup);
-            skippedItemIds.add(item.id);
-            await this.queue.requeue(item.id);
-            await sleep(FOLLOWUP_POLL_MS, itemDone);
-        }
-        catch (error) {
-            skippedItemIds.add(item.id);
-            await this.queue.requeue(item.id);
-            await recordRuntimeFollowupFailed({ agentId: this.options.agentId }, {
-                activeItemId: activeContext.item.id,
-                agentRuntime: this.options.agentRuntime.kind,
-                error: errorMessage(error),
-                reason: 'followup_failed',
-            });
-            this.logger.error(`Runtime worker follow-up append failed for item ${item.id}: ${errorMessage(error)}`);
-            await sleep(FOLLOWUP_POLL_MS, itemDone);
-        }
-        finally {
-            const current = context && !appended ? await this.queue.find(context.item.id).catch(() => undefined) : undefined;
-            if (context && (current?.handling.status === 'completed' || current?.handling.status === 'failed')) {
-                await this.notifySettledItems([context]);
-            }
-        }
-    }
-    async recordFollowupAppendSuccess(activeContext, context, text, handle) {
-        this.noteProviderActivity(handle);
-        await this.queue.complete(context.item.id);
-        handle.appendedFollowups.push(context);
-        await this.notifyItemFollowupAppended(activeContext, context);
-        this.logger.log(JSON.stringify({
-            activeItemId: activeContext.item.id,
-            agentRuntime: this.options.agentRuntime.kind,
-            event: 'runtime.followup_appended',
-            itemId: context.item.id,
-            text,
-            workerId: this.workerId,
-        }, null, 2));
-    }
     async notifyItemStarted(context) {
         try {
             await this.options.onItemStarted?.(context);
@@ -430,22 +281,10 @@ export class AgentRuntimeWorker {
             }
         }
     }
-    async recordFollowupAppendSkip(activeContext, item, followup) {
-        if (followup.status === 'rejected') {
-            await recordRuntimePending({ agentId: this.options.agentId }, {
-                activeItemId: activeContext.item.id,
-                agentRuntime: this.options.agentRuntime.kind,
-                reason: 'followup_rejected',
-            });
-        }
-        if (followup.status === 'failed') {
-            this.logger.error(`Runtime worker follow-up append failed for item ${item.id}: ${followup.error}`);
-        }
-    }
     async settleAbortedItem(context, abortReason) {
         await recordRuntimeAborted({ agentId: this.options.agentId }, abortReason, abortReason === 'idle_timeout' ? { timeoutMs: this.idleTimeoutMs } : undefined);
         if (abortReason === 'restart_drain') {
-            await this.queue.requeue(context.item.id);
+            await this.queue.requeue(context.item.id, { resumeReason: 'runtime_restart' });
             return;
         }
         await this.queue.fail(context.item.id);
@@ -460,32 +299,6 @@ function abortReasonOf(signal) {
         ? reason
         : undefined;
 }
-async function appendRuntimeFollowup(input) {
-    try {
-        const result = await input.agentRuntime.appendToActiveRun(await input.runtimeBridge.followupInput({
-            activeContext: input.activeContext,
-            context: input.context,
-        }));
-        if (!result.accepted)
-            return { status: 'rejected' };
-        await recordRuntimeFollowupAppended({ agentId: input.context.agentId }, {
-            activeItemId: input.activeContext.item.id,
-            agentRuntime: input.agentRuntime.kind,
-            text: result.text,
-        });
-        return { status: 'appended', text: result.text };
-    }
-    catch (error) {
-        const message = errorMessage(error);
-        await recordRuntimeFollowupFailed({ agentId: input.context.agentId }, {
-            activeItemId: input.activeContext.item.id,
-            agentRuntime: input.agentRuntime.kind,
-            error: message,
-            reason: 'followup_failed',
-        });
-        return { error: message, status: 'failed' };
-    }
-}
 function isWorkerAlive(workerId) {
     const pidText = workerId.split(':').at(-1);
     const pid = pidText ? Number.parseInt(pidText, 10) : Number.NaN;
@@ -499,42 +312,3 @@ function isWorkerAlive(workerId) {
         return false;
     }
 }
-function isProviderCrashError(error) {
-    const message = errorMessage(error);
-    return (/runtime exited before completing/i.test(message) ||
-        /runtime terminated by/i.test(message) ||
-        /runtime exited with code/i.test(message) ||
-        /stdin is closed/i.test(message));
-}
-function providerCrashRetryPrompt(input) {
-    return [
-        'Anima system note: the previous provider process crashed before completing this same item.',
-        `This is retry ${input.attempt}/${input.maxRetries}.`,
-        `Previous error: ${input.previousError}`,
-        'Continue the original task from the current files, conversation, and Slack state.',
-        'Do not repeat completed external side effects such as Slack messages, file sends, or file edits; inspect state first if needed.',
-    ].join('\n');
-}
-function sleep(ms, signal) {
-    if (signal.aborted)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const done = () => {
-            clearTimeout(timer);
-            signal.removeEventListener('abort', done);
-            resolve();
-        };
-        const timer = setTimeout(done, ms);
-        signal.addEventListener('abort', done, { once: true });
-    });
-}
-function withTimeout(promise, timeoutMs, message) {
-    let timer;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-    });
-    return Promise.race([promise, timeout]).finally(() => {
-        if (timer)
-            clearTimeout(timer);
-    });
-}

package/dist/server/runtime-management/managed-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-runtime.d.ts","sourceRoot":"","sources":["../../../server/runtime-management/managed-runtime.ts"],"names":[],"mappings":"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"}

package/dist/server/runtime-management/runtime-release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-release.d.ts","sourceRoot":"","sources":["../../../server/runtime-management/runtime-release.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAKrG,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;CACb,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEtB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAExE;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,MAAM,CAAC,CAsBlB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAQjF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAmB1E"}

package/dist/server/{runtime → runtime-management}/runtime-upgrade.d.ts

@@ -51,6 +51,7 @@ export declare class RuntimeUpgradeService {
     private readonly settings;
     constructor(options?: RuntimeUpgradeServiceOptions);
     status(): Promise<RuntimeUpgradeStatusResponse>;
+    checkNow(): Promise<RuntimeUpgradeStatusResponse>;
     prepareApply(input: {
         animactlScript: string;
         dashboardHost?: string;

package/dist/server/runtime-management/runtime-upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-upgrade.d.ts","sourceRoot":"","sources":["../../../server/runtime-management/runtime-upgrade.ts"],"names":[],"mappings":"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"}

package/dist/server/{runtime → runtime-management}/runtime-upgrade.js

@@ -74,6 +74,20 @@ export class RuntimeUpgradeService {
             updateAvailable,
         };
     }
+    async checkNow() {
+        const [currentVersion, releaseTrack, operation] = await Promise.all([
+            this.packageVersion(),
+            this.settings.getReleaseTrack(),
+            this.operationStore.read(),
+        ]);
+        const refreshed = await this.refreshCheckCache(releaseTrack);
+        return this.statusFromCheck({
+            check: refreshed,
+            currentVersion,
+            operation,
+            releaseTrack,
+        });
+    }
     async prepareApply(input) {
         const [currentVersion, releaseTrack, operation] = await Promise.all([
             this.packageVersion(),

package/dist/server/services/system.service.d.ts

@@ -0,0 +1,41 @@
+import { type ServerSettingsService } from '../settings/settings.service.js';
+import type { ServerInfo, ServicesRestartResponse } from '../../shared/server-info.js';
+import { type ProviderAvailability } from '../../shared/provider-catalog.js';
+export interface PreparedServicesRestart {
+    response: ServicesRestartResponse;
+    spawn: () => Promise<void>;
+}
+export interface SystemServiceOptions {
+    animactlScript?: string;
+    commandPresent?: (command: string) => Promise<boolean>;
+    commit?: Promise<string | undefined> | string;
+    now?: () => Date;
+    packageVersion?: () => Promise<string>;
+    projectRoot?: string;
+    restartDelayMs?: number;
+    settings?: ServerSettingsService;
+    startedAt?: string;
+}
+export declare class SystemServiceError extends Error {
+}
+export declare class SystemService {
+    private readonly animactlScript;
+    private readonly commandPresent;
+    private readonly commit;
+    private readonly now;
+    private readonly packageVersion;
+    private readonly projectRoot;
+    private readonly restartDelayMs;
+    private readonly settings;
+    private readonly startedAt;
+    constructor(options?: SystemServiceOptions);
+    providerAvailability(): Promise<{
+        providers: ProviderAvailability[];
+    }>;
+    serverInfo(): Promise<ServerInfo>;
+    serverStartedAt(): string;
+    prepareServicesRestart(): PreparedServicesRestart;
+}
+export declare const defaultSystemService: SystemService;
+export declare function docsUrl(track: 'dev' | 'canary' | 'stable'): string;
+//# sourceMappingURL=system.service.d.ts.map

package/dist/server/services/system.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.service.d.ts","sourceRoot":"","sources":["../../../server/services/system.service.ts"],"names":[],"mappings":"AAQA,OAAO,EAAgC,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAO3G,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAoB,KAAK,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAM/F,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC;IAC9C,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;CAAG;AAEhD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;IACvE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,GAAE,oBAAyB;IAYxC,oBAAoB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,oBAAoB,EAAE,CAAA;KAAE,CAAC;IAStE,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAuBvC,eAAe,IAAI,MAAM;IAIzB,sBAAsB,IAAI,uBAAuB;CAyBlD;AAED,eAAO,MAAM,oBAAoB,eAAsB,CAAC;AAsDxD,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAKlE"}

package/dist/server/services/system.service.js

@@ -0,0 +1,154 @@
+import { execFile, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, open, readFile, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { resolveAnimaHome } from '../anima-home.js';
+import { defaultServerSettingsService } from '../settings/settings.service.js';
+import { cleanServiceEnv } from './env.js';
+import { readLastServicesRestart, servicesRestartLogPath, servicesRestartResultPath, } from './restart-result.js';
+import { PROVIDER_CATALOG } from '../../shared/provider-catalog.js';
+const execFileAsync = promisify(execFile);
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../../..');
+const RESTART_AFTER_RESPONSE_DELAY_MS = 250;
+export class SystemServiceError extends Error {
+}
+export class SystemService {
+    animactlScript;
+    commandPresent;
+    commit;
+    now;
+    packageVersion;
+    projectRoot;
+    restartDelayMs;
+    settings;
+    startedAt;
+    constructor(options = {}) {
+        this.projectRoot = options.projectRoot ?? PROJECT_ROOT;
+        this.animactlScript = options.animactlScript ?? join(this.projectRoot, 'dist/server/cli/animactl.js');
+        this.commandPresent = options.commandPresent ?? commandPresent;
+        this.commit = Promise.resolve(options.commit ?? gitShortCommit(this.projectRoot));
+        this.now = options.now ?? (() => new Date());
+        this.packageVersion = options.packageVersion ?? (() => packageVersion(this.projectRoot));
+        this.restartDelayMs = options.restartDelayMs ?? RESTART_AFTER_RESPONSE_DELAY_MS;
+        this.settings = options.settings ?? defaultServerSettingsService;
+        this.startedAt = options.startedAt ?? this.now().toISOString();
+    }
+    async providerAvailability() {
+        return {
+            providers: await Promise.all(PROVIDER_CATALOG.map(async (entry) => ({
+                kind: entry.kind,
+                present: await this.commandPresent(entry.command),
+            }))),
+        };
+    }
+    async serverInfo() {
+        const animaHome = resolveAnimaHome();
+        const [config, version, commit, lastRestart] = await Promise.all([
+            this.settings.readConfig(),
+            this.packageVersion(),
+            this.commit,
+            readLastServicesRestart(animaHome),
+        ]);
+        const track = config.track ?? config.releaseTrack ?? 'stable';
+        return {
+            animaHome,
+            ...(commit ? { commit } : {}),
+            dashboardPort: config.dashboardPort ?? 4174,
+            docsUrl: docsUrl(track),
+            ...(lastRestart ? { lastRestart } : {}),
+            ok: true,
+            startedAt: this.startedAt,
+            track,
+            uptimeSeconds: Math.max(0, Math.floor((this.now().getTime() - Date.parse(this.startedAt)) / 1000)),
+            version,
+        };
+    }
+    serverStartedAt() {
+        return this.startedAt;
+    }
+    prepareServicesRestart() {
+        if (!existsSync(this.animactlScript)) {
+            throw new SystemServiceError(`animactl not found: ${this.animactlScript}`);
+        }
+        const animaHome = resolveAnimaHome();
+        const logPath = servicesRestartLogPath(animaHome);
+        const resultPath = servicesRestartResultPath(animaHome);
+        return {
+            response: {
+                ok: true,
+                animaHome,
+                delayMs: this.restartDelayMs,
+                logPath,
+                scheduled: true,
+            },
+            spawn: () => restartServicesDetached({
+                animaHome,
+                animactlScript: this.animactlScript,
+                logPath,
+                now: this.now,
+                projectRoot: this.projectRoot,
+                resultPath,
+            }),
+        };
+    }
+}
+export const defaultSystemService = new SystemService();
+async function restartServicesDetached(input) {
+    let log;
+    try {
+        await mkdir(dirname(input.logPath), { recursive: true });
+        await rm(input.resultPath, { force: true });
+        log = await open(input.logPath, 'a');
+        await log.write(`\n[${input.now().toISOString()}] web app requested services restart\n`);
+    }
+    catch (error) {
+        console.error(`Failed to open restart log ${input.logPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const child = spawn(process.execPath, [input.animactlScript, 'services', 'restart', '--drain-active', '--resume-running'], {
+        cwd: input.projectRoot,
+        detached: true,
+        env: { ...cleanServiceEnv(), ANIMA_HOME: input.animaHome, ANIMA_RESTART_RESULT_FILE: input.resultPath },
+        stdio: log ? ['ignore', log.fd, log.fd] : 'ignore',
+    });
+    child.on('error', (error) => {
+        console.error(`Failed to start services restart: ${error.message}`);
+    });
+    child.unref();
+    await log?.close();
+}
+async function packageVersion(projectRoot) {
+    try {
+        const pkg = JSON.parse(await readFile(join(projectRoot, 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' && pkg.version ? pkg.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+async function gitShortCommit(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--short', 'HEAD'], { cwd: projectRoot });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function docsUrl(track) {
+    const configured = process.env.ANIMA_DOCS_URL?.trim();
+    if (configured)
+        return configured;
+    if (track === 'dev')
+        return 'http://127.0.0.1:14175/';
+    return 'https://anima.meetquinn.ai/';
+}
+function commandPresent(command) {
+    return new Promise((resolvePresent) => {
+        const child = execFile(command, ['--version'], { encoding: 'utf8', timeout: 2_000 }, (error) => {
+            resolvePresent(!error);
+        });
+        child.stdin?.end();
+    });
+}