@shadowob/cloud 1.1.6-dev.311

package/dist/chunk-QV4XWO3P.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+// src/interfaces/cli/dashboard.command.ts
+import { exec } from "child_process";
+import { Command } from "commander";
+function createConsoleCommand(container) {
+  return new Command("console").description("Start the Shadow Cloud Console and open it in your browser").option("-p, --port <number>", "Port to listen on", "3004").option("-n, --namespace <ns...>", "Kubernetes namespace(s) to watch", ["shadowob-cloud"]).option("--no-open", "Do not open browser automatically").action(async (options) => {
+    const port = options.port;
+    const url = `http://localhost:${port}`;
+    if (options.open) {
+      setTimeout(() => {
+        container.logger.info(`Opening ${url} in browser...`);
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        exec(`${cmd} ${url}`, (err) => {
+          if (err) container.logger.dim("Could not open browser automatically");
+        });
+      }, 1500);
+    }
+    const { createServeCommand } = await import("./serve.command-5FMIPQRY.js");
+    const serve = createServeCommand(container);
+    await serve.parseAsync(
+      ["--port", port, "--namespace", ...options.namespace, "--host", "127.0.0.1"],
+      { from: "user" }
+    );
+  });
+}
+
+export {
+  createConsoleCommand
+};

package/dist/chunk-R52J3PH2.js

@@ -0,0 +1,120 @@
+import {
+  collectRuntimeEnvRequirements
+} from "./chunk-SUZ2ATT6.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
+};

package/dist/chunk-R5U7XKVJ.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __require,
+  __export
+};

