jishushell 0.4.30 → 0.5.22

package/dist/services/app/app-manager.js

@@ -14,7 +14,35 @@ import { createTask, emitTask, getRunningTasks, getTask } from "../task-registry
 import { compileTaskRuntime } from "./app-compiler.js";
 import * as capabilityRegistry from "../capability-registry.js";
 import { resolveProvideEndpoint } from "./provide-resolver.js";
-const DEFAULT_LIFECYCLE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+import { platformTransformSpec } from "./platform-transform.js";
+const DEFAULT_LIFECYCLE_PATH_ENTRIES = [
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+];
+const DEFAULT_LIFECYCLE_PATH = DEFAULT_LIFECYCLE_PATH_ENTRIES.join(":");
+const MACOS_LIFECYCLE_PATH_PROBES = [
+    "/Applications/Docker.app/Contents/Resources/bin",
+];
+const ANONYMOUS_DOWNLOAD_IMAGE_ALLOWLIST = new Set([
+    "filebrowser/filebrowser:latest",
+    "ghcr.io/browserless/chromium:latest",
+    "ghcr.io/fmaclen/hollama:latest",
+    "ghcr.io/open-webui/open-webui:main",
+    "mcr.microsoft.com/playwright:v1.55.0-noble",
+    "mintplexlabs/anythingllm:latest",
+    "paradedb/paradedb:v0.22.2-pg17",
+    "redis:7.0-alpine",
+    "searxng/searxng:latest",
+    "wechatopenai/weknora-app:latest",
+    "wechatopenai/weknora-docreader:latest",
+    "wechatopenai/weknora-ui:latest",
+]);
 function getConfigValue(name) {
     return name in config ? config[name] : undefined;
 }
@@ -81,7 +109,6 @@ function parseBuiltinTemplate(fileName, yamlText) {
                 const runtime = typeof task?.runtime === "string" ? task.runtime.trim() : "";
                 return runtime === "container" || runtime === "process";
             })
-            && (tasks.length === 1 || isOllamaTemplate)
             && (serviceRuntime === "container" || serviceRuntime === "process"),
         suggestedAppType,
         yaml: yamlText,
@@ -169,15 +196,44 @@ function expandPath(p) {
     }
     return p.replace(/^~(?=\/|$)/, process.env.HOME ?? homedir());
 }
-function buildLifecycleEnv() {
-    const mergedPath = `${process.env.PATH ?? ""}:${DEFAULT_LIFECYCLE_PATH}`
-        .split(":")
+function buildDeterministicPath(basePath, extraPaths = []) {
+    return [basePath ?? "", DEFAULT_LIFECYCLE_PATH, dirname(process.execPath), ...extraPaths]
+        .flatMap((entry) => entry.split(":"))
         .map((entry) => entry.trim())
-        .filter(Boolean);
+        .filter(Boolean)
+        .filter((entry, index, entries) => entries.indexOf(entry) === index)
+        .join(":");
+}
+function buildLifecycleEnv() {
+    const extraPaths = process.platform === "darwin"
+        ? MACOS_LIFECYCLE_PATH_PROBES.filter((entry) => existsSync(entry))
+        : [];
+    const mergedPath = buildDeterministicPath(process.env.PATH, extraPaths);
+    // Surface panel callback hooks to lifecycle scripts. post_start can curl
+    // ${JISHUSHELL_PANEL_URL}/api/internal/* with the internal token to read
+    // panel-managed state (default provider creds etc.) and self-configure
+    // without going through user JWT. Best-effort: if the token file or
+    // port lookup fails we just omit the vars and the script gets a clean
+    // "missing env" failure path.
+    const panelHooks = {};
+    try {
+        panelHooks.JISHUSHELL_PANEL_URL = `http://127.0.0.1:${config.getPanelPort()}`;
+        panelHooks.JISHUSHELL_INTERNAL_TOKEN = config.getInternalMcpToken();
+        // LAN host that *other* services (and the post_start script's curls into
+        // its own service) can reach. AnythingLLM binds eth0 via Nomad's
+        // `external` host_network, so the panel-host loopback (127.0.0.1) won't
+        // reach 18097 — post_start needs to hit the LAN IP to check its own
+        // health. getPanelLanHost() returns the same IP Nomad publishes ports on.
+        panelHooks.JISHUSHELL_LAN_HOST = config.getPanelLanHost();
+    }
+    catch {
+        // tolerate — only post_start cares
+    }
     return {
         ...process.env,
         HOME: process.env.HOME ?? homedir(),
-        PATH: [...new Set(mergedPath)].join(":"),
+        PATH: mergedPath,
+        ...panelHooks,
     };
 }
 const SUDO_PASSTHROUGH_ENV_KEYS = ["HOME", "PATH", "TMPDIR", "TMP", "TEMP", "XDG_RUNTIME_DIR"];
@@ -325,7 +381,7 @@ export async function validateSudoPassword(sudoPassword) {
                 }
                 resolve();
             });
