TUI sends absolute local paths causing ENOENT on server side #4686

import * as path from "path"

  async function submit() {
    if (props.disabled) return
    if (autocomplete.visible) return
    if (!store.prompt.input) return

    const sessionID = props.sessionID
      ? props.sessionID
      : await (async () => {
          const sessionID = await sdk.client.session.create({}).then((x) => x.data!.id)
          return sessionID
        })()
    const messageID = Identifier.ascending("message")
    let inputText = store.prompt.input

    // -------------------------------------------------------------------------
    // FIX: Dynamic Remote Root Detection
    // Extract the server's working directory from the current or latest session.
    // -------------------------------------------------------------------------
    let REMOTE_ROOT = "" 
    if (sync.data.session && sync.data.session.length > 0) {
      // Try to find the directory for the specific session we are in, 
      // otherwise use the most recent session's directory as the project root.
      const activeSession = sync.data.session.find((s) => s.id === sessionID) || sync.data.session[0]
      if (activeSession?.directory) {
        REMOTE_ROOT = activeSession.directory
      }
    }
    // -------------------------------------------------------------------------

    // Expand pasted text inline before submitting
    const allExtmarks = input.extmarks.getAllForTypeId(promptPartTypeId)
    const sortedExtmarks = allExtmarks.sort((a: { start: number }, b: { start: number }) => b.start - a.start)

    for (const extmark of sortedExtmarks) {
      const partIndex = store.extmarkToPartIndex.get(extmark.id)
      if (partIndex !== undefined) {
        const part = store.prompt.parts[partIndex]
        if (part?.type === "text" && part.text) {
          const before = inputText.slice(0, extmark.start)
          const after = inputText.slice(extmark.end)
          inputText = before + part.text + after
        }
      }
    }

    // FIX: Normalize file paths (Windows Client -> Linux Server)
    const cwd = process.cwd().replace(/\\/g, "/")
    const cwdLower = cwd.toLowerCase()

    const nonTextParts = store.prompt.parts
      .filter((part) => part.type !== "text")
      .map((part) => {
        if (part.type === "file" && part.source?.path) {
          let p = part.source.path.replace(/\\/g, "/")
          const pLower = p.toLowerCase()

          // 1. Strip local Windows CWD to get a clean relative path
          if (pLower.startsWith(cwdLower) || (pLower.startsWith("/") && pLower.includes(cwdLower))) {
             const idx = pLower.indexOf(cwdLower)
             let rel = p.slice(idx + cwdLower.length)
             rel = rel.replace(/^\/+/, "") // Remove leading slashes
             
             // If we found a dirty absolute path, replace it in the message text
             if (rel !== p) {
               const escapeRegExp = (string: string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
               const originalPathRegex = new RegExp(escapeRegExp(part.source.path), 'gi')
               const normalizedPathRegex = new RegExp(escapeRegExp(p), 'gi')

               inputText = inputText.replace(originalPathRegex, rel)
               inputText = inputText.replace(normalizedPathRegex, rel)
               
               p = rel
             }
          } else if (path.isAbsolute(part.source.path)) {
             // Fallback using path.relative logic
             const rel = path.relative(process.cwd(), part.source.path).split(path.sep).join("/")
             const escapeRegExp = (string: string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
             inputText = inputText.replace(new RegExp(escapeRegExp(part.source.path), 'gi'), rel)
             p = rel
          }

          // 2. Construct valid Linux Absolute URL using the Dynamic REMOTE_ROOT
          const cleanRemoteRoot = REMOTE_ROOT.replace(/\/$/, "")
          const cleanRelativePath = p.replace(/^\//, "")
          
          // Combine root + relative path
          let absoluteRemotePath = cleanRelativePath
          if (cleanRemoteRoot) {
             absoluteRemotePath = `${cleanRemoteRoot}/${cleanRelativePath}`
          }
          
          // Use 3 slashes for Linux file protocol if remote path implies root
          const newUrl = `file://${absoluteRemotePath.startsWith('/') ? '' : '/'}${absoluteRemotePath}`

          return {
            ...part,
            url: newUrl, 
            source: {
              ...part.source,
              path: p, // Keep path relative for display
            },
          }
        }
        return part
      })

    if (store.mode === "shell") {
      sdk.client.session.shell({
        path: {
          id: sessionID,
        },
        body: {
          agent: local.agent.current().name,
          model: {
            providerID: local.model.current().providerID,
            modelID: local.model.current().modelID,
          },
          command: inputText,
        },
      })
      setStore("mode", "normal")
    } else if (
      inputText.startsWith("/") &&
      iife(() => {
        const command = inputText.split(" ")[0].slice(1)
        return sync.data.command.some((x) => x.name === command)
      })
    ) {
      let [command, ...args] = inputText.split(" ")
      sdk.client.session.command({
        path: {
          id: sessionID,
        },
        body: {
          command: command.slice(1),
          arguments: args.join(" "),
          agent: local.agent.current().name,
          model: `${local.model.current().providerID}/${local.model.current().modelID}`,
          messageID,
        },
      })
    } else {
      sdk.client.session.prompt({
        path: {
          id: sessionID,
        },
        body: {
          ...local.model.current(),
          messageID,
          agent: local.agent.current().name,
          model: local.model.current(),
          parts: [
            {
              id: Identifier.ascending("part"),
              type: "text",
              text: inputText,
            },
            ...nonTextParts.map((x) => ({
              id: Identifier.ascending("part"),
              ...x,
            })),
          ],
        },
      })
    }
    history.append(store.prompt)
    input.extmarks.clear()
    setStore("prompt", {
      input: "",
      parts: [],
    })
    setStore("extmarkToPartIndex", new Map())
    props.onSubmit?.()

    // temporary hack to make sure the message is sent
    if (!props.sessionID)
      setTimeout(() => {
        route.navigate({
          type: "session",
          sessionID,
        })
      }, 50)
    input.clear()
  }