package/dist/chunk-RECNVWMT.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+// src/plugins/runtime-assets.ts
+var RUNTIME_ASSET_IMAGE = "node:22-alpine";
+var DEFAULT_CONTAINER_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+var PLUGIN_RUNTIME_DEPS_ROOT = "/opt/shadow-plugin-deps";
+var PLUGIN_SKILLS_STAGING_ROOT = "/plugin-skills";
+var PLUGIN_SUBAGENTS_STAGING_ROOT = "/plugin-subagents";
+function shQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function sanitizeId(value) {
+  return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 63);
+}
+function copyGitSourceSnippet(source, destRoot) {
+  const safeId = sanitizeId(source.id);
+  const clonePath = `/tmp/runtime-asset-src-${safeId}`;
+  const ref = source.ref ?? "main";
+  const from = source.from ?? ".";
+  const sourcePath = from === "." || from === "" ? clonePath : `${clonePath}/${from}`;
+  const commands = [
+    `rm -rf ${shQuote(clonePath)}`,
+    `git clone --depth 1 --branch ${shQuote(ref)} ${shQuote(source.url ?? "")} ${shQuote(clonePath)}`,
+    `mkdir -p ${shQuote(destRoot)}`
+  ];
+  if (source.include?.length) {
+    for (const item of source.include) {
+      commands.push(
+        `if [ -e ${shQuote(`${sourcePath}/${item}`)} ]; then cp -R ${shQuote(`${sourcePath}/${item}`)} ${shQuote(destRoot)}/; fi`
+      );
+    }
+  } else if (source.includePattern) {
+    commands.push(
+      `if [ -d ${shQuote(sourcePath)} ]; then find ${shQuote(sourcePath)} -maxdepth 1 -type d -name ${shQuote(source.includePattern)} -exec cp -R {} ${shQuote(destRoot)}/ \\;; fi`
+    );
+  } else {
+    commands.push(
+      `if [ -d ${shQuote(sourcePath)} ]; then cp -R ${shQuote(sourcePath)}/. ${shQuote(destRoot)}/; elif [ -f ${shQuote(sourcePath)} ]; then cp ${shQuote(sourcePath)} ${shQuote(destRoot)}/; fi`
+    );
+  }
+  return commands.join("\n");
+}
+function runtimeDependencySnippet(dep, runtimeRoot) {
+  switch (dep.kind) {
+    case "npm-global": {
+      const packages = dep.packages?.filter(Boolean) ?? [];
+      if (packages.length === 0) return "";
+      return `npm install -g --prefix ${shQuote(dep.targetPath ?? runtimeRoot)} ${packages.map(shQuote).join(" ")}`;
+    }
+    case "system-package": {
+      const packages = dep.packages?.filter(Boolean) ?? [];
+      if (packages.length === 0) return "";
+      return `install_system_packages ${packages.map(shQuote).join(" ")}`;
+    }
+    case "shell":
+      return dep.command?.length ? dep.command.join(" ") : "";
+    case "binary":
+      return dep.command?.length ? dep.command.join(" ") : "";
+    default:
+      return "";
+  }
+}
+function systemPackageInstallerSnippet() {
+  return [
+    "install_system_packages() {",
+    '  if [ "$#" -eq 0 ]; then return 0; fi',
+    '  pm=""',
+    "  if command -v apk >/dev/null 2>&1; then",
+    '    pm="apk"',
+    "  elif command -v apt-get >/dev/null 2>&1; then",
+    '    pm="apt"',
+    "  else",
+    '    echo "[runtime-assets] no supported package manager found for: $*" >&2',
+    "    return 127",
+    "  fi",
+    '  normalized=""',
+    '  for pkg in "$@"; do',
+    '    case "$pm:$pkg" in',
+    '      apt:py3-pip) pkg="python3-pip" ;;',
+    '      apt:py3-virtualenv) pkg="python3-venv" ;;',
+    '      apt:github-cli) pkg="gh" ;;',
+    "    esac",
+    '    normalized="$normalized ${pkg}"',
+    "  done",
+    '  if [ "$pm" = "apk" ]; then',
+    "    apk add --no-cache $normalized",
+    "  else",
+    "    export DEBIAN_FRONTEND=noninteractive",
+    "    apt-get update >/dev/null",
+    "    apt-get install -y --no-install-recommends $normalized",
+    "    rm -rf /var/lib/apt/lists/*",
+    "  fi",
+    "}"
+  ].join("\n");
+}
+function buildRuntimeAssetInstallScript(options) {
+  const runtimeRoot = options.runtimeRoot ?? "/runtime-deps";
+  const skillsRoot = options.skillsRoot ?? "/plugin-skills";
+  const subagentsRoot = options.subagentsRoot ?? "/plugin-subagents";
+  const hasGitSources = Boolean(options.skillSources?.length || options.subagentSources?.length);
+  const needsSystemInstaller = Boolean(
+    hasGitSources || options.runtimeDependencies?.some((dep) => dep.kind === "system-package")
+  );
+  const lines = [
+    "set -eu",
+    ...needsSystemInstaller ? [systemPackageInstallerSnippet()] : [],
+    `mkdir -p ${shQuote(runtimeRoot)}`
+  ];
+  if (options.skillSources?.length) lines.push(`mkdir -p ${shQuote(skillsRoot)}`);
+  if (options.subagentSources?.length) lines.push(`mkdir -p ${shQuote(subagentsRoot)}`);
+  if (hasGitSources) {
+    lines.push("command -v git >/dev/null 2>&1 || install_system_packages git >/dev/null");
+  }
+  for (const dep of options.runtimeDependencies ?? []) {
+    const snippet = runtimeDependencySnippet(dep, runtimeRoot);
+    if (snippet) lines.push(snippet);
+  }
+  for (const source of options.skillSources ?? []) {
+    if (source.kind === "git" && source.url) lines.push(copyGitSourceSnippet(source, skillsRoot));
+  }
+  for (const source of options.subagentSources ?? []) {
+    if (source.kind === "git" && source.url) lines.push(copyGitSourceSnippet(source, subagentsRoot));
+  }
+  lines.push(...options.sanityCommands ?? []);
+  lines.push('echo "[runtime-assets] ready"');
+  return lines.filter(Boolean).join("\n");
+}
+function buildRuntimeAssetK8sProvider(options) {
+  return {
+    buildK8s(agent, ctx) {
+      if (!options.isEnabled(agent, ctx.config)) return void 0;
+      const runtimeVolumeName = options.runtimeVolumeName ?? `${options.pluginId}-runtime`;
+      const skillsVolumeName = options.skillsVolumeName ?? `${options.pluginId}-skills`;
+      const subagentsVolumeName = options.subagentsVolumeName ?? `${options.pluginId}-subagents`;
+      const runtimeMountPath = options.runtimeMountPath ?? `${PLUGIN_RUNTIME_DEPS_ROOT}/${options.pluginId}`;
+      const initRuntimeMountPath = options.initRuntimeMountPath ?? "/runtime-deps";
+      const skillsMountPath = options.skillsMountPath;
+      const subagentsMountPath = options.subagentsMountPath;
+      const hasSkillSources = Boolean(options.skillSources?.length && skillsMountPath);
+      const hasSubagentSources = Boolean(options.subagentSources?.length && subagentsMountPath);
+      const volumeMounts = [{ name: runtimeVolumeName, mountPath: initRuntimeMountPath }];
+      const volumes = [{ name: runtimeVolumeName, spec: { emptyDir: {} } }];
+      const mainVolumeMounts = [
+        { name: runtimeVolumeName, mountPath: runtimeMountPath, readOnly: true }
+      ];
+      if (hasSkillSources) {
+        volumeMounts.push({ name: skillsVolumeName, mountPath: PLUGIN_SKILLS_STAGING_ROOT });
+        volumes.push({ name: skillsVolumeName, spec: { emptyDir: {} } });
+        mainVolumeMounts.push({
+          name: skillsVolumeName,
+          mountPath: skillsMountPath,
+          readOnly: true
+        });
+      }
+      if (hasSubagentSources) {
+        volumeMounts.push({ name: subagentsVolumeName, mountPath: PLUGIN_SUBAGENTS_STAGING_ROOT });
+        volumes.push({ name: subagentsVolumeName, spec: { emptyDir: {} } });
+        mainVolumeMounts.push({
+          name: subagentsVolumeName,
+          mountPath: subagentsMountPath,
+          readOnly: true
+        });
+      }
+      return {
+        initContainers: [
+          {
+            name: `${options.pluginId}-assets`,
+            image: RUNTIME_ASSET_IMAGE,
+            imagePullPolicy: "IfNotPresent",
+            command: [
+              "sh",
+              "-lc",
+              buildRuntimeAssetInstallScript({
+                runtimeDependencies: options.runtimeDependencies,
+                skillSources: options.skillSources,
+                subagentSources: options.subagentSources,
+                runtimeRoot: initRuntimeMountPath,
+                sanityCommands: options.sanityCommands
+              })
+            ],
+            volumeMounts,
+            resources: {
+              requests: { cpu: "100m", memory: "128Mi" },
+              limits: { cpu: "1000m", memory: "512Mi" }
+            },
+            securityContext: {
+              allowPrivilegeEscalation: false,
+              runAsNonRoot: false,
+              runAsUser: 0,
+              runAsGroup: 0,
+              capabilities: { drop: ["ALL"] }
+            }
+          }
+        ],
+        volumes,
+        volumeMounts: mainVolumeMounts,
+        envVars: [
+          { name: "PATH", value: `${runtimeMountPath}/bin:${DEFAULT_CONTAINER_PATH}` },
+          ...options.envVars ?? []
+        ],
+        labels: {
+          [`plugin.${options.pluginId}/enabled`]: "true",
+          ...options.labels ?? {}
+        }
+      };
+    }
+  };
+}
+
+export {
+  buildRuntimeAssetK8sProvider
+};

