@skaile/workspaces 1.15.1 → 2.0.0

package/dist/chunk-DYMWJAL4.js

@@ -0,0 +1,552 @@
+import { parseDep, isValidAssetName, slugifyAssetName } from './chunk-GEEW6SY2.js';
+import { createLogger } from './chunk-7GOCNYUV.js';
+import { stat, readFile, opendir } from 'fs/promises';
+import { basename, dirname, join } from 'path';
+import { parse } from 'yaml';
+
+// core/src/fs-deadline.ts
+var DEFAULT_FS_DEADLINE_MS = 15e3;
+var FS_DEADLINE_ENV_VAR = "SKAILE_FS_DEADLINE_MS";
+var FsDeadlineError = class extends Error {
+  timeoutMs;
+  operation;
+  constructor(operation, timeoutMs) {
+    super(
+      `filesystem operation "${operation}" exceeded ${timeoutMs}ms \u2014 the mount may be unresponsive`
+    );
+    this.name = "FsDeadlineError";
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+  }
+};
+function fsDeadlineMs(fallback = DEFAULT_FS_DEADLINE_MS) {
+  const raw = process.env[FS_DEADLINE_ENV_VAR];
+  if (raw === void 0) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+async function withFsDeadline(operation, fn, timeoutMs = fsDeadlineMs()) {
+  let timer;
+  try {
+    return await Promise.race([
+      fn(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new FsDeadlineError(operation, timeoutMs)), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function tryWithFsDeadline(operation, fn, fallback, timeoutMs = fsDeadlineMs()) {
+  try {
+    return await withFsDeadline(operation, fn, timeoutMs);
+  } catch {
+    return fallback;
+  }
+}
+
+// core/src/manifest.ts
+function readManifestFile(filePath, timeoutMs) {
+  return withFsDeadline(`readFile ${filePath}`, () => readFile(filePath, "utf8"), timeoutMs);
+}
+function readManifestFileOrEmpty(filePath, timeoutMs) {
+  return tryWithFsDeadline(`readFile ${filePath}`, () => readFile(filePath, "utf8"), "", timeoutMs);
+}
+function parseFrontmatter(text) {
+  const m = text.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!m) return { data: {}, body: text.trim() };
+  try {
+    const data = parse(m[1]) ?? {};
+    const body = text.slice(m[0].length).trim();
+    return { data, body };
+  } catch {
+    return { data: {}, body: text.trim() };
+  }
+}
+function extractVersion(meta) {
+  return String(
+    meta.version ?? meta.metadata?.version ?? ""
+  );
+}
+function parseRequires(meta) {
+  const raw = meta.requires ?? meta.metadata?.requires;
+  if (!raw) return [];
+  const list = typeof raw === "string" ? raw.split(",").map((s) => s.trim()) : Array.isArray(raw) ? raw : [];
+  return list.filter(Boolean).map(parseDep);
+}
+function collectAgentDeps(raw, out) {
+  if (!Array.isArray(raw)) return;
+  for (const d of raw) {
+    if (typeof d === "object" && d !== null && "name" in d) {
+      out.push({ kind: "agent", name: String(d.name) });
+    }
+  }
+}
+function collectStringRefs(raw, kind, out) {
+  if (!Array.isArray(raw)) return;
+  for (const r of raw) {
+    if (typeof r === "string" && r) out.push({ kind, name: r });
+  }
+}
+function collectMixinRefs(raw, defaultKind, out) {
+  if (!Array.isArray(raw)) return;
+  for (const r of raw) {
+    if (typeof r !== "string" || !r) continue;
+    if (r.startsWith(".") || r.startsWith("/")) continue;
+    const normalized = r.includes(":") ? r : `${defaultKind}:${r}`;
+    const colonIdx = normalized.indexOf(":");
+    const kind = normalized.slice(0, colonIdx).trim();
+    let rest = normalized.slice(colonIdx + 1).trim();
+    const hashIdx = rest.indexOf("#");
+    if (hashIdx !== -1) rest = rest.slice(0, hashIdx).trim();
+    let name;
+    if (rest.startsWith("@")) {
+      const slashIdx = rest.indexOf("/");
+      name = slashIdx !== -1 ? rest.slice(slashIdx + 1).trim() : "";
+    } else {
+      const atIdx = rest.indexOf("@");
+      name = atIdx !== -1 ? rest.slice(0, atIdx).trim() : rest;
+    }
+    if (name) out.push({ kind, name });
+  }
+}
+async function fromSkillMd(filePath, repoName) {
+  return fromSkillMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromSkillMdContent(content, repoName, filePath) {
+  const { data: meta } = parseFrontmatter(content);
+  let kind = String(meta.type ?? "skill");
+  if (!["skill", "agent", "prompt", "persona", "ruleset", "knowledge"].includes(kind))
+    kind = "skill";
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind,
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromAgentMd(filePath, repoName) {
+  return fromAgentMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromAgentMdContent(content, repoName, filePath) {
+  const { data: meta } = parseFrontmatter(content);
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind: "agent",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromAgentYaml(filePath, repoName) {
+  return fromAgentYamlContent(await readManifestFileOrEmpty(filePath), repoName, filePath);
+}
+function fromAgentYamlContent(content, repoName, filePath) {
+  let meta = {};
+  try {
+    meta = parse(content) ?? {};
+  } catch {
+  }
+  const requires = [];
+  collectAgentDeps(meta.requires, requires);
+  collectAgentDeps(meta.dependencies, requires);
+  collectStringRefs(meta.abilities, "skill", requires);
+  collectStringRefs(meta.contracts, "contract", requires);
+  for (const [field, defaultKind] of [
+    ["persona", "persona"],
+    ["rules", "ruleset"],
+    ["knowledge", "knowledge"]
+  ]) {
+    collectMixinRefs(meta[field], defaultKind, requires);
+  }
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind: "agent",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: String(meta.version ?? ""),
+    requires,
+    dependencies: []
+  };
+}
+async function fromPromptMd(filePath, repoName) {
+  return fromPromptMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromPromptMdContent(content, repoName, filePath) {
+  const { data: meta } = parseFrontmatter(content);
+  const name = String(meta.name ?? basename(filePath).replace(/\.prompt\.md$/, ""));
+  return {
+    name,
+    kind: "prompt",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromFlowYaml(filePath, repoName) {
+  return fromFlowYamlContent(await readManifestFileOrEmpty(filePath), repoName, filePath);
+}
+function fromFlowYamlContent(content, repoName, filePath) {
+  let meta = {};
+  try {
+    meta = parse(content) ?? {};
+  } catch {
+  }
+  const stem = basename(filePath).replace(/\.flow\.yaml$/, "").replace(/\.flow\.json$/, "");
+  return {
+    name: String(meta.name ?? meta.id ?? stem),
+    kind: "flow",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: String(meta.version ?? ""),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromBundleYaml(filePath, repoName) {
+  return fromBundleYamlContent(await readManifestFileOrEmpty(filePath), repoName, filePath);
+}
+function fromBundleYamlContent(content, repoName, filePath) {
+  let meta = {};
+  try {
+    meta = parse(content) ?? {};
+  } catch {
+  }
+  const name = String(meta.name ?? basename(filePath).replace(/\.bundle\.yaml$/, ""));
+  const deps = meta.dependencies;
+  const dependencies = Array.isArray(deps) ? deps.filter(Boolean) : [];
+  return {
+    name,
+    kind: "bundle",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: String(meta.version ?? ""),
+    requires: parseRequires(meta),
+    dependencies
+  };
+}
+async function bundleDepRefs(filePath) {
+  return bundleDepRefsFromContent(await readManifestFileOrEmpty(filePath), filePath);
+}
+function bundleDepRefsFromContent(content, filePath) {
+  const wholeDoc = /\.(bundle\.yaml|flow\.yaml|flow\.json)$/.test(filePath);
+  let meta = {};
+  try {
+    meta = wholeDoc ? parse(content) ?? {} : parseFrontmatter(content).data;
+  } catch {
+    return [];
+  }
+  const out = [];
+  const collect = (v) => {
+    if (Array.isArray(v)) {
+      for (const x of v) if (typeof x === "string" && x.trim()) out.push(x.trim());
+    }
+  };
+  collect(meta.requires);
+  collect(meta.metadata?.requires);
+  collect(meta.dependencies);
+  return [...new Set(out)];
+}
+async function fromContractMd(filePath, repoName) {
+  return fromContractMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromContractMdContent(content, repoName, filePath) {
+  const { data: meta } = parseFrontmatter(content);
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind: "contract",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromMcpServerMd(filePath, repoName) {
+  return fromMcpServerMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromMcpServerMdContent(content, repoName, filePath) {
+  const { data: meta } = parseFrontmatter(content);
+  const metadata = {};
+  if (meta.transport) metadata.transport = String(meta.transport);
+  if (meta.command) metadata.command = String(meta.command);
+  if (Array.isArray(meta.args)) metadata.args = meta.args.map(String);
+  if (meta.env && typeof meta.env === "object" && !Array.isArray(meta.env)) {
+    metadata.env = meta.env;
+  }
+  if (meta.url) metadata.url = String(meta.url);
+  if (meta.headers && typeof meta.headers === "object" && !Array.isArray(meta.headers)) {
+    metadata.headers = meta.headers;
+  }
+  if (meta.recipe && typeof meta.recipe === "object" && !Array.isArray(meta.recipe)) {
+    metadata.recipe = meta.recipe;
+  }
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind: "mcp-server",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: [],
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+async function fromKnowledgeYaml(filePath, repoName) {
+  return fromKnowledgeYamlContent(await readManifestFileOrEmpty(filePath), repoName, filePath);
+}
+function fromKnowledgeYamlContent(content, repoName, filePath) {
+  let meta = {};
+  try {
+    meta = parse(content) ?? {};
+  } catch {
+  }
+  return {
+    name: String(meta.name ?? basename(dirname(filePath))),
+    kind: "knowledge",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: String(meta.version ?? ""),
+    requires: parseRequires(meta),
+    dependencies: []
+  };
+}
+async function fromConnectorMd(filePath, repoName) {
+  return fromConnectorMdContent(await readManifestFile(filePath), repoName, filePath);
+}
+function fromConnectorMdContent(content, repoName, filePath) {
+  const { data: meta, body } = parseFrontmatter(content);
+  const name = String(meta.name ?? basename(dirname(filePath)));
+  return {
+    name,
+    kind: "connector",
+    description: String(meta.description ?? ""),
+    source: filePath,
+    publisher: repoName,
+    version: extractVersion(meta),
+    requires: parseRequires(meta),
+    dependencies: [],
+    metadata: {
+      entry: meta.entry ?? "./adapter.ts",
+      npm_deps: meta.npm_deps ?? {},
+      fields: meta.fields ?? [],
+      health_check: meta.health_check ?? null,
+      body
+    }
+  };
+}
+var DEFAULT_WALK_MAX_DEPTH = 32;
+var DEFAULT_WALK_MAX_ENTRIES = 5e4;
+var DEFAULT_WALK_BUDGET_MS = 6e4;
+var WALK_MAX_DEPTH_ENV_VAR = "SKAILE_SCAN_MAX_DEPTH";
+var WALK_MAX_ENTRIES_ENV_VAR = "SKAILE_SCAN_MAX_ENTRIES";
+var WALK_BUDGET_MS_ENV_VAR = "SKAILE_SCAN_DEADLINE_MS";
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var walkLogger;
+function warnTruncation(info) {
+  walkLogger ??= createLogger({ kind: "runner", subkind: "asset-scan" });
+  walkLogger.warn(`asset scan truncated (${info.reason}) \u2014 results are incomplete`, {
+    ...info
+  });
+}
+function truncate(state, info) {
+  if (state.reported.has(info.reason)) return;
+  state.reported.add(info.reason);
+  state.onTruncate(info);
+}
+async function dirIdentity(path, timeoutMs) {
+  const st = await tryWithFsDeadline(`stat ${path}`, () => stat(path), null, timeoutMs);
+  return st ? `${st.dev}:${st.ino}` : null;
+}
+async function readDirEntries(dir, state) {
+  const remaining = state.maxEntries - state.examined;
+  if (remaining <= 0) return { entries: [], capped: true };
+  try {
+    return await withFsDeadline(
+      `opendir ${dir}`,
+      async () => {
+        const handle = await opendir(dir);
+        const entries = [];
+        let capped = false;
+        for await (const e of handle) {
+          if (entries.length >= remaining) {
+            capped = true;
+            break;
+          }
+          entries.push(e);
+        }
+        entries.sort((a, b) => a.name < b.name ? -1 : 1);
+        return { entries, capped };
+      },
+      state.opTimeoutMs
+    );
+  } catch {
+    truncate(state, { reason: "unreadable", path: dir });
+    return null;
+  }
+}
+async function* walkDir(dir, options = {}) {
+  const state = {
+    maxDepth: options.maxDepth ?? envInt(WALK_MAX_DEPTH_ENV_VAR, DEFAULT_WALK_MAX_DEPTH),
+    maxEntries: options.maxEntries ?? envInt(WALK_MAX_ENTRIES_ENV_VAR, DEFAULT_WALK_MAX_ENTRIES),
+    opTimeoutMs: options.opTimeoutMs,
+    deadlineAt: Date.now() + (options.budgetMs ?? envInt(WALK_BUDGET_MS_ENV_VAR, DEFAULT_WALK_BUDGET_MS)),
+    examined: 0,
+    ancestors: /* @__PURE__ */ new Set(),
+    reported: /* @__PURE__ */ new Set(),
+    onTruncate: options.onTruncate ?? warnTruncation
+  };
+  const rootId = await dirIdentity(dir, state.opTimeoutMs);
+  if (rootId) state.ancestors.add(rootId);
+  yield* walkFrom(dir, 0, state);
+}
+async function* walkFrom(dir, depth, state) {
+  if (depth > state.maxDepth) {
+    truncate(state, { reason: "depth", path: dir, limit: state.maxDepth });
+    return;
+  }
+  if (Date.now() >= state.deadlineAt) {
+    truncate(state, { reason: "budget", path: dir });
+    return;
+  }
+  const read = await readDirEntries(dir, state);
+  if (!read) return;
+  if (read.capped) truncate(state, { reason: "entries", path: dir, limit: state.maxEntries });
+  for (const e of read.entries) {
+    if (state.examined >= state.maxEntries) {
+      truncate(state, { reason: "entries", path: dir, limit: state.maxEntries });
+      return;
+    }
+    if (Date.now() >= state.deadlineAt) {
+      truncate(state, { reason: "budget", path: dir });
+      return;
+    }
+    state.examined++;
+    const full = join(dir, e.name);
+    if (e.isSymbolicLink()) {
+      const st = await tryWithFsDeadline(`stat ${full}`, () => stat(full), null, state.opTimeoutMs);
+      if (!st) continue;
+      if (st.isDirectory()) {
+        if (e.name === ".git" || e.name === "node_modules") continue;
+        const id = `${st.dev}:${st.ino}`;
+        if (state.ancestors.has(id)) {
+          truncate(state, { reason: "cycle", path: full });
+          continue;
+        }
+        state.ancestors.add(id);
+        try {
+          yield* walkFrom(full, depth + 1, state);
+        } finally {
+          state.ancestors.delete(id);
+        }
+      } else {
+        yield { path: full, name: e.name };
+      }
+    } else if (e.isDirectory()) {
+      if (e.name !== ".git" && e.name !== "node_modules") yield* walkFrom(full, depth + 1, state);
+    } else if (e.isFile()) {
+      yield { path: full, name: e.name };
+    }
+  }
+}
+function normalizeEntryName(e) {
+  if (isValidAssetName(e.name)) return;
+  let slug;
+  try {
+    slug = slugifyAssetName(e.name);
+  } catch {
+    return;
+  }
+  const original = e.name;
+  e.name = slug;
+  if (e.metadata?.displayName === void 0) {
+    e.metadata = { ...e.metadata, displayName: original };
+  }
+}
+function entryFromManifest(name, content, filePath, repoName) {
+  if (name === "SKILL.md") return fromSkillMdContent(content, repoName, filePath);
+  if (name === "AGENT.md") return fromAgentMdContent(content, repoName, filePath);
+  if (name === "agent.yaml") return fromAgentYamlContent(content, repoName, filePath);
+  if (name === "CONTRACT.md") return fromContractMdContent(content, repoName, filePath);
+  if (name === "MCP.md") return fromMcpServerMdContent(content, repoName, filePath);
+  if (name === "CONNECTOR.md") return fromConnectorMdContent(content, repoName, filePath);
+  if (name === "knowledge.yaml") return fromKnowledgeYamlContent(content, repoName, filePath);
+  if (name.endsWith(".prompt.md")) return fromPromptMdContent(content, repoName, filePath);
+  if (name.endsWith(".bundle.yaml")) return fromBundleYamlContent(content, repoName, filePath);
+  if (name.endsWith(".flow.yaml") || name.endsWith(".flow.json"))
+    return fromFlowYamlContent(content, repoName, filePath);
+  return null;
+}
+function isManifestName(name) {
+  return name === "SKILL.md" || name === "AGENT.md" || name === "agent.yaml" || name === "CONTRACT.md" || name === "MCP.md" || name === "CONNECTOR.md" || name === "knowledge.yaml" || name.endsWith(".prompt.md") || name.endsWith(".bundle.yaml") || name.endsWith(".flow.yaml") || name.endsWith(".flow.json");
+}
+async function scanDirectory(root, repoName, options = {}) {
+  const entries = /* @__PURE__ */ new Map();
+  const onTruncate = options.onTruncate ?? warnTruncation;
+  const reported = /* @__PURE__ */ new Set();
+  const relay = (info) => {
+    reported.add(info.reason);
+    onTruncate(info);
+  };
+  const opTimeoutMs = options.opTimeoutMs ?? fsDeadlineMs();
+  function add(e) {
+    normalizeEntryName(e);
+    const key = `${e.kind}:${e.name}`;
+    const existing = entries.get(key);
+    if (!existing) {
+      entries.set(key, e);
+      return;
+    }
+    if (e.source > existing.source) entries.set(key, e);
+  }
+  for await (const { path: filePath, name } of walkDir(root, {
+    ...options,
+    opTimeoutMs,
+    onTruncate: relay
+  })) {
+    if (!isManifestName(name)) continue;
+    const content = await tryWithFsDeadline(
+      `readFile ${filePath}`,
+      () => readFile(filePath, "utf8"),
+      null,
+      opTimeoutMs
+    );
+    if (content === null) {
+      if (!reported.has("unreadable")) relay({ reason: "unreadable", path: filePath });
+      continue;
+    }
+    try {
+      const entry = entryFromManifest(name, content, filePath, repoName);
+      if (entry) add(entry);
+    } catch {
+    }
+  }
+  return [...entries.values()];
+}
+
+export { DEFAULT_FS_DEADLINE_MS, DEFAULT_WALK_BUDGET_MS, DEFAULT_WALK_MAX_DEPTH, DEFAULT_WALK_MAX_ENTRIES, FS_DEADLINE_ENV_VAR, FsDeadlineError, WALK_BUDGET_MS_ENV_VAR, WALK_MAX_DEPTH_ENV_VAR, WALK_MAX_ENTRIES_ENV_VAR, bundleDepRefs, fromAgentMd, fromAgentYaml, fromBundleYaml, fromConnectorMd, fromContractMd, fromFlowYaml, fromKnowledgeYaml, fromMcpServerMd, fromMcpServerMdContent, fromPromptMd, fromSkillMd, fsDeadlineMs, parseFrontmatter, parseRequires, scanDirectory, tryWithFsDeadline, walkDir, withFsDeadline };
+//# sourceMappingURL=chunk-DYMWJAL4.js.map
+//# sourceMappingURL=chunk-DYMWJAL4.js.map