-            child.on("error", (error) => {
+            child.on("error", (_error) => {
                 resolve();
             });
         });
@@ -334,8 +390,11 @@ export async function validateSudoPassword(sudoPassword) {
         preparedEnv.cleanup();
     }
 }
-function prepareLifecycleExecEnv(execOptions) {
-    const env = buildLifecycleEnv();
+function prepareLifecycleExecEnv(execOptions, envOverrides) {
+    const env = {
+        ...buildLifecycleEnv(),
+        ...(envOverrides ?? {}),
+    };
     const sudoPassword = execOptions?.sudoPassword;
     if (!sudoPassword) {
         return { env, cleanup: () => undefined };
@@ -364,6 +423,26 @@ function prepareLifecycleExecEnv(execOptions) {
         },
     };
 }
+function shouldBypassDockerCredentialHelperForDownloadImage(image) {
+    return ANONYMOUS_DOWNLOAD_IMAGE_ALLOWLIST.has(image.trim());
+}
+function createAnonymousDockerConfig() {
+    const dockerConfigDir = mkdtempSync(join(tmpdir(), "jishushell-docker-config-"));
+    writeFileSync(join(dockerConfigDir, "config.json"), `${JSON.stringify({ auths: {} }, null, 2)}\n`, { mode: 0o600 });
+    return {
+        envOverrides: {
+            DOCKER_CONFIG: dockerConfigDir,
+        },
+        cleanup: () => {
+            try {
+                rmSync(dockerConfigDir, { recursive: true, force: true });
+            }
+            catch {
+                // best effort cleanup for one-shot anonymous docker config files
+            }
+        },
+    };
+}
 const ANSI_ESCAPE_RE = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 function sanitizeTaskLine(line) {
     return line
@@ -687,11 +766,16 @@ function materializeInstalledSpec(spec, appId, offset) {
     const portShiftMap = buildPortShiftMap(spec, offset);
     const rewritten = rewriteInstalledSpecValue(spec, spec.id, appId, portShiftMap);
     const derivedName = deriveInstalledDisplayName(spec, appId);
-    return normalizeAppSpec({
+    const normalized = normalizeAppSpec({
         ...rewritten,
         id: spec.id,
         ...(derivedName ? { name: derivedName } : {}),
     });
+    // Final step: drop spec fields that work on the spec author's Linux
+    // baseline but break on the host platform (e.g. host_network:
+    // docker_bridge / user: "host" on darwin). Identity pass-through on
+    // Linux — see platform-transform.ts for the rule list.
+    return platformTransformSpec(normalized);
 }
 function deriveInstalledDisplayName(spec, appId) {
     const baseName = typeof spec.name === "string" && spec.name.trim() ? spec.name.trim() : spec.id;
@@ -801,7 +885,15 @@ async function resolveInstallTarget(spec, originalSpecYaml, requestedAppId) {
         return {
             appId,
             installedSpec,
-            installedSpecYaml: offset === 0 ? originalSpecYaml : stringify(installedSpec),
+            // Always re-serialize from `installedSpec` so the cached yaml
+            // reflects every transform `materializeInstalledSpec` ran —
+            // including the platform pass that strips host_network/user fields
+            // on darwin. Using `originalSpecYaml` for offset=0 (the previous
+            // behavior) bypassed the transformer for multi-instance apps'
+            // first install slot and re-introduced the Linux-only fields on
+            // disk; subsequent panel restarts then re-read the raw source via
+            // `loadInstalledAppSpec` and broke macOS placement again.
+            installedSpecYaml: stringify(installedSpec),
         };
     }
     throw new Error(`App '${baseId}' 没有可用安装槽位，目录名或端口已全部占用`);
@@ -819,37 +911,57 @@ const DOCKER_PULL_TIMEOUT_MS = 1_800_000;
 // Separate from the total timeout above: if docker pull stops producing any
 // stdout/stderr for long enough, treat it as stalled and retry rather than
 // waiting the full 30 minutes.
-const DOCKER_PULL_IDLE_TIMEOUT_MS = 180_000;
-async function pullDockerImageStep(label, image, display, task, timeoutMs = DOCKER_PULL_TIMEOUT_MS) {
+//
+// Why 600s (not 180s): on slow links (especially Docker Hub from China to
+// edge devices), large single layers — AnythingLLM ~500MB, Playwright/Hermes
+// ~2.3GB — can spend 5-8 minutes between progress lines without TTY. 180s
+// idle was killing pulls that were actually making progress, then rolling
+// back the partially-completed image. Layer cache is preserved across
+// retries (docker dedupes by layer sha), so a higher idle ceiling lets each
+// big layer finish without throwing away the layers already on disk.
+const DOCKER_PULL_IDLE_TIMEOUT_MS = 600_000;
+async function pullDockerImageStep(label, image, display, task, timeoutMs = DOCKER_PULL_TIMEOUT_MS, idleTimeoutMs) {
     if (await dockerImageExists(image)) {
         const skipMessage = `[lifecycle:${label}] docker image '${image}' already exists locally; skipping pull`;
         process.stdout.write(`  ${skipMessage}\n`);
         emitInstallTaskLog(task, skipMessage);
         return;
     }
+    const anonymousDockerConfig = shouldBypassDockerCredentialHelperForDownloadImage(image)
+        ? createAnonymousDockerConfig()
+        : null;
     let lastError;
-    for (let attempt = 1; attempt <= DOCKER_PULL_RETRY_ATTEMPTS; attempt++) {
-        try {
-            await spawnStepWithTimeout(label, display, display, "docker", ["pull", image], timeoutMs, task, undefined, undefined, { idleTimeoutMs: Math.min(DOCKER_PULL_IDLE_TIMEOUT_MS, timeoutMs) });
-            return;
-        }
-        catch (error) {
-            if (await dockerImageExists(image)) {
-                const recoveredMessage = `[lifecycle:${label}] docker image '${image}' is present locally after pull failure/timeout; treating step as successful`;
-                process.stdout.write(`  ${recoveredMessage}\n`);
-                emitInstallTaskLog(task, recoveredMessage);
+    try {
+        for (let attempt = 1; attempt <= DOCKER_PULL_RETRY_ATTEMPTS; attempt++) {
+            try {
+                await spawnStepWithTimeout(label, display, display, "docker", ["pull", image], timeoutMs, task, undefined, undefined, {
+                    idleTimeoutMs: idleTimeoutMs ?? Math.min(DOCKER_PULL_IDLE_TIMEOUT_MS, timeoutMs),
+                    envOverrides: anonymousDockerConfig?.envOverrides,
+                    stallMessageHint: "Docker credential resolution (for example docker-credential-desktop) may be involved.",
+                });
                 return;
             }
-            lastError = error;
-            if (attempt === DOCKER_PULL_RETRY_ATTEMPTS) {
-                break;
+            catch (error) {
+                if (await dockerImageExists(image)) {
+                    const recoveredMessage = `[lifecycle:${label}] docker image '${image}' is present locally after pull failure/timeout; treating step as successful`;
+                    process.stdout.write(`  ${recoveredMessage}\n`);
+                    emitInstallTaskLog(task, recoveredMessage);
+                    return;
+                }
+                lastError = error;
+                if (attempt === DOCKER_PULL_RETRY_ATTEMPTS) {
+                    break;
+                }
+                const reason = error instanceof Error ? error.message : String(error);
+                const retryMessage = `[lifecycle:${label}] docker pull failed for ${image} (attempt ${attempt}/${DOCKER_PULL_RETRY_ATTEMPTS}): ${reason}; retrying`;
+                process.stdout.write(`  ${retryMessage}\n`);
+                emitInstallTaskLog(task, retryMessage);
             }
-            const reason = error instanceof Error ? error.message : String(error);
-            const retryMessage = `[lifecycle:${label}] docker pull failed for ${image} (attempt ${attempt}/${DOCKER_PULL_RETRY_ATTEMPTS}): ${reason}; retrying`;
-            process.stdout.write(`  ${retryMessage}\n`);
-            emitInstallTaskLog(task, retryMessage);
         }
     }
+    finally {
+        anonymousDockerConfig?.cleanup();
+    }
     throw (lastError instanceof Error ? lastError : new Error(String(lastError)));
 }
 async function dockerImageExists(image) {
@@ -866,7 +978,7 @@ function spawnStepWithTimeout(label, display, taskDisplay, cmd, args, timeoutMs,
     process.stdout.write(`  [lifecycle:${label}] ${display}\n`);
     emitInstallTaskLog(task, `[lifecycle:${label}] ${taskDisplay}`);
     return new Promise((resolve, reject) => {
-        const preparedEnv = prepareLifecycleExecEnv(sudo ? execOptions : undefined);
+        const preparedEnv = prepareLifecycleExecEnv(sudo ? execOptions : undefined, runOptions?.envOverrides);
         let cleaned = false;
         let heartbeatTimer = null;
         let idleTimer = null;
@@ -904,10 +1016,11 @@ function spawnStepWithTimeout(label, display, taskDisplay, cmd, args, timeoutMs,
                 clearTimeout(idleTimer);
             idleTimer = setTimeout(() => {
                 const idleSeconds = Math.max(1, Math.round(runOptions.idleTimeoutMs / 1000));
-                const stallMessage = `[lifecycle:${label}] no output for ${idleSeconds}s; terminating stalled step: ${taskDisplay}`;
+                const stallMessageSuffix = runOptions.stallMessageHint ? ` ${runOptions.stallMessageHint}` : "";
+                const stallMessage = `[lifecycle:${label}] no output for ${idleSeconds}s; terminating stalled step: ${taskDisplay}${stallMessageSuffix}`;
                 process.stdout.write(`  ${stallMessage}\n`);
                 emitInstallTaskLog(task, stallMessage);
-                forcedError = new Error(`lifecycle '${label}' step stalled after ${idleSeconds}s with no output: ${display}`);
+                forcedError = new Error(`lifecycle '${label}' step stalled after ${idleSeconds}s with no output: ${display}${stallMessageSuffix}`);
                 child.kill("SIGTERM");
             }, runOptions.idleTimeoutMs);
             idleTimer.unref?.();
@@ -1108,7 +1221,7 @@ async function runLifecycleSteps(steps, label, artifacts, task, execOptions) {
             }
         }
         else if ("downloadImage" in step) {
-            await pullDockerImageStep(label, step.downloadImage, `downloadImage: ${step.downloadImage}`, task, step.timeout_ms);
+            await pullDockerImageStep(label, step.downloadImage, `downloadImage: ${step.downloadImage}`, task, step.timeout_ms, step.idle_timeout_ms);
             artifacts?.push({ type: "image", path: step.downloadImage });
         }
         else if ("deleteImage" in step) {
@@ -1208,7 +1321,7 @@ function cleanupArtifacts(artifacts, task) {
 }
 const DOCKER_IMAGE_RE = /^[a-zA-Z0-9][a-zA-Z0-9\-_.:/@]*$/;
 const APP_ID_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
-const REGISTRY_PATH = join(APPS_DIR, "capability-registry.json");
+const _REGISTRY_PATH = join(APPS_DIR, "capability-registry.json");
 const INSTALL_LOCK_FILENAME = "install.lock";
 // ── Directory helpers ─────────────────────────────────────────────────────
 function appDirForId(appId) {
@@ -1723,16 +1836,66 @@ function readRegistry() {
     const file = capabilityRegistry.readRegistry();
     return { capabilities: file.capabilities ?? {}, providersByCapability: file.providersByCapability };
 }
-function installedProvidersForCapability(capability) {
-    return listApps()
-        .filter((app) => app.spec.provides?.some((provide) => provide.capability === capability))
-        .map((app) => app.manifest.id);
-}
 // `ensureRequiredCapabilitiesAvailable` was removed in PR 3 sub-step 3c.
 // install never blocks on missing required providers any more —
 // resolveConnections(..., "preCreate") collects them into the `pending`
 // list and the UI surfaces them after install completes.
+// `listProvidedCapabilities()` does a full filesystem app scan (listApps →
+// readdir + per-app spec parse) plus a registry read. `augmentInstanceMetadata`
+// calls it ~2× per instance (getProvidedCapabilitiesForApp +
+// getEmbeddedUiHintForApp), so `GET /api/instances` over N instances did ~2N
+// full disk scans per request — the dashboard warm-path cost.
+//
+// Cache the result, but key validity on a CHEAP fingerprint of the
+// underlying state, not on time alone. A time-only TTL left a staleness
+// window where a freshly installed/uninstalled app (or created/deleted
+// instance — INSTANCES_DIR also feeds listApps) was missing from / lingered
+// in the list until the TTL expired, which broke the Connections UI and the
+// embedded-UI hint. The fingerprint (sorted dir entries of APPS_DIR +
+// INSTANCES_DIR, plus the registry file mtime) changes the instant the app
+// set or registry changes — including external mutations — so the cache
+// self-busts without having to hook every mutation site. It costs two
+// readdir + one stat, still vastly cheaper than re-parsing every app spec.
+// The short TTL stays only as a safety net for in-place spec edits that
+// don't change the dir set; the explicit register/unregister/markStopped
+// invalidations remain as a precise fast-path for sub-millisecond registry
+// writes that could share an mtime tick.
+const PROVIDED_CAPS_TTL_MS = 5_000;
+let _providedCapsEntry = null;
+function providedCapabilitiesFingerprint() {
+    const dirEntries = (dir) => {
+        try {
+            return existsSync(dir) ? readdirSync(dir).sort().join(",") : "";
+        }
+        catch {
+            return "";
+        }
+    };
+    let registryMtime = 0;
+    try {
+        registryMtime = lstatSync(_REGISTRY_PATH).mtimeMs;
+    }
+    catch {
+        /* registry file not written yet → 0 */
+    }
+    return `${dirEntries(APPS_DIR)}|${dirEntries(INSTANCES_DIR)}|${registryMtime}`;
+}
+export function invalidateProvidedCapabilitiesCache() {
+    _providedCapsEntry = null;
+}
 export function listProvidedCapabilities() {
+    const fp = providedCapabilitiesFingerprint();
+    const now = Date.now();
+    if (_providedCapsEntry &&
+        _providedCapsEntry.fp === fp &&
+        now - _providedCapsEntry.ts < PROVIDED_CAPS_TTL_MS) {
+        return _providedCapsEntry.data;
+    }
+    const data = computeProvidedCapabilities();
+    _providedCapsEntry = { data, fp, ts: now };
+    return data;
+}
+function computeProvidedCapabilities() {
     const reg = readRegistry();
     return listApps().flatMap((app) => (app.spec.provides ?? []).map((provide) => {
         const url = getProvideUrl(provide) ?? undefined;
@@ -1753,6 +1916,7 @@ export function listProvidedCapabilities() {
             ...(provide.visibility ? { visibility: provide.visibility } : {}),
             ...(provide.description ? { description: provide.description } : {}),
             ...(provide.terminal ? { terminal: provide.terminal } : {}),
+            ...(provide.embedded ? { embedded: provide.embedded } : {}),
             ...(address ? { address } : {}),
             registered: Boolean(registered),
             ...(registered?.address ? { registeredAddress: registered.address } : {}),
@@ -1763,11 +1927,38 @@ export function listProvidedCapabilities() {
 export function getProvidedCapabilitiesForApp(appId) {
     return listProvidedCapabilities().filter((entry) => entry.appId === appId);
 }
+/**
+ * Resolve the runtime endpoint (host + port) for a given app's capability.
+ * Returns the runtime-resolved port when available, falling back to the
+ * declared AppSpec port. This is used by the capability proxy to target the
+ * correct live endpoint after potential port reallocation.
+ */
+export function resolveRuntimeCapabilityPort(appId, capabilityName) {
+    const app = getApp(appId);
+    if (!app)
+        return null;
+    const provide = (app.spec.provides ?? []).find((p) => p.capability === capabilityName);
+    if (!provide)
+        return null;
+    const resolved = resolveProvideEndpoint(appId, app.spec, provide);
+    return resolved?.hostPort ?? getProvidePort(app.spec, provide);
+}
 export function getEmbeddedUiHintForApp(appId) {
     const provides = getProvidedCapabilitiesForApp(appId);
     if (!provides.length)
         return null;
-    const preferred = provides.find((provide) => provide.capability === BROWSERLESS_DEBUGGER_CAPABILITY);
+    // Selection priority for which provide becomes the embedded UI:
+    //   1. browserless-debugger (special — dev console, not the API)
+    //   2. any capability whose name ends in "-ui" (the canonical Web UI slot,
+    //      by convention served at "/"). Apps like AnythingLLM provide both an
+    //      API capability (`knowledge-anythingllm`, path `/api/v1`) AND a UI
+    //      capability (`anythingllm-ui`, path `/`). Without this preference
+    //      the first-iterated provide wins and the iframe ends up pointing
+    //      at `/api/v1` → 404.
+    //   3. fall back to natural order for legacy single-capability apps.
+    const browserlessPreferred = provides.find((provide) => provide.capability === BROWSERLESS_DEBUGGER_CAPABILITY);
+    const uiPreferred = provides.find((provide) => provide.capability.endsWith("-ui"));
+    const preferred = browserlessPreferred ?? uiPreferred ?? null;
     const orderedProvides = preferred
         ? [preferred, ...provides.filter((provide) => provide !== preferred)]
         : provides;
@@ -1787,6 +1978,14 @@ export function getEmbeddedUiHintForApp(appId) {
         }
         if (typeof provide.port !== "number" || provide.port < 1)
             continue;
+        // Honor explicit `embedded` opt-in/out on the provide before the
+        // auto-detection logic runs. `"proxy"` short-circuits to the
+        // same-origin proxy path (needed when upstream is firewall-blocked,
+        // emits X-Frame-Options, or otherwise can't be reached by the
+        // browser directly). `"direct"` forces the direct URL even when
+        // listening only on loopback — caller asserts they know what
+        // they're doing.
+        const embeddedMode = provide.embedded ?? "auto";
         // Prefer a direct upstream URL when the container port is published to
         // a LAN-reachable address (Pi with host_network "external", etc.). The
         // same-origin reverse-proxy path is necessary only when the container
@@ -1797,7 +1996,10 @@ export function getEmbeddedUiHintForApp(appId) {
         // absolute URLs starting with `/api/...` (e.g. OpenWebUI), because
         // those calls bypass `<base href>` and hit the panel API instead.
         const listeningHost = legacyInstanceManager.getListeningHostForPort(provide.port);
-        const directlyReachable = listeningHost && listeningHost !== "127.0.0.1" && listeningHost !== "::1";
+        const isLoopback = listeningHost === "127.0.0.1" || listeningHost === "::1";
+        const directlyReachable = embeddedMode !== "proxy"
+            && listeningHost
+            && (!isLoopback || embeddedMode === "direct");
         if (directlyReachable) {
             const advertised = legacyInstanceManager.getAdvertisedHostForPort(provide.port);
             const directUrl = `${protocol}://${advertised}:${provide.port}${provide.path ?? ""}`;
@@ -2162,6 +2364,7 @@ export function registerCapabilities(instanceId, spec, portOverride) {
         };
         capabilityRegistry.registerProvider(entry);
     }
+    invalidateProvidedCapabilitiesCache();
 }
 /**
  * Mark an instance's providers as `stopped` (preferred for stop) or
@@ -2171,9 +2374,11 @@ export function registerCapabilities(instanceId, spec, portOverride) {
  */
 export function unregisterCapabilities(instanceId) {
     capabilityRegistry.unregisterProviders(instanceId);
+    invalidateProvidedCapabilitiesCache();
 }
 export function markCapabilitiesStopped(instanceId) {
     capabilityRegistry.setProviderStatus(instanceId, "stopped");
+    invalidateProvidedCapabilitiesCache();
 }
 export function resolveRequires(spec) {
     if (!spec.requires || spec.requires.length === 0)