@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/plugin-install-restart.d.ts

@@ -0,0 +1,13 @@
+export type PluginInstallRestartResult = "restarted" | "declined" | "not-running";
+export interface PluginInstallRestartOptions {
+    restart: boolean;
+    interactive: boolean;
+}
+export interface PluginInstallRestartDeps {
+    isDaemonOnline(): boolean;
+    confirmRestart(): Promise<boolean>;
+    restartDaemon(): number;
+    log(message: string): void;
+}
+/** Apply an installed plugin immediately without unexpectedly starting a stopped daemon. */
+export declare function restartAfterPluginInstall(options: PluginInstallRestartOptions, deps: PluginInstallRestartDeps): Promise<PluginInstallRestartResult>;

package/dist/plugin-install-restart.js

@@ -0,0 +1,24 @@
+/** Apply an installed plugin immediately without unexpectedly starting a stopped daemon. */
+export async function restartAfterPluginInstall(options, deps) {
+    if (!options.interactive && !options.restart) {
+        deps.log("Rynx was not restarted in non-interactive mode. Pass `--restart` to apply the plugin immediately.");
+        return "declined";
+    }
+    if (!deps.isDaemonOnline()) {
+        deps.log("Rynx is not running under PM2; the plugin will load when its owning service next starts or restarts.");
+        return "not-running";
+    }
+    const shouldRestart = options.restart
+        ? true
+        : options.interactive
+            ? await deps.confirmRestart()
+            : false;
+    if (!shouldRestart) {
+        deps.log("Rynx restart skipped. Run `rynx restart` when you are ready to apply the plugin.");
+        return "declined";
+    }
+    if (deps.restartDaemon() !== 0) {
+        throw new Error("Plugin installed, but Rynx failed to restart. Run `rynx restart` manually.");
+    }
+    return "restarted";
+}

package/dist/plugin-installer.d.ts

@@ -1,27 +1,48 @@
+import { type PluginCapability, type PluginManifestV1 } from "@rynx-ai/plugin-sdk";
 import { type PluginRecord, type PluginSource } from "./plugin-store.js";
+import { type PluginPackageMaterializer } from "./plugin-package.js";
 export interface InstallResult {
     name: string;
     source: PluginSource;
     version?: string;
-    /** True when an existing same-named plugin was kept (user declined to overwrite). */
+    /** True when an existing same-named plugin was kept. */
     skipped?: boolean;
 }
+export interface InstallPluginOptions {
+    signal?: AbortSignal;
+    onConflict?: (existing: PluginRecord) => boolean | Promise<boolean>;
+    /** Pre-approved subset for non-interactive/programmatic callers. */
+    grants?: readonly PluginCapability[];
+    /** Resolve the approved subset after static inspection and before promotion. */
+    approveCapabilities?: (manifest: PluginManifestV1, existing: PluginRecord | undefined) => readonly PluginCapability[] | Promise<readonly PluginCapability[]>;
+    /** Dependency injection for offline tests and alternate package fetchers. */
+    materializer?: PluginPackageMaterializer;
+    /** Require the inspected manifest to retain this id (used by update). */
+    expectedId?: string;
+    /** Explicitly allow package/dependency lifecycle build scripts in staging. */
+    allowScripts?: boolean;
+}
 /**
- * Install (or re-install) a plugin from an npm spec or a local directory.
- *  - **local**: copy the package (minus `node_modules`) into `~/.rynx/plugins/<name>`
- *    and load it there. The plugin must be self-contained — it bundles its deps at
- *    build time (incl. the unpublished workspace `@rynx-ai/core`) and declares a
- *    `rynx.plugin` entry; the daemon installs nothing.
- *  - **npm**: `npm install` into `~/.rynx/plugins` (deps resolved by npm).
+ * Install or replace one arbitrary npm/local/git/URL plugin package.
  *
- * `onConflict` is consulted when a plugin of the same `name` already exists; if it
- * returns false the install is aborted with `{ skipped: true }` (nothing changes).
- * `onProgress` streams human-readable lines.
+ * A failed validation, materialization, atomic move, or registry update leaves
+ * the previously registered installation untouched.
+ */
+export declare function installPlugin(spec: string, onProgress?: (line: string) => void, opts?: InstallPluginOptions): Promise<InstallResult>;
+/**
+ * Remove the registry row but retain the immutable package until the next
+ * daemon boot. A currently running supervisor may still be executing it.
  */
-export declare function installPlugin(spec: string, onProgress?: (line: string) => void, opts?: {
-    signal?: AbortSignal;
-    onConflict?: (existing: PluginRecord) => boolean | Promise<boolean>;
-}): Promise<InstallResult>;
-/** Uninstall a plugin: drop its record, npm-uninstall if applicable, refresh catalog. */
 export declare function uninstallPlugin(name: string, onProgress?: (line: string) => void): Promise<boolean>;
+/**
+ * Delete inactive immutable versions at a daemon-start safe point.
+ *
+ * A short grace window prevents a concurrently materializing install (renamed
+ * just before its registry transaction) from being mistaken for an orphan.
+ */
+export declare function pruneInactivePluginInstallations({ minAgeMs, stagingMinAgeMs, now, }?: {
+    minAgeMs?: number;
+    stagingMinAgeMs?: number;
+    now?: number;
+}): string[];
 export type { PluginRecord };