@workflow-code/cli 0.2.4-20261011005.codex-cli-web → 0.2.4-20261011007.codex-cli-web

package/dist/web/kanban-data.mjs

@@ -0,0 +1,613 @@
+// src/web/kanban-data.ts
+import { readFile, readdir, realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+// .shared/project-info/index.ts
+var WORKFLOW_PROJECT_DATA_STORAGE_MODES = ["local", "server", "both"];
+var WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var WORKFLOW_RELATED_PROJECT_LIMIT = 32;
+var WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT = 32;
+var WORKFLOW_RELATED_PROJECT_KEY_LIMIT = 1024;
+var WORKFLOW_PROJECT_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var PROJECT_INFO_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+function createUndeclaredWorkflowProjectInfo() {
+  return {
+    localizedNames: {},
+    declarations: [],
+    platformSupport: { mode: "agnostic" },
+    dataStorage: null,
+    relatedProjects: []
+  };
+}
+function normalizeWorkflowProjectInfo(value) {
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo must be an object.");
+  }
+  const localizedNames = normalizeLocalizedNames(value["localizedNames"]);
+  const declarations = normalizeIds(value["declarations"], "workflowCode.projectInfo.declarations");
+  const platformSupport = normalizePlatformSupport(value["platformSupport"]);
+  const dataStorage = normalizeDataStorage(value["dataStorage"]);
+  const relatedProjects = normalizeRelatedProjects(value["relatedProjects"]);
+  return { localizedNames, declarations, platformSupport, dataStorage, relatedProjects };
+}
+function readWorkflowProjectInfo(packageJson) {
+  if (!isRecord(packageJson)) return createUndeclaredWorkflowProjectInfo();
+  const workflowCode = packageJson["workflowCode"];
+  if (!isRecord(workflowCode) || workflowCode["projectInfo"] === void 0) {
+    return createUndeclaredWorkflowProjectInfo();
+  }
+  const projectInfo = normalizeWorkflowProjectInfo(workflowCode["projectInfo"]);
+  const projectId = typeof packageJson["id"] === "string" ? packageJson["id"].trim() : void 0;
+  if (projectId !== void 0 && projectId !== "") {
+    assertWorkflowRelatedProjects(projectInfo, projectId);
+  }
+  return projectInfo;
+}
+function assertWorkflowRelatedProjects(projectInfo, currentProjectId) {
+  if (projectInfo.relatedProjects.length === 0) return;
+  const normalizedProjectId = currentProjectId.trim();
+  if (!WORKFLOW_PROJECT_UUID_PATTERN.test(normalizedProjectId)) {
+    throw new Error("package.json.id must be a UUID before related projects can be declared.");
+  }
+  if (projectInfo.relatedProjects.some(
+    (relation) => relation.projectId.toLowerCase() === normalizedProjectId.toLowerCase()
+  )) {
+    throw new Error("workflowCode.projectInfo.relatedProjects cannot reference the current project.");
+  }
+}
+function findWorkflowRelatedProject(projectInfo, alias) {
+  const normalizedAlias = alias.trim();
+  return projectInfo.relatedProjects.find((relation) => relation.alias === normalizedAlias);
+}
+function resolveWorkflowRelatedProjectAccess(input) {
+  const consumer = findWorkflowRelatedProject(input.consumerProjectInfo, input.alias);
+  if (consumer?.projectId.toLowerCase() !== input.targetProjectId.trim().toLowerCase()) {
+    return void 0;
+  }
+  const target = input.targetProjectInfo.relatedProjects.find(
+    (relation) => relation.projectId.toLowerCase() === input.consumerProjectId.trim().toLowerCase()
+  );
+  if (target === void 0) return void 0;
+  return { consumer, target, grant: target.grantToRelatedProject };
+}
+function isWorkflowProjectAccessAllowed(rule, value) {
+  if (rule === void 0 || rule.mode === "none") return false;
+  if (rule.mode === "all") return true;
+  return rule.prefixes.some((prefix) => value.startsWith(prefix));
+}
+function isWorkflowProjectDataStorageLocationAllowed(projectInfo, location) {
+  const mode = projectInfo.dataStorage?.mode;
+  return mode === "both" || mode === location;
+}
+function normalizeLocalizedNames(value) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.localizedNames must be an object.");
+  }
+  const entries = [];
+  for (const [rawLocale, rawName] of Object.entries(value)) {
+    const locale = rawLocale.trim();
+    if (locale === "") {
+      throw new Error("workflowCode.projectInfo.localizedNames contains an empty locale.");
+    }
+    if (typeof rawName !== "string") {
+      throw new Error(`workflowCode.projectInfo.localizedNames.${locale} must be a string.`);
+    }
+    const name = rawName.trim();
+    if (name !== "") entries.push([locale, name]);
+  }
+  return Object.fromEntries(entries);
+}
+function normalizePlatformSupport(value) {
+  if (value === void 0) return { mode: "agnostic" };
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.platformSupport must be an object.");
+  }
+  if (value["mode"] === "agnostic") {
+    if (value["platforms"] !== void 0) {
+      throw new Error("workflowCode.projectInfo.platformSupport.platforms is not allowed in agnostic mode.");
+    }
+    return { mode: "agnostic" };
+  }
+  if (value["mode"] !== "specific") {
+    throw new Error('workflowCode.projectInfo.platformSupport.mode must be "agnostic" or "specific".');
+  }
+  const platforms = normalizeIds(
+    value["platforms"],
+    "workflowCode.projectInfo.platformSupport.platforms"
+  );
+  if (platforms.length === 0) {
+    throw new Error("workflowCode.projectInfo.platformSupport.platforms must contain at least one platform.");
+  }
+  return { mode: "specific", platforms };
+}
+function normalizeDataStorage(value) {
+  if (value === void 0 || value === null) return null;
+  if (!isRecord(value)) {
+    throw new Error("workflowCode.projectInfo.dataStorage must be an object.");
+  }
+  const mode = value["mode"];
+  if (typeof mode !== "string" || !WORKFLOW_PROJECT_DATA_STORAGE_MODES.includes(
+    mode
+  )) {
+    throw new Error(
+      'workflowCode.projectInfo.dataStorage.mode must be "local", "server", or "both".'
+    );
+  }
+  return { mode };
+}
+function normalizeRelatedProjects(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new Error("workflowCode.projectInfo.relatedProjects must be an array.");
+  }
+  if (value.length > WORKFLOW_RELATED_PROJECT_LIMIT) {
+    throw new Error(
+      `workflowCode.projectInfo.relatedProjects supports at most ${WORKFLOW_RELATED_PROJECT_LIMIT} items.`
+    );
+  }
+  const aliases = /* @__PURE__ */ new Set();
+  const projectIds = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const field = `workflowCode.projectInfo.relatedProjects[${index}]`;
+    if (!isRecord(item)) throw new Error(`${field} must be an object.`);
+    const supportedFields = /* @__PURE__ */ new Set(["alias", "projectId", "grantToRelatedProject"]);
+    if (Object.keys(item).some((key) => !supportedFields.has(key))) {
+      throw new Error(`${field} contains unsupported fields.`);
+    }
+    const alias = readRelatedProjectString(item["alias"], `${field}.alias`);
+    if (!WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.test(alias)) {
+      throw new Error(`${field}.alias is invalid.`);
+    }
+    if (aliases.has(alias)) {
+      throw new Error(`workflowCode.projectInfo.relatedProjects contains duplicate alias "${alias}".`);
+    }
+    aliases.add(alias);
+    const projectId = readRelatedProjectString(item["projectId"], `${field}.projectId`);
+    if (!WORKFLOW_PROJECT_UUID_PATTERN.test(projectId)) {
+      throw new Error(`${field}.projectId must be a UUID.`);
+    }
+    const normalizedProjectId = projectId.toLowerCase();
+    if (projectIds.has(normalizedProjectId)) {
+      throw new Error(`workflowCode.projectInfo.relatedProjects contains duplicate projectId "${projectId}".`);
+    }
+    projectIds.add(normalizedProjectId);
+    return {
+      alias,
+      projectId,
+      grantToRelatedProject: normalizeRelatedProjectGrant(
+        item["grantToRelatedProject"],
+        `${field}.grantToRelatedProject`
+      )
+    };
+  });
+}
+function normalizeRelatedProjectGrant(value, field) {
+  if (!isRecord(value)) throw new Error(`${field} must be an object.`);
+  const supported = /* @__PURE__ */ new Set(["read", "write", "knowledge", "entrypoints"]);
+  if (Object.keys(value).some((key) => !supported.has(key))) {
+    throw new Error(`${field} contains unsupported fields.`);
+  }
+  const grant = {
+    read: normalizeProjectAccessRule(value["read"], `${field}.read`),
+    write: normalizeProjectAccessRule(value["write"], `${field}.write`)
+  };
+  const knowledge = value["knowledge"];
+  if (knowledge !== void 0) {
+    if (!isRecord(knowledge)) throw new Error(`${field}.knowledge must be an object.`);
+    if (Object.keys(knowledge).some((key) => key !== "read" && key !== "write")) {
+      throw new Error(`${field}.knowledge contains unsupported fields.`);
+    }
+    grant.knowledge = {
+      read: normalizeProjectAccessRule(knowledge["read"], `${field}.knowledge.read`),
+      write: normalizeProjectAccessRule(knowledge["write"], `${field}.knowledge.write`)
+    };
+  }
+  const entrypoints = value["entrypoints"];
+  if (entrypoints !== void 0) {
+    grant.entrypoints = normalizeProjectAccessRule(entrypoints, `${field}.entrypoints`);
+  }
+  return grant;
+}
+function normalizeProjectAccessRule(value, field) {
+  if (!isRecord(value)) throw new Error(`${field} must be an object.`);
+  const mode = value["mode"];
+  if (mode === "none" || mode === "all") {
+    if (Object.keys(value).some((key) => key !== "mode")) {
+      throw new Error(`${field} contains unsupported fields.`);
+    }
+    return { mode };
+  }
+  if (mode !== "prefixes") {
+    throw new Error(`${field}.mode must be "none", "all", or "prefixes".`);
+  }
+  if (Object.keys(value).some((key) => key !== "mode" && key !== "prefixes")) {
+    throw new Error(`${field} contains unsupported fields.`);
+  }
+  const rawPrefixes = value["prefixes"];
+  if (!Array.isArray(rawPrefixes) || rawPrefixes.length === 0 || rawPrefixes.length > WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT) {
+    throw new Error(
+      `${field}.prefixes must contain 1 to ${WORKFLOW_RELATED_PROJECT_PREFIX_LIMIT} items.`
+    );
+  }
+  const prefixes = rawPrefixes.map((prefix, index) => {
+    const normalized = readRelatedProjectString(prefix, `${field}.prefixes[${index}]`);
+    if (normalized.length > WORKFLOW_RELATED_PROJECT_KEY_LIMIT || normalized.includes("\0")) {
+      throw new Error(`${field}.prefixes[${index}] is invalid.`);
+    }
+    return normalized;
+  });
+  if (new Set(prefixes).size !== prefixes.length) {
+    throw new Error(`${field}.prefixes contains duplicates.`);
+  }
+  return { mode: "prefixes", prefixes };
+}
+function readRelatedProjectString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${field} must be a non-empty string.`);
+  }
+  return value.trim();
+}
+function normalizeIds(value, field) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array.`);
+  const values = value.map((item, index) => {
+    if (typeof item !== "string" || !PROJECT_INFO_ID_PATTERN.test(item.trim())) {
+      throw new Error(`${field}[${index}] must be a lowercase identifier.`);
+    }
+    return item.trim();
+  });
+  return uniqueStrings(values, true);
+}
+function uniqueStrings(values, caseSensitive) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const rawValue of values) {
+    const value = rawValue.trim();
+    if (value === "") continue;
+    const key = caseSensitive ? value : value.toLocaleLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// .shared/kanban-project/index.ts
+var KANBAN_FILE_MAX_BYTES = 50 * 1024 * 1024;
+var KANBAN_BRIDGE_SAFE_ERRORS = {
+  KANBAN_BRIDGE_INVALID_REQUEST: "The Kanban bridge request is invalid.",
+  KANBAN_BRIDGE_BUSY: "Too many Kanban bridge requests are pending.",
+  KANBAN_BRIDGE_TIMEOUT: "Kanban bridge request timed out.",
+  KANBAN_BRIDGE_UNAVAILABLE: "Kanban project data is unavailable in this host.",
+  KANBAN_BRIDGE_SESSION_INVALID: "The Kanban preview session is invalid or expired.",
+  KANBAN_BRIDGE_SERVER_ERROR: "Kanban project data operation failed.",
+  KANBAN_DATA_OPERATION_FAILED: "Kanban project data operation failed.",
+  KANBAN_RELATED_PROJECT_UNAVAILABLE: "Kanban related project is unavailable.",
+  KANBAN_FILE_UNAVAILABLE: "Kanban file is unavailable in this project.",
+  KANBAN_FILE_TOO_LARGE: "Kanban files cannot exceed 50 MiB."
+};
+var KANBAN_BRIDGE_CALL_FIELDS = /* @__PURE__ */ new Set(["requestId", "operation", "input"]);
+var MAX_KNOWLEDGE_DOCUMENT_PAGE_SIZE = 100;
+var MAX_KNOWLEDGE_SEARCH_PAGE_SIZE = 1e3;
+var MAX_KNOWLEDGE_CONTEXT_LINES = 50;
+var MAX_KNOWLEDGE_LINE_RANGE = 1e3;
+var KANBAN_BRIDGE_INPUT_FIELDS = {
+  "runtime.getLocale": [],
+  "files.createFile": ["name", "mimeType", "base64"],
+  "files.readFile": ["fileId"],
+  "files.deleteFile": ["fileId"],
+  "kv.getValue": ["key"],
+  "kv.setValue": ["key", "value"],
+  "relatedProject.kv.getValue": ["alias", "key"],
+  "relatedProject.kv.setValue": ["alias", "key", "value"],
+  "knowledge.listDocuments": ["pageSize", "cursor"],
+  "knowledge.getDocument": ["documentId"],
+  "knowledge.createDocument": ["id", "title", "markdown"],
+  "knowledge.editDocument": ["documentId", "title", "markdown"],
+  "knowledge.deleteDocument": ["documentId"],
+  "knowledge.searchDocuments": [
+    "query",
+    "documentId",
+    "beforeLines",
+    "afterLines",
+    "maxMatches",
+    "pageSize",
+    "cursor"
+  ],
+  "knowledge.readDocumentLines": ["documentId", "startLine", "endLine"]
+};
+function parseKanbanBridgeCall(value) {
+  if (!isRecord2(value)) throw new Error("Kanban bridge request must be an object.");
+  if (Object.keys(value).some((key) => !KANBAN_BRIDGE_CALL_FIELDS.has(key))) {
+    throw new Error("Kanban bridge request contains unsupported fields.");
+  }
+  const requestId = readNonEmptyString(value["requestId"], "bridge.requestId");
+  const operation = value["operation"];
+  if (!isKanbanBridgeOperation(operation)) {
+    throw new Error(`Unsupported Kanban bridge operation "${String(operation)}".`);
+  }
+  const input = value["input"];
+  if (!isRecord2(input)) throw new Error("Kanban bridge input must be an object.");
+  validateKanbanBridgeInput(operation, input);
+  return { requestId, operation, input };
+}
+function resolveKanbanRelatedProject(relatedProjects, alias, key) {
+  const relatedProject = relatedProjects.find((item) => item.alias === alias);
+  if (relatedProject === void 0 || key.trim() === "" || key.length > WORKFLOW_RELATED_PROJECT_KEY_LIMIT) {
+    throw Object.assign(new Error("Kanban related project is unavailable."), {
+      code: "KANBAN_RELATED_PROJECT_UNAVAILABLE"
+    });
+  }
+  return relatedProject;
+}
+function isKanbanJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  const valid = Array.isArray(value) ? value.every((item) => isKanbanJsonValue(item, seen)) : Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every((item) => isKanbanJsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function validateKanbanBridgeInput(operation, input) {
+  const allowedFields = new Set(KANBAN_BRIDGE_INPUT_FIELDS[operation]);
+  if (Object.keys(input).some((key) => !allowedFields.has(key))) {
+    throw new Error(`Kanban bridge ${operation} input contains unsupported fields.`);
+  }
+  switch (operation) {
+    case "runtime.getLocale":
+      return;
+    case "files.createFile": {
+      const name = readNonEmptyString(input["name"], "bridge.input.name");
+      if (name.length > 255 || /[\\/\\\\\0]/.test(name)) {
+        throw new Error("Kanban file name must be a plain file name.");
+      }
+      const mimeType = readOptionalNonEmptyString(input["mimeType"], "bridge.input.mimeType");
+      if (mimeType !== void 0 && !/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/.test(mimeType)) {
+        throw new Error("Kanban file MIME type is invalid.");
+      }
+      const base64 = readRequiredString(input["base64"], "bridge.input.base64");
+      if (base64.length > Math.ceil(KANBAN_FILE_MAX_BYTES / 3) * 4) {
+        throw Object.assign(new Error(KANBAN_BRIDGE_SAFE_ERRORS.KANBAN_FILE_TOO_LARGE), { code: "KANBAN_FILE_TOO_LARGE" });
+      }
+      if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) {
+        throw new Error("Kanban file content must be base64 encoded.");
+      }
+      const size = base64.length / 4 * 3 - (base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0);
+      if (size > KANBAN_FILE_MAX_BYTES) {
+        throw Object.assign(new Error(KANBAN_BRIDGE_SAFE_ERRORS.KANBAN_FILE_TOO_LARGE), { code: "KANBAN_FILE_TOO_LARGE" });
+      }
+      return;
+    }
+    case "files.readFile":
+    case "files.deleteFile":
+      if (!/^wf_[a-f0-9]+$/.test(readNonEmptyString(input["fileId"], "bridge.input.fileId"))) {
+        throw new Error("Kanban file id is invalid.");
+      }
+      return;
+    case "kv.getValue":
+      readNonEmptyString(input["key"], "bridge.input.key");
+      return;
+    case "kv.setValue":
+      readNonEmptyString(input["key"], "bridge.input.key");
+      if (input["value"] === void 0 || !isKanbanJsonValue(input["value"])) {
+        throw new Error("Kanban bridge KV value must be JSON-serializable and cannot be undefined.");
+      }
+      return;
+    case "relatedProject.kv.getValue":
+    case "relatedProject.kv.setValue": {
+      const alias = readNonEmptyString(input["alias"], "bridge.input.alias");
+      if (!WORKFLOW_RELATED_PROJECT_ALIAS_PATTERN.test(alias)) {
+        throw new Error("Kanban bridge related-project alias is invalid.");
+      }
+      const key = readNonEmptyString(input["key"], "bridge.input.key");
+      if (key.length > WORKFLOW_RELATED_PROJECT_KEY_LIMIT) {
+        throw new Error("Kanban bridge related-project key is too long.");
+      }
+      if (operation === "relatedProject.kv.setValue" && (input["value"] === void 0 || !isKanbanJsonValue(input["value"]))) {
+        throw new Error(
+          "Kanban bridge related-project KV value must be JSON-serializable and cannot be undefined."
+        );
+      }
+      return;
+    }
+    case "knowledge.listDocuments":
+      readOptionalIntegerInRange(
+        input["pageSize"],
+        "bridge.input.pageSize",
+        1,
+        MAX_KNOWLEDGE_DOCUMENT_PAGE_SIZE
+      );
+      readOptionalNonEmptyString(input["cursor"], "bridge.input.cursor");
+      return;
+    case "knowledge.getDocument":
+    case "knowledge.deleteDocument":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      return;
+    case "knowledge.createDocument":
+      readOptionalNonEmptyString(input["id"], "bridge.input.id");
+      readNonEmptyString(input["title"], "bridge.input.title");
+      readRequiredString(input["markdown"], "bridge.input.markdown");
+      return;
+    case "knowledge.editDocument":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      if (input["title"] === void 0 && input["markdown"] === void 0) {
+        throw new Error("Kanban bridge knowledge edit requires title or markdown.");
+      }
+      readOptionalStringValue(input["title"], "bridge.input.title");
+      readOptionalStringValue(input["markdown"], "bridge.input.markdown");
+      return;
+    case "knowledge.searchDocuments":
+      readNonEmptyString(input["query"], "bridge.input.query");
+      readOptionalNonEmptyString(input["documentId"], "bridge.input.documentId");
+      readOptionalIntegerInRange(
+        input["beforeLines"],
+        "bridge.input.beforeLines",
+        0,
+        MAX_KNOWLEDGE_CONTEXT_LINES
+      );
+      readOptionalIntegerInRange(
+        input["afterLines"],
+        "bridge.input.afterLines",
+        0,
+        MAX_KNOWLEDGE_CONTEXT_LINES
+      );
+      readOptionalIntegerInRange(
+        input["maxMatches"],
+        "bridge.input.maxMatches",
+        1,
+        MAX_KNOWLEDGE_SEARCH_PAGE_SIZE
+      );
+      readOptionalIntegerInRange(
+        input["pageSize"],
+        "bridge.input.pageSize",
+        1,
+        MAX_KNOWLEDGE_SEARCH_PAGE_SIZE
+      );
+      readOptionalNonEmptyString(input["cursor"], "bridge.input.cursor");
+      return;
+    case "knowledge.readDocumentLines":
+      readNonEmptyString(input["documentId"], "bridge.input.documentId");
+      const startLine = readPositiveInteger(input["startLine"], "bridge.input.startLine");
+      const endLine = readPositiveInteger(input["endLine"], "bridge.input.endLine");
+      if (endLine < startLine || endLine - startLine + 1 > MAX_KNOWLEDGE_LINE_RANGE) {
+        throw new Error("Kanban bridge knowledge line range is invalid or too large.");
+      }
+  }
+}
+function isKanbanBridgeOperation(value) {
+  return value === "runtime.getLocale" || value === "files.createFile" || value === "files.readFile" || value === "files.deleteFile" || value === "kv.getValue" || value === "kv.setValue" || value === "relatedProject.kv.getValue" || value === "relatedProject.kv.setValue" || value === "knowledge.listDocuments" || value === "knowledge.getDocument" || value === "knowledge.createDocument" || value === "knowledge.editDocument" || value === "knowledge.deleteDocument" || value === "knowledge.searchDocuments" || value === "knowledge.readDocumentLines";
+}
+function readRequiredString(value, field) {
+  if (typeof value !== "string") throw new Error(`Kanban ${field} must be a string.`);
+  return value;
+}
+function readOptionalStringValue(value, field) {
+  if (value === void 0) return void 0;
+  return readRequiredString(value, field);
+}
+function readOptionalNonEmptyString(value, field) {
+  if (value === void 0) return void 0;
+  return readNonEmptyString(value, field);
+}
+function readOptionalIntegerInRange(value, field, minimum, maximum) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`Kanban ${field} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return value;
+}
+function readPositiveInteger(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`Kanban ${field} must be a positive integer.`);
+  }
+  return value;
+}
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`kanban.json ${field} must be a non-empty string.`);
+  return value.trim();
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/web/kanban-data.ts
+var readKanbanProjectInfo = readWorkflowProjectInfo;
+var webProjectDataDirectory = (storageDir, projectDir) => path.join(storageDir, createHash("sha256").update(projectDir).digest("hex").slice(0, 24));
+async function localKanbanRelatedProjects(project) {
+  const info = readWorkflowProjectInfo(JSON.parse(await readFile(path.join(project.folderPath, "package.json"), "utf8")));
+  const relations = info.relatedProjects;
+  const projects = /* @__PURE__ */ new Map();
+  if (!relations.length) {
+    return { info, projects };
+  }
+  const parent = path.dirname(project.folderPath);
+  const directories = (await readdir(parent, { withFileTypes: true })).filter((item) => item.isDirectory() && !item.name.startsWith(".") && item.name !== "node_modules").slice(0, 500);
+  await Promise.all(directories.map(async (item) => {
+    try {
+      const folderPath = await realpath(path.join(parent, item.name));
+      const pkg = JSON.parse(await readFile(path.join(folderPath, "package.json"), "utf8"));
+      const relation = relations.find((relation2) => relation2.projectId.toLowerCase() === String(pkg.id).toLowerCase());
+      if (!relation) {
+        return;
+      }
+      const projectInfo = readWorkflowProjectInfo(pkg);
+      const access = resolveWorkflowRelatedProjectAccess({ consumerProjectId: project.id, consumerProjectInfo: info, targetProjectId: pkg.id, targetProjectInfo: projectInfo, alias: relation.alias });
+      if (access && isWorkflowProjectDataStorageLocationAllowed(projectInfo, "local")) {
+        if (projects.has(relation.alias)) {
+          throw new Error(`Duplicate related project UUID: ${pkg.id}`);
+        }
+        projects.set(relation.alias, { folderPath, id: pkg.id, projectInfo });
+      }
+    } catch (error) {
+      if (String(error).includes("Duplicate related project UUID")) {
+        throw error;
+      }
+    }
+  }));
+  return { info, projects };
+}
+async function runKanbanDataCall(core, project, storageDir, value) {
+  const call = parseKanbanBridgeCall(value), { operation, input } = call;
+  const { info, projects } = await localKanbanRelatedProjects(project);
+  if (info.dataStorage?.mode === "server" || !isWorkflowProjectDataStorageLocationAllowed(info, "local")) {
+    throw new Error("Kanban data must use its declared storage location.");
+  }
+  const directory = webProjectDataDirectory(storageDir, project.folderPath);
+  const kv = core.createWorkflowKVContext({ store: core.createLocalWorkflowKVStore({ rootDir: path.join(directory, "kv"), storageKind: "kv" }), projectId: project.id });
+  const knowledge = { persistentValue: core.createWorkflowPersistentValueContext({ store: core.createLocalWorkflowKVStore({ rootDir: path.join(directory, "values"), storageKind: "persistent_value" }), projectId: project.id }) };
+  switch (operation) {
+    case "kv.getValue":
+      return await kv.getValue(String(input.key)) ?? null;
+    case "kv.setValue":
+      await kv.setValue(String(input.key), input.value);
+      return null;
+    case "relatedProject.kv.getValue":
+    case "relatedProject.kv.setValue": {
+      const alias = String(input.alias), key = String(input.key);
+      resolveKanbanRelatedProject(info.relatedProjects, alias, key);
+      const target = projects.get(alias);
+      if (!target) {
+        throw Object.assign(new Error("Related project is unavailable."), { code: "KANBAN_RELATED_PROJECT_UNAVAILABLE" });
+      }
+      const access = resolveWorkflowRelatedProjectAccess({ consumerProjectId: project.id, consumerProjectInfo: info, targetProjectId: target.id, targetProjectInfo: target.projectInfo, alias });
+      if (!access || !isWorkflowProjectAccessAllowed(operation === "relatedProject.kv.getValue" ? access.grant.read : access.grant.write, key)) {
+        throw Object.assign(new Error("Related project did not grant this key."), { code: "KANBAN_RELATED_PROJECT_UNAVAILABLE" });
+      }
+      const related = core.createWorkflowKVContext({ projectId: target.id, store: core.createLocalWorkflowKVStore({ rootDir: path.join(webProjectDataDirectory(storageDir, target.folderPath), "kv"), storageKind: "kv" }) });
+      if (operation === "relatedProject.kv.getValue") {
+        return await related.getValue(key) ?? null;
+      }
+      await related.setValue(key, input.value);
+      return null;
+    }
+    case "knowledge.listDocuments":
+      return core.listKnowledgeDocumentPage(knowledge, input);
+    case "knowledge.getDocument":
+      return await core.getKnowledgeDocument(knowledge, String(input.documentId)) ?? null;
+    case "knowledge.createDocument":
+      return core.createKnowledgeDocument(knowledge, input);
+    case "knowledge.editDocument":
+      return core.editKnowledgeDocument(knowledge, { id: String(input.documentId), title: input.title, markdown: input.markdown });
+    case "knowledge.deleteDocument":
+      return core.deleteKnowledgeDocument(knowledge, String(input.documentId));
+    case "knowledge.searchDocuments":
+      return core.searchKnowledgeDocuments(knowledge, input);
+    case "knowledge.readDocumentLines":
+      return core.readKnowledgeDocumentLines(knowledge, input);
+    default:
+      throw new Error("Unsupported local Kanban operation.");
+  }
+}
+export {
+  localKanbanRelatedProjects,
+  readKanbanProjectInfo,
+  runKanbanDataCall,
+  webProjectDataDirectory
+};