package/dist/chunk-RTPBU5HF.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/utils/state.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+function getStateDir(configFilePath, stateSubdir = ".shadowob") {
+  return join(dirname(resolve(configFilePath)), stateSubdir);
+}
+function getStatePath(configFilePath, stateSubdir = ".shadowob") {
+  return join(getStateDir(configFilePath, stateSubdir), "provision-state.json");
+}
+function loadProvisionState(configFilePath, stateSubdir = ".shadowob") {
+  const statePath = getStatePath(configFilePath, stateSubdir);
+  if (!existsSync(statePath)) return null;
+  try {
+    const raw = readFileSync(statePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveProvisionState(configFilePath, state, stateSubdir = ".shadowob") {
+  const stateDir = getStateDir(configFilePath, stateSubdir);
+  const statePath = getStatePath(configFilePath, stateSubdir);
+  mkdirSync(stateDir, { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+  return statePath;
+}
+function mergeProvisionState(existing, newState) {
+  if (!existing) return newState;
+  const mergedPlugins = {};
+  for (const [pluginId, pluginState] of Object.entries(existing.plugins ?? {})) {
+    mergedPlugins[pluginId] = { ...pluginState };
+  }
+  for (const [pluginId, pluginState] of Object.entries(newState.plugins ?? {})) {
+    const prev = mergedPlugins[pluginId] ?? {};
+    const merged = { ...prev };
+    for (const [key, value] of Object.entries(pluginState)) {
+      const prevValue = prev[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && prevValue !== null && typeof prevValue === "object" && !Array.isArray(prevValue)) {
+        merged[key] = {
+          ...prevValue,
+          ...value
+        };
+      } else {
+        merged[key] = value;
+      }
+    }
+    mergedPlugins[pluginId] = merged;
+  }
+  return { ...newState, plugins: mergedPlugins };
+}
+function formatProvisionState(state) {
+  const lines = [];
+  lines.push(`Provisioned at  : ${new Date(state.provisionedAt).toLocaleString()}`);
+  if (state.namespace) lines.push(`K8s Namespace   : ${state.namespace}`);
+  if (state.stackName) lines.push(`Pulumi Stack    : ${state.stackName}`);
+  const shadowob = state.plugins?.shadowob;
+  if (shadowob) {
+    if (shadowob.shadowServerUrl) lines.push(`Shadow Server URL: ${shadowob.shadowServerUrl}`);
+    lines.push("");
+    if (shadowob.servers && Object.keys(shadowob.servers).length > 0) {
+      lines.push("Servers:");
+      for (const [configId, realId] of Object.entries(shadowob.servers)) {
+        lines.push(`  ${configId.padEnd(24)} \u2192 ${realId}`);
+      }
+    }
+    if (shadowob.channels && Object.keys(shadowob.channels).length > 0) {
+      lines.push("Channels:");
+      for (const [configId, realId] of Object.entries(shadowob.channels)) {
+        lines.push(`  ${configId.padEnd(24)} \u2192 ${realId}`);
+      }
+    }
+    if (shadowob.buddies && Object.keys(shadowob.buddies).length > 0) {
+      lines.push("Buddies:");
+      for (const [configId, info] of Object.entries(shadowob.buddies)) {
+        lines.push(`  ${configId.padEnd(24)} \u2192 agent: ${info.agentId}  user: ${info.userId}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  getStateDir,
+  getStatePath,
+  loadProvisionState,
+  saveProvisionState,
+  mergeProvisionState,
+  formatProvisionState
+};