@hoardodile/host 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -685,6 +685,18 @@ type PluginHooks = {
      * shape-validated (hex values, per-resource cap).
      */
     readonly runImageHashes: (api: ResourceAPI, pluginId: PluginManifestId) => Promise<ImageHashesResult | undefined>;
+    /**
+     * Run the plugin's optional `onInstall` hook — best-effort, invoked
+     * by the host after a successful install/update commit (marketplace
+     * install/update or a zip upload; never seed/dev plugins). The hook
+     * receives an install-scoped {@link ResourceAPI}: no resource is
+     * attached (the file surface answers empty, `context.detect` is
+     * `undefined`), while the asset methods still work and stay gated by
+     * the shared consent dialog. A throwing (or consent-denied) hook is
+     * logged via `hookFailureText` and swallowed — the install itself is
+     * never failed; plugins must re-check at runtime.
+     */
+    readonly runInstallHook: (pluginId: PluginManifestId) => Promise<void>;
 };
 declare function createPluginHooks(deps: PluginHooksDeps): PluginHooks;
 

package/dist/index.js

@@ -2298,6 +2298,59 @@ function parseManifest(dirPath, dirName) {
   }
   return result.data;
 }
+function createInstallScopeApi() {
+  const noResource = (method) => new Error(
+    `${method}() \u2014 no resource is attached to the onInstall hook; use the asset methods (download/statAsset/readAsset/deleteAsset) for install-time work`
+  );
+  return {
+    logInfo() {
+    },
+    logWarn() {
+    },
+    logError() {
+    },
+    context: { detect: void 0 },
+    listFileNames: async () => [],
+    readFile: async () => {
+      throw noResource("readFile");
+    },
+    statFile: async () => void 0,
+    statFiles: async (paths) => paths.map(() => void 0),
+    sniff: async () => void 0,
+    probe: async () => ({ kind: "unknown", reason: "unavailable" }),
+    hashBytes: async () => {
+      throw noResource("hashBytes");
+    },
+    computeImageHashes: async () => void 0,
+    listContainer: async () => {
+      throw noResource("listContainer");
+    },
+    extractArchive: async () => {
+      throw noResource("extractArchive");
+    },
+    download: async () => {
+      throw pluginAssetError(
+        "UNAVAILABLE",
+        "download() \u2014 this host has no plugin asset service; only the app server host can download into the plugin vault"
+      );
+    },
+    statAsset: async () => {
+      throw unavailableAsset2("statAsset");
+    },
+    readAsset: async () => {
+      throw unavailableAsset2("readAsset");
+    },
+    deleteAsset: async () => {
+      throw unavailableAsset2("deleteAsset");
+    }
+  };
+}
+function unavailableAsset2(method) {
+  return pluginAssetError(
+    "UNAVAILABLE",
+    `${method}() \u2014 this host has no plugin asset vault; only the app server host manages vault files`
+  );
+}
 
 // src/hooks.ts
 var MAX_IMAGE_HASHES_PER_RESOURCE = 2e3;
@@ -2472,6 +2525,17 @@ function createPluginHooks(deps) {
       pluginId
     );
   }
+  async function runInstallHook(pluginId) {
+    const entry = getRegistry().getById(pluginId);
+    if (entry === void 0) return;
+    await invokeHook(
+      entry,
+      entry.plugin.onInstall,
+      createInstallScopeApi(),
+      "onInstall",
+      "warn"
+    );
+  }
   return {
     defaultPluginId,
     getEffectiveEntry,
@@ -2483,7 +2547,8 @@ function createPluginHooks(deps) {
     resolveLocalCoverSource,
     runMetaHooks,
     supportsImageHashes,
-    runImageHashes
+    runImageHashes,
+    runInstallHook
   };
 }
 var HEX_VALUE = /^[0-9a-f]+$/;
@@ -2692,7 +2757,7 @@ function createPluginSandbox(config = DEFAULT_SANDBOX_CONFIG) {
       await teardownChild(previous);
     }
     if (!opts.eager) {
-      void teardownChild(state);
+      await teardownChild(state);
     }
     return createSandboxedPlugin(
       state.hooks ?? ["detect"],
@@ -2876,6 +2941,16 @@ function createPluginSandbox(config = DEFAULT_SANDBOX_CONFIG) {
     if (child === void 0) {
       throw new Error(`plugin ${state.id} sandbox unavailable`);
     }
+    try {
+      return await invokeOnChild(state, child, hook, api);
+    } finally {
+      if (hook === "onInstall") {
+        state.respawnTimes = [];
+        await teardownChild(state);
+      }
+    }
+  }
+  function invokeOnChild(state, child, hook, api) {
     const callId = nextCallId++;
     return new Promise((resolveCall, reject) => {
       const call = {