@shadowob/cloud 1.1.6-dev.311

package/dist/chunk-JY2HTT7Q.js

@@ -0,0 +1,437 @@
+// 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-KEPTCLUO.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {
+  collectRuntimeEnvRequirements
+} from "./chunk-QET4LT4J.js";
+
+// src/interfaces/cli/init.command.ts
+import { cp, stat, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { Command } from "commander";
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createInitCommand(container) {
+  return new Command("init").description("Generate an shadowob-cloud.json config template").option("-o, --output <path>", "Output file path", "shadowob-cloud.json").option("-t, --template <name>", "Template name (use --list to see all)", "gstack-buddy").option("-l, --list", "List all available templates and exit").option("--force", "Overwrite existing file").option("--quick", "Quick init: read .env, pick default template, no prompts").action(
+    async (options) => {
+      const templates = await container.template.discover();
+      if (options.list) {
+        console.log("\nAvailable templates:\n");
+        const maxName = Math.max(...templates.map((t) => t.name.length), 6);
+        const maxTitle = Math.min(Math.max(...templates.map((t) => t.title.length), 5), 32);
+        const header = `  ${"TEMPLATE".padEnd(maxName)}  ${"TITLE".padEnd(maxTitle)}  AGENTS  DESCRIPTION`;
+        console.log(header);
+        console.log(`  ${"-".repeat(maxName)}  ${"-".repeat(maxTitle)}  ------  -----------`);
+        for (const t of templates) {
+          const nameStr = t.name.padEnd(maxName);
+          const title = t.title.length > maxTitle ? `${t.title.slice(0, maxTitle - 1)}\u2026` : t.title;
+          const titleStr = title.padEnd(maxTitle);
+          const agentStr = String(t.agentCount).padStart(6);
+          const desc = t.description.length > 60 ? `${t.description.slice(0, 57)}...` : t.description;
+          console.log(`  ${nameStr}  ${titleStr}  ${agentStr}  ${desc}`);
+        }
+        console.log();
+        console.log("  Use: shadowob-cloud init --template <name> [-o output.json]");
+        console.log();
+        return;
+      }
+      if (options.quick) {
+        const outputPath2 = resolve(options.output);
+        if (await fileExists(outputPath2) && !options.force) {
+          container.logger.error(`File already exists: ${outputPath2}`);
+          container.logger.dim("Use --force to overwrite");
+          process.exit(1);
+        }
+        const templateName2 = templates.find((template) => template.name === "gstack-buddy")?.name ?? templates[0]?.name ?? "gstack-buddy";
+        const content = await container.template.getTemplate(templateName2) ?? {
+          version: "1.0.0",
+          environment: "production",
+          plugins: { shadowob: { servers: [], buddies: [], bindings: [] } },
+          registry: { providers: [], configurations: [] },
+          deployments: { namespace: "shadowob-cloud", agents: [] }
+        };
+        const envKeys = await collectRuntimeEnvRequirements(content);
+        const detected = envKeys.filter((key) => process.env[key]);
+        if (detected.length > 0) {
+          container.logger.info(
+            `Detected ${detected.length} provider env var(s) \u2014 config will reference them via \${env:...}`
+          );
+          for (const key of detected) container.logger.dim(`  ${key}`);
+        } else {
+          container.logger.warn("No API keys found in environment. Add them to .env and re-run.");
+        }
+        await writeFile(outputPath2, `${JSON.stringify(content, null, 2)}
+`, "utf-8");
+        container.logger.success(`Quick init from "${templateName2}": ${outputPath2}`);
+        container.logger.dim(
+          `Edit the file and run: shadowob-cloud validate -f ${options.output}`
+        );
+        return;
+      }
+      const outputPath = resolve(options.output);
+      if (await fileExists(outputPath) && !options.force) {
+        container.logger.error(`File already exists: ${outputPath}`);
+        container.logger.dim("Use --force to overwrite");
+        process.exit(1);
+      }
+      const templateName = options.template;
+      const meta = templates.find((t) => t.name === templateName);
+      if (!meta && templates.length > 0) {
+        container.logger.error(`Unknown template: ${templateName}`);
+        container.logger.dim(`Available: ${templates.map((t) => t.name).join(", ")}`);
+        container.logger.dim("Run: shadowob-cloud init --list");
+        process.exit(1);
+      }
+      const templateFilePath = meta ? await container.template.getTemplatePath(meta.name) : null;
+      if (!templateFilePath || !await fileExists(templateFilePath)) {
+        await writeFile(
+          outputPath,
+          `${JSON.stringify(
+            {
+              version: "1.0.0",
+              environment: "production",
+              plugins: { shadowob: { servers: [], buddies: [], bindings: [] } },
+              registry: { providers: [], configurations: [] },
+              deployments: { namespace: "shadowob-cloud", agents: [] }
+            },
+            null,
+            2
+          )}
+`,
+          "utf-8"
+        );
+        container.logger.success(`Created: ${outputPath}`);
+        return;
+      }
+      await cp(templateFilePath, outputPath);
+      container.logger.success(`Created config from "${templateName}" template: ${outputPath}`);
+      container.logger.dim(
+        `Edit the file, then run: shadowob-cloud validate -f ${options.output}`
+      );
+    }
+  );
+}
+
+export {
+  createInitCommand
+};