@workflow-code/cli 0.2.4-20260929001 → 0.2.4-20261010001.codex-cli-web

package/dist/web-U23BFLG4.js

@@ -0,0 +1,1523 @@
+#!/usr/bin/env node
+import {
+  assertLocalCliCoreCompatible
+} from "./chunk-T4FXQ7AQ.js";
+import "./chunk-J2JMC4MZ.js";
+import "./chunk-G7PZDTYW.js";
+import {
+  clearCliAuthConfig,
+  readCliAuthConfig
+} from "./chunk-PGM3IPWA.js";
+import "./chunk-BP2VDZQV.js";
+import {
+  i18n
+} from "./chunk-7WEXRL5A.js";
+import "./chunk-NSPRIPOP.js";
+
+// src/web.ts
+import { spawn as spawn3 } from "child_process";
+import path3 from "path";
+
+// src/web/server.ts
+import { createServer } from "http";
+import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { mkdir, readFile, rename, writeFile, realpath } from "fs/promises";
+import path2 from "path";
+import os from "os";
+import { pathToFileURL } from "url";
+import { spawn as spawn2 } from "child_process";
+
+// src/web/workflow-types.ts
+function workflowParameters(project, entrypointId) {
+  return project.entrypoints.find((entry) => entry.id === entrypointId) ?? project;
+}
+function workflowParamValue(field, value = field.defaultValue ?? "") {
+  if (field.type === "file" || field.control === "audio" || !(field.multiple || field.control === "checkboxes") || Array.isArray(value)) {
+    return value;
+  }
+  if (!value.trim()) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((entry) => ["string", "number", "boolean"].includes(typeof entry)).map(String);
+    }
+  } catch {
+  }
+  return [value];
+}
+function workflowFormValue(field, value) {
+  if (value === void 0 || value === null) {
+    return workflowParamValue(field);
+  }
+  if (typeof value === "string") {
+    return workflowParamValue(field, value);
+  }
+  if (field.type === "file" || field.control === "audio" || field.format === "json") {
+    return JSON.stringify(value);
+  }
+  return workflowParamValue(field, Array.isArray(value) ? value.map(String) : String(value));
+}
+function workflowParamArgs(fields, values, states = {}) {
+  const args = [];
+  for (const field of fields) {
+    if (states[field.name]?.visible === false) {
+      continue;
+    }
+    const value = workflowParamValue(field, values[field.name]);
+    const entries = Array.isArray(value) ? value.length ? [JSON.stringify(value)] : [] : [value];
+    for (const entry of entries) {
+      if (entry === "") {
+        continue;
+      }
+      if (field.flag) {
+        args.push(field.flag, entry);
+      } else if (field.type === "positional") {
+        args.push(entry);
+      }
+    }
+  }
+  return args;
+}
+function applyOutputChunk(items, value) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  const chunk = value;
+  if (chunk.type === "output_item_start" && chunk.item) {
+    const index = items.findIndex((item) => item.id && item.id === chunk.item?.id);
+    if (index >= 0) {
+      items[index] = { ...chunk.item };
+    } else {
+      items.push({ ...chunk.item });
+    }
+  } else if (chunk.type === "output_item_delta") {
+    const item = items.find((entry) => entry.id === chunk.itemId);
+    if (item) {
+      if (chunk.item) {
+        Object.assign(item, { ...chunk.item, metadata: { ...item.metadata, ...chunk.item.metadata } });
+      }
+      if (typeof chunk.delta === "string") {
+        item.content = `${typeof item.content === "string" ? item.content : ""}${chunk.delta}`;
+      } else if (chunk.delta !== void 0) {
+        item.content = chunk.delta;
+      }
+    }
+  }
+}
+function outputText(items) {
+  return items.filter((item) => !item.collapsed && item.metadata?.plan !== true && ["text", "markdown", void 0].includes(item.contentType)).map((item) => typeof item.content === "string" ? item.content : "").filter(Boolean).join("\n\n");
+}
+function validateWorkflowValues(fields, values, states = {}) {
+  for (const field of fields) {
+    if (states[field.name]?.visible === false || states[field.name]?.disabled) {
+      continue;
+    }
+    const value = workflowParamValue(field, values[field.name]);
+    const label = field.label || field.name;
+    if (field.required && (typeof value === "string" && !value.trim() || Array.isArray(value) && !value.length)) {
+      throw new Error(`\u8BF7\u586B\u5199 ${label}\u3002`);
+    }
+    if (value === "" || Array.isArray(value) && !value.length) {
+      continue;
+    }
+    if (field.type === "number" && (typeof value !== "string" || !Number.isFinite(Number(value)))) {
+      throw new Error(`${label} \u9700\u8981\u662F\u6709\u6548\u6570\u5B57\u3002`);
+    }
+    if (field.type === "boolean" && value !== "true" && value !== "false") {
+      throw new Error(`${label} \u9700\u8981\u662F\u6709\u6548\u5E03\u5C14\u503C\u3002`);
+    }
+    if (field.format === "json" || field.type === "file" || field.control === "audio") {
+      let parsed;
+      try {
+        parsed = JSON.parse(typeof value === "string" ? value : JSON.stringify(value));
+      } catch {
+        throw new Error(`${label} \u9700\u8981\u662F\u6709\u6548\u7684 JSON\u3002`);
+      }
+      if (field.required && (field.type === "file" || field.control === "audio") && (parsed === null || Array.isArray(parsed) && !parsed.length)) {
+        throw new Error(`\u8BF7\u586B\u5199 ${label}\u3002`);
+      }
+    }
+    const choices = states[field.name]?.resolvedOptions ?? field.options;
+    if (choices && choices.length > 0) {
+      const allowed = new Set(choices.filter((option) => states[field.name]?.options?.[option.value]?.visible !== false && !states[field.name]?.options?.[option.value]?.disabled).map((option) => option.value));
+      if ((Array.isArray(value) ? value : [value]).some((entry) => !allowed.has(entry))) {
+        throw new Error(`${label} \u7684\u9009\u9879\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u3002`);
+      }
+    }
+  }
+}
+function resolvedWorkflowValues(fields, values) {
+  validateWorkflowValues(fields, values);
+  return Object.fromEntries(fields.map((field) => {
+    const value = workflowParamValue(field, values[field.name]);
+    if (field.type === "boolean") {
+      return [field.name, value === "true"];
+    }
+    if (field.type === "number" && value !== "") {
+      return [field.name, Number(value)];
+    }
+    if ((field.type === "file" || field.control === "audio" || field.format === "json") && typeof value === "string" && value !== "") {
+      return [field.name, JSON.parse(value)];
+    }
+    return [field.name, value];
+  }));
+}
+function redactWorkflowData(value, secrets = [], redactKeys = true) {
+  if (typeof value === "string") {
+    for (const secret of secrets.filter(Boolean)) {
+      value = value.replaceAll(secret, "[redacted]");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactWorkflowData(entry, secrets, redactKeys));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      redactKeys && /password|secret|authorization|cookie|^(?:api[-_]?key|access[-_]?token|refresh[-_]?token)$/i.test(key) ? "[redacted]" : redactWorkflowData(entry, secrets, redactKeys)
+    ]));
+  }
+  return value;
+}
+
+// src/web/conversation-controller.ts
+var ConversationController = class {
+  constructor(project, runtime, saved, options) {
+    this.project = project;
+    this.runtime = runtime;
+    this.options = options;
+    this.sessions = (saved.sessions ?? []).filter((entry) => typeof entry.id === "string" && typeof entry.title === "string" && Array.isArray(entry.messages));
+    if (!this.sessions.length) {
+      this.sessions.push(this.blank());
+    }
+    this.activeId = this.sessions.some((entry) => entry.id === saved.activeId) ? saved.activeId : this.sessions.at(-1).id;
+    for (const entry of this.sessions) {
+      entry.createdAt ??= entry.messages[0]?.createdAt ?? 0;
+      entry.updatedAt ??= entry.messages.at(-1)?.createdAt ?? entry.createdAt;
+      delete entry.activeRunId;
+      entry.queuedInputs ??= [];
+      for (const message of entry.messages) {
+        delete message.submittingInput;
+        if (message.status === "running") {
+          message.status = message.pendingInput ? "waiting_for_input" : "aborted";
+          message.error = "\u8FD0\u884C\u5DF2\u4E2D\u65AD";
+        }
+      }
+    }
+  }
+  project;
+  runtime;
+  options;
+  sessions;
+  activeId;
+  tasks = /* @__PURE__ */ new Map();
+  disposed = false;
+  removing = /* @__PURE__ */ new Set();
+  get current() {
+    return this.sessions.find((entry) => entry.id === this.activeId);
+  }
+  get running() {
+    return !!this.current.activeRunId;
+  }
+  get hasRuns() {
+    return this.tasks.size > 0;
+  }
+  blank() {
+    const now = Date.now();
+    return { id: globalThis.crypto.randomUUID(), title: "\u65B0\u5BF9\u8BDD", createdAt: now, updatedAt: now, messages: [], parameterValues: {}, toolPermissionPolicies: {}, queuedInputs: [], draft: { text: "", attachments: [] } };
+  }
+  async persist() {
+    const sessions = this.sessions.map((entry) => ({ ...entry, messages: entry.messages.map(({ submittingInput: _, ...message }) => message) }));
+    await this.options.save(JSON.parse(JSON.stringify(sessions)), this.activeId);
+  }
+  changed() {
+    if (!this.disposed) {
+      this.options.changed();
+    }
+  }
+  async create() {
+    const blank = this.sessions.find((entry) => !entry.messages.length && !entry.activeRunId && !entry.queuedInputs?.length && !entry.draft?.text && !entry.draft?.attachments.length);
+    const next = blank ?? this.blank();
+    next.updatedAt = Date.now();
+    if (blank) {
+      this.sessions.splice(this.sessions.indexOf(blank), 1);
+    }
+    this.sessions.push(next);
+    this.activeId = next.id;
+    this.changed();
+    await this.persist();
+  }
+  async select(id) {
+    if (!this.sessions.some((entry) => entry.id === id)) {
+      return;
+    }
+    this.activeId = id;
+    this.changed();
+    await this.persist();
+  }
+  async rename(id, title) {
+    const entry = this.sessions.find((entry2) => entry2.id === id);
+    if (!entry || !title.trim()) {
+      return;
+    }
+    entry.title = title.trim().slice(0, 160);
+    entry.titleLocked = true;
+    this.changed();
+    await this.persist();
+  }
+  async lockTitle(id, locked) {
+    const entry = this.sessions.find((entry2) => entry2.id === id);
+    if (entry) {
+      entry.titleLocked = locked;
+      this.changed();
+      await this.persist();
+    }
+  }
+  async remove(id) {
+    if (this.removing.has(id)) {
+      return;
+    }
+    const index = this.sessions.findIndex((entry2) => entry2.id === id);
+    if (index < 0) {
+      return;
+    }
+    const entry = this.sessions[index];
+    this.removing.add(id);
+    try {
+      const task = entry.activeRunId && this.tasks.get(entry.activeRunId);
+      if (task) {
+        task.cancelled = true;
+        this.runtime.cancel(entry.activeRunId);
+        await task.finished;
+      }
+      await this.runtime.deleteConversation(this.project, id);
+      this.sessions.splice(this.sessions.indexOf(entry), 1);
+      if (!this.sessions.length) {
+        this.sessions.push(this.blank());
+      }
+      if (this.activeId === id) {
+        this.activeId = this.sessions.at(-1).id;
+      }
+      this.changed();
+      await this.persist();
+    } finally {
+      this.removing.delete(id);
+    }
+  }
+  async updateDraft(id, text, attachments, editingQueueId) {
+    const entry = this.sessions.find((entry2) => entry2.id === id);
+    if (!entry) {
+      return;
+    }
+    entry.draft = { text: text.slice(0, 1e5), attachments, editingQueueId: editingQueueId ?? entry.draft?.editingQueueId };
+    await this.persist();
+  }
+  async send(input) {
+    const entry = this.current;
+    const parameters = workflowParameters(this.project, input.entrypointId);
+    validateWorkflowValues(parameters.fields, input.params, input.states);
+    if (this.removing.has(entry.id)) {
+      return;
+    }
+    if (this.project.projectType !== "conversation" && input.text) {
+      this.rawArgs(input.text);
+    }
+    if (this.project.projectType === "conversation" && this.project.conversation?.defaultInput?.enabled !== false && !input.text.trim() && !input.attachments.length) {
+      return;
+    }
+    const queued = { ...input, id: globalThis.crypto.randomUUID(), createdAt: Date.now(), params: { ...input.params }, attachments: [...input.attachments] };
+    const waiting = entry.messages.some((message) => message.pendingInput);
+    if (entry.activeRunId || waiting || entry.queuedInputs?.length) {
+      if (!this.project.conversation?.inputQueue?.enabled) {
+        throw new Error("\u5F53\u524D\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u3002");
+      }
+      if (entry.draft?.editingQueueId) {
+        const index = entry.queuedInputs.findIndex((item) => item.id === entry.draft?.editingQueueId);
+        if (index >= 0) {
+          queued.id = entry.queuedInputs[index].id;
+          entry.queuedInputs[index] = queued;
+        } else {
+          entry.queuedInputs.push(queued);
+        }
+      } else {
+        (entry.queuedInputs ??= []).push(queued);
+      }
+      entry.draft = { text: "", attachments: [] };
+      this.changed();
+      await this.persist();
+      if (!entry.activeRunId && !waiting) {
+        this.drain(entry);
+      }
+      return;
+    }
+    entry.draft = { text: "", attachments: [] };
+    this.start(entry, queued);
+    await this.persist();
+  }
+  start(entry, input, answer) {
+    const parameters = workflowParameters(this.project, input.entrypointId);
+    const args = workflowParamArgs(parameters.fields, input.params, input.states);
+    if (this.project.projectType === "conversation" && this.project.conversation?.defaultInput?.enabled !== false) {
+      args.push("--message", input.text);
+      for (const [flag, files] of [
+        ["--images", input.attachments.filter((file) => file.kind === "image")],
+        ["--videos", input.attachments.filter((file) => file.mimeType.startsWith("video/"))],
+        ["--files", input.attachments.filter((file) => file.kind !== "image" && !file.mimeType.startsWith("video/"))]
+      ]) {
+        if (files.length) {
+          args.push(flag, JSON.stringify(files.map(({ previewUrl: _, ...reference }) => reference)));
+        }
+      }
+    } else if (this.project.projectType !== "conversation" && input.text) {
+      args.push(...this.rawArgs(input.text));
+    }
+    if (!answer) {
+      if (!entry.messages.length && !entry.titleLocked) {
+        entry.title = (input.text || input.attachments[0]?.name || "\u5DE5\u4F5C\u6D41\u8FD0\u884C").slice(0, 80);
+      }
+      entry.messages.push({ id: globalThis.crypto.randomUUID(), role: "user", content: input.text || "", attachments: input.attachments, args, input, entrypointId: input.entrypointId, createdAt: Date.now() });
+      answer = { id: globalThis.crypto.randomUUID(), role: "assistant", content: "", items: [], status: "running", createdAt: Date.now(), model: typeof input.params.model === "string" ? input.params.model : void 0, args, entrypointId: input.entrypointId, events: [] };
+      answer.runId = answer.id;
+      entry.messages.push(answer);
+    }
+    const request = {
+      project: this.project,
+      conversationId: entry.id,
+      args: answer.args ?? args,
+      runId: answer.runId,
+      entrypointId: answer.entrypointId,
+      toolPermissionPolicies: entry.toolPermissionPolicies,
+      resolvedInputs: [...answer.resolvedInputs ?? [], ...answer.submittingInput ? [answer.submittingInput] : []],
+      resumeAfterRequestId: answer.submittingInput?.requestId
+    };
+    answer.status = "running";
+    answer.error = void 0;
+    if (!answer.submittingInput) {
+      answer.pendingInput = void 0;
+    }
+    entry.updatedAt = Date.now();
+    entry.activeRunId = answer.runId;
+    const task = { cancelled: false, finished: Promise.resolve() };
+    this.tasks.set(answer.runId, task);
+    this.changed();
+    task.finished = this.execute(entry, answer, request, task).catch((error) => this.options.log(`Workflow persistence: ${String(error)}`));
+  }
+  rawArgs(text) {
+    const raw = JSON.parse(text);
+    if (!Array.isArray(raw) || !raw.every((arg) => typeof arg === "string")) {
+      throw new Error("\u8FD0\u884C\u53C2\u6570\u9700\u8981\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u3002");
+    }
+    return raw;
+  }
+  async execute(entry, answer, request, task) {
+    const pending = answer.pendingInput;
+    try {
+      await this.persist();
+      if (task.cancelled || this.disposed) {
+        throw new Error("\u5DF2\u505C\u6B62");
+      }
+      const report = await this.runtime.run(request, (event) => {
+        if (this.disposed) {
+          return;
+        }
+        (answer.events ??= []).push(event);
+        if (event.type === "node_chunk") {
+          applyOutputChunk(answer.items ??= [], event.chunk);
+          answer.content = outputText(answer.items);
+        }
+        if (event.type === "conversation_title_updated" && !entry.titleLocked && typeof event.title === "string") {
+          entry.title = event.title.slice(0, 160);
+        }
+        if (event.type === "token_usage_updated") {
+          answer.tokenUsage = { enabled: true, display: true, run: event.usage };
+        }
+        if (event.type === "user_input_requested") {
+          answer.pendingInput = event;
+        }
+        if (event.type === "user_input_resolved") {
+          this.confirmInput(answer, event);
+          if (answer.pendingInput?.requestId === event.requestId) {
+            answer.pendingInput = void 0;
+          }
+        }
+        if (event.type === "file_created") {
+          (answer.files ??= []).push(event.file);
+        }
+        if (event.type === "timer_started" || event.type === "timer_finished") {
+          const timer = event.timer;
+          answer.timers = [...(answer.timers ?? []).filter((entry2) => entry2.timerId !== timer.timerId), timer];
+        }
+        this.changed();
+      });
+      answer.report = report;
+      answer.status = report.status;
+      answer.durationMs = report.durationMs;
+      if (report.output?.items?.length) {
+        answer.items = report.output.items;
+        answer.content = outputText(answer.items);
+      }
+      answer.pendingInput = report.status === "waiting_for_input" ? report.pendingUserInput : void 0;
+      for (const resolved of report.resolvedUserInputs ?? []) {
+        this.confirmInput(answer, resolved);
+      }
+      if (answer.submittingInput && report.status === "success") {
+        this.confirmInput(answer, answer.submittingInput);
+      }
+      answer.files = [...new Map([...answer.files ?? [], ...report.files ?? []].map((file) => [file.id, file])).values()];
+      answer.tokenUsage = report.tokenUsage ?? answer.tokenUsage;
+      answer.timers = report.timers ?? answer.timers;
+      if (report.status === "failed") {
+        const data = report.result?.data;
+        answer.error = report.result?.error?.message || (data && typeof data === "object" && "errMessage" in data && typeof data.errMessage === "string" ? data.errMessage : "\u8FD0\u884C\u5931\u8D25");
+      }
+      if (report.status === "aborted" || report.status === "timed_out") {
+        answer.error = report.status === "aborted" ? "\u5DF2\u505C\u6B62" : "\u8FD0\u884C\u8D85\u65F6";
+      }
+      if (answer.submittingInput && pending && report.status === "failed") {
+        answer.status = "waiting_for_input";
+        answer.pendingInput = pending;
+      }
+      if (!answer.content && !answer.items?.length && report.status === "success") {
+        answer.content = report.result?.data === void 0 ? "\u5DF2\u5B8C\u6210" : JSON.stringify(report.result.data, null, 2);
+      }
+    } catch (error) {
+      answer.error = error instanceof Error ? error.message : String(error);
+      answer.status = task.cancelled ? "aborted" : answer.submittingInput && pending ? "waiting_for_input" : "failed";
+      if (answer.status === "waiting_for_input") {
+        answer.pendingInput = pending;
+      } else if (task.cancelled) {
+        answer.pendingInput = void 0;
+      }
+      this.options.log(`Workflow run: ${answer.error}`);
+    } finally {
+      if (answer.status !== "waiting_for_input") {
+        answer.timers = answer.timers?.map((timer) => timer.status === "running" ? { ...timer, status: "cleared", endedAt: (/* @__PURE__ */ new Date()).toISOString(), durationMs: Math.max(0, Date.now() - new Date(timer.startedAt).getTime()) } : timer);
+      }
+      delete answer.submittingInput;
+      if (entry.activeRunId === answer.runId) {
+        delete entry.activeRunId;
+      }
+      this.tasks.delete(answer.runId);
+      this.changed();
+      await this.persist();
+      if (!this.disposed && !this.removing.has(entry.id) && !answer.pendingInput && (!task.cancelled || task.promote)) {
+        this.drain(entry);
+      }
+    }
+  }
+  confirmInput(answer, resolved) {
+    const previous = answer.resolvedInputs?.find((input) => input.requestId === resolved.requestId) ?? (answer.submittingInput?.requestId === resolved.requestId ? answer.submittingInput : void 0);
+    const confirmed = { ...previous, ...resolved, precedingOutputItemIds: previous?.precedingOutputItemIds ?? resolved.precedingOutputItemIds };
+    answer.resolvedInputs = [...(answer.resolvedInputs ?? []).filter((input) => input.requestId !== resolved.requestId), confirmed];
+    if (answer.submittingInput?.requestId === resolved.requestId) {
+      delete answer.submittingInput;
+    }
+  }
+  drain(entry) {
+    if (entry.activeRunId || entry.messages.some((message) => message.pendingInput) || entry.draft?.editingQueueId || this.disposed || this.removing.has(entry.id)) {
+      return;
+    }
+    const input = entry.queuedInputs?.shift();
+    if (input) {
+      try {
+        this.start(entry, input);
+      } catch (error) {
+        entry.queuedInputs.unshift(input);
+        this.options.log(String(error));
+        this.changed();
+      }
+    }
+  }
+  stop(entry = this.current) {
+    const task = entry.activeRunId && this.tasks.get(entry.activeRunId);
+    if (task) {
+      task.cancelled = true;
+      this.runtime.cancel(entry.activeRunId);
+    } else {
+      const pending = entry.messages.find((message) => message.pendingInput);
+      if (pending) {
+        pending.pendingInput = void 0;
+        pending.status = "aborted";
+        pending.error = "\u5DF2\u505C\u6B62";
+        this.changed();
+        void this.persist().catch((error) => this.options.log(String(error)));
+      }
+    }
+  }
+  async resume(messageId, requestId, values) {
+    const entry = this.current;
+    const answer = entry.messages.find((message) => message.id === messageId && message.pendingInput?.requestId === requestId);
+    if (!answer?.pendingInput || entry.activeRunId) {
+      return;
+    }
+    const request = answer.pendingInput;
+    const allowed = Object.fromEntries(request.params.map((field) => [field.name, values[field.name] ?? request.defaultValues?.[field.name] ?? field.defaultValue ?? ""]));
+    const form = Object.fromEntries(request.params.map((field) => [field.name, workflowFormValue(field, allowed[field.name])]));
+    const typedValues = resolvedWorkflowValues(request.params, form);
+    const resolved = {
+      requestId,
+      nodeName: request.nodeName,
+      values: typedValues,
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      request,
+      precedingOutputItemIds: (answer.items ?? []).map((item, index) => item.id ?? String(index))
+    };
+    answer.submittingInput = resolved;
+    if (request.metadata?.type === "agent-plan-approval" && allowed.decision === "approve") {
+      const mode = workflowParameters(this.project, answer.entrypointId).fields.find((field) => field.panel === "mode");
+      if (mode) {
+        (entry.parameterValues ??= {})[answer.entrypointId ?? ""] ??= {};
+        entry.parameterValues[answer.entrypointId ?? ""][mode.name] = "build";
+      }
+    }
+    this.start(entry, { id: messageId, text: "", params: {}, entrypointId: answer.entrypointId, attachments: [], createdAt: Date.now() }, answer);
+    await this.persist();
+  }
+  async editQueued(id) {
+    const input = this.current.queuedInputs?.find((input2) => input2.id === id);
+    if (!input) {
+      return;
+    }
+    this.current.draft = { text: input.text, attachments: input.attachments, editingQueueId: id };
+    (this.current.parameterValues ??= {})[input.entrypointId ?? ""] = input.params;
+    this.changed();
+    await this.persist();
+  }
+  async removeQueued(id) {
+    this.current.queuedInputs = (this.current.queuedInputs ?? []).filter((input) => input.id !== id);
+    if (this.current.draft?.editingQueueId === id) {
+      this.current.draft = { text: "", attachments: [] };
+    }
+    this.changed();
+    await this.persist();
+    this.drain(this.current);
+  }
+  async cancelQueueEdit() {
+    this.current.draft = { text: "", attachments: [] };
+    this.changed();
+    await this.persist();
+    this.drain(this.current);
+  }
+  async runQueued() {
+    this.drain(this.current);
+    await this.persist();
+  }
+  async reorderQueued(ids) {
+    const queue = this.current.queuedInputs ?? [];
+    if (ids.length !== queue.length || new Set(ids).size !== queue.length || ids.some((id) => !queue.some((input) => input.id === id))) {
+      return;
+    }
+    this.current.queuedInputs = ids.map((id) => queue.find((input) => input.id === id));
+    this.changed();
+    await this.persist();
+  }
+  async promoteQueued(id) {
+    const entry = this.current;
+    const queue = entry.queuedInputs ?? [];
+    if (!queue.some((input) => input.id === id)) {
+      return;
+    }
+    await this.reorderQueued([id, ...queue.filter((input) => input.id !== id).map((input) => input.id)]);
+    if (entry.draft?.editingQueueId) {
+      entry.draft = { text: "", attachments: [] };
+    }
+    const task = entry.activeRunId && this.tasks.get(entry.activeRunId);
+    if (task) {
+      task.promote = true;
+      task.cancelled = true;
+      this.runtime.cancel(entry.activeRunId);
+    } else {
+      this.stop(entry);
+      this.drain(entry);
+    }
+  }
+  async retry(id) {
+    const index = this.current.messages.findIndex((message) => message.id === id && message.role === "assistant");
+    const user = [...this.current.messages.slice(0, index)].reverse().find((message) => message.role === "user");
+    if (!user || this.current.activeRunId) {
+      return;
+    }
+    if (user.input) {
+      await this.send(user.input);
+      return;
+    }
+    const parameters = workflowParameters(this.project, user.entrypointId);
+    const params = {};
+    for (const field of parameters.fields) {
+      const index2 = user.args?.indexOf(field.flag ?? "") ?? -1;
+      if (index2 >= 0) {
+        params[field.name] = user.args[index2 + 1];
+      }
+    }
+    await this.send({ text: user.content, params, entrypointId: user.entrypointId, attachments: user.attachments ?? [] });
+  }
+  async idle() {
+    while (this.tasks.size) {
+      await Promise.all([...this.tasks.values()].map((task) => task.finished));
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    for (const entry of this.sessions) {
+      this.stop(entry);
+    }
+  }
+};
+
+// src/web/runtime.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function cliRoot() {
+  let directory = path.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth++) {
+    try {
+      if (JSON.parse(readFileSync(path.join(directory, "package.json"), "utf8")).name === "@workflow-code/cli") {
+        return directory;
+      }
+    } catch {
+    }
+    directory = path.dirname(directory);
+  }
+  throw new Error("Cannot locate the CLI installation.");
+}
+function createWebRuntime(projectDir, storageDir, connection) {
+  const root = cliRoot();
+  const builtWorker = path.join(root, "dist/web/worker.mjs");
+  const worker = existsSync(builtWorker) ? builtWorker : path.join(root, "src/web/worker.mjs");
+  const children = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const invoke = (request, onEvent) => new Promise((resolve, reject) => {
+    if (disposed) {
+      reject(new Error("Web runtime has stopped."));
+      return;
+    }
+    const auth = connection();
+    const env = { ...process.env, WORKFLOW_RUNTIME_PLATFORM: "cli", WORKFLOW_SERVER_URL: auth?.serverUrl ?? "", WORKFLOW_SERVER_ADMIN_KEY: auth?.accessToken ?? "" };
+    for (const key of ["TSX_TSCONFIG_PATH", "WORKFLOW_LOCAL_CORE_ROOT", "WORKFLOW_LOCAL_SHARED_ROOT", "WORKFLOW_LOCAL_SOURCE_MODE"]) {
+      delete env[key];
+    }
+    if (env.NODE_OPTIONS) {
+      env.NODE_OPTIONS = env.NODE_OPTIONS.replace(/(?:--conditions=development|--conditions\s+development|-C=development|-C\s+development)/g, "");
+    }
+    const child = spawn(process.execPath, [worker], { cwd: projectDir, env, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+    children.add(child);
+    if (request.method === "run") {
+      active.set(String(request.runId), child);
+    }
+    let buffer = "", stderr = "", failure;
+    let result;
+    const timeout = setTimeout(() => {
+      failure = "Workflow execution timed out.";
+      child.kill("SIGTERM");
+    }, request.method === "run" ? 6e5 : 3e4);
+    const forcedExit = setTimeout(() => child.kill("SIGKILL"), request.method === "run" ? 605e3 : 35e3);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr = (stderr + chunk).slice(-12e3);
+    });
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk;
+      let newline;
+      while ((newline = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (!line.startsWith("__WORKFLOW_WEB__")) {
+          continue;
+        }
+        try {
+          const message = redactWorkflowData(JSON.parse(line.slice("__WORKFLOW_WEB__".length)), [auth?.accessToken ?? ""], false);
+          if (message.kind === "event") {
+            onEvent?.(message.value);
+          }
+          if (message.kind === "result") {
+            result = message.value;
+          }
+          if (message.kind === "error") {
+            failure = message.error;
+          }
+        } catch {
+          failure = "Invalid workflow runtime response.";
+        }
+      }
+    });
+    const cleanup = () => {
+      clearTimeout(timeout);
+      clearTimeout(forcedExit);
+      children.delete(child);
+      if (active.get(String(request.runId)) === child) {
+        active.delete(String(request.runId));
+      }
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.once("close", (code, signal) => {
+      cleanup();
+      if (failure) {
+        reject(new Error(failure));
+      } else if (result !== void 0) {
+        if (request.method === "run") {
+          result.logs = String(redactWorkflowData(stderr, [auth?.accessToken ?? ""]));
+        }
+        resolve(result);
+      } else {
+        reject(new Error(signal || code === 130 ? "Stopped." : String(redactWorkflowData(stderr.trim(), [auth?.accessToken ?? ""])) || `Workflow runtime exited (${code}).`));
+      }
+    });
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(JSON.stringify({ ...request, storageDir }));
+  });
+  return {
+    available: true,
+    inspect: (paths) => invoke({ method: "inspect", paths }),
+    resolveParams: (project, request, entrypointId) => invoke({ method: "resolve", project, request, entrypointId }),
+    run: (request, onEvent) => invoke({ method: "run", ...request }, onEvent),
+    uploadFiles: (project, conversationId, files) => invoke({ method: "upload", project, conversationId, files }),
+    readFile: (project, id) => invoke({ method: "file", project, id }),
+    deleteFiles: async (project, conversationId, ids) => {
+      await invoke({ method: "delete-files", project, conversationId, ids });
+    },
+    readResource: (project, conversationId, kind, target) => invoke({ method: "resource", project, conversationId, kind, target }),
+    deleteConversation: async (project, conversationId) => {
+      await invoke({ method: "delete-conversation", project, conversationId });
+    },
+    cancel: (runId) => {
+      const running = runId ? [active.get(runId)].filter((child) => !!child) : [...active.values()];
+      for (const child of running) {
+        child.kill("SIGTERM");
+        const timer = setTimeout(() => {
+          if (children.has(child)) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+        timer.unref();
+      }
+    },
+    dispose: () => {
+      disposed = true;
+      for (const child of children) {
+        child.kill("SIGKILL");
+      }
+    }
+  };
+}
+
+// src/web/resource-cards.ts
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var string = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function conversationResourceCards(items, projectId, conversationId) {
+  const cards = /* @__PURE__ */ new Map();
+  for (const [index, item] of items.entries()) {
+    if (!["agent-part", "opencode-part"].includes(String(item.metadata?.kind)) || item.metadata?.partType !== "tool") {
+      continue;
+    }
+    const content = record(item.content);
+    if (content?.status !== "success") {
+      continue;
+    }
+    let output = record(content.output);
+    if (Array.isArray(output?.content) && output.content.length === 1) {
+      try {
+        output = record(JSON.parse(String(record(output.content[0])?.text)));
+      } catch {
+      }
+    }
+    let descriptor = record(record(output?.details)?.resourceCard);
+    const input = record(content.input) ?? {};
+    const tool = string(content.tool) ?? "";
+    if (tool === "workflow-ui_present_card") {
+      const presentation = output?.action ? output : input;
+      if (presentation.action === "remove") {
+        cards.delete(String(presentation.cardId));
+        continue;
+      }
+      if (presentation.action !== "upsert") {
+        continue;
+      }
+      descriptor = presentation;
+    }
+    if (!descriptor) {
+      const target2 = { source: "local", projectId, conversationId };
+      let kind2;
+      if (tool === "workflow-kv_kv_store" || /workflow-desktop_(?:read|list|write)_project_kv/.test(tool)) {
+        kind2 = "kv";
+        Object.assign(target2, { projectId: input.projectId ?? projectId, key: input.key, scope: input.scope ?? "project", conversationId: input.conversationId ?? conversationId });
+      } else if (tool === "workflow-knowledge_knowledge_documents" || /workflow-desktop_(?:query|mutate)_project_knowledge/.test(tool)) {
+        kind2 = "knowledge";
+        Object.assign(target2, { projectId: input.projectId ?? projectId, documentId: input.documentId ?? record(output?.document)?.id });
+      } else if (tool === "read" || tool === "workflow-desktop_open_dock_tool" && input.tool === "files") {
+        kind2 = "file";
+        target2.filePath = input.filePath ?? input.path;
+      } else if (tool === "workflow-desktop_open_project" && input.kind === "project") {
+        kind2 = "project";
+        target2.projectId = input.targetId;
+      } else if (tool === "workflow-desktop_open_dock_tool") {
+        if (input.tool === "browser") {
+          kind2 = "browser";
+          target2.url = input.url;
+        }
+        if (input.tool === "preview") {
+          kind2 = "kanban";
+        }
+        if (input.tool === "open-project" && input.openedProjectKind === "project") {
+          kind2 = "project";
+          target2.projectId = input.openedProjectId;
+        }
+      }
+      if (!kind2) {
+        continue;
+      }
+      descriptor = { kind: kind2, target: target2, title: record(output?.document)?.title };
+    }
+    const kind = descriptor.kind;
+    if (!["kv", "knowledge", "project", "browser", "file", "kanban"].includes(kind)) {
+      continue;
+    }
+    const target = Object.fromEntries(Object.entries(record(descriptor.target) ?? {}).filter((entry) => typeof entry[1] === "string" && entry[1].length < 8192));
+    if (target.source === "current") {
+      target.source = "local";
+      target.projectId = projectId;
+    }
+    if (target.source && !["local", "server"].includes(target.source)) {
+      continue;
+    }
+    if (kind === "browser") {
+      try {
+        const url = new URL(target.url);
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+    } else {
+      target.source ??= "local";
+      target.projectId ??= projectId;
+      if (target.scope === "conversation") {
+        target.conversationId ??= conversationId;
+      }
+      if (kind === "file" && (!target.filePath || /^(?:[\\/]|[a-z]:)|(?:^|[\\/])\.\.(?:[\\/]|$)/i.test(target.filePath))) {
+        continue;
+      }
+    }
+    const id = string(descriptor.cardId) ?? `${kind}:${JSON.stringify(target)}`;
+    const title = (string(descriptor.title) ?? target.key ?? target.documentId ?? target.filePath ?? target.url ?? target.projectId ?? kind).slice(0, 200);
+    cards.set(id, { id, kind, title, target, itemId: item.id ?? String(index) });
+  }
+  return [...cards.values()];
+}
+
+// src/web/server.ts
+async function startWebServer(options) {
+  const projectDir = await realpath(path2.resolve(options.projectDir));
+  const key = createHash("sha256").update(projectDir).digest("hex").slice(0, 24);
+  const storageDir = path2.resolve(options.dataDir ?? path2.join(os.homedir(), ".workflow-code", "web"));
+  const historyPath = path2.join(storageDir, key, "conversations.json");
+  const clients = /* @__PURE__ */ new Set();
+  let connection;
+  let account = { status: "signed-out", serverUrl: "http://localhost:7126", revision: 0 };
+  let signedOut = false;
+  let authIdentity = "";
+  let login;
+  const runtime = options.runtime ?? createWebRuntime(projectDir, storageDir, () => connection);
+  let inspected;
+  try {
+    inspected = await runtime.inspect([projectDir]);
+  } catch (error) {
+    runtime.dispose();
+    throw error;
+  }
+  const descriptor = inspected.projects[0];
+  if (!descriptor) {
+    runtime.dispose();
+    throw new Error(inspected.errors.join("\n") || "No Workflow project found.");
+  }
+  if (!options.runtime) {
+    assertLocalCliCoreCompatible(projectDir, descriptor.runtime.coreVersion);
+  }
+  if (!["conversation", "workflow"].includes(descriptor.projectType)) {
+    runtime.dispose();
+    throw new Error("workflow-code web currently supports Conversation and Workflow projects.");
+  }
+  const project = { ...descriptor, uri: pathToFileURL(projectDir).href };
+  let saved = {};
+  try {
+    saved = JSON.parse(await readFile(historyPath, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      runtime.dispose();
+      throw new Error(`Cannot read conversation history: ${String(error)}`);
+    }
+  }
+  let pendingSave = Promise.resolve();
+  let broadcastTimer;
+  let authRevision = 0;
+  const parameterStates = /* @__PURE__ */ new Map();
+  const parameterEpochs = /* @__PURE__ */ new Map();
+  const publicFile = (file) => ({ ...file, previewUrl: `/api/file/${encodeURIComponent(file.id)}` });
+  const publicValue = (value) => {
+    if (Array.isArray(value)) {
+      return value.map(publicValue);
+    }
+    if (value && typeof value === "object") {
+      const record2 = value;
+      if (typeof record2.id === "string" && /^wf_[a-f0-9]{32}$/.test(record2.id) && typeof record2.mimeType === "string") {
+        return publicFile(record2);
+      }
+      return Object.fromEntries(Object.entries(record2).map(([name, entry]) => [name, publicValue(entry)]));
+    }
+    return value;
+  };
+  const state = () => publicValue(redactWorkflowData({ type: "state", project, sessions: controller.sessions, activeId: controller.activeId, running: controller.running, parameterValues: controller.current.parameterValues ?? {}, account, authenticationRevision: authRevision }, [connection?.accessToken ?? ""]));
+  const broadcast = () => {
+    if (broadcastTimer) {
+      return;
+    }
+    broadcastTimer = setTimeout(() => {
+      broadcastTimer = void 0;
+      const data = `data: ${JSON.stringify(state())}
+
+`;
+      for (const client of clients) {
+        client.write(data);
+      }
+    }, 30);
+  };
+  const controller = new ConversationController(project, runtime, saved, {
+    changed: broadcast,
+    log: (message) => process.stderr.write(`${message}
+`),
+    save: (sessions, activeId) => {
+      const content = JSON.stringify({ sessions, activeId });
+      pendingSave = pendingSave.catch(() => void 0).then(async () => {
+        await mkdir(path2.dirname(historyPath), { recursive: true });
+        const temp = `${historyPath}.${process.pid}.tmp`;
+        await writeFile(temp, content, { mode: 384 });
+        await rename(temp, historyPath);
+      });
+      return pendingSave;
+    }
+  });
+  const refreshAuth = async () => {
+    const config = await readCliAuthConfig();
+    const serverUrl = process.env.WORKFLOW_SERVER_URL ?? config.serverUrl;
+    const token = process.env.WORKFLOW_SERVER_ADMIN_KEY ?? config.apiKey;
+    const identity = signedOut ? "" : `${serverUrl}
+${token}`;
+    if (identity === authIdentity && account.status !== "checking") {
+      return;
+    }
+    authIdentity = identity;
+    connection = !signedOut && serverUrl && token ? { serverUrl: serverUrl.replace(/\/+$/, ""), accessToken: token } : void 0;
+    authRevision++;
+    parameterStates.clear();
+    for (const session of controller.sessions) {
+      controller.stop(session);
+    }
+    account = { status: connection ? "checking" : "signed-out", serverUrl: serverUrl || "http://localhost:7126", revision: authRevision };
+    if (connection) {
+      try {
+        const response = await fetch(`${connection.serverUrl}/api/auth/me`, { headers: { Authorization: `Bearer ${connection.accessToken}` }, signal: AbortSignal.timeout(1e4), redirect: "error" });
+        const result = await response.json();
+        if (!response.ok || result.errCode !== 0 || !result.data?.profile) {
+          throw new Error("Workflow login is invalid or expired.");
+        }
+        account = { ...account, status: "authenticated", user: result.data.profile, expiresAt: result.data.principal?.expiresAt ?? config.expiresAt };
+      } catch (error) {
+        connection = void 0;
+        account = { ...account, status: "error", error: String(error.message) };
+      }
+    }
+    broadcast();
+  };
+  await refreshAuth();
+  const authPoll = setInterval(() => void refreshAuth().catch((error) => process.stderr.write(`${String(error)}
+`)), 5e3);
+  authPoll.unref();
+  const capability = randomBytes(32).toString("hex");
+  const cookie = `workflow_web_${randomBytes(8).toString("hex")}`;
+  let origin = "";
+  const json = (response, status, value) => {
+    response.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+    response.end(JSON.stringify(value));
+  };
+  const authMatches = (value) => {
+    const a = Buffer.from(value), b = Buffer.from(capability);
+    return a.length === b.length && timingSafeEqual(a, b);
+  };
+  const readBody = async (request) => {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+      size += chunk.length;
+      if (size > 72 * 1024 * 1024) {
+        throw new Error("Request exceeds 72 MiB.");
+      }
+      chunks.push(chunk);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("Invalid request.");
+    }
+    return value;
+  };
+  const readAttachments = async (files) => {
+    if (!Array.isArray(files) || files.length > 32) {
+      throw new Error("Invalid attachments.");
+    }
+    return Promise.all(files.map(async (file) => {
+      if (typeof file?.id !== "string") {
+        throw new Error("Invalid attachment.");
+      }
+      const { reference } = await runtime.readFile(project, file.id);
+      if (reference.conversationId !== controller.activeId) {
+        throw new Error("Attachment belongs to another conversation.");
+      }
+      return reference;
+    }));
+  };
+  const handleMessage = async (message) => {
+    if (typeof message.type !== "string") {
+      throw new Error("Invalid message.");
+    }
+    if (message.projectUri && message.projectUri !== project.uri) {
+      throw new Error("Project changed.");
+    }
+    if (message.sessionId && message.sessionId !== controller.activeId) {
+      throw new Error("Conversation changed.");
+    }
+    const replies = [];
+    const current = controller.current;
+    const entrypointId = typeof message.entrypointId === "string" && message.entrypointId ? message.entrypointId : project.defaultEntrypoint;
+    if (entrypointId && !project.entrypoints.some((entry) => entry.id === entrypointId)) {
+      throw new Error("Unknown entrypoint.");
+    }
+    switch (message.type) {
+      case "ready":
+        replies.push(state());
+        break;
+      case "resolve": {
+        try {
+          const parameters = workflowParameters(project, entrypointId);
+          const supplied = message.params ?? {};
+          if (!supplied || typeof supplied !== "object" || Array.isArray(supplied) || Object.values(supplied).some((value) => typeof value !== "string" && !(Array.isArray(value) && value.every((entry) => typeof entry === "string")))) {
+            throw new Error("Invalid parameters.");
+          }
+          const values = Object.fromEntries(parameters.fields.filter((field) => supplied[field.name] !== void 0).map((field) => [field.name, supplied[field.name]]));
+          const stateKey = `${current.id}:${entrypointId ?? ""}`;
+          const epoch = (parameterEpochs.get(stateKey) ?? 0) + 1;
+          parameterEpochs.set(stateKey, epoch);
+          const revision = authRevision;
+          const states = parameterStates.get(stateKey) ?? {};
+          const trigger = message.trigger?.kind === "param" && parameters.fields.some((field) => field.name === message.trigger.paramName) ? { kind: "param", paramName: message.trigger.paramName } : { kind: message.trigger?.kind === "input" ? "input" : "init" };
+          const result = parameters.paramResolver?.enabled ? await runtime.resolveParams(project, { draftText: String(message.draftText ?? "").slice(0, 2e4), args: workflowParamArgs(parameters.fields, values, states), inputMode: "form", trigger }, entrypointId) : { params: {} };
+          if (parameterEpochs.get(stateKey) !== epoch || revision !== authRevision) {
+            break;
+          }
+          for (const [name, patch] of Object.entries(result.params ?? {})) {
+            states[name] = { ...states[name], ...patch, options: { ...states[name]?.options, ...patch.options } };
+            if (patch.value === null) {
+              delete values[name];
+            } else if (patch.value !== void 0) {
+              values[name] = patch.value;
+            }
+          }
+          parameterStates.set(stateKey, states);
+          (current.parameterValues ??= {})[entrypointId ?? ""] = values;
+          await controller.persist();
+          replies.push({ type: "params", projectUri: project.uri, sessionId: current.id, requestId: message.requestId, params: result.params });
+        } catch (error) {
+          replies.push({ type: "params", projectUri: project.uri, sessionId: current.id, requestId: message.requestId, error: String(error.message) });
+        }
+        break;
+      }
+      case "send": {
+        if (typeof message.text !== "string" || message.text.length > 1e5) {
+          throw new Error("Invalid message text.");
+        }
+        const params = message.params;
+        if (!params || typeof params !== "object" || Array.isArray(params) || Object.values(params).some((value) => typeof value !== "string" && !(Array.isArray(value) && value.every((entry) => typeof entry === "string")))) {
+          throw new Error("Invalid parameters.");
+        }
+        const parameters = workflowParameters(project, entrypointId);
+        const stateKey = `${current.id}:${entrypointId ?? ""}`;
+        parameterEpochs.set(stateKey, (parameterEpochs.get(stateKey) ?? 0) + 1);
+        const revision = authRevision;
+        const resolved = parameters.paramResolver?.enabled ? await runtime.resolveParams(project, { draftText: message.text, args: workflowParamArgs(parameters.fields, params), inputMode: "form", trigger: { kind: "init" } }, entrypointId) : { params: parameterStates.get(`${current.id}:${entrypointId ?? ""}`) ?? {} };
+        if (revision !== authRevision) {
+          throw new Error("Workflow login changed. Send the message again.");
+        }
+        validateWorkflowValues(parameters.fields, params, resolved.params);
+        (current.parameterValues ??= {})[entrypointId ?? ""] = { ...params };
+        await controller.send({ text: message.text, params, states: resolved.params, entrypointId, attachments: await readAttachments(message.attachments ?? []) });
+        replies.push({ type: "sent", sessionId: current.id });
+        break;
+      }
+      case "stop":
+        controller.stop();
+        break;
+      case "new":
+        await controller.updateDraft(current.id, String(message.text ?? ""), await readAttachments(message.attachments ?? []));
+        await controller.create();
+        break;
+      case "select":
+        await controller.select(String(message.id));
+        break;
+      case "draft":
+        await controller.updateDraft(current.id, String(message.text ?? ""), await readAttachments(message.attachments ?? []));
+        break;
+      case "retry":
+        await controller.retry(String(message.messageId));
+        break;
+      case "resume":
+        await controller.resume(String(message.messageId), String(message.requestId), message.values ?? {});
+        break;
+      case "tool-policy": {
+        const tools = workflowParameters(project, entrypointId).tools ?? [];
+        current.toolPermissionPolicies = Object.fromEntries(tools.map((tool) => [tool.name, { enabled: typeof message.policies?.[tool.name]?.enabled === "boolean" ? message.policies[tool.name].enabled : tool.enabled, autoApprove: typeof message.policies?.[tool.name]?.autoApprove === "boolean" ? message.policies[tool.name].autoApprove : tool.autoApprove }]));
+        await controller.persist();
+        broadcast();
+        break;
+      }
+      case "queue-edit":
+        await controller.editQueued(String(message.id));
+        break;
+      case "queue-remove":
+        await controller.removeQueued(String(message.id));
+        break;
+      case "queue-cancel-edit":
+        await controller.cancelQueueEdit();
+        break;
+      case "queue-run":
+        await controller.runQueued();
+        break;
+      case "queue-reorder":
+        if (Array.isArray(message.ids) && message.ids.every((id) => typeof id === "string")) {
+          await controller.reorderQueued(message.ids);
+        }
+        break;
+      case "queue-promote":
+        await controller.promoteQueued(String(message.id));
+        break;
+      case "session-action": {
+        const session = controller.sessions.find((entry) => entry.id === message.id);
+        if (!session) {
+          throw new Error("Conversation no longer exists.");
+        }
+        if (message.action === "rename") {
+          await controller.rename(session.id, String(message.title ?? ""));
+        } else if (message.action === "lock") {
+          await controller.lockTitle(session.id, !session.titleLocked);
+        } else if (message.action === "delete") {
+          await controller.remove(session.id);
+        } else if (message.action === "export") {
+          replies.push({ type: "download", name: `conversation-${session.id}.json`, content: JSON.stringify(redactWorkflowData(session), null, 2) });
+        }
+        break;
+      }
+      case "upload": {
+        if (!Array.isArray(message.files) || message.files.length > 32 || message.files.some((file) => typeof file?.name !== "string" || typeof file.data !== "string" || file.path !== void 0)) {
+          throw new Error("Invalid upload.");
+        }
+        const files = await runtime.uploadFiles(project, current.id, message.files);
+        replies.push({ type: "attachments", projectUri: project.uri, sessionId: current.id, paramName: message.paramName, messageId: message.messageId, requestId: message.requestId, files: files.map(publicFile) });
+        break;
+      }
+      case "trace":
+      case "logs":
+      case "export-message": {
+        const answer = current.messages.find((entry) => entry.id === message.messageId);
+        if (!answer) {
+          throw new Error("Message no longer exists.");
+        }
+        if (message.type === "export-message") {
+          replies.push({ type: "download", name: `run-${answer.id}.json`, content: JSON.stringify(redactWorkflowData(answer), null, 2) }, { type: "exported", sessionId: current.id, messageId: answer.id });
+        } else {
+          replies.push({ type: "preview", title: message.type === "logs" ? "\u8FD0\u884C\u65E5\u5FD7" : "\u8FD0\u884C\u8DDF\u8E2A", content: message.type === "logs" ? answer.report?.logs ?? "" : answer.report });
+        }
+        break;
+      }
+      case "resource": {
+        const answer = current.messages.find((entry) => entry.id === message.messageId);
+        const card = conversationResourceCards(answer?.items ?? [], project.id, current.id).find((entry) => entry.id === message.cardId);
+        if (!card || card.target.projectId && card.target.projectId !== project.id || card.target.source === "server") {
+          throw new Error("Resource is outside this project.");
+        }
+        if (card.kind === "kv" || card.kind === "knowledge") {
+          replies.push({ type: "preview", title: card.title, content: await runtime.readResource(project, current.id, card.kind, card.target) });
+        } else if (card.kind === "file") {
+          const filename = await realpath(path2.resolve(projectDir, card.target.filePath));
+          const relative = path2.relative(projectDir, filename);
+          if (relative.startsWith("..") || path2.isAbsolute(relative)) {
+            throw new Error("File is outside this project.");
+          }
+          replies.push({ type: "preview", title: card.title, content: await readFile(filename, "utf8") });
+        } else {
+          throw new Error("This resource requires an editor host.");
+        }
+        break;
+      }
+      case "usage": {
+        if (!connection) {
+          throw new Error("Workflow Server login is not configured.");
+        }
+        const response = await fetch(`${connection.serverUrl}/api/auth/sub2api/catalog`, { headers: { Authorization: `Bearer ${connection.accessToken}` }, signal: AbortSignal.timeout(15e3), redirect: "error" });
+        const result = await response.json();
+        if (!response.ok || result.errCode !== 0) {
+          throw new Error(result.errMessage || "Cannot load usage.");
+        }
+        replies.push({ type: "usage", sessionId: current.id, usage: result.data });
+        break;
+      }
+      case "login": {
+        if (process.env.WORKFLOW_SERVER_ADMIN_KEY !== void 0) {
+          throw new Error("This session is supplied by the host. Sign in through the host.");
+        }
+        if (login) {
+          break;
+        }
+        const url = new URL(String(message.serverUrl));
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+          throw new Error("Invalid Workflow Server URL.");
+        }
+        signedOut = false;
+        account = { ...account, status: "checking" };
+        broadcast();
+        login = spawn2(process.execPath, [path2.join(cliRoot(), "dist/index.js"), "workspace", "login", "--server", url.toString().replace(/\/$/, "")], { shell: false, stdio: ["ignore", "ignore", "pipe"] });
+        login.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+        login.once("error", (error) => {
+          login = void 0;
+          account = { ...account, status: "error", error: error.message };
+          broadcast();
+        });
+        login.once("close", () => {
+          login = void 0;
+          authIdentity = "";
+          void refreshAuth();
+        });
+        break;
+      }
+      case "logout":
+        signedOut = true;
+        login?.kill();
+        if (process.env.WORKFLOW_SERVER_ADMIN_KEY === void 0) {
+          await clearCliAuthConfig();
+        }
+        authIdentity = "signed-out";
+        await refreshAuth();
+        break;
+      default:
+        throw new Error(`Unsupported action: ${message.type}`);
+    }
+    return replies;
+  };
+  let mutations = Promise.resolve();
+  const server = createServer((request, response) => {
+    void (async () => {
+      response.setHeader("X-Content-Type-Options", "nosniff");
+      response.setHeader("Referrer-Policy", "no-referrer");
+      if (request.headers.host !== new URL(origin).host || request.headers.origin && request.headers.origin !== origin || request.headers["sec-fetch-site"] === "cross-site") {
+        json(response, 403, { message: "Invalid request origin." });
+        return;
+      }
+      const url = new URL(request.url ?? "/", origin);
+      if (url.pathname === "/api/session" && request.method === "POST") {
+        if (!authMatches(String(request.headers.authorization ?? "").replace(/^Bearer /, ""))) {
+          json(response, 401, { message: "Invalid session." });
+          return;
+        }
+        response.setHeader("Set-Cookie", `${cookie}=${capability}; HttpOnly; SameSite=Strict; Path=/`);
+        json(response, 200, { ok: true });
+        return;
+      }
+      if (url.pathname.startsWith("/api/")) {
+        const value = String(request.headers.cookie ?? "").split(";").map((value2) => value2.trim()).find((value2) => value2.startsWith(`${cookie}=`))?.slice(cookie.length + 1) ?? "";
+        if (!authMatches(value)) {
+          json(response, 401, { message: "Open the URL printed by workflow-code web." });
+          return;
+        }
+        if (url.pathname === "/api/events" && request.method === "GET") {
+          response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+          response.write(`data: ${JSON.stringify(state())}
+
+`);
+          clients.add(response);
+          const heartbeat = setInterval(() => response.write(": heartbeat\n\n"), 2e4);
+          response.once("close", () => {
+            clearInterval(heartbeat);
+            clients.delete(response);
+          });
+          return;
+        }
+        if (url.pathname === "/api/message" && request.method === "POST") {
+          const message = await readBody(request);
+          let messages = [];
+          const operation = () => handleMessage(message).then((value2) => {
+            messages = value2;
+          });
+          const task = message.type === "resolve" || message.type === "ready" ? operation() : mutations.catch(() => void 0).then(operation);
+          if (message.type !== "resolve" && message.type !== "ready") {
+            mutations = task;
+          }
+          await task;
+          json(response, 200, { messages: redactWorkflowData(messages, [connection?.accessToken ?? ""]) });
+          return;
+        }
+        if (url.pathname.startsWith("/api/file/") && request.method === "GET") {
+          const file = await runtime.readFile(project, decodeURIComponent(url.pathname.slice("/api/file/".length)));
+          const bytes = await readFile(file.path);
+          const safeType = /^(?:image\/(?:png|jpeg|gif|webp|avif)|audio\/[a-z0-9.+-]+|video\/[a-z0-9.+-]+)$/.test(file.reference.mimeType);
+          response.writeHead(200, { "Content-Type": safeType ? file.reference.mimeType : "application/octet-stream", "Content-Disposition": `${safeType ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(file.reference.name)}`, "Cache-Control": "no-store" });
+          response.end(bytes);
+          return;
+        }
+        json(response, 404, { message: "Unknown API endpoint." });
+        return;
+      }
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        json(response, 405, { message: "Method not allowed." });
+        return;
+      }
+      if (url.pathname === "/favicon.ico") {
+        response.writeHead(204);
+        response.end();
+        return;
+      }
+      if (url.pathname === "/") {
+        response.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https: http:; font-src 'self'; connect-src 'self'; media-src 'self' blob:; object-src 'none'; base-uri 'none'; frame-ancestors 'self' vscode-webview:; form-action 'self'" });
+        response.end(`<!doctype html><html lang="zh-CN" data-theme="${options.theme ?? "auto"}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="workflow-project" content="${key}"><title>Workflow</title><link rel="stylesheet" href="/assets/codicons/codicon.css"><link rel="stylesheet" href="/assets/theme.css"><link rel="stylesheet" href="/assets/workflow-ui.css"></head><body data-surface="editor"><div id="app"></div><script src="/assets/workflow-ui.js" defer></script></body></html>`);
+        return;
+      }
+      const assets = { "/assets/workflow-ui.js": "application/javascript", "/assets/workflow-ui.css": "text/css", "/assets/theme.css": "text/css", "/assets/codicons/codicon.css": "text/css", "/assets/codicons/codicon.ttf": "font/ttf" };
+      if (!assets[url.pathname]) {
+        json(response, 404, { message: "Not found." });
+        return;
+      }
+      const content = await readFile(path2.join(cliRoot(), "dist/web", url.pathname.slice("/assets/".length)));
+      response.writeHead(200, { "Content-Type": assets[url.pathname], "Cache-Control": "no-cache" });
+      response.end(content);
+    })().catch((error) => {
+      if (!response.headersSent) {
+        json(response, 400, { message: String(redactWorkflowData(error.message, [connection?.accessToken ?? ""])) });
+      } else {
+        response.end();
+      }
+    });
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(options.port ?? 0, "127.0.0.1", () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+  } catch (error) {
+    clearInterval(authPoll);
+    controller.dispose();
+    runtime.dispose();
+    throw error;
+  }
+  origin = `http://127.0.0.1:${server.address().port}`;
+  let closing;
+  return {
+    origin,
+    url: `${origin}/#session=${capability}`,
+    project,
+    controller,
+    close: () => closing ??= (async () => {
+      clearInterval(authPoll);
+      if (broadcastTimer) {
+        clearTimeout(broadcastTimer);
+      }
+      login?.kill();
+      controller.dispose();
+      runtime.dispose();
+      for (const client of clients) {
+        client.end();
+      }
+      await new Promise((resolve) => server.close(() => resolve()));
+      await controller.idle();
+      await controller.persist();
+      await pendingSave;
+    })()
+  };
+}
+
+// src/web.ts
+function parseWebArgs(argv) {
+  const options = { projectDir: process.cwd(), port: 0, theme: "auto", open: true, json: false, help: false };
+  let projectSet = false;
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--no-open") {
+      options.open = false;
+    } else if (arg === "--json") {
+      options.json = true;
+    } else if (["--help", "-h"].includes(arg)) {
+      options.help = true;
+    } else if (["--port", "--data-dir", "--theme"].includes(arg)) {
+      const value = argv[++index];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      if (arg === "--port") {
+        if (!/^\d+$/.test(value) || Number(value) > 65535) {
+          throw new Error("--port must be an integer between 0 and 65535.");
+        }
+        options.port = Number(value);
+      } else if (arg === "--theme") {
+        if (!["auto", "light", "dark"].includes(value)) {
+          throw new Error("--theme must be auto, light, or dark.");
+        }
+        options.theme = value;
+      } else {
+        options.dataDir = path3.resolve(value);
+      }
+    } else if (arg.startsWith("-") || projectSet) {
+      throw new Error(`Unknown web argument: ${arg}`);
+    } else {
+      options.projectDir = path3.resolve(arg);
+      projectSet = true;
+    }
+  }
+  return options;
+}
+async function main(argv) {
+  const options = parseWebArgs(argv);
+  if (options.help) {
+    console.log(i18n.language.startsWith("zh") ? "workflow-code web [\u9879\u76EE\u76EE\u5F55]\n  --port <0-65535>   \u76D1\u542C\u7AEF\u53E3\uFF0C0 \u81EA\u52A8\u5206\u914D\n  --no-open          \u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668\n  --theme <auto|light|dark>\n  --data-dir <\u76EE\u5F55>   \u5BF9\u8BDD\u548C\u6587\u4EF6\u5B58\u50A8\u4F4D\u7F6E\n  --json             \u8F93\u51FA\u7ED3\u6784\u5316\u542F\u52A8\u4FE1\u606F" : "workflow-code web [project-directory]\n  --port <0-65535>   Listen port; 0 selects an available port\n  --no-open          Do not open a browser\n  --theme <auto|light|dark>\n  --data-dir <path>   Conversation and file storage directory\n  --json             Print structured startup information");
+    return 0;
+  }
+  const app = await startWebServer(options);
+  const close = () => {
+    process.off("SIGINT", close);
+    process.off("SIGTERM", close);
+    void app.close().catch((error) => {
+      console.error(error);
+      process.exitCode = 1;
+    });
+  };
+  process.once("SIGINT", close);
+  process.once("SIGTERM", close);
+  console.log(options.json ? JSON.stringify({ type: "ready", protocolVersion: 1, 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 (options.open) {
+    const invocation = process.platform === "darwin" ? { command: "open", args: [app.url] } : process.platform === "win32" ? { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", app.url] } : { command: "xdg-open", args: [app.url] };
+    const browser = spawn3(invocation.command, invocation.args, { detached: true, shell: false, stdio: "ignore" });
+    browser.once("error", (error) => console.error(`Cannot open browser: ${error.message}`));
+    browser.unref();
+  }
+  return 0;
+}
+export {
+  main,
+  parseWebArgs
+};