@workflow-code/cli 0.2.4-20261012004.codex-studio-integration → 0.2.4-20261012006.codex-studio-integration

package/dist/{chunk-WN7VAGK6.js → chunk-5DWX3LL6.js}

@@ -5,7 +5,7 @@ import {
 import {
   createCliRelatedProjectRuntime,
   parseCliRelatedProjectSpec
-} from "./chunk-MNY562W5.js";
+} from "./chunk-5FPIZZE4.js";
 import {
   readWorkflowProjectInfo
 } from "./chunk-P6K3NB5S.js";

package/dist/{chunk-MNY562W5.js → chunk-5FPIZZE4.js}

@@ -12,7 +12,7 @@ import os from "os";
 import path from "path";
 import { readFileSync, realpathSync, statSync } from "fs";
 import * as workflowCode from "workflow-code";
-var targetStorageApi = workflowCode;
+var defaultStorageApi = workflowCode;
 function parseCliRelatedProjectSpec(value) {
   const separatorIndex = value.indexOf("=");
   if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
@@ -30,6 +30,7 @@ function parseCliRelatedProjectSpec(value) {
 }
 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();
@@ -76,7 +77,7 @@ function createCliRelatedProjectRuntime(options) {
           configured.projectDir,
           `Related project "${alias}"`
         );
-        if (currentTarget.projectId.toLowerCase() !== configured.projectId.toLowerCase()) {
+        if (currentConsumer.projectId.toLowerCase() !== consumer.projectId.toLowerCase() || currentTarget.projectId.toLowerCase() !== configured.projectId.toLowerCase()) {
           return void 0;
         }
         const access = resolveWorkflowRelatedProjectAccess({
@@ -93,7 +94,8 @@ function createCliRelatedProjectRuntime(options) {
         if (fixedStore === void 0 && typeof createRemoteStore !== "function") {
           throw new Error("Installed workflow-code does not support related project storage.");
         }
-        const store = fixedStore ?? createRemoteStore({
+        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,
@@ -105,8 +107,9 @@ function createCliRelatedProjectRuntime(options) {
           runId: options.runId,
           conversationId: options.conversationId
         };
-        const persistentValue = fixedPersistentValueStore === void 0 ? void 0 : targetStorageApi.createWorkflowPersistentValueContext?.({
-          store: fixedPersistentValueStore,
+        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
         });
@@ -119,8 +122,9 @@ function createCliRelatedProjectRuntime(options) {
           // 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: localKvStoreDir,
-          persistentValueStoreDir: localPersistentValueStoreDir
+          kvStoreDir: roots.kvStoreDir,
+          persistentValueStoreDir: roots.persistentValueStoreDir,
+          storageApi: targetStorageApi
         });
         return {
           projectId: currentTarget.projectId,
@@ -139,6 +143,7 @@ function createCliRelatedProjectRuntime(options) {
 }
 function createLocalProjectRunner(options) {
   const projectDir = options.projectDir;
+  const targetStorageApi = options.storageApi;
   const inspect = targetStorageApi.inspectLocalWorkflowStructure;
   const run = targetStorageApi.runLocalWorkflowWithReport;
   const unwrap = targetStorageApi.readEntrypointOutput;

package/dist/index.js

@@ -24,7 +24,7 @@ async function main(argv = process.argv.slice(2)) {
   const prepared = prepareCliInvocation(argv);
   argv = prepared.argv;
   if (argv[0] === "web") {
-    const webCli = await import("./web-OMVO2EGT.js");
+    const webCli = await import("./web-FDREEISF.js");
     return webCli.main(argv.slice(1));
   }
   if (argv[0] === "workspace") {
@@ -33,7 +33,7 @@ async function main(argv = process.argv.slice(2)) {
     return typeof process.exitCode === "number" ? process.exitCode : 0;
   }
   if (argv[0] === "mcp") {
-    const mcpCli = await import("./mcp-UQTMW3LK.js");
+    const mcpCli = await import("./mcp-RPT64F7T.js");
     return mcpCli.main(argv.slice(1));
   }
   if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
@@ -43,7 +43,7 @@ async function main(argv = process.argv.slice(2)) {
   }
   const { register } = await import("tsx/esm/api");
   register();
-  const localCli = await import("./local-QLYFH4WT.js");
+  const localCli = await import("./local-XHR2O2FP.js");
   return localCli.main(argv, { localeInitialized: true });
 }
 function formatHelp() {

package/dist/{local-QLYFH4WT.js → local-XHR2O2FP.js}

@@ -9,9 +9,9 @@ import {
   main,
   parseWorkflowArgs,
   readInstalledWorkflowCoreVersion
-} from "./chunk-WN7VAGK6.js";
+} from "./chunk-5DWX3LL6.js";
 import "./chunk-J2JMC4MZ.js";
-import "./chunk-MNY562W5.js";
+import "./chunk-5FPIZZE4.js";
 import "./chunk-P6K3NB5S.js";
 import "./chunk-7WEXRL5A.js";
 import "./chunk-NSPRIPOP.js";

package/dist/{mcp-UQTMW3LK.js → mcp-RPT64F7T.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   parseCliRelatedProjectSpec
-} from "./chunk-MNY562W5.js";
+} from "./chunk-5FPIZZE4.js";
 import {
   isWorkflowAuthConfigLoggedIn,
   normalizeWorkflowAuthConfig,

package/dist/web/kanban-workspace.js

@@ -12643,6 +12643,8 @@
     "Configuration name": "\u914D\u7F6E\u540D\u79F0",
     "Connecting to project": "\u6B63\u5728\u8FDE\u63A5\u9879\u76EE",
     "Connection changed.": "\u8FDE\u63A5\u5DF2\u53D8\u66F4\u3002",
+    "Copy timed out.": "\u590D\u5236\u8D85\u65F6\u3002",
+    "Host clipboard is unavailable.": "\u5BBF\u4E3B\u526A\u8D34\u677F\u4E0D\u53EF\u7528\u3002",
     "Connection interrupted": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD",
     "Connection interrupted.": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD\u3002",
     "Connection not verified": "\u8FDE\u63A5\u672A\u9A8C\u8BC1",
@@ -15693,6 +15695,69 @@ ${state2.user?.avatarUrl ?? ""}`;
     }
   };
 
+  // src/web/ui/clipboard-bridge.ts
+  var ClipboardBridge = class {
+    constructor(send, browserWrite, requiresHost = false) {
+      this.send = send;
+      this.browserWrite = browserWrite;
+      this.requiresHost = requiresHost;
+    }
+    send;
+    browserWrite;
+    requiresHost;
+    enabled = false;
+    pending = /* @__PURE__ */ new Map();
+    enable(version) {
+      this.enabled = version === 1;
+    }
+    async writeText(text2) {
+      if (!this.enabled) {
+        if (this.requiresHost) {
+          throw new Error(t2("Host clipboard is unavailable."));
+        }
+        return this.browserWrite(text2);
+      }
+      const requestId = crypto.randomUUID();
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.pending.delete(requestId);
+          reject(new Error(t2("Copy timed out.")));
+        }, 1e4);
+        this.pending.set(requestId, { resolve, reject, timer });
+        try {
+          this.send({ type: "workflow-clipboard", version: 1, command: "writeText", requestId, text: text2 });
+        } catch (error) {
+          clearTimeout(timer);
+          this.pending.delete(requestId);
+          reject(error);
+        }
+      });
+    }
+    receive(reply) {
+      if (reply?.version !== 1 || typeof reply.requestId !== "string" || typeof reply.ok !== "boolean" || reply.error !== void 0 && typeof reply.error !== "string") {
+        return;
+      }
+      const pending2 = this.pending.get(reply.requestId);
+      if (!pending2) {
+        return;
+      }
+      this.pending.delete(reply.requestId);
+      clearTimeout(pending2.timer);
+      if (reply.ok) {
+        pending2.resolve();
+      } else {
+        pending2.reject(new Error(reply.error || t2("Host clipboard is unavailable.")));
+      }
+    }
+    dispose() {
+      for (const pending2 of this.pending.values()) {
+        clearTimeout(pending2.timer);
+        pending2.reject(new Error(t2("Connection changed.")));
+      }
+      this.pending.clear();
+    }
+  };
+
   // src/web/ui/host.ts
   function acquireWorkflowHost() {
     const embedded = globalThis.acquireVsCodeApi;
@@ -15714,6 +15779,12 @@ ${state2.user?.avatarUrl ?? ""}`;
         window.parent.postMessage(message, "*");
       }
     });
+    const clipboard = new ClipboardBridge(
+      (message) => window.parent.postMessage(message, "*"),
+      (text2) => navigator.clipboard.writeText(text2),
+      window.parent !== window && document.body.dataset.accountHost === "true"
+    );
+    addEventListener("pagehide", () => clipboard.dispose());
     const connection = new BrowserConnection((message) => {
       if (message.type === "state" && message.account) {
         accountPanel.update(message.account);
@@ -15736,6 +15807,10 @@ ${state2.user?.avatarUrl ?? ""}`;
       if (event.data.traceVersion !== void 0) {
         trace.enable(event.data.traceVersion);
       }
+      if (event.data.clipboardVersion !== void 0) {
+        clipboard.enable(event.data.clipboardVersion);
+      }
+      clipboard.receive(event.data.clipboard);
       const traceCommand = trace.command(event.data.traceCommand);
       if (traceCommand) {
         void request2(traceCommand).catch((error) => trace.receive({ type: "trace-run", runId: traceCommand.id, error: error.message }));
@@ -15829,8 +15904,13 @@ ${state2.user?.avatarUrl ?? ""}`;
           }
         }
         if (message.type === "copy") {
-          void navigator.clipboard.writeText(message.text).catch((error) => emit({ type: "error", message: error.message }));
-          return;
+          try {
+            await clipboard.writeText(message.text);
+          } catch (error) {
+            emit({ type: "error", message: error.message });
+            return false;
+          }
+          return true;
         }
         if (message.type === "attach") {
           chooseFiles(message);

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
+};

package/dist/web/worker.mjs

@@ -123,6 +123,13 @@ try {
       process.env.WORKFLOW_DEVELOPER_ASSISTANT_WORKSPACE_MANIFEST = manifestPath;
     }
     const storage = { host: 'local', local: { kvStoreDir: path.join(dataDir, 'kv'), persistentValueStoreDir: path.join(dataDir, 'values') } };
+    if (request.method === 'run' || request.method === 'resolve') {
+      const { createWebRelatedProjectRuntime } = await import(new URL(import.meta.url.includes('/src/web/') ? './related-projects.ts' : './related-projects.mjs', import.meta.url));
+      const related = createWebRelatedProjectRuntime(core, { projectDir, storageDir: request.storageDir,
+        relatedProjects: request.relatedProjects ?? [], runId: request.runId, conversationId: request.conversationId });
+      storage.local.relatedProjectResolver = related.localResolver;
+      storage.server = { relatedProjectResolver: related.serverResolver };
+    }
     const filesDir = path.join(dataDir, 'files');
     const createdFiles = [];
     const managed = createServerWorkflowFileStore({ rootDir: filesDir, workflowName: request.project.id, conversationId: request.conversationId });

package/dist/web/workflow-ui.js

@@ -12643,6 +12643,8 @@
     "Configuration name": "\u914D\u7F6E\u540D\u79F0",
     "Connecting to project": "\u6B63\u5728\u8FDE\u63A5\u9879\u76EE",
     "Connection changed.": "\u8FDE\u63A5\u5DF2\u53D8\u66F4\u3002",
+    "Copy timed out.": "\u590D\u5236\u8D85\u65F6\u3002",
+    "Host clipboard is unavailable.": "\u5BBF\u4E3B\u526A\u8D34\u677F\u4E0D\u53EF\u7528\u3002",
     "Connection interrupted": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD",
     "Connection interrupted.": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD\u3002",
     "Connection not verified": "\u8FDE\u63A5\u672A\u9A8C\u8BC1",
@@ -17386,6 +17388,69 @@ ${state.user?.avatarUrl ?? ""}`;
     }
   };
 
+  // src/web/ui/clipboard-bridge.ts
+  var ClipboardBridge = class {
+    constructor(send, browserWrite, requiresHost = false) {
+      this.send = send;
+      this.browserWrite = browserWrite;
+      this.requiresHost = requiresHost;
+    }
+    send;
+    browserWrite;
+    requiresHost;
+    enabled = false;
+    pending = /* @__PURE__ */ new Map();
+    enable(version) {
+      this.enabled = version === 1;
+    }
+    async writeText(text3) {
+      if (!this.enabled) {
+        if (this.requiresHost) {
+          throw new Error(t2("Host clipboard is unavailable."));
+        }
+        return this.browserWrite(text3);
+      }
+      const requestId = crypto.randomUUID();
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.pending.delete(requestId);
+          reject(new Error(t2("Copy timed out.")));
+        }, 1e4);
+        this.pending.set(requestId, { resolve, reject, timer });
+        try {
+          this.send({ type: "workflow-clipboard", version: 1, command: "writeText", requestId, text: text3 });
+        } catch (error) {
+          clearTimeout(timer);
+          this.pending.delete(requestId);
+          reject(error);
+        }
+      });
+    }
+    receive(reply) {
+      if (reply?.version !== 1 || typeof reply.requestId !== "string" || typeof reply.ok !== "boolean" || reply.error !== void 0 && typeof reply.error !== "string") {
+        return;
+      }
+      const pending = this.pending.get(reply.requestId);
+      if (!pending) {
+        return;
+      }
+      this.pending.delete(reply.requestId);
+      clearTimeout(pending.timer);
+      if (reply.ok) {
+        pending.resolve();
+      } else {
+        pending.reject(new Error(reply.error || t2("Host clipboard is unavailable.")));
+      }
+    }
+    dispose() {
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error(t2("Connection changed.")));
+      }
+      this.pending.clear();
+    }
+  };
+
   // src/web/ui/host.ts
   function acquireWorkflowHost() {
     const embedded = globalThis.acquireVsCodeApi;
@@ -17407,6 +17472,12 @@ ${state.user?.avatarUrl ?? ""}`;
         window.parent.postMessage(message, "*");
       }
     });
+    const clipboard = new ClipboardBridge(
+      (message) => window.parent.postMessage(message, "*"),
+      (text3) => navigator.clipboard.writeText(text3),
+      window.parent !== window && document.body.dataset.accountHost === "true"
+    );
+    addEventListener("pagehide", () => clipboard.dispose());
     const connection = new BrowserConnection((message) => {
       if (message.type === "state" && message.account) {
         accountPanel.update(message.account);
@@ -17429,6 +17500,10 @@ ${state.user?.avatarUrl ?? ""}`;
       if (event.data.traceVersion !== void 0) {
         trace.enable(event.data.traceVersion);
       }
+      if (event.data.clipboardVersion !== void 0) {
+        clipboard.enable(event.data.clipboardVersion);
+      }
+      clipboard.receive(event.data.clipboard);
       const traceCommand = trace.command(event.data.traceCommand);
       if (traceCommand) {
         void request(traceCommand).catch((error) => trace.receive({ type: "trace-run", runId: traceCommand.id, error: error.message }));
@@ -17522,8 +17597,13 @@ ${state.user?.avatarUrl ?? ""}`;
           }
         }
         if (message.type === "copy") {
-          void navigator.clipboard.writeText(message.text).catch((error) => emit({ type: "error", message: error.message }));
-          return;
+          try {
+            await clipboard.writeText(message.text);
+          } catch (error) {
+            emit({ type: "error", message: error.message });
+            return false;
+          }
+          return true;
         }
         if (message.type === "attach") {
           chooseFiles(message);
@@ -18249,8 +18329,10 @@ ${state.user?.avatarUrl ?? ""}`;
       error.textContent = message;
       error.hidden = false;
     }
-    function copy2(text3, button) {
-      vscode.postMessage({ type: "copy", text: text3 });
+    async function copy2(text3, button) {
+      if (await vscode.postMessage({ type: "copy", text: text3 }) === false) {
+        return;
+      }
       button.innerHTML = iconHtml("check");
       button.title = t2("Copied");
       setTimeout(() => {

package/dist/web/workflow-workspace.js

@@ -16172,6 +16172,8 @@
     "Configuration name": "\u914D\u7F6E\u540D\u79F0",
     "Connecting to project": "\u6B63\u5728\u8FDE\u63A5\u9879\u76EE",
     "Connection changed.": "\u8FDE\u63A5\u5DF2\u53D8\u66F4\u3002",
+    "Copy timed out.": "\u590D\u5236\u8D85\u65F6\u3002",
+    "Host clipboard is unavailable.": "\u5BBF\u4E3B\u526A\u8D34\u677F\u4E0D\u53EF\u7528\u3002",
     "Connection interrupted": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD",
     "Connection interrupted.": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD\u3002",
     "Connection not verified": "\u8FDE\u63A5\u672A\u9A8C\u8BC1",
@@ -19237,6 +19239,69 @@ ${state2.user?.avatarUrl ?? ""}`;
     }
   };
 
+  // src/web/ui/clipboard-bridge.ts
+  var ClipboardBridge = class {
+    constructor(send, browserWrite, requiresHost = false) {
+      this.send = send;
+      this.browserWrite = browserWrite;
+      this.requiresHost = requiresHost;
+    }
+    send;
+    browserWrite;
+    requiresHost;
+    enabled = false;
+    pending = /* @__PURE__ */ new Map();
+    enable(version) {
+      this.enabled = version === 1;
+    }
+    async writeText(text3) {
+      if (!this.enabled) {
+        if (this.requiresHost) {
+          throw new Error(t2("Host clipboard is unavailable."));
+        }
+        return this.browserWrite(text3);
+      }
+      const requestId2 = crypto.randomUUID();
+      return new Promise((resolve2, reject) => {
+        const timer = setTimeout(() => {
+          this.pending.delete(requestId2);
+          reject(new Error(t2("Copy timed out.")));
+        }, 1e4);
+        this.pending.set(requestId2, { resolve: resolve2, reject, timer });
+        try {
+          this.send({ type: "workflow-clipboard", version: 1, command: "writeText", requestId: requestId2, text: text3 });
+        } catch (error) {
+          clearTimeout(timer);
+          this.pending.delete(requestId2);
+          reject(error);
+        }
+      });
+    }
+    receive(reply) {
+      if (reply?.version !== 1 || typeof reply.requestId !== "string" || typeof reply.ok !== "boolean" || reply.error !== void 0 && typeof reply.error !== "string") {
+        return;
+      }
+      const pending = this.pending.get(reply.requestId);
+      if (!pending) {
+        return;
+      }
+      this.pending.delete(reply.requestId);
+      clearTimeout(pending.timer);
+      if (reply.ok) {
+        pending.resolve();
+      } else {
+        pending.reject(new Error(reply.error || t2("Host clipboard is unavailable.")));
+      }
+    }
+    dispose() {
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error(t2("Connection changed.")));
+      }
+      this.pending.clear();
+    }
+  };
+
   // src/web/ui/host.ts
   function acquireWorkflowHost() {
     const embedded = globalThis.acquireVsCodeApi;
@@ -19258,6 +19323,12 @@ ${state2.user?.avatarUrl ?? ""}`;
         window.parent.postMessage(message, "*");
       }
     });
+    const clipboard = new ClipboardBridge(
+      (message) => window.parent.postMessage(message, "*"),
+      (text3) => navigator.clipboard.writeText(text3),
+      window.parent !== window && document.body.dataset.accountHost === "true"
+    );
+    addEventListener("pagehide", () => clipboard.dispose());
     const connection = new BrowserConnection((message) => {
       if (message.type === "state" && message.account) {
         accountPanel.update(message.account);
@@ -19280,6 +19351,10 @@ ${state2.user?.avatarUrl ?? ""}`;
       if (event.data.traceVersion !== void 0) {
         trace.enable(event.data.traceVersion);
       }
+      if (event.data.clipboardVersion !== void 0) {
+        clipboard.enable(event.data.clipboardVersion);
+      }
+      clipboard.receive(event.data.clipboard);
       const traceCommand = trace.command(event.data.traceCommand);
       if (traceCommand) {
         void request(traceCommand).catch((error) => trace.receive({ type: "trace-run", runId: traceCommand.id, error: error.message }));
@@ -19373,8 +19448,13 @@ ${state2.user?.avatarUrl ?? ""}`;
           }
         }
         if (message.type === "copy") {
-          void navigator.clipboard.writeText(message.text).catch((error) => emit({ type: "error", message: error.message }));
-          return;
+          try {
+            await clipboard.writeText(message.text);
+          } catch (error) {
+            emit({ type: "error", message: error.message });
+            return false;
+          }
+          return true;
         }
         if (message.type === "attach") {
           chooseFiles(message);

package/dist/{web-OMVO2EGT.js → web-FDREEISF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   assertLocalCliCoreCompatible
-} from "./chunk-WN7VAGK6.js";
+} from "./chunk-5DWX3LL6.js";
 import {
   assertKanbanMethodJson,
   consumeKanbanRelatedProjectRevisionStream,
@@ -21,7 +21,7 @@ import {
   sanitizeKanbanValues
 } from "./chunk-HLMW6LAQ.js";
 import "./chunk-J2JMC4MZ.js";
-import "./chunk-MNY562W5.js";
+import "./chunk-5FPIZZE4.js";
 import {
   clearCliAuthConfig,
   createEmptyWorkflowAuthConfig,
@@ -100,6 +100,8 @@ var messages_zh_cn_default = {
   "Configuration name": "\u914D\u7F6E\u540D\u79F0",
   "Connecting to project": "\u6B63\u5728\u8FDE\u63A5\u9879\u76EE",
   "Connection changed.": "\u8FDE\u63A5\u5DF2\u53D8\u66F4\u3002",
+  "Copy timed out.": "\u590D\u5236\u8D85\u65F6\u3002",
+  "Host clipboard is unavailable.": "\u5BBF\u4E3B\u526A\u8D34\u677F\u4E0D\u53EF\u7528\u3002",
   "Connection interrupted": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD",
   "Connection interrupted.": "\u8FDE\u63A5\u5DF2\u4E2D\u65AD\u3002",
   "Connection not verified": "\u8FDE\u63A5\u672A\u9A8C\u8BC1",
@@ -2485,7 +2487,7 @@ function cliRoot() {
   }
   throw new Error("Cannot locate the CLI installation.");
 }
-function createWebRuntime(projectDir, storageDir, connection) {
+function createWebRuntime(projectDir, storageDir, connection, relatedProjects = () => []) {
   const root = cliRoot();
   const builtWorker = path5.join(root, "dist/web/worker.mjs");
   const worker = existsSync(builtWorker) ? builtWorker : path5.join(root, "src/web/worker.mjs");
@@ -2597,7 +2599,7 @@ function createWebRuntime(projectDir, storageDir, connection) {
       }
     });
     child.stdin.on("error", () => void 0);
-    child.stdin.end(JSON.stringify({ ...request, storageDir, runtimeProjectDir: projectDir }));
+    child.stdin.end(JSON.stringify({ ...request, storageDir, runtimeProjectDir: projectDir, relatedProjects: relatedProjects() }));
   });
   return {
     available: true,
@@ -2735,7 +2737,8 @@ async function startWebServer(options) {
   let authenticationInitialized = false;
   let authCheck;
   const sensitiveTokens = /* @__PURE__ */ new Set();
-  const runtime = options.runtime ?? createWebRuntime(projectDir, storageDir, () => connection);
+  let relatedProjects = options.host?.relatedProjects ?? [];
+  const runtime = options.runtime ?? createWebRuntime(projectDir, storageDir, () => connection, () => relatedProjects);
   let inspected;
   try {
     inspected = await inspectWebProject(runtime, projectDir, options.host);
@@ -3448,6 +3451,9 @@ ${token}`;
     controller,
     workflowController,
     kanbanController,
+    setHostRelatedProjects: (value) => {
+      relatedProjects = value;
+    },
     setHostConnection: async (value) => {
       authEpoch++;
       authCheck?.abort();
@@ -3486,6 +3492,23 @@ import { createInterface } from "readline";
 
 // src/web/host-config.ts
 import path7 from "path";
+function parseHostRelatedProjects(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.length > 100) {
+    throw new Error("Invalid host related projects.");
+  }
+  const aliases = /* @__PURE__ */ new Set(), directories = /* @__PURE__ */ new Set();
+  return value.map((project) => {
+    if (!project || typeof project.alias !== "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(project.alias) || typeof project.projectDir !== "string" || !path7.isAbsolute(project.projectDir) || aliases.has(project.alias) || directories.has(project.projectDir)) {
+      throw new Error("Invalid host related projects.");
+    }
+    aliases.add(project.alias);
+    directories.add(project.projectDir);
+    return { alias: project.alias, projectDir: project.projectDir };
+  });
+}
 function parseHostConnection(value) {
   if (value === null || value === void 0) {
     return;
@@ -3519,7 +3542,13 @@ function parseHostConfiguration(value) {
   if (configuration.surface !== "assistant" && (assistant || assistantProjectDir !== void 0)) {
     throw new Error("Assistant configuration requires the assistant surface.");
   }
-  return { surface: configuration.surface, assistant, assistantProjectDir, connection: parseHostConnection(configuration.connection) };
+  return {
+    surface: configuration.surface,
+    assistant,
+    assistantProjectDir,
+    connection: parseHostConnection(configuration.connection),
+    relatedProjects: parseHostRelatedProjects(configuration.relatedProjects)
+  };
 }
 
 // src/web.ts
@@ -3613,7 +3642,7 @@ async function main(argv) {
   };
   process.once("SIGINT", close);
   process.once("SIGTERM", close);
-  console.log(options.json ? JSON.stringify({ type: "ready", protocolVersion: 1, hostProtocolVersion: 1, accountProtocolVersion: 1, traceProtocolVersion: 1, assistantProtocolVersion: host?.assistant ? ASSISTANT_PROTOCOL_VERSION : void 0, url: app.url, project: { id: app.project.id, name: app.project.name, projectType: app.project.projectType }, runtime: app.project.runtime }) : `Workflow Web: ${app.url}`);
+  console.log(options.json ? JSON.stringify({ type: "ready", protocolVersion: 1, hostProtocolVersion: 1, accountProtocolVersion: 1, relatedProjectsProtocolVersion: 1, traceProtocolVersion: 1, assistantProtocolVersion: host?.assistant ? ASSISTANT_PROTOCOL_VERSION : void 0, url: app.url, project: { id: app.project.id, name: app.project.name, projectType: app.project.projectType }, runtime: app.project.runtime }) : `Workflow Web: ${app.url}`);
   if (lines) {
     void (async () => {
       try {
@@ -3628,6 +3657,8 @@ async function main(argv) {
               process.exitCode = 1;
               close();
             });
+          } else if (message.type === "related-projects") {
+            app.setHostRelatedProjects(parseHostRelatedProjects(message.relatedProjects));
           } else if (message.type === "close") {
             break;
           } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-code/cli",
-  "version": "0.2.4-20261012004.codex-studio-integration",
+  "version": "0.2.4-20261012006.codex-studio-integration",
   "type": "module",
   "bin": {
     "workflow-code": "./dist/index.js"
@@ -36,17 +36,17 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.7",
     "workflow-code": "0.2.4-20260929001",
+    "@workflow-code/auth-config": "0.1.0",
     "@workflow-code/execution-targets": "0.1.0",
     "@workflow-code/i18n": "0.1.0",
     "@workflow-code/kanban-project": "0.1.0",
     "@workflow-code/openai-responses": "0.1.0",
     "@workflow-code/project-dependencies": "0.1.0",
     "@workflow-code/project-info": "0.1.0",
-    "@workflow-code/runtime-compatibility": "0.1.0",
     "@workflow-code/project-upload": "0.1.0",
-    "@workflow-code/workflow-mcp": "0.1.0",
+    "@workflow-code/runtime-compatibility": "0.1.0",
     "@workflow-code/workflow-ids": "0.1.0",
-    "@workflow-code/auth-config": "0.1.0"
+    "@workflow-code/workflow-mcp": "0.1.0"
   },
   "scripts": {
     "bootstrap": "node scripts/bootstrap.mjs",