@xano/sdk 1.0.0

package/dist/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/dist/chunk-Q325JKYB.js

@@ -0,0 +1,189 @@
+import {
+  AGENTS_MD_PATH,
+  CODEGEN_MARKER,
+  managedBlockVersion,
+  renderAgentsMd,
+  upsertManagedBlock
+} from "./chunk-AHJWCYQO.js";
+import {
+  detectPackageManager
+} from "./chunk-WRBKLYSJ.js";
+import {
+  allFrontendPresets
+} from "./chunk-OPHB5ORL.js";
+import {
+  allIconLibraries
+} from "./chunk-UCQ2VUTG.js";
+import {
+  projectFileCli,
+  projectSdkDir,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  DEFAULT_DARK_MODE
+} from "./chunk-TFFGOFVZ.js";
+
+// src/emit/agent-file-refresh.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { basename, join as join2 } from "path";
+
+// src/emit/project-detect.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function readJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readText(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function installedPackages(projectDir) {
+  const pkg = readJson(join(projectDir, "package.json"));
+  const names = /* @__PURE__ */ new Set();
+  for (const block of ["dependencies", "devDependencies"]) {
+    const deps = pkg?.[block];
+    if (typeof deps === "object" && deps !== null) {
+      for (const name of Object.keys(deps)) names.add(name);
+    }
+  }
+  return names;
+}
+function detectFrontendPreset(projectDir) {
+  const installed = installedPackages(projectDir);
+  if (installed.size === 0) return void 0;
+  let best;
+  let bestScore = 0;
+  let tied = false;
+  for (const preset of allFrontendPresets()) {
+    const declared = Object.keys(preset.dependencies);
+    if (declared.length === 0) continue;
+    const score = declared.filter((name) => installed.has(name)).length / declared.length;
+    if (score > bestScore) {
+      best = preset;
+      bestScore = score;
+      tied = false;
+    } else if (score === bestScore && score > 0) {
+      tied = true;
+    }
+  }
+  return bestScore > 0 && !tied ? best : void 0;
+}
+function detectIconLibrary(projectDir) {
+  const installed = installedPackages(projectDir);
+  for (const library of allIconLibraries()) {
+    for (const binding of [library.react, library.svelte]) {
+      if (Object.keys(binding.dependency).some((name) => installed.has(name))) return library.id;
+    }
+  }
+  return void 0;
+}
+function detectThemeLabel(projectDir) {
+  const css = readText(join(projectDir, "frontend", "src", "index.css"));
+  const match = css?.match(/\/\*\s*Theme:\s*(.+?)\.\s*Rebrand here/);
+  const label = match?.[1]?.trim();
+  return label !== void 0 && label.length > 0 ? label : void 0;
+}
+function detectDarkMode(projectDir) {
+  if (existsSync(join(projectDir, "frontend", "src", "lib", "theme.ts"))) return "toggle";
+  const entries = [
+    join(projectDir, "frontend", "index.html"),
+    join(projectDir, "frontend", "src", "app.html")
+  ];
+  for (const entry of entries) {
+    const html = readText(entry);
+    if (html === void 0) continue;
+    return html.includes("prefers-color-scheme") ? "system" : "off";
+  }
+  return void 0;
+}
+function detectFrontendGuidance(projectDir) {
+  const preset = detectFrontendPreset(projectDir);
+  if (preset === void 0) return void 0;
+  const label = detectThemeLabel(projectDir);
+  return {
+    label: preset.label,
+    section: preset.agentGuidanceSection(detectIconLibrary(projectDir)),
+    ...label === void 0 ? {} : { theme: { theme: { label }, dark: detectDarkMode(projectDir) ?? DEFAULT_DARK_MODE } }
+  };
+}
+
+// src/emit/agent-file-refresh.ts
+var AGENT_ENV_VARS = [
+  "CLAUDECODE",
+  "CLAUDE_CODE",
+  "CURSOR_TRACE_ID",
+  "CURSOR_AGENT",
+  "CODEX_SANDBOX",
+  "AIDER_MODEL",
+  "GITHUB_COPILOT_AGENT"
+];
+function codingAgentDetected(env = process.env) {
+  return AGENT_ENV_VARS.some((name) => (env[name] ?? "") !== "");
+}
+var CI_ENV_VARS = [
+  "CI",
+  "GITHUB_ACTIONS",
+  "GITLAB_CI",
+  "BUILDKITE",
+  "TEAMCITY_VERSION"
+];
+function isCI(env = process.env) {
+  return CI_ENV_VARS.some((name) => (env[name] ?? "") !== "");
+}
+function guidanceModeFor(projectDir) {
+  return existsSync2(join2(projectDir, CODEGEN_MARKER)) ? "generated" : "authored";
+}
+function appNameFor(projectDir) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(projectDir, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.length > 0) return pkg.name;
+  } catch {
+  }
+  return basename(projectDir);
+}
+function refreshAgentFiles(opts) {
+  const env = opts.env ?? process.env;
+  if (opts.explicit !== true && (isCI(env) || !codingAgentDetected(env))) return [];
+  const path = AGENTS_MD_PATH;
+  const absolute = join2(opts.projectDir, path);
+  if (!existsSync2(absolute)) return [];
+  try {
+    const existing = readFileSync2(absolute, "utf8");
+    if (managedBlockVersion(existing) === null) return [];
+    const manager = detectPackageManager(opts.projectDir);
+    const rendered = renderAgentsMd(
+      opts.appName ?? appNameFor(opts.projectDir),
+      opts.mode ?? guidanceModeFor(opts.projectDir),
+      {
+        version: opts.sdkVersion,
+        frontend: opts.frontend ?? detectFrontendGuidance(opts.projectDir),
+        cli: projectFileCli(opts.projectDir, manager),
+        sdkDir: projectSdkDir(opts.projectDir, manager)
+      }
+    );
+    const updated = upsertManagedBlock(existing, rendered);
+    if (updated === existing) return [];
+    if (opts.write !== false) writeFileSync(absolute, updated);
+    return [path];
+  } catch (err) {
+    warn(`could not refresh ${path}: ${err instanceof Error ? err.message : String(err)}`, "agents.refresh-failed");
+    return [];
+  }
+}
+
+export {
+  detectFrontendPreset,
+  codingAgentDetected,
+  CI_ENV_VARS,
+  isCI,
+  refreshAgentFiles
+};
+//# sourceMappingURL=chunk-Q325JKYB.js.map

