@shadowob/cloud 1.1.6-dev.311

package/dist/chunk-BF6CV2Y4.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+// src/utils/logger.ts
+import * as chalkModule from "chalk";
+function identity(text) {
+  return text;
+}
+var passthroughChalk = {
+  blue: identity,
+  green: identity,
+  yellow: identity,
+  red: identity,
+  cyan: identity,
+  dim: identity,
+  bold: identity
+};
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isChalkFormatter(value) {
+  if (!isObjectLike(value)) return false;
+  return typeof value.blue === "function" && typeof value.green === "function" && typeof value.yellow === "function" && typeof value.red === "function" && typeof value.cyan === "function" && typeof value.dim === "function" && typeof value.bold === "function";
+}
+function resolveChalkFormatter(moduleLike) {
+  const queue = [moduleLike];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const candidate = queue.shift();
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (isChalkFormatter(candidate)) {
+      return candidate;
+    }
+    if (isObjectLike(candidate) && "default" in candidate) {
+      queue.push(candidate.default);
+    }
+  }
+  return passthroughChalk;
+}
+var chalk = resolveChalkFormatter(chalkModule);
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2717"), msg),
+  step: (msg) => console.log(chalk.cyan("\u25B8"), msg),
+  dim: (msg) => console.log(chalk.dim(msg)),
+  table: (rows) => {
+    if (rows.length === 0) return;
+    const keys = Object.keys(rows[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => (r[k] ?? "").length)));
+    const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+    const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+    console.log(chalk.bold(header));
+    console.log(chalk.dim(separator));
+    for (const row of rows) {
+      console.log(keys.map((k, i) => (row[k] ?? "").padEnd(widths[i])).join("  "));
+    }
+  }
+};
+
+export {
+  log
+};

package/dist/chunk-CTNUKOQE.js

