@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/cli/flow-weaver-chunk-4DVY73ML.mjs

@@ -0,0 +1,280 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import {
+  Ze
+} from "./flow-weaver-chunk-GAQXZHNO.mjs";
+
+// src/marketplace/registry.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/marketplace/npmrc.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PUBLIC_REGISTRY = "https://registry.npmjs.org/";
+function parseNpmrc(text, env = process.env) {
+  const out = /* @__PURE__ */ new Map();
+  if (typeof text !== "string") return out;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+    let missing = false;
+    value = value.replace(/\$\{([^}]+)\}/g, (_, name) => {
+      const v = env[name];
+      if (v === void 0) missing = true;
+      return v ?? "";
+    });
+    if (missing) continue;
+    out.set(key, value);
+  }
+  return out;
+}
+function nerfDart(url) {
+  const u = new URL(url);
+  const p = u.pathname.endsWith("/") ? u.pathname : `${u.pathname}/`;
+  return `//${u.host}${p}`;
+}
+var withSlash = (u) => u.endsWith("/") ? u : `${u}/`;
+function readNpmConfig(projectDir, env = process.env, home = os.homedir()) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const file of [path.join(home, ".npmrc"), path.join(projectDir, ".npmrc")]) {
+    let text;
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const [k, v] of parseNpmrc(text, env)) merged.set(k, v);
+  }
+  const envRegistry = env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY;
+  if (envRegistry) merged.set("registry", envRegistry);
+  return merged;
+}
+function authorizationFor(url, config) {
+  const dart = nerfDart(url);
+  let best;
+  for (const [key, value] of config) {
+    const m = key.match(/^(\/\/.+\/):(_authToken|_auth|_password)$/);
+    if (!m || !dart.startsWith(m[1]) || !value) continue;
+    if (best && m[1].length <= best.len) continue;
+    if (m[2] === "_authToken") best = { len: m[1].length, value: `Bearer ${value}` };
+    else if (m[2] === "_auth") best = { len: m[1].length, value: `Basic ${value}` };
+    else {
+      const user = config.get(`${m[1]}:username`);
+      if (user) best = { len: m[1].length, value: `Basic ${Buffer.from(`${user}:${value}`).toString("base64")}` };
+    }
+  }
+  return best?.value;
+}
+function resolveRegistries(projectDir, config = readNpmConfig(projectDir)) {
+  const byUrl = /* @__PURE__ */ new Map();
+  const defaultUrl = withSlash(config.get("registry") || PUBLIC_REGISTRY);
+  byUrl.set(defaultUrl, { url: defaultUrl, scopes: [], isDefault: true });
+  for (const [key, value] of config) {
+    const m = key.match(/^(@[^:]+):registry$/);
+    if (!m || !value) continue;
+    const url = withSlash(value);
+    const r = byUrl.get(url) ?? { url, scopes: [], isDefault: false };
+    r.scopes.push(m[1]);
+    byUrl.set(url, r);
+  }
+  for (const r of byUrl.values()) {
+    const authorization = authorizationFor(r.url, config);
+    if (authorization) r.authorization = authorization;
+  }
+  return [...byUrl.values()];
+}
+
+// src/marketplace/registry.ts
+var MARKETPLACE_KEYWORD = "flow-weaver-marketplace-pack";
+var NPM_SEARCH_URL = "https://registry.npmjs.org/-/v1/search";
+var PACK_NAME_RE = /^(@[^/]+\/)?flow-weaver-pack-.+$/;
+function isPackResult(pkg) {
+  return (pkg.keywords ?? []).includes(MARKETPLACE_KEYWORD) || PACK_NAME_RE.test(pkg.name);
+}
+async function searchOne(searchUrl, query, limit, publicSyntax, authorization) {
+  const url = new URL(searchUrl);
+  const text = publicSyntax ? [`keywords:${MARKETPLACE_KEYWORD}`, ...query ? [query] : []].join(" ") : query || "flow-weaver";
+  url.searchParams.set("text", text);
+  url.searchParams.set("size", String(limit));
+  const response = await fetch(url.toString(), authorization ? { headers: { Authorization: authorization } } : void 0);
+  if (!response.ok) {
+    throw new Error(`npm search failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return (data.objects ?? []).filter((obj) => isPackResult(obj.package)).map((obj) => ({
+    name: obj.package.name,
+    version: obj.package.version,
+    description: obj.package.description,
+    keywords: obj.package.keywords,
+    publisher: obj.package.publisher?.username,
+    official: obj.package.name.startsWith("@synergenius/")
+  }));
+}
+async function searchPackages(options = {}) {
+  const { query, limit = 20, registryUrl } = options;
+  const searchUrl = registryUrl ?? NPM_SEARCH_URL;
+  const isPublic = searchUrl.startsWith(PUBLIC_REGISTRY);
+  let authorization;
+  if (registryUrl) {
+    try {
+      authorization = resolveRegistries(process.cwd()).find((r) => searchUrl.startsWith(r.url))?.authorization;
+    } catch {
+      authorization = void 0;
+    }
+  }
+  return searchOne(searchUrl, query, limit, isPublic, authorization);
+}
+async function searchAllRegistries(options = {}) {
+  const { query, limit = 20 } = options;
+  const registries = options.registries ?? resolveRegistries(options.projectDir ?? process.cwd());
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const searched = [];
+  await Promise.all(registries.map(async (r) => {
+    const entry = { url: r.url, scopes: r.scopes, authenticated: !!r.authorization, ok: false, count: 0 };
+    try {
+      const found = await searchOne(`${r.url}-/v1/search`, query, limit, r.url === PUBLIC_REGISTRY, r.authorization);
+      entry.ok = true;
+      entry.count = found.length;
+      for (const pkg of found) {
+        if (seen.has(pkg.name)) continue;
+        seen.add(pkg.name);
+        results.push({ ...pkg, registry: new URL(r.url).host });
+      }
+    } catch (err) {
+      entry.error = getErrorMessage(err);
+    }
+    searched.push(entry);
+  }));
+  searched.sort((a, b) => registries.findIndex((r) => r.url === a.url) - registries.findIndex((r) => r.url === b.url));
+  return { results, searched };
+}
+async function listInstalledPackages(projectDir) {
+  const nodeModules = path2.join(projectDir, "node_modules");
+  if (!fs2.existsSync(nodeModules)) return [];
+  const patterns = [
+    path2.join(nodeModules, "*", "flowweaver.manifest.json"),
+    path2.join(nodeModules, "@*", "*", "flowweaver.manifest.json")
+  ];
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const manifestPaths = await Ze(pattern.replace(/\\/g, "/"), { absolute: true });
+    for (const manifestPath of manifestPaths) {
+      try {
+        const pkgDir = path2.dirname(manifestPath);
+        const manifest = JSON.parse(
+          fs2.readFileSync(manifestPath, "utf-8")
+        );
+        if (seen.has(manifest.name)) continue;
+        seen.add(manifest.name);
+        const pkgJsonPath = path2.join(pkgDir, "package.json");
+        let version = manifest.version;
+        if (fs2.existsSync(pkgJsonPath)) {
+          const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+          version = pkg.version ?? manifest.version;
+        }
+        results.push({
+          name: manifest.name,
+          version,
+          manifest,
+          path: pkgDir
+        });
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+function getInstalledPackageManifest(projectDir, packageName) {
+  const packageDir = path2.join(projectDir, "node_modules", packageName);
+  const manifestPath = path2.join(packageDir, "flowweaver.manifest.json");
+  if (!fs2.existsSync(manifestPath)) return null;
+  try {
+    return JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function discoverTagHandlers(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const handlers = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.tagHandlers) continue;
+    for (const handler of manifest.tagHandlers) {
+      handlers.push({
+        ...handler,
+        absoluteFile: path2.join(pkg.path, handler.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return handlers;
+}
+async function discoverValidationRuleSets(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const ruleSets = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.validationRuleSets) continue;
+    for (const ruleSet of manifest.validationRuleSets) {
+      ruleSets.push({
+        ...ruleSet,
+        absoluteFile: path2.join(pkg.path, ruleSet.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return ruleSets;
+}
+async function discoverDocTopics(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const topics = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.docs) continue;
+    for (const doc of manifest.docs) {
+      topics.push({
+        ...doc,
+        absoluteFile: path2.join(pkg.path, doc.file),
+        packageName: pkg.name
+      });
+    }
+  }
+  return topics;
+}
+async function discoverInitContributions(projectDir) {
+  const packages = await listInstalledPackages(projectDir);
+  const contributions = [];
+  for (const pkg of packages) {
+    const manifest = pkg.manifest;
+    if (!manifest.initContributions) continue;
+    contributions.push({
+      ...manifest.initContributions,
+      packageName: pkg.name
+    });
+  }
+  return contributions;
+}
+
+export {
+  resolveRegistries,
+  searchPackages,
+  searchAllRegistries,
+  listInstalledPackages,
+  getInstalledPackageManifest,
+  discoverTagHandlers,
+  discoverValidationRuleSets,
+  discoverDocTopics,
+  discoverInitContributions
+};

package/dist/cli/flow-weaver-chunk-54M4KNEL.mjs

@@ -0,0 +1,200 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  compileWorkflow
+} from "./flow-weaver-chunk-V6DHWFQG.mjs";
+import {
+  AnnotationParser
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+
+// src/export/index.ts
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+async function exportWorkflow(options) {
+  const { createTargetRegistry } = await import("./flow-weaver-deployment-WJJRK7NO.mjs");
+  const registry = await createTargetRegistry(options.projectDir ?? process.cwd());
+  const target = registry.get(options.target);
+  if (!target) {
+    const available = registry.getNames();
+    throw new Error(
+      available.length === 0 ? `No export targets installed. Install a target pack (e.g. npm install flow-weaver-pack-${options.target})` : `Unknown target "${options.target}". Installed: ${available.join(", ")}`
+    );
+  }
+  const inputPath = path.resolve(options.input);
+  const outputDir = path.resolve(options.output);
+  const isDryRun = options.dryRun ?? false;
+  if (options.multi) {
+    return exportMultiWorkflowViaRegistry(
+      target,
+      inputPath,
+      outputDir,
+      isDryRun,
+      options
+    );
+  }
+  return exportSingleWorkflowViaRegistry(
+    target,
+    inputPath,
+    outputDir,
+    isDryRun,
+    options
+  );
+}
+async function exportSingleWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+  const parser = new AnnotationParser();
+  const projectDir = path.dirname(inputPath);
+  await parser.loadPackHandlers(projectDir);
+  const parseResult = parser.parse(inputPath);
+  if (parseResult.workflows.length === 0) {
+    throw new Error(`No workflows found in ${inputPath}`);
+  }
+  const workflow = options.workflow ? parseResult.workflows.find(
+    (w) => w.name === options.workflow || w.functionName === options.workflow
+  ) : parseResult.workflows[0];
+  if (!workflow) {
+    const available = parseResult.workflows.map((w) => w.name).join(", ");
+    throw new Error(`Workflow "${options.workflow}" not found. Available: ${available}`);
+  }
+  const artifacts = await target.generate({
+    sourceFile: inputPath,
+    workflowName: workflow.functionName,
+    displayName: workflow.name,
+    outputDir,
+    description: workflow.description,
+    production: options.production ?? false,
+    includeDocs: options.includeDocs,
+    targetOptions: {
+      ...options.durableSteps && { durableSteps: true }
+    }
+  });
+  const needsCompiledWorkflow = artifacts.files.some(
+    (f) => f.type === "handler" && f.content.includes("from './workflow")
+  );
+  let compiledContent;
+  if (needsCompiledWorkflow) {
+    const workDir = isDryRun ? path.join(os.tmpdir(), `fw-export-dryrun-${Date.now()}`) : outputDir;
+    fs.mkdirSync(workDir, { recursive: true });
+    try {
+      const compiledPath = await compileToOutput(
+        inputPath,
+        workflow.functionName,
+        workDir,
+        options.production
+      );
+      compiledContent = fs.readFileSync(compiledPath, "utf8");
+    } finally {
+      if (isDryRun) {
+        try {
+          fs.rmSync(workDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+  }
+  const files = artifacts.files.map((f) => ({
+    path: path.join(outputDir, f.relativePath),
+    content: f.content
+  }));
+  if (compiledContent) {
+    const workflowOutputPath = path.join(outputDir, "workflow.ts");
+    files.push({ path: workflowOutputPath, content: compiledContent });
+  }
+  if (!isDryRun) {
+    for (const file of files) {
+      const dirPath = path.dirname(file.path);
+      fs.mkdirSync(dirPath, { recursive: true });
+      fs.writeFileSync(file.path, file.content, "utf-8");
+    }
+  }
+  return {
+    target: options.target,
+    files,
+    workflow: workflow.name,
+    description: workflow.description,
+    warnings: artifacts.warnings
+  };
+}
+async function exportMultiWorkflowViaRegistry(target, inputPath, outputDir, isDryRun, options) {
+  if (!fs.existsSync(inputPath)) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+  const parser = new AnnotationParser();
+  const projectDir = path.dirname(inputPath);
+  await parser.loadPackHandlers(projectDir);
+  const parseResult = parser.parse(inputPath);
+  if (parseResult.workflows.length === 0) {
+    throw new Error(`No workflows found in ${inputPath}`);
+  }
+  let selectedWorkflows = parseResult.workflows;
+  if (options.workflows && options.workflows.length > 0) {
+    selectedWorkflows = parseResult.workflows.filter(
+      (w) => options.workflows.includes(w.name) || options.workflows.includes(w.functionName)
+    );
+    if (selectedWorkflows.length === 0) {
+      const available = parseResult.workflows.map((w) => w.name).join(", ");
+      throw new Error(`None of the requested workflows found. Available: ${available}`);
+    }
+  }
+  const serviceName = path.basename(options.input, path.extname(options.input)) + "-service";
+  const bundleWorkflows = selectedWorkflows.map((w) => ({
+    name: w.name,
+    functionName: w.functionName,
+    description: w.description,
+    expose: true
+  }));
+  if (!target.generateBundle) {
+    throw new Error(
+      `Target "${options.target}" does not support multi-workflow export`
+    );
+  }
+  const artifacts = await target.generateBundle(bundleWorkflows, [], {
+    sourceFile: inputPath,
+    workflowName: serviceName,
+    displayName: serviceName,
+    outputDir,
+    production: options.production ?? false,
+    includeDocs: options.includeDocs,
+    targetOptions: {
+      ...options.durableSteps && { durableSteps: true }
+    }
+  });
+  const files = artifacts.files.map(
+    (f) => ({
+      path: path.join(outputDir, f.relativePath),
+      content: f.content
+    })
+  );
+  if (!isDryRun) {
+    for (const file of files) {
+      const dirPath = path.dirname(file.path);
+      fs.mkdirSync(dirPath, { recursive: true });
+      fs.writeFileSync(file.path, file.content, "utf-8");
+    }
+  }
+  return {
+    target: options.target,
+    files,
+    workflow: serviceName,
+    workflows: selectedWorkflows.map((w) => w.name),
+    warnings: artifacts.warnings
+  };
+}
+async function compileToOutput(inputPath, functionName, outputDir, production) {
+  const outputPath = path.join(outputDir, "workflow.ts");
+  fs.copyFileSync(inputPath, outputPath);
+  await compileWorkflow(outputPath, {
+    write: true,
+    inPlace: true,
+    parse: { workflowName: functionName },
+    generate: { production: production ?? false }
+  });
+  return outputPath;
+}
+
+export {
+  exportWorkflow
+};