package/dist/chunk-Q7DGTQ5G.js

@@ -0,0 +1,255 @@
+// src/statements/surfaces.ts
+var STATEMENT_SURFACES = [
+  ["action.call", "mvp:action"],
+  ["action.package.call", "mvp:action_package"],
+  ["addon.call", "mvp:workspace_run_addon"],
+  ["ai.agent.run", "mvp:call_agent"],
+  ["ai.external.mcp.server_details", "mvp:mcp_server_details"],
+  ["ai.external.mcp.tool.list", "mvp:mcp_list_tools"],
+  ["ai.external.mcp.tool.run", "mvp:mcp_call_tool"],
+  ["api.call", "mvp:workspace_run_endpoint"],
+  ["api.realtime_event", "mvp:realtime_event"],
+  ["api.request", "mvp:api_request"],
+  ["api.stream", "mvp:streaming_api_response"],
+  ["array.difference", "mvp:array_difference"],
+  ["array.every", "mvp:array_every"],
+  ["array.filter_count", "mvp:array_filter_count"],
+  ["array.filter", "mvp:array_filter"],
+  ["array.find_index", "mvp:array_find_index"],
+  ["array.find", "mvp:array_find"],
+  ["array.group_by", "mvp:array_group_by"],
+  ["array.has", "mvp:array_has"],
+  ["array.intersection", "mvp:array_intersection"],
+  ["array.map", "mvp:array_map"],
+  ["array.merge", "mvp:array_merge"],
+  ["array.partition", "mvp:array_partition"],
+  ["array.pop", "mvp:array_pop"],
+  ["array.push", "mvp:array_push"],
+  ["array.shift", "mvp:array_shift"],
+  ["array.union", "mvp:array_union"],
+  ["array.unshift", "mvp:array_unshift"],
+  ["await", "mvp:async_function_await"],
+  ["break", "mvp:foreach_break"],
+  ["cloud.algolia.request", "mvp:algolia_request"],
+  ["cloud.aws.opensearch.document", "mvp:amazon_opensearch_document"],
+  ["cloud.aws.opensearch.query", "mvp:amazon_opensearch_query"],
+  ["cloud.aws.opensearch.request", "mvp:amazon_opensearch_request"],
+  ["cloud.aws.s3.delete_file", "mvp:amazon_s3_delete_file"],
+  ["cloud.aws.s3.get_file_info", "mvp:amazon_s3_get_file_metadata"],
+  ["cloud.aws.s3.list_directory", "mvp:amazon_s3_list_directory"],
+  ["cloud.aws.s3.read_file", "mvp:amazon_s3_create_var_from_file_resource"],
+  ["cloud.aws.s3.sign_url", "mvp:amazon_s3_signed_url"],
+  ["cloud.aws.s3.upload_file", "mvp:amazon_s3_upload_file"],
+  ["cloud.azure.storage.delete_file", "mvp:azure_blob_storage_delete_file"],
+  ["cloud.azure.storage.get_file_info", "mvp:azure_blob_storage_get_file_metadata"],
+  ["cloud.azure.storage.list_directory", "mvp:azure_blob_storage_list_directory"],
+  ["cloud.azure.storage.read_file", "mvp:azure_blob_storage_create_var_from_file_resource"],
+  ["cloud.azure.storage.sign_url", "mvp:azure_blob_storage_signed_url"],
+  ["cloud.azure.storage.upload_file", "mvp:azure_blob_storage_upload_file"],
+  ["cloud.elasticsearch.document", "mvp:elasticsearch_document"],
+  ["cloud.elasticsearch.query", "mvp:elasticsearch_query"],
+  ["cloud.elasticsearch.request", "mvp:elasticsearch_request"],
+  ["cloud.google.storage.delete_file", "mvp:google_cloud_storage_delete_file"],
+  ["cloud.google.storage.get_file_info", "mvp:google_cloud_storage_get_file_metadata"],
+  ["cloud.google.storage.list_directory", "mvp:google_cloud_storage_list_directory"],
+  ["cloud.google.storage.read_file", "mvp:google_cloud_storage_create_var_from_file_resource"],
+  ["cloud.google.storage.sign_url", "mvp:google_cloud_storage_signed_url"],
+  ["cloud.google.storage.upload_file", "mvp:google_cloud_storage_upload_file"],
+  ["cloud.job.await", "mvp:cloud_job_await"],
+  ["cloud.job.status", "mvp:cloud_job_status"],
+  ["cloud.job", "mvp:cloud_job"],
+  ["comment", "mvp:comment"],
+  ["conditional", "mvp:conditional"],
+  ["continue", "mvp:foreach_continue"],
+  ["datadog.log_bulk", "mvp:datadog_log_bulk"],
+  ["datadog.log", "mvp:datadog_log"],
+  ["datadog.metric_bulk", "mvp:datadog_metric_bulk"],
+  ["datadog.metric", "mvp:datadog_metric"],
+  ["db.add_or_edit", "mvp:dbo_addoreditby"],
+  ["db.add", "mvp:dbo_add"],
+  ["db.bulk.add", "mvp:dbo_bulkadd"],
+  ["db.bulk.delete", "mvp:dbo_bulkdelete"],
+  ["db.bulk.patch", "mvp:dbo_bulkpatch"],
+  ["db.bulk.update", "mvp:dbo_bulkupdate"],
+  ["db.del", "mvp:dbo_delby"],
+  ["db.direct_query", "mvp:dbo_direct_query"],
+  ["db.edit", "mvp:dbo_editby"],
+  ["db.external.mssql.direct_query", "mvp:dbo_external_mssql_query"],
+  ["db.external.mysql.direct_query", "mvp:dbo_external_mysql_query"],
+  ["db.external.oracle.direct_query", "mvp:dbo_external_oracle_query"],
+  ["db.external.postgres.direct_query", "mvp:dbo_external_postgres_query"],
+  ["db.external.snowflake.direct_query", "mvp:dbo_external_snowflake_query"],
+  ["db.get", "mvp:dbo_getby"],
+  ["db.has", "mvp:dbo_hasby"],
+  ["db.increment", "mvp:dbo_increment"],
+  ["db.patch", "mvp:dbo_patch"],
+  ["db.query", "mvp:dbo_view"],
+  ["db.schema", "mvp:dbo_get_schema"],
+  ["db.set_datasource", "mvp:set_data_source"],
+  ["db.transaction", "mvp:db_transaction"],
+  ["db.truncate", "mvp:dbo_truncate"],
+  ["debug.log", "mvp:debug_log"],
+  ["debug.stop", "mvp:die"],
+  ["for", "mvp:for"],
+  ["foreach.remove", "mvp:foreach_remove"],
+  ["foreach", "mvp:foreach"],
+  ["function.call", "mvp:workspace_run_function"],
+  ["function.run", "mvp:function"],
+  ["group", "mvp:group"],
+  ["lambda", "mvp:lambda"],
+  ["math.add", "mvp:math_add"],
+  ["math.bitwise.and", "mvp:bitwise_and"],
+  ["math.bitwise.or", "mvp:bitwise_or"],
+  ["math.bitwise.xor", "mvp:bitwise_xor"],
+  ["math.div", "mvp:math_div"],
+  ["math.mod", "mvp:math_mod"],
+  ["math.mul", "mvp:math_mul"],
+  ["math.sub", "mvp:math_sub"],
+  ["mcp.elicit", "mvp:mcp_elicit"],
+  ["mcp.oauth.complete", "mvp:mcp_oauth_complete"],
+  ["mcp.oauth.request", "mvp:mcp_oauth_request"],
+  ["mcp.oauth.revoke", "mvp:mcp_oauth_revoke"],
+  ["mcp.progress", "mvp:mcp_progress"],
+  ["middleware.call", "mvp:workspace_run_middleware"],
+  ["microservice.request", "mvp:microservice_request"],
+  ["object.entries", "mvp:object_entries"],
+  ["object.keys", "mvp:object_keys"],
+  ["object.values", "mvp:object_values"],
+  // `mvp:placeholder` has no surface on purpose. The engine writes one in place
+  // of a statement it could not resolve and then refuses the same bytes on
+  // import, so authoring one can only produce an un-deployable workspace. It is
+  // listed in {@link DECODE_ONLY_STATEMENTS}, carried through `raw()`, and
+  // blocked at `export()` — the same treatment retired versions get, and for the
+  // same reason: keeping it out of this catalog keeps it out of the manifest an
+  // agent authors from.
+  ["precondition", "mvp:precondition"],
+  ["realtime.get_session", "mvp:get_session"],
+  ["realtime.publish", "mvp:realtime_publish"],
+  ["redis.count", "mvp:redis_countlist"],
+  ["redis.decr", "mvp:redis_decr"],
+  ["redis.del", "mvp:redis_del"],
+  ["redis.get", "mvp:redis_get"],
+  ["redis.has", "mvp:redis_has"],
+  ["redis.incr", "mvp:redis_incr"],
+  ["redis.keys", "mvp:redis_keys"],
+  ["redis.pop", "mvp:redis_poplist"],
+  ["redis.push", "mvp:redis_pushlist"],
+  ["redis.range", "mvp:redis_rangelist"],
+  ["redis.ratelimit", "mvp:redis_ratelimit"],
+  ["redis.remove", "mvp:redis_remove_list"],
+  ["redis.set", "mvp:redis_set"],
+  ["redis.shift", "mvp:redis_shiftlist"],
+  ["redis.unshift", "mvp:redis_unshiftlist"],
+  ["return", "mvp:return"],
+  ["security.check_password", "mvp:check_pass"],
+  ["security.create_auth_token", "mvp:create_auth"],
+  ["security.create_curve_key", "mvp:crypto_create_ec_key"],
+  ["security.create_password", "mvp:generate_pass"],
+  ["security.create_rsa_key", "mvp:crypto_create_rsa_key"],
+  ["security.create_secret_key", "mvp:crypto_create_octet_key"],
+  ["security.create_uuid", "mvp:uuid4"],
+  ["security.decrypt", "mvp:crypto_decrypt"],
+  ["security.encrypt", "mvp:crypto_encrypt"],
+  // Only the LATEST of each versioned crypto family is authorable. The earlier
+  // spellings still run and still appear in pulled workspaces, but each version
+  // was a breaking change to the one before it, so offering them would invite
+  // authoring against a retired contract. They are listed in
+  // {@link SUPERSEDED_STATEMENTS} and carried through `raw()` instead — which
+  // also keeps them out of the agent-grounding manifest, since that is built
+  // from this catalog.
+  ["security.jwe_decode", "mvp:crypto_jwe_decode2"],
+  ["security.jwe_encode", "mvp:crypto_jwe_encode3"],
+  ["security.jws_decode", "mvp:crypto_jws_decode2"],
+  ["security.jws_encode", "mvp:crypto_jws_encode2"],
+  ["security.random_bytes", "mvp:random_bytes"],
+  ["security.random_number", "mvp:rand"],
+  ["stack|expect.to_be_defined", "mvp:test_expect_to_be_defined"],
+  ["stack|expect.to_be_empty", "mvp:test_expect_to_be_empty"],
+  ["stack|expect.to_be_false", "mvp:test_expect_to_be_false"],
+  ["stack|expect.to_be_greater_than", "mvp:test_expect_to_be_greater_than"],
+  ["stack|expect.to_be_in_the_future", "mvp:test_expect_to_be_in_the_future"],
+  ["stack|expect.to_be_in_the_past", "mvp:test_expect_to_be_in_the_past"],
+  ["stack|expect.to_be_less_than", "mvp:test_expect_to_be_less_than"],
+  ["stack|expect.to_be_null", "mvp:test_expect_to_be_null"],
+  ["stack|expect.to_be_true", "mvp:test_expect_to_be_true"],
+  ["stack|expect.to_be_within", "mvp:test_expect_to_be_within"],
+  ["stack|expect.to_contain", "mvp:test_expect_to_contain"],
+  ["stack|expect.to_end_with", "mvp:test_expect_to_end_with"],
+  ["stack|expect.to_equal", "mvp:test_expect_to_equal"],
+  ["stack|expect.to_match", "mvp:test_expect_to_match"],
+  ["stack|expect.to_not_be_defined", "mvp:test_expect_to_not_be_defined"],
+  ["stack|expect.to_not_be_null", "mvp:test_expect_to_not_be_null"],
+  ["stack|expect.to_not_equal", "mvp:test_expect_to_not_equal"],
+  ["stack|expect.to_start_with", "mvp:test_expect_to_start_with"],
+  ["stack|expect.to_throw", "mvp:test_expect_to_throw"],
+  ["storage.create_attachment", "mvp:create_attachment"],
+  ["storage.create_audio", "mvp:create_audio"],
+  ["storage.create_file_resource", "mvp:create_file_resource"],
+  ["storage.create_image", "mvp:create_image"],
+  ["storage.create_video", "mvp:create_video"],
+  ["storage.delete_file", "mvp:delete_file"],
+  ["storage.read_file_resource", "mvp:create_var_from_file_resource"],
+  ["storage.sign_private_url", "mvp:vault_sign_url"],
+  ["stream.from_csv", "mvp:csv_stream"],
+  ["stream.from_jsonl", "mvp:jsonl_stream"],
+  ["stream.from_request", "mvp:streaming_api_request"],
+  ["switch", "mvp:switch"],
+  ["task.call", "mvp:workspace_run_task"],
+  ["text.append", "mvp:text_append"],
+  ["text.contains", "mvp:text_contains"],
+  ["text.ends_with", "mvp:text_ends_with"],
+  ["text.icontains", "mvp:text_icontains"],
+  ["text.iends_with", "mvp:text_iends_with"],
+  ["text.istarts_with", "mvp:text_istarts_with"],
+  ["text.ltrim", "mvp:text_ltrim"],
+  ["text.prepend", "mvp:text_prepend"],
+  ["text.rtrim", "mvp:text_rtrim"],
+  ["text.starts_with", "mvp:text_starts_with"],
+  ["text.trim", "mvp:text_trim"],
+  ["throw", "mvp:throw_error"],
+  ["tool.call", "mvp:workspace_run_tool"],
+  ["trigger.call", "mvp:workspace_run_trigger"],
+  ["try_catch", "mvp:try_catch"],
+  ["util.geo_distance", "mvp:calculate_geo_distance"],
+  ["util.get_all_input", "mvp:get_all_input"],
+  ["util.get_env", "mvp:get_env"],
+  ["util.get_input", "mvp:get_input"],
+  ["util.get_raw_input", "mvp:get_input"],
+  ["util.get_vars", "mvp:get_vars"],
+  ["util.ip_lookup", "mvp:ipaddress_lookup"],
+  ["util.post_process", "mvp:post_process"],
+  ["util.send_email", "mvp:send_email"],
+  ["util.set_header", "mvp:setheader"],
+  ["util.sleep", "mvp:sleep"],
+  ["util.template_engine", "mvp:template_string"],
+  ["var.update", "mvp:update_var"],
+  ["var", "mvp:set_var"],
+  ["webflow.request", "mvp:connect_webflow_api_request"],
+  ["while", "mvp:while"],
+  ["workflow_test.call", "mvp:workspace_run_workflow_test"],
+  ["zip.add_to_archive", "mvp:zip_add_file_resource"],
+  ["zip.create_archive", "mvp:zip_create_file_resource"],
+  ["zip.delete_from_archive", "mvp:zip_delete_file_resource"],
+  ["zip.extract", "mvp:zip_extract_file_resource"],
+  ["zip.view_contents", "mvp:zip_view_contents"]
+];
+var TOTAL_STATEMENTS = STATEMENT_SURFACES.length;
+var IMPLEMENTED_STATEMENTS = STATEMENT_SURFACES.map(([key]) => key);
+var SPATH_OVERRIDES = {
+  break: "foreach_break",
+  continue: "foreach_continue",
+  "foreach.remove": "foreach_remove",
+  "var.update": "update_var",
+  var: "set_var"
+};
+function sPathOf(surfaceKey) {
+  return SPATH_OVERRIDES[surfaceKey] ?? surfaceKey.replace(/^stack\|/, "");
+}
+
+export {
+  STATEMENT_SURFACES,
+  TOTAL_STATEMENTS,
+  IMPLEMENTED_STATEMENTS,
+  sPathOf
+};
+//# sourceMappingURL=chunk-Q7DGTQ5G.js.map