@@ -0,0 +1,439 @@
+#!/usr/bin/env node
+
+// src/plugins/helpers.ts
+function loadManifest(raw) {
+  if (typeof raw.id !== "string" || typeof raw.name !== "string" || typeof raw.description !== "string" || typeof raw.version !== "string" || typeof raw.category !== "string" || typeof raw.icon !== "string" || typeof raw.auth !== "object" || raw.auth === null || !Array.isArray(raw.capabilities) || !Array.isArray(raw.tags)) {
+    const id = typeof raw.id === "string" ? raw.id : "unknown";
+    throw new Error(`Invalid plugin manifest for "${id}": missing required fields`);
+  }
+  return raw;
+}
+function makeHooks() {
+  return {
+    resolveAgent: [],
+    buildConfig: [],
+    buildPrompt: [],
+    buildEnv: [],
+    buildRuntime: [],
+    buildResources: [],
+    validate: [],
+    provision: [],
+    healthCheck: []
+  };
+}
+function makeAPI(hooks, collected) {
+  const mergeRuntime = (fragment) => {
+    collected.runtime = mergeCollectedRuntime(collected.runtime ?? {}, fragment);
+  };
+  return {
+    addSkills: (s) => {
+      collected.skills = s;
+    },
+    addCLI: (tools) => {
+      collected.cli = [...collected.cli ?? [], ...tools];
+    },
+    addMCP: (server) => {
+      collected.mcp = [...collected.mcp ?? [], server];
+      mergeRuntime({ mcpServers: [server] });
+    },
+    addRuntimeDependencies: (deps) => {
+      mergeRuntime({ runtimeDependencies: deps });
+    },
+    addSkillSources: (sources) => {
+      mergeRuntime({ skillSources: sources });
+    },
+    addSubagentSources: (sources) => {
+      mergeRuntime({ subagentSources: sources });
+    },
+    addRuntimeArtifacts: (artifacts) => {
+      mergeRuntime({ artifacts });
+    },
+    addCredentialFiles: (files) => {
+      mergeRuntime({ credentialFiles: files });
+    },
+    addVerificationChecks: (checks) => {
+      mergeRuntime({ verificationChecks: checks });
+    },
+    addProviderCatalog: (catalog) => {
+      collected.providerCatalogs = [...collected.providerCatalogs ?? [], catalog];
+    },
+    addSecretFields: (fields) => {
+      collected.secretFields = [...collected.secretFields ?? [], ...fields];
+    },
+    ignoreEnvRefs: (keys) => {
+      collected.ignoredEnvRefs = [.../* @__PURE__ */ new Set([...collected.ignoredEnvRefs ?? [], ...keys])];
+    },
+    onResolveAgent: (fn) => hooks.resolveAgent.push(fn),
+    onBuildConfig: (fn) => hooks.buildConfig.push(fn),
+    onBuildPrompt: (fn) => hooks.buildPrompt.push(fn),
+    onBuildEnv: (fn) => hooks.buildEnv.push(fn),
+    onBuildRuntime: (fn) => hooks.buildRuntime.push(fn),
+    onBuildResources: (fn) => hooks.buildResources.push(fn),
+    onValidate: (fn) => hooks.validate.push(fn),
+    onProvision: (fn) => hooks.provision.push(fn),
+    onHealthCheck: (fn) => hooks.healthCheck.push(fn)
+  };
+}
+function mergeByKey(items, keyOf) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    map.set(keyOf(item), item);
+  }
+  return [...map.values()];
+}
+function mcpServerKey(server) {
+  return server.id ?? `${server.transport}:${server.url ?? server.command ?? ""}:${server.args?.join(" ") ?? ""}`;
+}
+function mergeCollectedRuntime(current, fragment) {
+  const manifestPatches = [
+    ...current.openclaw?.manifestPatches ?? [],
+    ...fragment.openclaw?.manifestPatches ?? []
+  ];
+  const shadowob = mergeShadowobRuntime(current.shadowob, fragment.shadowob);
+  return {
+    ...manifestPatches.length > 0 ? { openclaw: { manifestPatches } } : {},
+    ...shadowob ? { shadowob } : {},
+    ...current.artifacts?.length || fragment.artifacts?.length ? {
+      artifacts: mergeByKey(
+        [...current.artifacts ?? [], ...fragment.artifacts ?? []],
+        (artifact) => artifact.kind
+      )
+    } : {},
+    ...current.runtimeDependencies?.length || fragment.runtimeDependencies?.length ? {
+      runtimeDependencies: mergeByKey(
+        [...current.runtimeDependencies ?? [], ...fragment.runtimeDependencies ?? []],
+        (dep) => dep.id
+      )
+    } : {},
+    ...current.skillSources?.length || fragment.skillSources?.length ? {
+      skillSources: mergeByKey(
+        [...current.skillSources ?? [], ...fragment.skillSources ?? []],
+        (source) => source.id
+      )
+    } : {},
+    ...current.subagentSources?.length || fragment.subagentSources?.length ? {
+      subagentSources: mergeByKey(
+        [...current.subagentSources ?? [], ...fragment.subagentSources ?? []],
+        (source) => source.id
+      )
+    } : {},
+    ...current.mcpServers?.length || fragment.mcpServers?.length ? {
+      mcpServers: mergeByKey(
+        [...current.mcpServers ?? [], ...fragment.mcpServers ?? []],
+        mcpServerKey
+      )
+    } : {},
+    ...current.credentialFiles?.length || fragment.credentialFiles?.length ? {
+      credentialFiles: mergeByKey(
+        [...current.credentialFiles ?? [], ...fragment.credentialFiles ?? []],
+        (file) => `${file.envKey}:${file.path}`
+      )
+    } : {},
+    ...current.verificationChecks?.length || fragment.verificationChecks?.length ? {
+      verificationChecks: mergeByKey(
+        [...current.verificationChecks ?? [], ...fragment.verificationChecks ?? []],
+        (check) => check.id
+      )
+    } : {}
+  };
+}
+function mergeShadowobRuntime(current, fragment) {
+  if (!current) return fragment;
+  if (!fragment) return current;
+  const accounts = new Map(current.accounts.map((account) => [account.buddyId, account]));
+  for (const account of fragment.accounts) {
+    accounts.set(account.buddyId, { ...accounts.get(account.buddyId), ...account });
+  }
+  return {
+    ...current,
+    ...fragment,
+    capabilities: {
+      ...current.capabilities ?? {},
+      ...fragment.capabilities ?? {}
+    },
+    accounts: [...accounts.values()]
+  };
+}
+function definePlugin(manifest, setup) {
+  const hooks = makeHooks();
+  const collected = {};
+  const api = makeAPI(hooks, collected);
+  setup(api);
+  if (collected.runtime) {
+    hooks.buildRuntime.unshift(() => collected.runtime);
+  }
+  return {
+    manifest,
+    skills: collected.skills,
+    cli: collected.cli,
+    mcp: collected.mcp,
+    runtime: collected.runtime,
+    providerCatalogs: collected.providerCatalogs,
+    secretFields: collected.secretFields,
+    ignoredEnvRefs: collected.ignoredEnvRefs,
+    _hooks: hooks,
+    _buildConfig: hooks.buildConfig,
+    _buildEnv: hooks.buildEnv,
+    _validate: hooks.validate
+  };
+}
+function defaultEnvVars(manifest, context) {
+  const envVars = {};
+  for (const field of manifest.auth.fields) {
+    const value = context.secrets[field.key];
+    if (value) envVars[field.key] = value;
+  }
+  return envVars;
+}
+function defaultValidation(manifest, context) {
+  const errors = [];
+  for (const field of manifest.auth.fields) {
+    if (field.required && !context.secrets[field.key]) {
+      errors.push({
+        path: `secrets.${field.key}`,
+        message: `${field.label} is required`,
+        severity: "error"
+      });
+    }
+  }
+  return { valid: errors.filter((e) => e.severity === "error").length === 0, errors };
+}
+function openClawEnvRef(key) {
+  return ["$", "{env:", key, "}"].join("");
+}
+function defaultConnectorSkills(manifest) {
+  const env = Object.fromEntries(
+    manifest.auth.fields.map((field) => [field.key, openClawEnvRef(field.key)])
+  );
+  return {
+    entries: [
+      {
+        id: manifest.id,
+        name: manifest.name,
+        description: manifest.description,
+        ...Object.keys(env).length > 0 ? { env } : {}
+      }
+    ]
+  };
+}
+function defineSkillPlugin(manifest, options, extraSetup) {
+  return definePlugin(manifest, (api) => {
+    if (options.skills) api.addSkills(options.skills);
+    if (options.cli?.length) api.addCLI(options.cli);
+    if (options.mcp) {
+      const mcps = Array.isArray(options.mcp) ? options.mcp : [options.mcp];
+      for (const s of mcps) api.addMCP(s);
+    }
+    api.onBuildConfig((_ctx) => {
+      const fragment = {};
+      if (options.skills) {
+        const sc = {};
+        if (options.skills.bundled?.length) sc.allowBundled = options.skills.bundled;
+        if (options.skills.entries?.length) {
+          const entries = {};
+          for (const skill of options.skills.entries) {
+            entries[skill.id] = {
+              enabled: true,
+              ...skill.apiKey ? { apiKey: skill.apiKey } : {},
+              ...skill.env ? { env: skill.env } : {}
+            };
+          }
+          sc.entries = entries;
+        }
+        fragment.skills = sc;
+      }
+      return fragment;
+    });
+    api.onBuildEnv((ctx) => defaultEnvVars(manifest, ctx));
+    api.onValidate((ctx) => defaultValidation(manifest, ctx));
+    extraSetup?.(api);
+  });
+}
+function defineConnectorPlugin(manifest, options, extraSetup) {
+  const mcpServers = options.mcp ? Array.isArray(options.mcp) ? options.mcp : [options.mcp] : [];
+  const skills = options.skills ?? defaultConnectorSkills(manifest);
+  return definePlugin(manifest, (api) => {
+    api.addSkills(skills);
+    if (options.cli?.length) api.addCLI(options.cli);
+    for (const server of mcpServers) api.addMCP(server);
+    if (options.runtimeDependencies?.length) api.addRuntimeDependencies(options.runtimeDependencies);
+    if (options.skillSources?.length) api.addSkillSources(options.skillSources);
+    if (options.subagentSources?.length) api.addSubagentSources(options.subagentSources);
+    if (options.credentialFiles?.length) api.addCredentialFiles(options.credentialFiles);
+    if (options.verificationChecks?.length) api.addVerificationChecks(options.verificationChecks);
+    api.addSecretFields(
+      manifest.auth.fields.map((field) => ({
+        key: field.key,
+        label: field.label,
+        description: field.description,
+        required: field.required,
+        sensitive: field.sensitive,
+        placeholder: field.placeholder,
+        helpUrl: field.helpUrl
+      }))
+    );
+    api.onBuildConfig((_ctx) => {
+      const fragment = {};
+      if (skills) {
+        const skillConfig = {};
+        const extraDirs = [
+          ...new Set(
+            (options.skillSources ?? []).map((source) => source.targetPath).filter((path) => Boolean(path))
+          )
+        ];
+        if (extraDirs.length > 0) skillConfig.load = { extraDirs };
+        if (skills.bundled?.length) skillConfig.allowBundled = skills.bundled;
+        if (skills.entries?.length) {
+          const entries = {};
+          for (const skill of skills.entries) {
+            entries[skill.id] = {
+              enabled: true,
+              ...skill.apiKey ? { apiKey: skill.apiKey } : {},
+              ...skill.env ? { env: skill.env } : {}
+            };
+          }
+          skillConfig.entries = entries;
+        }
+        fragment.skills = skillConfig;
+      }
+      return fragment;
+    });
+    if (options.config) api.onBuildConfig(options.config);
+    api.onBuildEnv((ctx) => ({
+      ...defaultEnvVars(manifest, ctx),
+      ...options.env?.(ctx) ?? {}
+    }));
+    api.onValidate((ctx) => options.validate?.(ctx) ?? defaultValidation(manifest, ctx));
+    if (options.prompt) {
+      api.onBuildPrompt(
+        (ctx) => typeof options.prompt === "function" ? options.prompt(ctx) : options.prompt
+      );
+    }
+    extraSetup?.(api);
+  });
+}
+function defineChannelPlugin(manifest, channelBuilder, extraSetup) {
+  return definePlugin(manifest, (api) => {
+    api.onBuildConfig(channelBuilder);
+    api.onBuildEnv((ctx) => defaultEnvVars(manifest, ctx));
+    api.onValidate((ctx) => defaultValidation(manifest, ctx));
+    extraSetup?.(api);
+  });
+}
+function defineProviderPlugin(manifest, options, extraSetup) {
+  return definePlugin(manifest, (api) => {
+    const apiKeyField = manifest.auth.fields.find((f) => f.required && f.sensitive) ?? manifest.auth.fields.find((f) => f.sensitive);
+    const envKey = options.provider.envKey ?? apiKeyField?.key;
+    if (envKey) {
+      api.addProviderCatalog({
+        id: options.provider.id,
+        api: mapProviderApi(options.provider.api),
+        baseUrl: options.provider.baseUrl,
+        envKey,
+        envKeyAliases: options.provider.envKeyAliases,
+        baseUrlEnvKey: options.provider.baseUrlEnvKey,
+        modelEnvKey: options.provider.modelEnvKey,
+        priority: options.provider.priority,
+        models: options.provider.models ?? []
+      });
+    }
+    api.addSecretFields(
+      manifest.auth.fields.map((field) => ({
+        key: field.key,
+        label: field.label,
+        description: field.description,
+        required: field.required,
+        sensitive: field.sensitive,
+        placeholder: field.placeholder
+      }))
+    );
+    api.onBuildConfig((ctx) => {
+      const { agentConfig } = ctx;
+      const resolvedEnvKey = resolveProviderEnvKey(options.provider.envKey ?? apiKeyField?.key, {
+        aliases: options.provider.envKeyAliases,
+        secrets: ctx.secrets
+      });
+      const providerEntry = {
+        ...resolvedEnvKey ? { apiKey: `\${env:${resolvedEnvKey}}` } : {},
+        models: options.provider.models?.map((m) => ({
+          id: m.id,
+          name: m.name ?? m.id,
+          ...m.contextWindow != null ? { contextWindow: m.contextWindow } : {},
+          ...m.maxTokens != null ? { maxTokens: m.maxTokens } : {}
+        })) ?? [],
+        request: { allowPrivateNetwork: true }
+      };
+      if (agentConfig.baseUrl || options.provider.baseUrl) {
+        providerEntry.baseUrl = agentConfig.baseUrl ?? options.provider.baseUrl;
+      }
+      if (agentConfig.models) providerEntry.models = agentConfig.models;
+      if (options.provider.api) {
+        providerEntry.api = mapProviderApi(options.provider.api);
+      }
+      return { models: { mode: "merge", providers: { [options.provider.id]: providerEntry } } };
+    });
+    api.onBuildEnv((ctx) => {
+      const out = defaultEnvVars(manifest, ctx);
+      for (const key of providerEnvKeys(options.provider)) {
+        const value = ctx.secrets[key] ?? process.env[key];
+        if (value) out[key] = value;
+      }
+      return out;
+    });
+    api.onValidate((ctx) => {
+      const result = defaultValidation(manifest, ctx);
+      if (apiKeyField && hasProviderEnvValue(options.provider.envKey ?? apiKeyField.key, {
+        aliases: options.provider.envKeyAliases,
+        secrets: ctx.secrets
+      })) {
+        result.errors = result.errors.filter((error) => error.path !== `secrets.${apiKeyField.key}`);
+        result.valid = result.errors.filter((error) => error.severity === "error").length === 0;
+      }
+      return result;
+    });
+    extraSetup?.(api);
+  });
+}
+function mapProviderApi(api) {
+  const MAP = {
+    anthropic: "anthropic-messages",
+    openai: "openai-completions",
+    "openai-chat": "openai-completions",
+    google: "google-generative-ai",
+    gemini: "google-generative-ai",
+    bedrock: "bedrock-converse-stream",
+    azure: "azure-openai-responses",
+    "azure-openai": "azure-openai-responses"
+  };
+  return MAP[api] ?? api;
+}
+function resolveProviderEnvKey(envKey, options) {
+  if (!envKey) return void 0;
+  for (const key of [envKey, ...options.aliases ?? []]) {
+    if (options.secrets[key] ?? process.env[key]) return key;
+  }
+  return envKey;
+}
+function hasProviderEnvValue(envKey, options) {
+  if (!envKey) return false;
+  return [envKey, ...options.aliases ?? []].some(
+    (key) => Boolean(options.secrets[key] ?? process.env[key])
+  );
+}
+function providerEnvKeys(provider) {
+  return [
+    provider.envKey,
+    ...provider.envKeyAliases ?? [],
+    provider.baseUrlEnvKey,
+    provider.modelEnvKey
+  ].filter((key) => Boolean(key));
+}
+
+export {
+  loadManifest,
+  definePlugin,
+  defineSkillPlugin,
+  defineConnectorPlugin,
+  defineChannelPlugin,
+  defineProviderPlugin
+};

