@co0ontty/wand 4.57.0 → 4.58.0

package/vendor/codex-taskboard/server/cloud-config.mjs

@@ -1,188 +0,0 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import path from "node:path";
-
-const CONFIG_VERSION = 1;
-
-class CloudConfigError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = "CloudConfigError";
-    this.code = code;
-  }
-}
-
-function emptyConfig() {
-  return {
-    version: CONFIG_VERSION,
-    remoteUrl: null,
-    actorName: null,
-    sharedKey: null,
-    projectMappings: {},
-  };
-}
-
-export function normalizeCloudUrl(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new CloudConfigError("INVALID_CLOUD_URL", "Cloud taskboard URL must be a valid URL");
-  }
-  const isLoopback = url.hostname === "localhost"
-    || url.hostname === "127.0.0.1"
-    || url.hostname === "[::1]";
-  if (
-    (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback))
-    || url.username
-    || url.password
-    || url.pathname !== "/"
-    || url.search
-    || url.hash
-  ) {
-    throw new CloudConfigError(
-      "INVALID_CLOUD_URL",
-      "Cloud taskboard URL must be an HTTPS origin (loopback HTTP is allowed for development)",
-    );
-  }
-  return url.origin;
-}
-
-function validateCredentials(actorName, sharedKey) {
-  if (
-    typeof actorName !== "string"
-    || !actorName.trim()
-    || actorName.length > 120
-    || actorName.includes(":")
-  ) {
-    throw new CloudConfigError(
-      "INVALID_CLOUD_ACTOR",
-      "Cloud actor name must be 1 to 120 characters and cannot contain ':'",
-    );
-  }
-  if (typeof sharedKey !== "string" || !sharedKey || sharedKey.length > 4096) {
-    throw new CloudConfigError(
-      "INVALID_CLOUD_KEY",
-      "Cloud shared key must be 1 to 4096 characters",
-    );
-  }
-  return { actorName: actorName.trim(), sharedKey };
-}
-
-function validateProjectMappings(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new CloudConfigError("INVALID_CLOUD_CONFIG", "Cloud project mappings are invalid");
-  }
-  const projectMappings = {};
-  for (const [projectId, workspacePath] of Object.entries(value)) {
-    if (!projectId || typeof workspacePath !== "string" || !path.isAbsolute(workspacePath)) {
-      throw new CloudConfigError("INVALID_CLOUD_CONFIG", "Cloud project mappings are invalid");
-    }
-    projectMappings[projectId] = workspacePath;
-  }
-  return projectMappings;
-}
-
-function parseConfig(value) {
-  if (
-    value === null
-    || typeof value !== "object"
-    || Array.isArray(value)
-    || value.version !== CONFIG_VERSION
-  ) {
-    throw new CloudConfigError("INVALID_CLOUD_CONFIG", "Cloud companion configuration is invalid");
-  }
-  const allowedKeys = new Set([
-    "version",
-    "remoteUrl",
-    "actorName",
-    "sharedKey",
-    "projectMappings",
-  ]);
-  if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
-    throw new CloudConfigError("INVALID_CLOUD_CONFIG", "Cloud companion configuration is invalid");
-  }
-  const projectMappings = validateProjectMappings(value.projectMappings);
-  if (value.remoteUrl === null && value.actorName === null && value.sharedKey === null) {
-    return { ...emptyConfig(), projectMappings };
-  }
-  const credentials = validateCredentials(value.actorName, value.sharedKey);
-  return {
-    version: CONFIG_VERSION,
-    remoteUrl: normalizeCloudUrl(value.remoteUrl),
-    ...credentials,
-    projectMappings,
-  };
-}
-
-export function createCloudConfigStore({ configPath }) {
-  if (!configPath) throw new Error("configPath is required");
-  let pendingWrite = Promise.resolve();
-
-  async function readFromDisk() {
-    try {
-      return parseConfig(JSON.parse(await readFile(configPath, "utf8")));
-    } catch (error) {
-      if (error?.code === "ENOENT") return emptyConfig();
-      throw error;
-    }
-  }
-
-  async function writeAtomically(config) {
-    await mkdir(path.dirname(configPath), { recursive: true });
-    const temporaryPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(temporaryPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
-    await rename(temporaryPath, configPath);
-  }
-
-  function update(mutator) {
-    const operation = pendingWrite.then(async () => {
-      const next = mutator(await readFromDisk());
-      await writeAtomically(next);
-      return next;
-    });
-    pendingWrite = operation.catch(() => {});
-    return operation;
-  }
-
-  return {
-    async read() {
-      await pendingWrite;
-      return readFromDisk();
-    },
-    async configure({ remoteUrl, actorName, sharedKey }) {
-      const normalizedUrl = normalizeCloudUrl(remoteUrl);
-      const credentials = validateCredentials(actorName, sharedKey);
-      return update((config) => ({
-        ...config,
-        remoteUrl: normalizedUrl,
-        ...credentials,
-      }));
-    },
-    clearCloud() {
-      return update((config) => ({
-        ...config,
-        remoteUrl: null,
-        actorName: null,
-        sharedKey: null,
-      }));
-    },
-    setProjectWorkspace(projectId, workspacePath) {
-      if (typeof projectId !== "string" || !projectId.trim()) {
-        throw new CloudConfigError("INVALID_PROJECT_MAPPING", "projectId is required");
-      }
-      if (typeof workspacePath !== "string" || !path.isAbsolute(workspacePath)) {
-        throw new CloudConfigError(
-          "INVALID_PROJECT_MAPPING",
-          "workspacePath must be absolute",
-        );
-      }
-      return update((config) => ({
-        ...config,
-        projectMappings: {
-          ...config.projectMappings,
-          [projectId]: workspacePath,
-        },
-      }));
-    },
-  };
-}

package/vendor/codex-taskboard/server/cloud-proxy.mjs

@@ -1,310 +0,0 @@
-import path from "node:path";
-
-import { DEFAULT_PROJECT_ID } from "../shared/domain.mjs";
-import { normalizeCloudUrl } from "./cloud-config.mjs";
-
-const LOCAL_COMPANION_ROUTES = new Set([
-  "/health",
-  "/api/meta",
-  "/api/device-workspaces",
-  "/api/local/cloud-session",
-]);
-
-export class CloudProxyError extends Error {
-  constructor(status, code, message, details) {
-    super(message);
-    this.name = "CloudProxyError";
-    this.status = status;
-    this.code = code;
-    this.details = details;
-  }
-}
-
-export function isLocalCompanionRoute(pathname) {
-  return LOCAL_COMPANION_ROUTES.has(pathname)
-    || pathname.startsWith("/api/local/")
-    || /^\/api\/projects\/[^/]+\/development-contexts$/.test(pathname);
-}
-
-function basicAuthorization(actorName, sharedKey) {
-  return `Basic ${Buffer.from(`${actorName}:${sharedKey}`, "utf8").toString("base64")}`;
-}
-
-async function prepareRequest(request, {
-  assertTaskProjectMoveAllowed,
-  resolveThreadBinding,
-} = {}) {
-  const url = new URL(request.url);
-  let projectWorkspace = null;
-  let body = request.body;
-  const isJson = request.headers.get("content-type")?.includes("application/json");
-  const isProjectCreate = request.method === "POST" && url.pathname === "/api/projects";
-  const taskPatchMatch = request.method === "PATCH"
-    ? url.pathname.match(/^\/api\/tasks\/([^/]+)$/)
-    : null;
-  const isTaskMutation = (
-    (request.method === "POST" && url.pathname === "/api/tasks")
-    || Boolean(taskPatchMatch)
-  );
-  const isConversationMutation = request.method !== "GET"
-    && (/^\/api\/tasks(?:\/|$)/.test(url.pathname) || /^\/api\/comments\//.test(url.pathname));
-
-  if (isJson && (isProjectCreate || isTaskMutation || isConversationMutation)) {
-    let payload;
-    try {
-      payload = await request.clone().json();
-    } catch {
-      throw new CloudProxyError(400, "INVALID_JSON", "Request body must contain valid JSON");
-    }
-    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
-      throw new CloudProxyError(400, "INVALID_BODY", "Request body must be a JSON object");
-    }
-    if (
-      taskPatchMatch
-      && typeof payload.projectId === "string"
-      && typeof assertTaskProjectMoveAllowed === "function"
-    ) {
-      let taskId;
-      try {
-        taskId = decodeURIComponent(taskPatchMatch[1]);
-      } catch {
-        throw new CloudProxyError(400, "INVALID_PATH", "Task id contains invalid encoding");
-      }
-      await assertTaskProjectMoveAllowed(taskId, payload.projectId);
-    }
-    if (isProjectCreate && Object.hasOwn(payload, "workspacePath")) {
-      if (typeof payload.workspacePath === "string") {
-        if (!path.isAbsolute(payload.workspacePath)) {
-          throw new CloudProxyError(
-            400,
-            "INVALID_PROJECT_MAPPING",
-            "Project workspacePath must be absolute",
-          );
-        }
-        projectWorkspace = {
-          projectId: typeof payload.id === "string" ? payload.id : null,
-          workspacePath: payload.workspacePath,
-        };
-      }
-      delete payload.workspacePath;
-    }
-    if (isTaskMutation && payload.developmentContext?.type === "worktree") {
-      payload.developmentContext = {
-        type: "worktree",
-        ...(payload.developmentContext.branch === undefined
-          ? {}
-          : { branch: payload.developmentContext.branch }),
-      };
-    }
-    if (
-      isConversationMutation
-      && typeof payload.threadId === "string"
-      && !Object.hasOwn(payload, "threadBinding")
-      && typeof resolveThreadBinding === "function"
-    ) {
-      const threadBinding = resolveThreadBinding(payload.threadId);
-      if (threadBinding) payload.threadBinding = threadBinding;
-    }
-    body = JSON.stringify(payload);
-  }
-
-  return { body, projectWorkspace };
-}
-
-async function localizeTask(task, resolveDevelopmentContext) {
-  if (!task || typeof task !== "object" || task.developmentContext?.type !== "worktree") {
-    return task;
-  }
-  const cloudContext = {
-    type: "worktree",
-    ...(task.developmentContext.branch === undefined
-      ? {}
-      : { branch: task.developmentContext.branch }),
-  };
-  const localContext = resolveDevelopmentContext
-    ? await resolveDevelopmentContext(task.projectId, cloudContext)
-    : null;
-  return {
-    ...task,
-    developmentContext: localContext ?? { ...cloudContext, path: null },
-  };
-}
-
-async function localizeResponse(
-  response,
-  { readConfig, setProjectWorkspace, projectWorkspace, resolveDevelopmentContext },
-) {
-  if (response.status === 401) return response;
-  if (!response.headers.get("content-type")?.includes("application/json")) return response;
-  const payload = await response.json();
-
-  if (response.ok && projectWorkspace) {
-    const projectId = projectWorkspace.projectId ?? payload.project?.id;
-    if (projectId) {
-      await setProjectWorkspace(projectId, projectWorkspace.workspacePath);
-    }
-  }
-
-  const config = await readConfig();
-  if (Array.isArray(payload.projects)) {
-    payload.projects = payload.projects.map((project) => ({
-      ...project,
-      workspacePath: project.id === DEFAULT_PROJECT_ID
-        ? null
-        : config.projectMappings[project.id] ?? null,
-    }));
-  }
-  if (payload.project && typeof payload.project === "object") {
-    payload.project = {
-      ...payload.project,
-      workspacePath: payload.project.id === DEFAULT_PROJECT_ID
-        ? null
-        : config.projectMappings[payload.project.id] ?? null,
-    };
-  }
-  const contexts = new Map();
-  const scans = new Map();
-  const resolveOnce = resolveDevelopmentContext
-    ? (projectId, context) => {
-      const key = `${projectId ?? ""}\0${context.branch ?? ""}`;
-      if (!contexts.has(key)) {
-        contexts.set(key, resolveDevelopmentContext(projectId, context, scans));
-      }
-      return contexts.get(key);
-    }
-    : null;
-  if (payload.task) {
-    payload.task = await localizeTask(payload.task, resolveOnce);
-  }
-  if (Array.isArray(payload.tasks)) {
-    payload.tasks = await Promise.all(
-      payload.tasks.map((task) => localizeTask(task, resolveOnce)),
-    );
-  }
-
-  const headers = new Headers(response.headers);
-  headers.delete("content-length");
-  headers.delete("content-encoding");
-  return new Response(JSON.stringify(payload), {
-    status: response.status,
-    statusText: response.statusText,
-    headers,
-  });
-}
-
-export function createCloudProxy({
-  configStore,
-  getConfig,
-  fetch: fetchImplementation = globalThis.fetch,
-  resolveDevelopmentContext,
-  assertTaskProjectMoveAllowed,
-  resolveThreadBinding,
-}) {
-  const readConfig = getConfig ?? (() => configStore.read());
-  const setProjectWorkspace = configStore?.setProjectWorkspace?.bind(configStore);
-
-  return {
-    async webSocketTarget(pathname = "/api/events") {
-      const config = await readConfig();
-      if (!config?.remoteUrl || !config.actorName || !config.sharedKey) {
-        throw new CloudProxyError(
-          409,
-          "CLOUD_NOT_CONFIGURED",
-          "Cloud collaboration is not configured",
-        );
-      }
-      let remoteUrl;
-      try {
-        remoteUrl = normalizeCloudUrl(config.remoteUrl);
-      } catch (error) {
-        throw new CloudProxyError(
-          500,
-          "INVALID_CLOUD_CONFIG",
-          error instanceof Error ? error.message : String(error),
-        );
-      }
-      const url = new URL(pathname, `${remoteUrl}/`);
-      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-      return {
-        url: url.href,
-        headers: { authorization: basicAuthorization(config.actorName, config.sharedKey) },
-      };
-    },
-    async forward(request) {
-      const config = await readConfig();
-      if (!config?.remoteUrl || !config.actorName || !config.sharedKey) {
-        throw new CloudProxyError(
-          409,
-          "CLOUD_NOT_CONFIGURED",
-          "Cloud collaboration is not configured",
-        );
-      }
-      let remoteUrl;
-      try {
-        remoteUrl = normalizeCloudUrl(config.remoteUrl);
-      } catch (error) {
-        throw new CloudProxyError(
-          500,
-          "INVALID_CLOUD_CONFIG",
-          error instanceof Error ? error.message : String(error),
-        );
-      }
-
-      const sourceUrl = new URL(request.url);
-      const upstreamUrl = new URL(
-        `${sourceUrl.pathname}${sourceUrl.search}`,
-        `${remoteUrl}/`,
-      );
-      const headers = new Headers(request.headers);
-      headers.delete("authorization");
-      headers.delete("host");
-      headers.delete("connection");
-      headers.delete("transfer-encoding");
-      headers.delete("accept-encoding");
-      for (const name of [...headers.keys()]) {
-        if (name.toLowerCase().startsWith("x-taskboard-user-")) headers.delete(name);
-      }
-      headers.set("authorization", basicAuthorization(config.actorName, config.sharedKey));
-
-      const prepared = await prepareRequest(request, {
-        assertTaskProjectMoveAllowed,
-        resolveThreadBinding,
-      });
-      if (prepared.projectWorkspace && !setProjectWorkspace) {
-        throw new CloudProxyError(
-          500,
-          "PROJECT_MAPPING_UNAVAILABLE",
-          "Local project mapping storage is unavailable",
-        );
-      }
-      if (typeof prepared.body === "string") headers.delete("content-length");
-      const init = {
-        method: request.method,
-        headers,
-        redirect: "manual",
-      };
-      if (request.method !== "GET" && request.method !== "HEAD" && prepared.body !== null) {
-        init.body = prepared.body;
-        if (typeof prepared.body !== "string") init.duplex = "half";
-      }
-
-      let response;
-      try {
-        response = await fetchImplementation(upstreamUrl, init);
-      } catch (error) {
-        throw new CloudProxyError(
-          502,
-          "REMOTE_UNAVAILABLE",
-          `Cannot reach cloud taskboard at ${remoteUrl}`,
-          error instanceof Error ? error.message : String(error),
-        );
-      }
-      return localizeResponse(response, {
-        readConfig,
-        setProjectWorkspace,
-        projectWorkspace: prepared.projectWorkspace,
-        resolveDevelopmentContext,
-      });
-    },
-  };
-}