@workflow-code/cli 0.2.4-20261011008.codex-cli-web → 0.2.4-20261012001

package/dist/web/related-projects.mjs

@@ -0,0 +1,528 @@
+// src/web/related-projects.ts
+import path3 from "node:path";
+
+// src/related-projects.ts
+import os from "node:os";
+import path from "node:path";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import * as workflowCode from "workflow-code";
+
+// .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 workflowCode2 = packageJson["workflowCode"];
+  if (!isRecord(workflowCode2) || workflowCode2["projectInfo"] === void 0) {
+    return createUndeclaredWorkflowProjectInfo();
+  }
+  const projectInfo = normalizeWorkflowProjectInfo(workflowCode2["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 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/workflow-ids/index.ts
+var WORKFLOW_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;
+function isWorkflowUuid(value) {
+  return WORKFLOW_UUID_PATTERN.test(value.trim());
+}
+function assertWorkflowUuid(value, label = "workflow id") {
+  const normalized = value.trim();
+  if (!isWorkflowUuid(normalized)) {
+    throw new Error(`Invalid ${label} "${value}".`);
+  }
+  return normalized;
+}
+
+// src/related-projects.ts
+var defaultStorageApi = workflowCode;
+function createCliRelatedProjectRuntime(options) {
+  if (options.relatedProjects.length === 0) return {};
+  const targetStorageApi = options.storageApi ?? defaultStorageApi;
+  const consumer = readProjectSnapshot(options.consumerProjectDir, "Current project");
+  const configuredByAlias = /* @__PURE__ */ new Map();
+  const configuredProjectIds = /* @__PURE__ */ new Set();
+  const configuredPaths = /* @__PURE__ */ new Set();
+  for (const spec of options.relatedProjects) {
+    if (configuredByAlias.has(spec.alias)) {
+      throw new Error(`Related project alias "${spec.alias}" was specified more than once.`);
+    }
+    const target = readProjectSnapshot(spec.projectDir, `Related project "${spec.alias}"`);
+    const targetProjectId = target.projectId.toLowerCase();
+    if (configuredProjectIds.has(targetProjectId)) {
+      throw new Error(`Related project UUID "${target.projectId}" was specified more than once.`);
+    }
+    if (configuredPaths.has(target.projectDir)) {
+      throw new Error(`Related project directory "${target.projectDir}" was specified more than once.`);
+    }
+    assertConfirmedRelationship(consumer, target, spec.alias);
+    configuredByAlias.set(spec.alias, target);
+    configuredProjectIds.add(targetProjectId);
+    configuredPaths.add(target.projectDir);
+  }
+  const localKvStoreDir = options.localKvStoreDir ?? path.join(os.tmpdir(), "workflow-code-kv");
+  const localPersistentValueStoreDir = options.localPersistentValueStoreDir;
+  const localKvStore = targetStorageApi.createLocalWorkflowKVStore({
+    rootDir: localKvStoreDir,
+    storageKind: "kv"
+  });
+  const localPersistentValueStore = typeof targetStorageApi.createWorkflowPersistentValueContext === "function" && localPersistentValueStoreDir !== void 0 ? targetStorageApi.createLocalWorkflowKVStore({
+    rootDir: localPersistentValueStoreDir,
+    storageKind: "persistent_value"
+  }) : void 0;
+  return {
+    localKvStore,
+    localResolver: createResolver("local", localKvStore, localPersistentValueStore),
+    serverResolver: createResolver("server")
+  };
+  function createResolver(location, fixedStore, fixedPersistentValueStore) {
+    return {
+      resolve(alias) {
+        const configured = configuredByAlias.get(alias);
+        if (configured === void 0) return void 0;
+        const currentConsumer = readProjectSnapshot(consumer.projectDir, "Current project");
+        const currentTarget = readProjectSnapshot(
+          configured.projectDir,
+          `Related project "${alias}"`
+        );
+        if (currentConsumer.projectId.toLowerCase() !== consumer.projectId.toLowerCase() || currentTarget.projectId.toLowerCase() !== configured.projectId.toLowerCase()) {
+          return void 0;
+        }
+        const access = resolveWorkflowRelatedProjectAccess({
+          consumerProjectId: currentConsumer.projectId,
+          consumerProjectInfo: currentConsumer.projectInfo,
+          targetProjectId: currentTarget.projectId,
+          targetProjectInfo: currentTarget.projectInfo,
+          alias
+        });
+        if (access === void 0 || !isWorkflowProjectDataStorageLocationAllowed(currentTarget.projectInfo, location)) {
+          return void 0;
+        }
+        const createRemoteStore = targetStorageApi.createRemoteWorkflowRelatedProjectKVStoreFromEnv;
+        if (fixedStore === void 0 && typeof createRemoteStore !== "function") {
+          throw new Error("Installed workflow-code does not support related project storage.");
+        }
+        const roots = options.localStorageForProject?.(currentTarget.projectDir) ?? { kvStoreDir: localKvStoreDir, persistentValueStoreDir: localPersistentValueStoreDir };
+        const store = location === "local" && options.localStorageForProject ? targetStorageApi.createLocalWorkflowKVStore({ rootDir: roots.kvStoreDir, storageKind: "kv" }) : fixedStore ?? createRemoteStore({
+          consumerProjectId: currentConsumer.projectId,
+          targetProjectId: currentTarget.projectId,
+          alias,
+          env: options.env
+        });
+        if (store === void 0) return void 0;
+        const source = {
+          projectId: currentConsumer.projectId,
+          runId: options.runId,
+          conversationId: options.conversationId
+        };
+        const persistentStore = location === "server" ? store : options.localStorageForProject && roots.persistentValueStoreDir !== void 0 ? targetStorageApi.createLocalWorkflowKVStore({ rootDir: roots.persistentValueStoreDir, storageKind: "persistent_value" }) : fixedPersistentValueStore;
+        const persistentValue = persistentStore === void 0 ? void 0 : targetStorageApi.createWorkflowPersistentValueContext?.({
+          store: persistentStore,
+          projectId: currentTarget.projectId,
+          source
+        });
+        const runner = createLocalProjectRunner({
+          projectDir: currentTarget.projectDir,
+          // Where the target keeps its data decides which store its own run
+          // uses: a project that lives on the server runs against the server,
+          // exactly as it would if its author started it here.
+          location,
+          // The roots settled above, not the raw options: the relation and the
+          // target's own run have to land on the same store, defaults
+          // included, or one side writes what the other cannot see.
+          kvStoreDir: roots.kvStoreDir,
+          persistentValueStoreDir: roots.persistentValueStoreDir,
+          storageApi: targetStorageApi
+        });
+        return {
+          projectId: currentTarget.projectId,
+          grant: access.grant,
+          kv: targetStorageApi.createWorkflowKVContext({
+            store,
+            projectId: currentTarget.projectId,
+            source
+          }),
+          ...persistentValue === void 0 ? {} : { persistentValue },
+          ...runner === void 0 ? {} : { runner }
+        };
+      }
+    };
+  }
+}
+function createLocalProjectRunner(options) {
+  const projectDir = options.projectDir;
+  const targetStorageApi = options.storageApi;
+  const inspect = targetStorageApi.inspectLocalWorkflowStructure;
+  const run = targetStorageApi.runLocalWorkflowWithReport;
+  const unwrap = targetStorageApi.readEntrypointOutput;
+  if (typeof inspect !== "function" || typeof run !== "function" || typeof unwrap !== "function") {
+    return void 0;
+  }
+  return {
+    async listEntrypoints() {
+      const structure = inspect({ workflowDir: projectDir });
+      return (structure.entrypoints ?? []).map((entrypoint) => ({
+        id: entrypoint.id,
+        ...entrypoint.title === void 0 ? {} : { title: entrypoint.title },
+        ...entrypoint.description === void 0 ? {} : { description: entrypoint.description }
+      }));
+    },
+    async run(entrypointId, args) {
+      const report = await run({
+        workflowDir: projectDir,
+        entrypointId,
+        args: [...args],
+        storage: options.location === "server" ? { host: "server" } : {
+          host: "local",
+          local: {
+            kvStoreDir: options.kvStoreDir,
+            persistentValueStoreDir: options.persistentValueStoreDir
+          }
+        }
+      });
+      if (report.result === void 0) {
+        throw new Error(`Related project entrypoint "${entrypointId}" returned no result.`);
+      }
+      return unwrap(report.result.data);
+    }
+  };
+}
+function assertConfirmedRelationship(consumer, target, alias) {
+  const consumerRelation = consumer.projectInfo.relatedProjects.find(
+    (relation) => relation.alias === alias
+  );
+  if (consumerRelation?.projectId.toLowerCase() !== target.projectId.toLowerCase()) {
+    throw new Error(
+      `Current project does not declare related project "${alias}" with UUID "${target.projectId}".`
+    );
+  }
+  if (resolveWorkflowRelatedProjectAccess({
+    consumerProjectId: consumer.projectId,
+    consumerProjectInfo: consumer.projectInfo,
+    targetProjectId: target.projectId,
+    targetProjectInfo: target.projectInfo,
+    alias
+  }) === void 0) {
+    throw new Error(`Related project "${alias}" is not confirmed by both project manifests.`);
+  }
+}
+function readProjectSnapshot(projectDir, label) {
+  let canonicalDir;
+  try {
+    canonicalDir = realpathSync(projectDir);
+    if (!statSync(canonicalDir).isDirectory()) {
+      throw new Error("not a directory");
+    }
+  } catch (error) {
+    throw new Error(`${label} directory is unavailable: ${projectDir}`, { cause: error });
+  }
+  const packagePath = path.join(canonicalDir, "package.json");
+  let packageJson;
+  try {
+    packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
+  } catch (error) {
+    throw new Error(`${label} must contain a readable package.json: ${canonicalDir}`, {
+      cause: error
+    });
+  }
+  if (!isRecord2(packageJson) || typeof packageJson["id"] !== "string") {
+    throw new Error(`${label} package.json.id must be a UUID.`);
+  }
+  const projectId = assertWorkflowUuid(packageJson["id"], `${label} package.json.id`);
+  const projectInfo = readWorkflowProjectInfo(packageJson);
+  if (projectInfo.dataStorage === null) {
+    throw new Error(`${label} must declare workflowCode.projectInfo.dataStorage.mode.`);
+  }
+  return { projectDir: canonicalDir, projectId, projectInfo };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/web/kanban-data.ts
+import { createHash } from "node:crypto";
+import path2 from "node:path";
+
+// .shared/kanban-project/index.ts
+var KANBAN_FILE_MAX_BYTES = 50 * 1024 * 1024;
+
+// src/web/kanban-data.ts
+var webProjectDataDirectory = (storageDir, projectDir) => path2.join(storageDir, createHash("sha256").update(projectDir).digest("hex").slice(0, 24));
+
+// src/web/related-projects.ts
+function createWebRelatedProjectRuntime(core, options) {
+  const roots = (projectDir) => {
+    const directory = webProjectDataDirectory(options.storageDir, projectDir);
+    return { kvStoreDir: path3.join(directory, "kv"), persistentValueStoreDir: path3.join(directory, "values") };
+  };
+  const local = roots(options.projectDir);
+  return createCliRelatedProjectRuntime({
+    consumerProjectDir: options.projectDir,
+    relatedProjects: options.relatedProjects,
+    localKvStoreDir: local.kvStoreDir,
+    localPersistentValueStoreDir: local.persistentValueStoreDir,
+    localStorageForProject: roots,
+    storageApi: core,
+    runId: options.runId,
+    conversationId: options.conversationId,
+    env: process.env
+  });
+}
+export {
+  createWebRelatedProjectRuntime
+};