package/dist/chunk-EEFMJYKB.js

@@ -0,0 +1,97 @@
+import {
+  buildRuntimeAssetK8sProvider
+} from "./chunk-POSVEKIY.js";
+
+// src/plugins/connector-kit.ts
+function connectorManifest(options) {
+  const capabilities = options.capabilities ?? ["tool", "data-source", "action"];
+  return {
+    id: options.id,
+    name: options.name,
+    description: options.description,
+    version: "1.0.0",
+    category: options.category,
+    icon: options.icon,
+    website: options.website,
+    docs: options.docs,
+    auth: {
+      type: options.authType ?? "api-key",
+      fields: options.fields
+    },
+    capabilities: capabilities.includes("skill") ? capabilities : [...capabilities, "skill"],
+    tags: options.tags,
+    popularity: options.popularity
+  };
+}
+function connectorField(key, label, options = {}) {
+  return {
+    key,
+    label,
+    description: options.description,
+    required: options.required ?? true,
+    sensitive: options.sensitive ?? true,
+    placeholder: options.placeholder,
+    helpUrl: options.helpUrl
+  };
+}
+function npmGlobalDependency(id, packages, description) {
+  return {
+    id,
+    kind: "npm-global",
+    packages,
+    targetPath: "/runtime-deps",
+    binPath: `/runtime-deps/bin/${id}`,
+    description
+  };
+}
+function installedCheck(id, label, command) {
+  return {
+    id,
+    label,
+    kind: "command",
+    command,
+    timeoutMs: 1e4,
+    risk: "safe"
+  };
+}
+function commandCheck(id, label, command, requiredEnvAny) {
+  return {
+    id,
+    label,
+    kind: "command",
+    command,
+    timeoutMs: 2e4,
+    risk: "safe",
+    requiredEnvAny
+  };
+}
+function attachConnectorRuntimeAssets(plugin, options) {
+  plugin.k8s = buildRuntimeAssetK8sProvider({
+    pluginId: plugin.manifest.id,
+    isEnabled: (agent, config) => {
+      const agentEnabled = agent.use?.some((entry) => entry.plugin === plugin.manifest.id);
+      const globalEnabled = Array.isArray(config.use) && config.use.some(
+        (entry) => entry && typeof entry === "object" && entry.plugin === plugin.manifest.id
+      );
+      return Boolean(agentEnabled || globalEnabled);
+    },
+    runtimeMountPath: options.runtimeMountPath,
+    initRuntimeMountPath: options.initRuntimeMountPath,
+    skillsMountPath: options.skillsMountPath,
+    subagentsMountPath: options.subagentsMountPath,
+    runtimeDependencies: options.runtimeDependencies,
+    skillSources: options.skillSources,
+    subagentSources: options.subagentSources,
+    sanityCommands: options.sanityCommands
+  });
+  return plugin;
+}
+
+export {
+  connectorManifest,
+  connectorField,
+  npmGlobalDependency,
+  installedCheck,
+  commandCheck,
+  attachConnectorRuntimeAssets
+};